jayadharshani/Energy huggingface dataset:
Crop Rotation Audit for Stable Parcels
Domain: agriculture_env — Precision Agriculture

Summary: Audit French stable agricultural parcels for crop-rotation eligibility and risk, then produce full eligible and flagged GeoPackage outputs with exact schema and layer requirements.

Task prompt:
You are auditing crop rotation eligibility for stable agricultural parcels in France.

Task directory:
- `base`

Visible inputs:
- Parcel GeoPackage: `base\input\seq1524_d02.gpkg`
- Task brief: `base\input\task_prompt.md`
- Citation note: `base\input\citation.txt`
- Optional Python runtime manifest:
  - `base\input\runtime_env\pyproject.toml`
  - `base\input\runtime_env\uv.lock`
  - `base\input\runtime_env\requirements.txt`
- Software note: `base\software\README.txt`

Optional Python runtime:
- Use `base\software\python_geo.bat` if you want the benchmark-provisioned geospatial Python stack (pinned `numpy`, `pandas`, `geopandas`, `shapely`, `pyogrio`, `fiona`, `pyproj`).
- The package manifest is visible at `base\input\runtime_env\pyproject.toml` if you prefer to build your own environment.

Your task:
1. Read `base\input\task_prompt.md` and follow it exactly.
2. Load the input layer `seq1524_d02` from `base\input\seq1524_d02.gpkg`.
3. Produce these two GeoPackages under `base\output`:
   - `eligible_units.gpkg`
   - `flagged_units.gpkg`
4. Use exact layer names:
   - `eligible_units`
   - `flagged_units`

Rules:
- Do not modify files under `input/`.
- Preserve the input geometry and original columns exactly as required by the task brief.
- Keep the output CRS as EPSG:2154.
- Write final outputs only under `base\output`.


The agent must:
Read the staged crop-rotation brief in `input/task_prompt.md` and apply it exactly.
Load the `seq1524_d02` layer from `input/seq1524_d02.gpkg`.
Compute the eight required audit columns for every eligible `id_lcp`.
Write `output/eligible_units.gpkg` with preserved original columns and geometry plus the audit fields.
Write `output/flagged_units.gpkg` as the flagged subset with the same schema and exact layer names.

Software: Python
GeoPandas
pandas
pyogrio
shapely
pyproj
fiona

Input files:
name: seq1524_d02.gpkg
format: GeoPackage
description: Stable agricultural parcel polygons with yearly crop-code columns from 2015 through 2024
name: task_prompt.md
format: Markdown
description: Agent-visible crop-rotation audit contract with eligibility and field-computation rules
name: runtime_env/requirements.txt
format: text
description: Optional pinned Python geospatial dependencies for an agent-created local runtime
American Option Pricing via Longstaff-Schwartz
Domain: business_finance — Quantitative Finance & Trading

Summary: Implement a three-tier Monte Carlo option-pricing benchmark covering Black-Scholes validation, a single-asset American put solved with Longstaff-Schwartz regression, and a correlated 5-asset basket American put with pathwise Greeks.

Task prompt:
You are working on an Ubuntu coding task about pricing American-style options with Monte Carlo and Longstaff-Schwartz regression.

Task directory:
- `base`

Visible input files:
- Problem specification: `base/input/problem_spec.md`
- Python runtime manifest: `base/input/runtime_env/pyproject.toml`
- Python lockfile: `base/input/runtime_env/uv.lock`
- Canonical Python wrapper: `base/software/python.sh`

Recommended workflow:
1. Change into `base`
2. Read the staged problem specification in full before coding
3. Use `"base/software/python.sh" your_script.py` or `"base/software/python.sh" -c "..."` to run Python with the staged NumPy/SciPy runtime
4. Implement the solver under the writable output directory
5. Write every required artifact under `base/output`

Required outputs under `base/output`:
- `results.json`
- `exercise_boundary_tier2.npy`

Requirements:
- Use only Python + NumPy + SciPy. Do not use financial libraries or autodiff frameworks.
- Use exact log-normal GBM simulation, not Euler discretization.
- Follow the fixed seeds, path counts, regression basis requirements, and output schema from the problem spec.
- Tier 1 and Tier 2 are required for any passing score; Tier 3 is required for full credit.
- If Tier 3 is incomplete, keep Tier 1 / Tier 2 outputs truthful rather than fabricating Tier 3 metrics.


The agent must:
Read the staged problem specification in full before implementing the solver.
Use the staged Python wrapper if a task-local NumPy/SciPy runtime is needed.
Produce `results.json` and `exercise_boundary_tier2.npy` under the writable output directory.
Keep the reported metrics, exercise boundary sample, and saved `.npy` boundary internally consistent.
Treat Tier 1 and Tier 2 as mandatory and Tier 3 as the full-credit upgrade path.

Software: Python
NumPy
SciPy
uv

Input files:
name: problem_spec.md
format: Markdown
description: Full public specification for the three-tier American option pricing benchmark.
name: runtime_env/pyproject.toml
format: TOML
description: Pinned solve-time manifest for NumPy and SciPy.
name: runtime_env/uv.lock
format: Lockfile
description: Pinned uv lockfile for the staged runtime.
name: software/python.sh
format: Shell script
description: Canonical agent-facing Python entry point for the staged runtime.
Annual Report Full Extraction (1500 files)
Domain: business_finance — Accounting & Finance

Summary: Download 1500 annual reports from East Money, extract core technical personnel records, and produce one consolidated workbook with the required schema.

Task prompt:
Task Type:
- Full pipeline (download + parse + structure output), with file verification.

Goal:
- Download all reports listed in base\input\file_list.txt from East Money (东方财富).
- Extract core technical personnel data.
- Output one consolidated Excel file.

Input Files:
1) base\input\file_list.txt
   - UTF-8 text file, one PDF filename per line.
   - Example line: `688001_某公司_2023年年报.pdf`

Output File:
1) base\output\final_dataset.xlsx
   - One sheet.
   - One row per person.
   - Required columns (exact names):
     识别码, 证券代码, 股票简称, 姓名, 性别, 年龄, 国籍, 最高学历, 简历,
     2019薪酬, 2020薪酬, 2021薪酬, 2022薪酬, 2023薪酬, 2024薪酬,
     2019持股, 2020持股, 2021持股, 2022持股, 2023持股, 2024持股.

Data Rules:
- `识别码` (Identifier) format:
  - Build as: `股票简称 + 姓名` (no separator).
  - Use `股票简称` for the company part (do NOT use `证券代码`).
  - Example: if company is `华兴源创` and person is `曹振宇`, then `识别码` is `华兴源创曹振宇`.
  - Example: if company is `天准科技` and person is `徐一华`, then `识别码` is `天准科技徐一华`.
- Try to fill each required field from evidence as completely as possible.
- Use NaN only when the value cannot be reliably found.
- For numeric output values, keep at least 3 decimal places (0.001 precision) when applicable.
- `最高学历` code mapping:
  - 1 = PhD
  - 2 = Master
  - 3 = Bachelor
  - 4 = Associate
  - 5 = Other / Undisclosed
- Output format requirement for `最高学历`:
  - Use numeric code values only (1/2/3/4/5).
  - `1` and `1.0` are treated as the same numeric value.
  - Text labels like `博士` / `硕士` are not accepted in this column.

Scoring:
- Full score requires all conditions below to be satisfied:
  1) Every required PDF in `file_list.txt` is correctly downloaded.
  2) `final_dataset.xlsx` matches the required schema exactly.
  3) Extracted values are accurate on hidden verification samples.


The agent must:
Read `input/file_list.txt` to determine the 1500 annual-report PDFs in scope
Download all listed annual reports from East Money into `output/downloads/`
Extract core technical personnel data for each report
Produce `final_dataset.xlsx` with the required columns and data rules

Software: Microsoft Edge
Python

Input files:
name: file_list.txt
format: txt
description: UTF-8 list of 1500 annual-report PDF filenames
Basel Operational Risk BIA Classification
Domain: business_finance — Actuarial & Risk Modeling

Summary: Classify Chinese operational-risk loss events into Basel event categories and business lines, then calculate regulatory capital under the Basic Indicator Approach.

Task prompt:
You are working on a Linux VM as an operational-risk analyst.

## Task Directory
`base`

## Visible Inputs
- Task prompt: `base/input/TASK_PROMPT.md`
- Raw Chinese loss events: `base/input/operational_risk_events.xlsx`
- Basel loss event categories: `base/input/loss_event_categories.xlsx`
- Basel business line mapping: `base/input/business_line_mapping.xlsx`
- BIA capital parameters: `base/input/capital_calculation_params.xlsx`
- Output schemas/examples: `base/input/output_schemas`

## Your Task
Classify each of the 60 loss events into one Basel loss event category code
(`EL1` through `EL7`) and one Basel business line code (`BL1` through `BL8`).
Then calculate operational-risk regulatory capital under the Basel Basic
Indicator Approach.

Write all final files under `base/output`:
- `classified_events.csv`
- `capital_calculation.json`
- `execution_log.txt`

Follow the file contracts in `base/input/TASK_PROMPT.md` and the schemas under
`base/input/output_schemas`. Do not modify files under `base/input`.


The agent must:
Read all 60 Chinese operational-risk event descriptions.
Assign one Basel loss event category code from `EL1` through `EL7` to each event.
Assign one Basel business line code from `BL1` through `BL8` to each event.
Calculate operational-risk regulatory capital using the Basel Basic Indicator Approach parameters.
Write `classified_events.csv`, `capital_calculation.json`, and `execution_log.txt` under the output directory.

Software: LibreOffice Calc
Python
openpyxl

Input files:
name: TASK_PROMPT.md
format: md
description: Solve-time task instructions and output contract.
name: operational_risk_events.xlsx
format: xlsx
description: Chinese operational-risk event records to classify.
name: loss_event_categories.xlsx
format: xlsx
description: Basel loss event category definitions and indicators.
name: business_line_mapping.xlsx
format: xlsx
description: Basel business line definitions and mapping guidance.
name: capital_calculation_params.xlsx
format: xlsx
description: BIA alpha coefficient and gross income parameters.
name: output_schemas
format: csv/json/txt
description: Required schemas and format examples for the deliverables.
Digital Marketing A/B Test Analysis
Domain: business_finance — Sales & Marketing

Summary: Design and analyze a marketing A/B test with exclusion handling, stratified assignment checks, two-proportion inference, BH correction, and a final ship/hold recommendation.

Task prompt:
You are working on a Linux VM to complete a digital marketing A/B test analysis.

Visible task files:
- `base/input/experiment_brief.md`
- `base/input/historical_metrics.csv`
- `base/input/eligible_population.csv`
- `base/input/exclusion_rules.yaml`
- `base/input/active_experiment_customers.csv`
- `base/input/experiment_results_raw.csv`
- `base/input/runtime_env/pyproject.toml`
- `base/input/runtime_env/uv.lock`

Write exactly these outputs under `base/output`:

1. `randomization_assignment.csv` — CSV with columns `metric,value`.
   Required rows (one per metric): `n_control`, `n_treatment`, `ratio`
   (treatment/control ratio), `srm_chi2`, `srm_pvalue`, `srm_pass`.
   Compute the sample-ratio mismatch (SRM) chi-squared test over the
   **full** `experiment_results_raw.csv` population (do NOT filter by
   exclusion rules — use every row in the raw results file).

2. `experiment_results.tsv` — tab-separated file with exactly 4 rows
   (one per metric: `opened_rate`, `clicked_rate`, `converted_rate`,
   `unsubscribed_rate`). Columns: `metric`, `is_primary` (True/False),
   `control_rate`, `treatment_rate`, `absolute_lift`,
   `relative_lift_pct`, `ci_lower_95`, `ci_upper_95`, `z_statistic`,
   `p_value_raw`, `significant_at_05` (True/False), `bh_rank`,
   `bh_threshold`, `bh_significant` (True/False). The last three
   Benjamini-Hochberg columns apply only to secondary metrics; leave
   them blank for the primary metric. Rates are computed over delivered
   emails from the **full** `experiment_results_raw.csv` (do NOT apply
   exclusion rules).

3. `experiment_report.md` — Markdown report that includes:
   the required per-arm sample size (from a power analysis on
   `historical_metrics.csv`), a clear **Recommendation** section
   containing the word "ship" or "hold", and the observed absolute
   lift on the primary metric.


The agent must:

Software: Python 3.12
scipy
statsmodels
pandas
GrowthBook

Input files:
Equity Research Summary
Domain: business_finance — Enterprise Analytics & Planning

Summary: Build a company equity-research workbook from staged filings and market sources, then produce the required summary outputs.

Task prompt:
You are an equity research analyst preparing a one-page Tesla workbook in LibreOffice Calc.

## Variant
`tsla_fy2023`: Single Tesla equity-research workbook using live Yahoo pages plus fixed FY2023 SEC values.

## Runtime Entry Points
- Read the staged instructions: `tsla_fy2023\input\instruction.md`
- Read the allowed public source URLs: `tsla_fy2023\input\source_urls.txt`
- Launch LibreOffice Calc from: `tsla_fy2023\software\launch_calc.bat`

## Your Task
Create a single worksheet named for a Tesla financial summary workbook.

Use Yahoo Finance for the live market-data / valuation fields and SEC EDGAR for the fixed
FY2023 annual financial-statement sections.

The workbook must include these sections:
- Market Data
- Valuation Metrics
- Income Statement (FY2023, $mm)
- Balance Sheet (FY2023, $mm)
- Cash Flow (FY2023, $mm)
- Key Metrics Dashboard

## Output Requirements
- Save exactly one workbook to: `tsla_fy2023\output\TSLA_Financial_Summary.xlsx`
- The filename must be exactly `TSLA_Financial_Summary.xlsx`
- Use spreadsheet formulas, not hardcoded values, for derived cells such as margins,
  free cash flow, equity, and dashboard metrics
- Keep the live Yahoo Finance cells populated in the final workbook

The agent must:
Open Yahoo Finance for Tesla (`TSLA`), visit the quote page and the Statistics page, and collect the live market-data and valuation fields listed in `input/instruction.md`.
Open SEC EDGAR for Tesla and locate the Tesla FY2023 annual 10-K financial statements needed for the workbook.
Launch LibreOffice Calc via `software/launch_calc.bat`.
Build a single-sheet workbook with the required title, section headers, labels, formulas, and formatting.
Save the final workbook as `TSLA_Financial_Summary.xlsx` into the runtime `output/` directory.

Software: Chrome

Input files:
name: instruction.md
format: Markdown
description: Sanitized runtime brief with required sections, output filename, and source workflow
name: source_urls.txt
format: UTF-8 text
description: Public URLs the agent is allowed to use for data gathering
FF5 Public Reconstruction
Domain: business_finance — Enterprise Analytics & Planning

Summary: Reconstruct the monthly Fama-French five-factor series from 2015-01 onward using only the staged allowlisted public sources, then save the required factor CSV.

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

Read these staged files first:
- `base/input/agent_prompt.md`
- `base/input/README.md`
- `base/input/manifest.json`

Task-local entry points:
- Browser launcher: `base/software/browser`
- Python wrapper: `base/software/python`
- UV wrapper: `base/software/uv`

If you want the pinned Python runtime manifest, it is staged at:
- `base/input/runtime_env/pyproject.toml`
- `base/input/runtime_env/uv.lock`

Your job is to reconstruct the monthly U.S. Fama-French five factors from public data starting at `2015-01`, following the full instructions in `agent_prompt.md`.

Write exactly one required file:
- `base/output/ff5_factors_monthly_2015_onward.csv`

Output requirements:
- filename must be exactly `ff5_factors_monthly_2015_onward.csv`
- columns must be exactly `date,MKT_RF,SMB,HML,RMW,CMA`
- `date` format must be `YYYY-MM`
- values must be monthly factor values in percent units
- no duplicate dates

Constraints:
1. Follow the allowlist and workflow restrictions in `agent_prompt.md` and `manifest.json`.
2. If you install Python dependencies, use the staged runtime manifest rather than modifying benchmark-owned evaluator state.
3. Write only your task output under `base/output`.


The agent must:
Read `input/agent_prompt.md`, `input/README.md`, and `input/manifest.json` before starting.
Stay inside the staged public-data allowlist while reading the paper, gathering data, and building the factor pipeline.
Optionally install task-facing Python dependencies from `input/runtime_env/` with the staged `uv.lock`.
Write exactly one CSV named `ff5_factors_monthly_2015_onward.csv` under `output/` with columns `date,MKT_RF,SMB,HML,RMW,CMA`.

Software: Google Chrome
Python
uv

Input files:
name: agent_prompt.md
format: Markdown
description: Primary agent-visible benchmark brief, including the allowed public sources and output contract.
name: README.md
format: Markdown
description: Short runtime note describing how the staged package should be used.
name: manifest.json
format: JSON
description: Visible allowlist and required output metadata.
name: runtime_env
format: uv Python environment manifest
description: Optional pinned task-facing Python dependency manifest (`pyproject.toml` plus `uv.lock`).
Apple FY2024 Balance Sheet Reconstruction
Domain: business_finance — Accounting & Finance

Summary: Extract Apple Inc.'s FY2024 Consolidated Balance Sheet from its Form 10-K and return a structured JSON report with exact USD-million values.

Task prompt:
You are working on a Linux VM as a financial statement extraction analyst.

## Task Directory
`base`

## Visible Inputs
- Task prompt: `base/input/TASK_PROMPT.md`
- Apple FY2024 10-K PDF: `base/input/aapl-2024-10k.pdf`
- SEC EDGAR HTML: `base/input/aapl-20240928.htm`
- Task metadata: `base/input/task.json`
- Output schema: `base/input/output_schema.json`
- Source notes: `base/input/material_sources.md`
- Tool wrappers: `base/software/python`, `base/software/pdftotext`, `base/software/grep`

## Your Task
Reconstruct Apple Inc.'s Consolidated Balance Sheet for fiscal year 2024
(period ended September 28, 2024) as structured JSON.

Write the final JSON to `base/output/balance_sheet.json`. Follow the schema in
`base/input/output_schema.json`, use USD millions exactly as reported, and
do not modify files under `base/input`.


The agent must:
Locate the Consolidated Balance Sheets in the staged Apple FY2024 Form 10-K materials.
Extract the September 28, 2024 value for every required field in the schema.
Write `output/balance_sheet.json` without modifying staged input files.

Software: Python
pdftotext
grep

Input files:
name: aapl-2024-10k.pdf
format: pdf
description: Cached Apple FY2024 Form 10-K PDF.
name: aapl-20240928.htm
format: html
description: SEC EDGAR HTML filing for the same 10-K.
name: output_schema.json
format: json
description: Required output keys and types.
Internal Employee Agent Conversation Replay
Domain: business_finance — HR & Project Management

Summary: Read staged HR and IT support conversations, then produce one deterministic `results.json` that captures the correct per-turn responses and tool usage across all sessions.

Task prompt:
You are working on a Linux VM.

## Your Task
Act as the company's internal HR / IT assistant across all staged conversation sessions and write the final structured artifact to `base/output/results.json`.

## Visible Inputs
- agent rules: `base/input/agent_rules.md`
- HR knowledge base: `base/input/hr_knowledge_base.md`
- IT knowledge base: `base/input/it_knowledge_base.md`
- conversation sessions: `base/input/queries.json`
- email / JIRA fallback stubs: `base/input/stubs.py`
- deterministic web-search grounding for the `search_web` cases: `base/input/web_search_grounding.json`

## What To Produce
Write exactly one JSON file at `base/output/results.json` with this shape:

```json
{
  "1.1": [{"response": "...", "tools_used": []}],
  "5.1": [
    {"response": "...", "tools_used": ["draft_hr_email"]},
    {"response": "...", "tools_used": ["send_hr_email"]}
  ]
}
```

## Required Behavior
- process each test id in `queries.json` as one independent conversation session
- keep turn order within each test id
- keep session memory across turns inside the same test id
- use the exact canonical tool names from `agent_rules.md` in `tools_used`
- if you need a deterministic fallback for `search_web`, use the staged `web_search_grounding.json`
- you may use the staged `stubs.py` for local HR email / JIRA fallback behavior

## Important Constraints
- write only to `base/output/results.json` inside the visible `output/` directory
- do not modify staged files under `input/`
- do not read or modify hidden evaluator directories
- keep the artifact deterministic and valid JSON


The agent must:
Read the staged rules, knowledge bases, conversation sessions, and deterministic web-search grounding.
Process each test id in `queries.json` as an independent multi-turn session while preserving turn order and within-session memory.
Write exactly one `results.json` file under `output/`.
Use the exact canonical tool names from `agent_rules.md` in every `tools_used` list.
Keep the artifact deterministic, valid JSON, and confined to the visible `output/` directory.

Software: Python

Input files:
name: agent_rules.md
format: Markdown
description: Canonical tool names and operational rules for the HR / IT assistant.
name: hr_knowledge_base.md
format: Markdown
description: HR policy knowledge base used to answer the staged employee conversations.
name: it_knowledge_base.md
format: Markdown
description: IT support knowledge base used to answer the staged employee conversations.
name: queries.json
format: JSON
description: All staged multi-turn conversation sessions keyed by test id.
name: stubs.py
format: Python
description: Visible fallback helpers for email and JIRA-style actions.
name: web_search_grounding.json
format: JSON
description: Deterministic grounding data for the `search_web` cases.
M&A Filing Consistency Audit
Domain: business_finance — Litigation Support & Discovery

Summary: Review four Chinese regulatory filings about the same share-transfer transaction and write an English audit report that identifies supported inconsistencies with Chinese evidence and location markers.

Task prompt:
You are reviewing four Chinese regulatory filings about the same share-transfer transaction.

## Task
Read the staged materials, cross-check the filings for factual inconsistencies, and write one
English audit report.

## Visible Inputs
- Task root: `base`
- Task brief: `base/input/task_brief.md`
- Document manifest: `base/input/document_manifest.json`
- Original PDFs: `base/input/source_documents`
- Page-labeled extracted text: `base/input/extracted_text`
- Optional Python helper: `software/python` (relative to the task root above)

## What To Deliver
Save exactly one Markdown file here:

- `base/output/audit_report.md`

## Report Requirements
1. Write in English.
2. Report every material inconsistency you can support from the staged documents.
3. For each finding, include:
   - a short English title;
   - a brief explanation of the conflict;
   - original Chinese evidence text;
   - a document name and page-number location marker.
4. Do not invent unsupported issues.
5. If you want to script against the staged files, use `software/python` from the task root.


The agent must:
Read the staged task brief, document manifest, source PDFs, and extracted-text mirrors.
Cross-check the four filings for material factual inconsistencies.
Write exactly one English Markdown audit report to `output/audit_report.md`.
For every finding, include the original Chinese evidence text and a document-plus-page location marker.
Avoid unsupported extra findings.

Software: software/python

Input files:
name: task_brief.md
format: Markdown
description: Agent-visible task instructions and output contract.
name: document_manifest.json
format: JSON
description: Maps the canonical filenames to the original Chinese filings and page counts.
name: source_documents
format: PDF directory
description: The four original staged regulatory filings in PDF form.
name: extracted_text
format: UTF-8 text directory
description: Page-labeled text mirrors of the four filings for reproducible search and citation.