Kk2406/Ll huggingface dataset:
Metabase BI Dashboard
Domain: business_finance — Enterprise Analytics & Planning

Summary: Build a business analytics dashboard in Metabase using a pre-loaded SQLite database, then export key metrics as a structured JSON report.

Task prompt:
You are a business analyst building a BI dashboard in Metabase.

## Environment
- Metabase is available on this Windows machine. To start it, run the launcher script:
  `base\software\launch_metabase.bat`
  Then wait for the server to become ready and open http://localhost:3000 in the browser.
- Login credentials are in: `base\input\metabase_credentials.txt`
- The database "Business Analytics" is already connected in Metabase.

## Your Task
1. Read the task requirements at `base\input\requirements.md`
2. Read the output schema at `base\input\output_schema.json`
3. Launch Metabase using the launcher script and log in
4. Using the Metabase GUI, build the required dashboard with all 6 charts and a heading text card
5. Query the Business Analytics database to extract the required metrics
6. Save the final metrics as a JSON file conforming to the output schema

## Output
- Save your JSON report to: `base\output\dashboard_metrics.json`
- The JSON must conform to the schema in the output_schema.json
- All numerical values must be rounded to 2 decimal places
- Revenue calculations must only include orders with status = 'completed'

Required actions:
Launch Metabase via the launcher script and wait for the server to start
Log in at http://localhost:3000 with the provided credentials
Build a dashboard with 6 charts and a heading text card in the Metabase GUI
Query the Business Analytics SQLite database to extract all required metrics
Save dashboard_metrics.json conforming to the output schema to the output directory

Software: Metabase 0.54.3
Microsoft Edge

Input files:
name: Task requirements
format: md
description: Detailed dashboard requirements specifying 6 charts and a heading text card.
name: Output schema
format: json
description: JSON Schema defining the required structure for dashboard_metrics.json.
name: Metabase credentials
format: txt
description: Login credentials for the Metabase instance.
PE Screening Memo 1
Domain: business_finance — Accounting & Finance

Summary: Review a staged Zscaler diligence packet and write a structured private-equity screening memo with an explicit investment recommendation.

Task prompt:
You are working on a Linux finance benchmark task.

Read these staged files first:
- `zscaler_fy2025/input/task_brief.md`
- `zscaler_fy2025/input/memo_template.md`
- `zscaler_fy2025/input/source_manifest.json`

Task-local software notes:
- `zscaler_fy2025/software/README.txt`

Your job is to write the requested private-equity screening memo for Zscaler
using only the staged packet in `zscaler_fy2025/input`.

Write exactly one required file:
- `zscaler_fy2025/output/screening_memo.md`

Output requirements:
- filename must be exactly `screening_memo.md`
- output must be valid UTF-8 Markdown
- follow the structure from `memo_template.md`
- make an explicit `Go`, `No-Go`, or `Hold / Needs More Diligence` recommendation

Constraints:
1. Use only the staged packet.
2. Do not use web search.
4. Write only your final memo under `zscaler_fy2025/output`.


Required actions:
Read the staged brief, memo template, and source manifest before starting.
Use only the staged Zscaler packet and do not use web search.
Write a Markdown screening memo that follows the visible template exactly enough to preserve the required section structure.
Make an explicit `Go`, `No-Go`, or `Hold / Needs More Diligence` recommendation and support it with packet-grounded reasoning.
Save the final memo as `output/screening_memo.md`.

Software: Python

Input files:
name: task_brief.md
format: Markdown
description: Primary agent-visible benchmark brief with the output contract and workflow constraints.
name: memo_template.md
format: Markdown
description: Required memo structure and section template.
name: source_manifest.json
format: JSON
description: Human-readable inventory of the visible diligence packet.
name: q2_2025_earnings_release.pdf/.txt
format: PDF and plaintext extract
description: Official Zscaler IR Q2 FY2025 results release.
name: q2_2025_earnings_presentation.pdf/.txt
format: PDF and plaintext extract
description: Official Zscaler IR Q2 FY2025 earnings presentation.
name: q3_2025_earnings_release.pdf/.txt
format: PDF and plaintext extract
description: Official Zscaler IR Q3 FY2025 results release.
name: q3_2025_earnings_presentation.pdf/.txt
format: PDF and plaintext extract
description: Official Zscaler IR Q3 FY2025 earnings presentation.
name: zscaler_10k_2025.pdf/.txt
format: PDF and plaintext extract
description: Official FY2025 Zscaler Form 10-K plus plaintext extract.
SaaS One-Pager Brand Refresh
Domain: business_finance — Graphic, Visual & Product Design

Summary: Rebuild a flattened SaaS one-pager as an editable single-slide PowerPoint on Windows, apply the staged NorthstarOS rebrand changes, and export both a PPTX and a PNG.

Task prompt:
You are editing a SaaS one-pager on a Windows VM.

## Variant
`base`: NorthstarOS one-pager brand refresh

## Runtime Entry Point
- Open PowerPoint from: `base\software\OpenPowerPoint.bat`

## Visible Inputs
- Source one-pager PNG: `base\input\original_onepager.png`
- Edit brief: `base\input\edit_request.txt`
- Brand guide PDF: `base\input\brand_guide.pdf`
- KPI data CSV: `base\input\metrics.csv`
- Chart data CSV: `base\input\chart_data.csv`
- Replacement assets directory: `base\input\assets`
- Task brief: `base\input\task_brief.md`
- Output contract: `base\input\output_contract.json`

## What You Must Do
1. Read the staged brief and input files.
2. Rebuild the one-pager as a meaningfully editable single-slide PowerPoint.
3. Apply the requested NorthstarOS brand refresh while preserving the overall composition.
4. Save the editable PowerPoint exactly to `base\output\edited_onepager.pptx`.
5. Export the final slide exactly to `base\output\edited_onepager.png`.

## Output Requirements
- The `.pptx` must remain meaningfully editable.
- Save only the final required deliverables inside `base\output`.
- Do not modify files under `input/`.


Required actions:
Read the staged source one-pager, edit brief, brand guide, KPI CSV, chart CSV, and asset bundle from `input/`.
Rebuild the page as a meaningfully editable single-slide PowerPoint on Windows.
Apply the requested NorthstarOS brand refresh while preserving the overall composition.
Save exactly `output/edited_onepager.pptx` and `output/edited_onepager.png`.

Software: Microsoft PowerPoint

Input files:
name: original_onepager.png
format: PNG image
description: Flattened source one-pager to recreate and refresh.
name: edit_request.txt
format: text
description: Natural-language NorthstarOS brand refresh request.
name: brand_guide.pdf
format: PDF
description: Visible palette and style direction for the refresh.
name: metrics.csv
format: CSV
description: Replacement KPI values for the three metric cards.
name: chart_data.csv
format: CSV
description: Replacement line-chart data for the throughput section.
name: assets
format: asset directory
description: Visible logo, hero, headshot, QR, and icon assets, including original and replacement variants where supplied.
name: task_brief.md
format: Markdown
description: Benchmark-authored solve-time instructions.
name: output_contract.json
format: JSON
description: Visible output filename contract.
SSE Northbound Programmatic Trading Research
Domain: business_finance — Compliance & Regulatory

Summary: Answer three closed-book Shanghai Stock Exchange reporting questions from staged Chinese source documents and return a structured JSON memo with Chinese citations and evidence.

Task prompt:
You are acting as a regulatory consultant on Shanghai Stock Exchange Northbound programmatic-trading reporting.

## Closed-Book Rule

- Use only the staged materials under `base/input`.
- Do not use outside web search or external regulatory knowledge.

## Inputs

- Task brief: `base/input/task_brief.md`
- Question set: `base/input/question_set.json`
- Output contract: `base/input/output_contract.json`
- Document manifest: `base/input/document_manifest.json`
- Original source files: `base/input/source_documents`
- Extracted UTF-8 text mirrors: `base/input/extracted_text`

## Your Task

Answer the three client questions in the staged brief:

1. whether leverage-related information must be reported separately through each broker for same-LEI accounts;
2. whether the staged rules provide specific numerical amounts for `流量费` and `撤单费`;
3. whether a French firm can report using only the original foreign-language software name.

## Deliverable

Write exactly one JSON file here:

- `base/output/research_answers.json`

Each top-level question key must contain:

- `conclusion`: exactly `Yes`, `No`, or `Unknown`
- `citation_document`: the Simplified Chinese source document name you rely on
- `evidence_snippet`: an exact Simplified Chinese excerpt copied from the staged source
- `answer_text`: a short English explanation


Required actions:
Read the staged task brief, question set, output contract, document manifest, source documents, and extracted-text mirrors.
Answer all three client questions using only the staged Shanghai Stock Exchange materials.
Write exactly one JSON file to `output/research_answers.json`.
For each question, provide a `Yes`/`No`/`Unknown` conclusion, a Chinese citation, an exact Chinese evidence excerpt, and a short English explanation.
Stay closed-book and do not use outside web search or external regulatory knowledge.

Software: Python

Input files:
name: task_brief.md
format: Markdown
description: Agent-visible task instructions and the three client questions.
name: question_set.json
format: JSON
description: Structured list of the three required research questions and allowed conclusion labels.
name: output_contract.json
format: JSON
description: Defines the required output filename, top-level keys, and per-question JSON fields.
name: document_manifest.json
format: JSON
description: Maps the staged Chinese source files to their citation aliases.
name: source_documents
format: DOCX/XLSX directory
description: The ten original staged Shanghai Stock Exchange source files.
name: extracted_text
format: UTF-8 text directory
description: Search-friendly text mirrors of the staged Chinese source files.
Taxform 4 1
Domain: business_finance — Accounting & Finance

Summary: Prepare a U.S. tax return from staged wage documents and instructions, then save the required JSON outputs.

Task prompt:
You are preparing a U.S. tax return inside a browser-based local task environment.

## Variant
`variant_1`: W-2 income with a single Form 1040 output.

## Runtime Entry Points
- Start the local HTTP server by running: `variant_1\software\start_http_server.bat`
- Read the taxpayer instructions at: `variant_1\input\instruction.txt`

## Source Forms To Read
These pages are prefilled reference documents. Read them, but do not edit them.
- Form W-2 — Wage and Tax Statement: `http://localhost:8080/forms/formw2.html?data=/`

## Output Forms To Complete
Fill these blank return pages in the browser, then click `Save Results` on each one.
- Form 1040 — U.S. Individual Income Tax Return: `http://localhost:8080/forms/form1040.html`

## What You Must Do
1. Run `variant_1\software\start_http_server.bat` to serve the staged `input/` directory on `http://localhost:8080`.
2. Read `variant_1\input\instruction.txt` carefully.
3. Open every source form listed above and extract the needed values.
4. Open every output form listed above and complete the tax return.
5. Click `Save Results` on each required output form.
6. Move the downloaded JSON file(s) into `variant_1\output`.

## Required Final Output Files
Place these exact files in `variant_1\output`:
- `form1040_output.json`

Required actions:
Launch the task-local HTTP server from `software/start_http_server.bat`, which serves the staged `input/` directory at `http://localhost:8080`.
Read `input/instruction.txt` and the staged source forms listed in `input/README.md`, combining free-text tax instructions with values shown on the pre-filled W-2 / 1099 forms.
Fill the blank output form pages (`form1040.html`, and `form1040s1.html` for `variant_5`) in the browser, then click `Save Results` on each output form so the browser downloads the required JSON outputs.

Software: Python
Chrome

Input files:
name: README.md
format: Markdown
description: Source-authored setup and page-order instructions
name: instruction.txt
format: UTF-8 text
description: Taxpayer scenario, filing rules, and calculation instructions
name: forms/
format: HTML, PDF, JS, CSS
description: Interactive tax forms and static assets served locally
name: *_input.json
format: JSON
description: Source-form payloads read via the ?data=/ query string
Branch-and-Bound ATSP Solver
Domain: computing_math — Mathematical & Operations Research

Summary: Implement a Python branch-and-bound solver for deterministic asymmetric TSP instances and report certified results across three tiers.

Task prompt:
You are working on a Linux VM.

## Task Directory
`base`

## Visible Inputs
- Task prompt: `base/input/TASK_PROMPT.md`
- ATSP problem specification: `base/input/problem_spec.md`
- Runtime manifest: `base/input/runtime_env/pyproject.toml`
- Python entry point with task dependencies: `base/software/python`

## Your Task
Implement a branch-and-bound solver for the asymmetric travelling salesman
problem described in the problem specification. Solve the 12-city and 20-city
instances to proven optimality, solve the 35-city instance to at most 0.5%
optimality gap, and write the required JSON report to:

`base/output/results.json`

Use only Python, NumPy, and SciPy. Do not use external optimization solvers or
TSP packages. Do not modify files under `base/input`.


Required actions:
Regenerate the deterministic 3D city coordinates for the 12, 20, and 35 city tiers.
Implement branch-and-bound and assignment-relaxation based lower bounds without external optimization solvers.
Write a valid `results.json` containing tours, costs, bounds, gaps, node counts, and runtime metrics.

Software: Python
NumPy
SciPy

Input files:
name: problem_spec.md
format: markdown
description: Authoritative ATSP problem statement and output schema.
name: TASK_PROMPT.md
format: markdown
description: Normalized solve-time instructions staged for the agent.
name: pyproject.toml
format: toml
description: Solve-time Python dependency manifest for NumPy and SciPy.
CFR Game Theory Equilibrium
Domain: computing_math — Mathematical & Operations Research

Summary: Implement exact and regret-minimization solvers for three zero-sum games and write one combined JSON output.

Task prompt:
You are working on a Linux VM.

## Your Task
Implement equilibrium solvers for three progressively harder two-player zero-sum games and save one combined `results.json`.

## Visible Input
- Authoritative problem specification: `base/input/problem_spec.md`
- Solve-time runtime manifest: `base/input/runtime_env/pyproject.toml`
- Solve-time runtime lockfile: `base/input/runtime_env/uv.lock`

## Runtime Entry Points
- Bootstrap the staged NumPy runtime with `base/software/bootstrap_runtime.sh`
- Run Python with staged task dependencies using `base/software/python_with_task_deps.sh`

## What You Must Produce
Write exactly one file at `base/output/results.json`.

The JSON must contain top-level keys `tier1`, `tier2`, and `tier3`:
- `tier1`: matrix-game equilibrium value, row/column mixed strategies, and row/column support indices
- `tier2`: Kuhn poker CFR iterations, final exploitability, average strategy, game value estimate, and information-set count
- `tier3`: 4-rank Leduc MCCFR iterations, final exploitability, full average strategy map, information-set count, and exact game parameters

## Rules
- Read `base/input/problem_spec.md` first and follow it closely.
- Do not modify any files under `base/input`.
- Do not write outside `base/output`.
- Use only the staged local inputs and the software already available on this VM.


Required actions:
Read the staged problem specification and implement all three tiers of the benchmark.
Use the staged runtime wrappers to install and run the NumPy-only solve-time environment if needed.
Return one combined `results.json` containing Tier 1 matrix-game, Tier 2 Kuhn CFR, and Tier 3 Leduc MCCFR outputs.

Software: Python
uv
NumPy

Input files:
name: Problem specification
format: Markdown
description: Agent-visible task specification for all three game-solving tiers.
name: Runtime manifest
format: pyproject.toml
description: Staged solve-time Python dependency manifest.
name: Runtime lockfile
format: uv.lock
description: Locked solve-time dependency set for the staged runtime.
name: Bootstrap wrapper
format: shell script
description: Agent-visible helper for creating the staged runtime environment.
name: Python wrapper
format: shell script
description: Agent-visible helper for running Python with the staged task dependencies.
Clustered-Cyclic Code Circuit Simulation
Domain: computing_math — Quantum Computing

Summary: Reproduce circuit-level logical failure-rate data for three clustered-cyclic CSS quantum error-correcting codes using the supplied construction notes and simulation grid.

Task prompt:
You are working on a Linux VM.

## Variant
`base`: Three clustered-cyclic CSS codes with QUITS/Stim circuit-level memory simulation.

## Input Files
- Task notes: `base/input/cc_codes_quits_extraction.tex`
- Simulation grid: `base/input/simulation_grid.csv`
- Output requirements: `base/input/output_requirements.txt`
- Python runtime manifest: `base/input/runtime_env/pyproject.toml`

## Your Task
Reproduce the circuit-level memory-simulation logical failure-rate table for the three clustered-cyclic CSS codes described in the task notes.

Use the staged notes to extract the code construction, QUITS repeated-syndrome-extraction workflow, direction-aware edge-coloring schedule, Stim detector-error-model workflow, BP+OSD decoder settings, and logical failure-rate formulas.

Run every row in the simulation grid. For each row, report the logical failure count, total logical failure probability, per-round logical failure rate, and per-logical-qubit per-round logical failure rate.

You may install the task-specific open-source Python dependencies from `input/runtime_env/pyproject.toml` or `input/requirements.txt`.

## Output
Write the final CSV here:
- `base/output/logical_error_rates_3codes.csv`


Required actions:
Read `input/cc_codes_quits_extraction.tex`, `input/simulation_grid.csv`, and `input/output_requirements.txt`.
Install or inspect the open-source Python runtime from `input/runtime_env/pyproject.toml` or `input/requirements.txt`.
Construct and simulate the `[24,8,3]`, `[40,8,5]`, and `[54,18,3]` clustered-cyclic CSS code cases from the supplied notes.
Compute `num_failures`, `p_logical`, `lfr_per_round`, and `lfr_per_round_per_qubit` for every row in the simulation grid.
Save the final CSV as `output/logical_error_rates_3codes.csv`.

Software: Python
Stim
ldpc
QUITS
NumPy
pandas

Input files:
name: cc_codes_quits_extraction.tex
format: tex
description: Agent-facing construction and simulation notes from the submitter.
name: simulation_grid.csv
format: csv
description: The required code, physical error-rate, round-count, and shot-count grid.
name: output_requirements.txt
format: txt
description: The required output CSV schema and derived-rate formulas.
name: pyproject.toml
format: toml
description: Open-source Python dependency manifest for the simulation runtime.
Retail ETL Warehouse Cleanup
Domain: computing_math — Data & Analytics Engineering

Summary: Build a cleaned SQLite star-schema warehouse plus two truthful JSON sidecars from messy retail CSV, JSON, and TSV source files on a Linux VM.

Task prompt:
You are working on a Linux VM to build a cleaned SQLite warehouse from messy retail source files.

Visible task files:
- `base/input/task_prompt.md`
- `base/input/target_schema_spec.json`
- `base/input/output_contract.json`
- `base/input/raw_transactions/`
- `base/input/raw_customers/customers.json`
- `base/input/raw_products/product_catalog.tsv`
- `base/input/runtime_env/`
- `base/software/README.txt`
- `base/software/python_etl_env.sh`

What you must do:
1. Read the staged task prompt, schema spec, and output contract.
2. Build the final SQLite warehouse and truthful JSON sidecars from the staged raw inputs.
3. Write these three deliverables at the output-directory root:
   - `base/output/warehouse.db`
   - `base/output/data_quality_report.json`
   - `base/output/warehouse_summary.json`
4. If you use the staged helper wrapper, its runtime scratch may live under `base/output/_runtime`.

Rules:
- Do not modify files under `input/`.
- Keep the final deliverables at the output-directory root.
- Write valid SQLite / JSON outputs only.


Required actions:
Read the staged prompt, schema spec, output contract, and messy retail source files under `input/`.
Build a cleaned SQLite warehouse with deduplication, null handling, standardization, surrogate keys, and a full `dim_dates` table.
Write `output/warehouse.db`, `output/data_quality_report.json`, and `output/warehouse_summary.json`.
Keep the JSON sidecars truthful to the produced warehouse.

Software: Python 3.10
uv
pandas
SQLite

Input files:
name: task_prompt.md
format: Markdown
description: Agent-visible task brief for the ETL workflow.
name: target_schema_spec.json
format: JSON
description: Semantic warehouse schema contract and transformation requirements.
name: output_contract.json
format: JSON
description: Required deliverable filenames and JSON key structure.
name: raw_transactions
format: CSV directory
description: Six monthly transaction CSV files with schema drift and dirty rows.
name: customers.json
format: JSON
description: Retail customer records including unresolved ghost-customer rows.
name: product_catalog.tsv
format: TSV
description: Product catalog with supplier, category, and boolean normalization issues.
name: runtime_env
format: uv Python environment
description: Optional locked Python environment staged for the agent.
name: python_etl_env.sh
format: Shell wrapper
description: Optional helper wrapper that runs the staged Python environment and keeps scratch under `output/_runtime/`.
Repair Standalone DiT Pipeline CFG Alignment
Domain: computing_math — AI Engineering, Safety & CS Research

Summary: Repair a buggy standalone DiT sampling pipeline so its classifier-free guidance behavior matches the intended reference implementation while preserving the one-file edit workflow.

Task prompt:
You are repairing a standalone Diffusers-based DiT pipeline on a Linux VM.

Task directory:
- `base`

Visible files:
- Buggy starter pipeline: `base/input/pipeline_dit.py`
- Raw sampling harness context: `base/input/sample.py`
- Raw run script context: `base/input/run_sample.sh`
- Benchmark-owned prompt: `base/input/task_prompt.md`

Your task:
1. Read `base/input/task_prompt.md` first.
2. Repair the standalone starter file at `base/input/pipeline_dit.py`.
3. Keep the fix localized to the pipeline file.
4. Save exactly one final file to:
   `base/output/pipeline_dit.py`

Do not modify files under `input/`.
Do not rely on hidden evaluator files while solving.


Required actions:
Read the benchmark-owned task prompt and inspect the buggy standalone `pipeline_dit.py` plus the raw context files `sample.py` and `run_sample.sh`.
Repair the standalone DiT pipeline so the guidance behavior matches the intended reference behavior.
Keep the fix localized to the pipeline file rather than replacing the broader workflow.
Write exactly one final file to `output/pipeline_dit.py`.

Software: Python
Diffusers
PyTorch

Input files:
name: pipeline_dit.py
format: Python
description: Buggy standalone starter pipeline.
name: sample.py
format: Python
description: Raw sampling harness context from the submission.
name: run_sample.sh
format: Shell
description: Raw launch script context from the submission.
name: task_prompt.md
format: Markdown
description: Benchmark-owned solve-time instructions.