agents-last-exam/agents-last-exam huggingface dataset:
Title: Particle Filter Nonlinear Tracking
Domain: computing_math — Mathematical & Operations Research

Summary: Implement a three-tier particle-filter benchmark in Python, covering a linear-Gaussian validation case, 2D range-bearing tracking, and a coordinated-turn smoother case with Student-t process noise.

Task prompt:
You are working on an Ubuntu coding task about particle filtering for nonlinear tracking.

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 `base/input/problem_spec.md` 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 environment
4. Implement your solver and save it to `base/output/pf_solver.py`
5. Run the solver and write every required artifact under `base/output`

Required outputs under `base/output`:
- `pf_solver.py`
- `tier1_results.npz`
- `tier2_results.npz`
- `tier3_results.npz`
- `results.json`

Requirements:
- Use only Python + NumPy + SciPy. Do not use FilterPy, particles, pyro, Stan, or any state-estimation package.
- Follow the seed, model, and schema requirements in `base/input/problem_spec.md`.
- If you cannot complete Tier 3, still write truthful Tier 1 / Tier 2 outputs and a truthful `results.json` rather than fabricating missing work.
- Do not modify files outside `base/output`.


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.
Implement the solver in `output/pf_solver.py`.
Produce `tier1_results.npz`, `tier2_results.npz`, `tier3_results.npz`, and `results.json` under the writable output directory.
Keep the saved arrays and `results.json` truthful and internally consistent.

Software: Python
NumPy
SciPy
uv

Input files:
name: problem_spec.md
format: Markdown
path: input/problem_spec.md
description: Full public task specification for the three-tier particle-filter benchmark.
name: runtime_env/pyproject.toml
format: TOML
path: input/runtime_env/pyproject.toml
description: Pinned staged runtime manifest for NumPy and SciPy.
name: runtime_env/uv.lock
format: Lockfile
path: input/runtime_env/uv.lock
description: Pinned uv lockfile for the staged solve-time runtime.
name: software/python.sh
format: Shell script
path: software/python.sh
description: Canonical agent-facing Python entry point for the staged task-local runtime.
Title: Enterprise PCAP Triage In Wireshark
Domain: computing_math — Cybersecurity & Digital Forensics

Summary: Analyze a staged enterprise packet capture in Wireshark, identify the compromised internal host, reconstruct the infection chain, and deliver a structured triage report.

Task prompt:
You are a cybersecurity analyst working on a Windows VM.

## Your Task
Use Wireshark to analyze the staged enterprise packet capture and produce a structured triage report.

## Input Files
- PCAP: `base\input\capture_enhanced.pcap`
- Output schema: `base\input\output_schema.json`
- Software notes: `base\software\README.txt`

## Software
- Launch Wireshark from: `C:\Program Files\Wireshark\Wireshark.exe`

## What You Must Do
1. Identify the compromised internal host.
2. Reconstruct the infection chain chronologically.
3. Recover the initial vector and malicious delivery URL.
4. Identify the C2 server information.
5. Extract the required IOC sets.
6. Save one JSON report that follows the visible schema.

## Output Requirements
- Save exactly one file to: `base\output\report.json`
- Filename must be `report.json`
- The JSON must follow the schema in `output_schema.json`


The agent must:
Open the staged packet capture in Wireshark on the Windows VM.
Identify the compromised internal workstation from the network evidence.
Reconstruct the infection timeline in chronological order with the required timestamps and endpoints.
Recover the initial vector, malicious delivery URL, and C2 server details.
Extract the IOC sets required by the visible JSON schema.
Save exactly one schema-valid `report.json` in `output/`.

Software: Wireshark

Input files:
name: Enterprise packet capture
format: PCAP
path: input/capture_enhanced.pcap
description: The staged network capture the agent must inspect in Wireshark.
name: Visible output schema
format: JSON
path: input/output_schema.json
description: Defines the required top-level report fields, nested structures, enums, and date-time formats.
name: Software notes
format: TXT
path: software/README.txt
description: Points the agent to the installed Wireshark GUI and TShark paths on the VM.
Title: Ranking Node Feature Parity Recovery
Domain: computing_math — Software Engineering

Summary: Recover a ranking-service node by rebuilding the feature manifest, deleting only safe rollback debris, and preserving required serving shards.

Task prompt:
You are the on-call ML platform engineer for a Linux ranking-serving node.

The evaluator will prepare a writable task workspace at:
- `/workspace`

Start by reading:
- `/workspace/instruction.md`
- `/workspace/config.json`
- `/workspace/logs/service.log`

You must repair the node by implementing:
- `/workspace/safe_recover.py`

Your tool must:
1. Rebuild the serving feature manifest from authoritative evidence on disk.
2. Free enough space by deleting only safe debris inside `/workspace/cache` and `/workspace/trash`.
3. Produce these files:
   - `/workspace/cleanup_summary.json`
   - `/workspace/incident_report.md`
   - `/workspace/state/feature_manifest.json`

Important constraints:
- Do not touch `/protected`.
- Do not modify files outside the allowed outputs listed in the task instruction.
- Do not delete anything outside `/workspace/cache` and `/workspace/trash`.
- The staged task-local pytest runtime is available via `/workspace/.venv/bin/pytest`.

Notes:
- Runtime dependencies are staged task-locally; do not rely on installing packages globally.


The agent must:

Software: Python 3
pytest

Input files:
Title: Synthetic Causal Structure Inference
Domain: computing_math — Data & Analytics Engineering

Summary: Inspect 40 synthetic tabular datasets, infer each dataset's causal scenario and graph structure, and submit one combined JSON benchmark prediction file.

Task prompt:
You are working on a Linux VM to solve a synthetic causal-structure benchmark.

## Input Files
- Task brief: `base/input/task_brief.md`
- Benchmark prompt: `base/input/AGENT_PROMPT_FOR_SYNTHETIC_CAUSAL_TASK.md`
- Sanitized dataset manifest: `base/input/manifest.json`
- Dataset directories: `base/input/public/dataset_###/`
- Optional runtime manifest: `base/input/runtime_env`
- Optional Python wrapper: `base/software/python_causal_env.sh`

## Optional Python Setup
If you want the staged scientific Python environment, use the wrapper:

```bash
"base/software/python_causal_env.sh" your_script.py
```

That wrapper keeps any created runtime environment under `base/output`.

## Your Task
1. Read `base/input/task_brief.md` and `base/input/AGENT_PROMPT_FOR_SYNTHETIC_CAUSAL_TASK.md`.
2. Read `base/input/manifest.json` to get the full sanitized dataset list.
3. For each dataset directory under `base/input/public`, infer:
   - `scenario`
   - `identification_strategy`
   - `identifiable_effect`
   - `variable_roles`
   - `directed_edges`
   - `latent_confounders`
4. Save one final JSON file at `base/output/submission.json`.

## Output Requirements
- The file must be valid JSON.
- Top-level keys must be `benchmark_name` and `predictions`.
- `benchmark_name` must match the staged benchmark value shown in `base/input/manifest.json`.
- Include exactly one prediction object for every dataset listed in `base/input/manifest.json`.
- Use the sanitized dataset ids from the manifest exactly as written.
- Do not modify files under `base/input`.


The agent must:
Read the staged task brief, benchmark prompt, and sanitized manifest.
Inspect each dataset directory under `input/public/dataset_###/`.
Infer the scenario family, identification strategy, identifiability, variable roles, directed edges, and latent confounders for every dataset.
Write one final `submission.json` containing exactly one prediction object for every sanitized dataset id.

Software: Python
pandas
numpy
statsmodels
scikit-learn
networkx

Input files:
name: Task brief
format: `.md`
path: input/task_brief.md
description: High-level wrapper with output path and runtime notes
name: Benchmark prompt
format: `.md`
path: input/AGENT_PROMPT_FOR_SYNTHETIC_CAUSAL_TASK.md
description: Detailed public benchmark instructions with allowed labels and schema example
name: Sanitized manifest
format: `.json`
path: input/manifest.json
description: Lists the benchmark name and every required sanitized dataset id
name: Dataset bundle
format: directory
path: input/public/
description: Forty dataset directories, each containing `synthetic.csv` and `task.json`
name: Runtime manifest
format: directory
path: input/runtime_env/
description: Optional staged Python environment manifest and lockfile
Title: Tris Crackme
Domain: computing_math — Cybersecurity & Digital Forensics

Summary: Analyze the bundled registration crackme and make the program appear successfully registered.

Task prompt:
Goal:
Solve the registration crackme and make the bundled Windows program appear registered.

Target program:
- Executable: base\input\tris.exe

Requirements:
1. Launch and analyze the program if needed.
2. Make the registration succeed. You can use any method to achieve this, such as reverse engineering, patching, or registry manipulation. Make sure that after restarting the program, it still shows as registered.

Verification:
- Score is 1.0 only if the program shows as registered when launched.

The agent must:
Reverse the bundled registration crackme.
Make the program appear registered, typically by writing the correct registry values.
Leave the registered state persistent across restarts.

Software: Python

Input files:
name: tris.exe
format: Windows PE
path: input/tris.exe
description: agent-visible target
Title: Homework Grading Numerical PDEs 02
Domain: education_info — Educational Technology

Summary: Grade five synthetic graduate numerical-PDE homework submissions from released materials, then emit scores, error tags, per-student feedback, a class summary, and a grader manifest.

Task prompt:
You are grading synthetic graduate numerical-PDE homework submissions on Linux.

Task directory:
- `base`

Visible inputs:
- Instructions: `base/input/TASK_PROMPT.md`
- Released materials: `base/input/released/`
- Starter scaffold: `base/input/starter_project/`

Your task:
1. Read the grading protocol, rubric, solution key, and the five student submissions.
2. Grade each student submission part by part.
3. Assign rubric-aligned error tags where appropriate.
4. Write concise student feedback and a short common-mistakes summary.
5. Save exactly these files under `base/output/`:
   - `grades.csv`
   - `error_tags.csv`
   - `per_student_feedback.json`
   - `common_mistakes_summary.md`
   - `grader_manifest.json`

Rules:
- Treat `input/` as read-only.
- Keep student IDs stable across every output file.
- Use the task-local `software/python` wrapper if you want to script the grading workflow (it `exec`s the preinstalled system Python).
- Write final deliverables only under `output/`.


The agent must:
Read the released grading materials and student submissions.
Produce rubric-aligned grades for all five students.
Assign the appropriate error tags.
Write all five required deliverables under `output/`.

Software: Python

Input files:
name: Released materials
format: Markdown, PDF, JSON
path: input/released/
description: Problem set, rubric, solution key, protocol, and student submissions.
name: Starter scaffold
format: Python + JSON
path: input/starter_project/
description: Benchmark-owned helper scaffold for output formatting and manifest writing.
Title: MARC Remediation FOLIO Overlay
Domain: education_info — Library & Information Science

Summary: Complete a Python starter project that remediates legacy MARC batches, applies cataloging policy rules, and prepares deterministic FOLIO Data Import overlay artifacts.

Task prompt:
You are working on a Linux VM to complete a MARC remediation and FOLIO overlay starter project.

## Task Directory
`base`

## Visible Inputs
- Full prompt: `base/input/TASK_PROMPT.md`
- Harness summary: `base/input/task_spec.md`
- Editable starter project: `base/input/starter_project`
- Visible public case: `base/input/starter_project/input/public_case`
- Software note: `base/software/README.txt`
- Python 3.12 entry point: `base/software/python3.12`

## Your Task
1. Copy `base/input/starter_project` to `base/output/submission`.
2. Implement `scripts/remediate_catalog.py` in the copied project while preserving this CLI:
   `python scripts/remediate_catalog.py --case-dir <case_dir> --output-dir <output_dir>`
3. Use the case files and policy rules to remediate MARC records, choose FOLIO overlay actions, and emit all required output artifacts.
4. Run the CLI on the visible public case before finishing:
   `base/software/python3.12 scripts/remediate_catalog.py --case-dir input/public_case --output-dir outputs/public_case`

## Final Deliverable
Leave the completed project at:

`base/output/submission`

Do not modify files under `base/input`. Write final work only under `base/output`.


The agent must:
Copy `input/starter_project/` to `output/submission/` before editing.
Preserve the CLI contract: `python scripts/remediate_catalog.py --case-dir <case_dir> --output-dir <output_dir>`.
Apply the visible cataloging policy uniformly to MARCXML/MRK records, FOLIO matches, authority mappings, and 949 holdings/item data.
Write `remediated_records.xml`, `overlay_decisions.csv`, `folio_import_plan.json`, `qa_report.json`, and `remediation_summary.md` under `output/submission/outputs/public_case/`.

Software: Python

Input files:
name: TASK_PROMPT.md
format: Markdown
path: input/TASK_PROMPT.md
description: Full agent-facing task prompt.
name: task_spec.md
format: Markdown
path: input/task_spec.md
description: Harness-facing summary of the expected starter-copy workflow and output location.
name: starter_project
format: Python project directory
path: input/starter_project/
description: Editable starter project with public MARC/FOLIO case files and a stub remediation CLI.
name: README.txt
format: Text
path: software/README.txt
description: Stage 1 software note stating that the workflow is Python stdlib-only.
name: python3.12
format: Shell wrapper
path: software/python3.12
description: Stage 4-verified Python 3.12.13 runtime entry point.
Title: Yi Manuscript Translation 1
Domain: education_info — Translation & Localization

Summary: Inspect a classical Yi manuscript image, identify which glyph a phonetic gloss refers to, localize that glyph, and write a cited translation report from bundled source texts.

Task prompt:
You are analyzing a classical Yi manuscript image on a Windows VM.

## Task Folder
`base`

## Visible Input Files
- Question: `base\input\question.txt`
- Manuscript image: `base\input\inscription.png`
- Bundled source texts: `base\input\reference_materials\`

## Software
- Image launcher: `base\software\launch_viewer.cmd`
- Use any plain-text editor already present on the VM for the final report and JSON output

## What You Must Do
1. Read `question.txt` to understand the task.
2. Open the manuscript image with `software\launch_viewer.cmd` and inspect the phonetic gloss in the upper-left margin.
3. Determine which single glyph the gloss refers to by combining image inspection with the bundled `reference_materials`.
4. Save a bounding box for that glyph exactly to `base\output\bounding_box.json`.
5. Write a structured plain-text report exactly to `base\output\report.txt`.

## Output Requirements
- `bounding_box.json` must be UTF-8 JSON with integer keys `x1`, `y1`, `x2`, `y2`
- Coordinates must use the original image pixels, not screenshot coordinates
- `report.txt` must contain these seven section headers exactly:
  `EXAMINATION`
  `SOURCE IMAGE`
  `TECHNIQUE`
  `IDENTIFICATION OF TARGET CHARACTER POSITION`
  `REFERENCE MATERIALS CONSULTED`
  `TRANSLATION`
  `IMPRESSION`
- Do not use the internet or external sources; rely only on the bundled files

The agent must:
Read `input/question.txt` and inspect the staged `input/inscription.png` image via `software/launch_viewer.cmd`.
Determine which glyph the phonetic gloss refers to by using only the bundled `input/reference_materials/` files.
Write `output/bounding_box.json` with integer pixel coordinates for the target glyph.
Write `output/report.txt` with the seven required sections and a cited translation.

Software: Windows Image Viewer
Text Editor

Input files:
name: Task brief
format: `.txt`
path: input/question.txt
description: Explains the manuscript-inspection and reporting task.
name: Manuscript image
format: `.png`
path: input/inscription.png
description: Classical Yi manuscript image containing the glossed glyph.
name: Reference materials
format: directory of `.txt` files
path: input/reference_materials/
description: Bundled source texts the agent may search and cite.
Title: Analog Active
Domain: engineering — Electronics Engineering

Summary: Design and simulate the required analog circuit in LTspice from the staged specification and deliver the completed schematic output.

Task prompt:
You are given an LTspice schematic with the LTM4648 µModule DC/DC buck regulator IC already         placed on the canvas. Your task is to complete the circuit design by adding all required external components,         wiring them to the correct IC pins, and running a transient simulation to verify the output.

        Existing File Structure:
        Analog_Active_v1\
        ├── input\
        │   └── design_spec.txt               # Design specification
        │   └── ltm4648_datasheet.pdf         # Datasheet for LTM4648 IC
        └── output\
            └── circuit.asc                    # LTspice schematic with LTM4648 IC (open in LTspice)

        Design Specification:
        - IC: LTM4648 µModule DC/DC Buck Regulator
        - Input Voltage: 5.0V
        - Output Voltage: 1.5V
        - Output Current: 10.0A
        - Output Ripple: < 30.0mV peak-to-peak
        - Startup Settling Time: Output must reach 1.5V within ~0.6ms
        - Simulation: Transient analysis, 1ms duration, with startup.

        Component Value Formats (use these exact formats in LTspice):
        - Voltage source: Set value to "5.0" (plain number, no suffix)
        - Resistors: Use plain numeric values (e.g., "5700" not "5.7k", "0.19" not "190m")

        Environment:
        - LTspice is open with circuit.asc loaded, showing the LTM4648 µModule IC on the canvas
        - The output node is pre-labeled "out"

        Once the circuit is complete:
        1. Save the schematic (Ctrl+S) to ensure circuit.asc is updated
        2. Run the transient simulation to verify output behavior
        3. Save a screenshot of the completed schematic using save_milestone_screenshot(path="Analog_Active_v1\output\schematic_screenshot.png")

        Do not ask for confirmation. Execute each step directly.

The agent must:
Open the staged LTspice starter schematic for the active variant.
Read the design specification and LTM4648 datasheet to choose the required external component values and wiring.
Complete the buck-converter schematic, add a `1 ms` startup transient analysis, save the updated `circuit.asc`, and run simulation.
Keep the generated `circuit.raw` plus a schematic screenshot under `output/`.

Software: Python

Input files:
name: design_spec.txt
format: text
path: input/design_spec.txt
description: Active-variant targets for VIN, VOUT, load current, ripple, and startup behavior
name: ltm4648_datasheet.pdf
format: PDF
path: input/ltm4648_datasheet.pdf
description: Reference datasheet for the staged regulator
Title: ABB IRB6700 Asset To URDF
Domain: engineering — Robotics & Autonomous Systems

Summary: Reconstruct a complete ABB IRB6700 robot URDF from staged mesh assets and structural metadata. The agent must preserve the required links, joints, limits, mimic behavior, and auxiliary frames while producing exactly one valid `submission.urdf` file.

Task prompt:
You are reconstructing a robot URDF on a Linux VM.

## Variant
`base`: ABB IRB6700 URDF reconstruction

## Input Files
- Mesh assets: `base/input/meshes`
- Structural metadata: `base/input/metadata`
- Task brief: `base/input/task_brief.md`

## What You Must Do
1. Read `base/input/task_brief.md`.
2. Use the mesh assets and metadata under `base/input` to reconstruct the ABB IRB6700 robot as a URDF.
3. Save exactly one final file at `base/output/submission.urdf`.

## Output Requirements
- The file must be named `submission.urdf`.
- The file must be valid XML/URDF.
- Preserve the required link names, joint names, kinematic tree, joint limits, mimic rules, and auxiliary frames.
- Reference meshes under the staged `meshes/` directory.
- Do not place the final answer anywhere outside `base/output`.


The agent must:
1. Read the staged task brief and inspect the ABB IRB6700 meshes plus metadata.
2. Reconstruct a valid URDF with the required links, joints, limits, mimic behavior, and auxiliary frames.
3. Save exactly one final file named `submission.urdf` under `output/`.

Software: Python

Input files:
name: meshes/
format: stl directory
path: input/meshes/
description: Visual and collision STL meshes for the ABB IRB6700 links.
name: link_manifest.json
format: json
path: input/metadata/link_manifest.json
description: Lists the required mesh-bearing and auxiliary links.
name: joint_manifest.json
format: json
path: input/metadata/joint_manifest.json
description: Lists the required joints and their joint types.
name: kinematic_tree_hint.json
format: json
path: input/metadata/kinematic_tree_hint.json
description: Defines the required parent-child tree edges.
name: joint_limits.csv
format: csv
path: input/metadata/joint_limits.csv
description: Normalized joint limits for the actuated joints.
name: mimic_rules.json
format: json
path: input/metadata/mimic_rules.json
description: Defines the required mimic-joint source and multiplier rules.
name: task_brief.md
format: markdown
path: input/task_brief.md
description: Agent-visible solve-time brief with the output contract and constraints.