agents-last-exam/agents-last-exam huggingface dataset:
Title: Low-Thrust LEO To GEO Trajectory
Domain: engineering — Aerospace & Mechanical Engineering

Summary: Compute a three-tier orbital transfer from inclined low Earth orbit to geostationary orbit using analytic, numerical low-thrust, and optimal-control methods.

Task prompt:
You are working on a Linux VM.

Task root:
- `base`

Visible files:
- Problem specification: `base/input/problem_spec.md`
- Task prompt: `base/input/task_prompt.md`
- Output contract: `base/input/output_contract.json`
- Python runtime manifest: `base/input/runtime_env/pyproject.toml`
- Task-scoped Python entry point: `base/software/python`
- uv entry point: `base/software/uv`

Required output directory:
- `base/output`

Read the staged problem specification and output contract, then create the required result and trajectory files directly under the output directory. Use `base/software/python` for Python/NumPy/SciPy work. If the task-scoped Python runtime is missing, use `base/software/uv` and `base/input/runtime_env/pyproject.toml` to create or repair it under `base/.runtime_env`. Do not modify files under `base/input`.


The agent must:
1. Compute the Tier 1 Hohmann transfer quantities.
2. Integrate the Tier 2 continuous tangential low-thrust spiral and save the required trajectory array.
3. Solve the Tier 3 fixed-time low-thrust transfer with inclination change and save the required trajectory and control arrays.
4. Write `output/results.json` with the required `tier1`, `tier2`, and `tier3` sections.
5. Save `output/tier2_trajectory.npy`, `output/tier3_trajectory.npy`, and `output/tier3_control.npy` with the required schemas.

Software: Python
uv
NumPy
SciPy

Input files:
name: problem_spec.md
format: md
path: input/problem_spec.md
description: Full low-thrust LEO-to-GEO problem statement with formulas, state definitions, and output requirements.
name: task_prompt.md
format: md
path: input/task_prompt.md
description: Concise instruction listing the required output files and the task-scoped Python/uv entry points.
name: output_contract.json
format: json
path: input/output_contract.json
description: Machine-readable schema for the required output files.
name: pyproject.toml
format: toml
path: input/runtime_env/pyproject.toml
description: Pinned runtime dependency manifest for NumPy and SciPy.
Title: Cailian Road Highway Alignment
Domain: engineering — Civil, Architectural & Geospatial Engineering

Summary: Use AutoCAD Civil 3D 2024 to design a Cailian Road horizontal alignment, generate an existing-ground surface profile, and export station-sampled alignment metrics.

Task prompt:
You are a civil engineer using AutoCAD Civil 3D 2024 on Windows.

## Your Task
Design a horizontal alignment for Cailian Road and generate a vertical profile that follows the existing ground surface.

## Control Points
- Start: X = -52093.6660, Y = -5836.2683, Z = 5.5
- End:   X = -50855.6202, Y = -4142.4687, Z = 5.3
- Both endpoints must be connected within 0.5 m.

## Design Constraints
- Minimum curve radius: 85.0 m
- Minimum spiral length (if spirals are used): 25.0 m
- Design speed: 30 km/h
- Total alignment length: 1800.0 m - 2400.0 m
- The alignment should include at least 2 horizontal curves to form a meaningful highway design.

## Steps
1. Open `base\input\topo_surface.dwg` - the existing-ground TIN surface.
2. Create a horizontal Alignment between the start and end control points, respecting the design constraints above.
3. Use *Create Profile from Surface* to generate the raw existing-ground profile along the alignment. Do NOT edit the profile.
4. Save the drawing with the alignment and profile to: `base\output\alignment.dwg`
5. Export alignment metrics at 20 m station intervals to: `base\output\alignment_metrics.tsv`
   - TSV columns must be exactly: Station, X, Y, Z
   - Z values must be the surface elevations at each (X, Y) point.

## Software
- Launch Civil 3D from: `base\software\open_civil3d_2024.bat`

## Output
- Save alignment drawing to: `base\output\alignment.dwg`
- Save metrics TSV to: `base\output\alignment_metrics.tsv`
- Keep all work inside `base\output`

The agent must:
Launch AutoCAD Civil 3D 2024 through the staged task-local launcher.
Open the staged `input/topo_surface.dwg` existing-ground TIN surface.
Create a non-trivial Cailian Road horizontal alignment that connects the fixed control points and satisfies the stated curve, spiral, speed, and total-length constraints.
Generate an unedited existing-ground profile from the surface along the alignment.
Save `output/alignment.dwg` and export `output/alignment_metrics.tsv` with 20 m stations and columns `Station`, `X`, `Y`, `Z`.

Software: Autodesk Civil 3D 2024

Input files:
name: topo_surface.dwg
format: Autodesk DWG
path: input/topo_surface.dwg
description: Existing-ground TIN surface for the Cailian Road corridor.
name: open_civil3d_2024.bat
format: Windows batch script
path: software/open_civil3d_2024.bat
description: Task-local launcher for the installed and licensed AutoCAD Civil 3D 2024 application.
Title: Chisel-to-Verilog Source Location Alignment
Domain: engineering — Semiconductor & Microelectronics Design

Summary: Given a Chisel hardware design (Fifo.scala) and its firtool-optimized SystemVerilog output, identify the exact set of Chisel source locations that a specific sub-expression semantically corresponds to.

Task prompt:
You are a hardware design engineer specializing in Chisel and SystemVerilog.

## Your Task

Given a Chisel hardware design (Fifo.scala) and its firtool-optimized SystemVerilog output, identify the exact set of Chisel source locations (Fifo.scala:line:col) that a specific sub-expression of the optimized Verilog semantically corresponds to.

The optimized Verilog's @[...] source-location comment is both noisy (lists unrelated locations) and incomplete (misses real locations), so answering requires genuine analysis — not comment-reading.

## Working Directory

All materials are under: `base/input/workdir/`

- `TASK.md` — detailed instructions and rules
- `src/main/scala/Fifo.scala` — original Chisel source (DoubleBuffer FIFO, 87 lines)
- `generated/optimized.sv` — firtool emission (target: line 21, sub-expression `stateReg == 2'h2`)
- `generated/DoubleBufferFifo.fir` — FIRRTL intermediate (you may regenerate alternative emissions)

## Tools Available

Use the canonical task-local CLI entry points under `base/software/`:

- `base/software/yosys` — Yosys 0.33+
- `base/software/firtool` — CIRCT firtool 1.138.0
- `base/software/sbt` — sbt 1.9.9 with Chisel 6.5.0 dependencies prewarmed
- `base/software/python` — Python 3.10
- `base/software/jq` — jq 1.x

The VM has no internet access during solve time.

## Rules

1. Do NOT edit any file under `src/`, `generated/`, or `TASK.md`. Writes are only allowed under the task output directory.
2. Focus on the sub-expression `stateReg == 2'h2` at line 21, columns 23-39 of optimized.sv.
3. Approach is unconstrained (formal verification, simulation, semantic analysis — whatever works).

## Output

Write a single file: `base/output/answer.json`

```json
{
  "target_signal": "stateReg == 2'h2",
  "target_location_in_optimized_sv": "21.23-39",
  "chisel_sources": ["Fifo.scala:<L1>:<C1>", ...]
}
```


The agent must:
Read TASK.md for the detailed query
Examine Fifo.scala and optimized.sv
Perform genuine semantic analysis (not just read annotations)
Write output/answer.json with the correct chisel_sources set

Software: Yosys 0.33+
firtool 1.138.0 (CIRCT)
sbt 1.9+ with Chisel 6.5.0
Python 3.10

Input files:
name: Task instructions
format: md
path: input/workdir/TASK.md
description: Restates the query and includes firtool annotation noisiness disclaimer
name: Chisel source
format: scala
path: input/workdir/src/main/scala/Fifo.scala
description: Original Chisel source — DoubleBuffer FIFO with 3-state enum
name: Optimized SystemVerilog
format: sv
path: input/workdir/generated/optimized.sv
description: firtool-optimized emission; target line 21 contains stateReg == 2'h2
name: FIRRTL intermediate
format: fir
path: input/workdir/generated/DoubleBufferFifo.fir
description: FIRRTL intermediate for optional re-emission via firtool
Title: gcode
Domain: engineering — Manufacturing & Industrial Systems

Summary: Create machining toolpaths for the staged workpiece in PowerMill and deliver the required NC output.

Task prompt:
You are a CAM (Computer-Aided Manufacturing) engineer using Autodesk PowerMill.

## Your Task
Design toolpaths to machine workpiece **125162_319** using the provided blank PowerMill project.

## Input Files
- **PowerMill project** (blank, with pre-configured tools, zero toolpaths):
  `125162_319\input\125162-319-NCFM-T`
- **Ideal workpiece geometry** (.prt format): `125162_319\input\125162_319.prt`
- **Reference image**: `125162_319\input\125162_319.jpg`

## What You Must Do
1. Copy the PowerMill project from `125162_319\input\125162-319-NCFM-T` to `125162_319\output\125162-319-NCFM-T`
   (work on the copy so the original stays intact)
2. Open PowerMill from `125162_319\software\PowerMill 2025.lnk` and load the copied project at:
   `125162_319\output\125162-319-NCFM-T`
3. Study the ideal workpiece geometry (.prt file) to understand the target shape.
   The copied PowerMill project already contains the machine, stock, tool library,
   and workpiece setup; the `.prt` file is an external geometry reference.
4. Design toolpaths that will machine the workpiece from raw stock:
   - Use roughing toolpaths to remove bulk material
   - Use finishing toolpaths for surfaces requiring higher precision
   - Use the pre-configured tools already in the project (do NOT create new tools)
5. **Critical**: Ensure each toolpath has NO collisions and NO gouging
6. Run a stock model simulation to confirm the final result
7. **Save** the PowerMill project (Ctrl+S)

## Color Coding on the Workpiece
The .prt file has faces colored by precision requirement:
- Tight tolerance faces (e.g., VDI12/15): require finer finish toolpaths
- Loose tolerance faces (e.g., spray/texture faces): standard finish is acceptable

## Quality Requirements
- The stock simulation must complete without collisions or gouging
- The machined geometry must reproduce the supplied `.prt` target accurately
- Keep critical finished surfaces within 0.3 mm and all modeled surfaces within 2.0 mm

## Important
- Work ONLY within the project at `125162_319\output\125162-319-NCFM-T`
- Do NOT move or rename the project folder
- SAVE your project when finished

The agent must:
Open the staged blank PowerMill project for the selected workpiece.
Review the staged `.prt` geometry and `.jpg` visual reference.
Design roughing and finishing toolpaths using the preconfigured tool library.
Ensure the toolpaths have no collisions and no gouges.
Run a stock-model simulation in PowerMill.
Save the modified project inside `output/`.

Software: Python

Input files:
name: Blank PowerMill project
format: directory
path: input/<PM_PROJECT_NAME>/
description: cloned from the expert PM project with all toolpaths and stock models removed
name: Ideal workpiece geometry
format: `.prt`
path: input/<variant_name>.prt
description: agent-visible target geometry; colored faces communicate tolerance intent
name: Workpiece preview
format: `.jpg`
path: input/<variant_name>.jpg
description: visual reference image
Title: Humanoid Velocity Tracking Policy
Domain: engineering — Robotics & Autonomous Systems

Summary: Produce a deterministic Isaac Lab humanoid locomotion policy that tracks commanded planar velocities and satisfies fixed API, stability, and rollout metric gates.

Task prompt:
You are producing a policy submission for an Isaac Lab humanoid velocity-tracking benchmark.

## Variant
`base`: Humanoid velocity tracking policy

## Input Files
- Task brief: `base\input\task_brief.md`
- Success criteria and exact evaluation command: `base\input\SUCCESS.md`
- Observation/action ordering: `base\input\PROPRIO_SPEC.md`
- Robot asset and articulation config: `base\input\assets`
- Evaluation harness: `base\input\eval`
- Starter template: `base\input\submission_template`

## What You Must Do
1. Read the staged task brief, proprioceptive-state spec, and success criteria.
2. Train, distill, hand-author, or otherwise produce a deterministic policy that implements the required `Policy` API.
3. Save exactly two files in `base\output`: `policy.py` and `checkpoint.pt`.

## Output Requirements
- `policy.py` must define `Policy(checkpoint_path: str, device: str)`.
- `Policy.inference(obs)` must return exactly `{"action": tensor}`.
- The action tensor must have shape `(N, 23)`, dtype `torch.float32`, and live on the same device as `obs["command"]`.
- Do not write final answers outside `base\output`.

The agent must:
Read the staged task brief, proprioceptive-state spec, and success criteria.
Produce a deterministic `Policy` implementation that maps `(command, state)` tensors to 23 humanoid joint actions.
Save exactly `policy.py` and `checkpoint.pt` in the runtime output directory.

Software: Isaac Lab
Isaac Sim
PyTorch
CUDA

Input files:
name: task_brief.md
format: md
path: input/task_brief.md
description: Agent-facing summary of the policy submission task.
name: SUCCESS.md
format: md
path: input/SUCCESS.md
description: Hard gates, reference evaluation command, metrics, and acceptance thresholds.
name: PROPRIO_SPEC.md
format: md
path: input/PROPRIO_SPEC.md
description: Fixed observation vector and 23-DOF action ordering.
name: assets/
format: directory
path: input/assets/
description: Humanoid URDF, meshes, and articulation configuration.
name: eval/
format: directory
path: input/eval/
description: Isaac Lab evaluation environment and `run_eval.py` entry point.
Domain: engineering — Robotics & Autonomous Systems

Summary: Run mjlab whole-body-control rollouts for 8 Unitree G1 humanoid policy cases, classify each as successful/nearly_successful/failed, and emit a schema-conformant `policy_evaluation_report.json` with per-case visual demo artifacts.

Task prompt:
You are evaluating whole-body-control policy rollouts for a Unitree G1 humanoid in mjlab.

## Variant
``: 

## Input Files
- Task brief: `/input/task_brief.md`
- Policy case list: `/input/policy_cases.json`
- Required JSON output schema: `/input/output_schema.json`
- mjlab runtime archive and exported package list: `/input/runtime_env`
- Offline motion and checkpoint archives: `/input/runtime_env/motions-1.zip`
  and `/input/runtime_env/policies.zip`

## What You Must Do
1. Inspect the 8 policy cases in `/input/policy_cases.json`.
2. Use mjlab and the listed `play_command` or `video_command` values to observe
   each policy against its reference motion. The runtime archive, motion files,
   and policy checkpoints are staged under `/input/runtime_env` if you
   need to install mjlab locally on the VM.
3. For each case, save a visible motion demo artifact. The supplied
   `video_command` adds mjlab's existing `--video` flag; mjlab writes those
   videos under the run/checkpoint log directory, so copy or rename the
   recorded artifact into `/output/visual_demos`.
4. Classify every case as exactly one of `successful`, `nearly_successful`, or
   `failed`, using the definitions in `/input/task_brief.md`.
5. Save the final JSON report at `/output/policy_evaluation_report.json` and one visible motion
   demo artifact per case under `/output/visual_demos`.

## Output Requirements
- The final answer must include `policy_evaluation_report.json` and a
  `visual_demos/` directory.
- It must validate against `/input/output_schema.json`.
- Include all 8 case IDs exactly once.
- Preserve the exact `case_id`, `motion`, `mjlab_task`, `motion_file`, and `checkpoint_file`
  values from `/input/policy_cases.json`.
- Each evaluation item must include `evidence.visual_demo_path`, pointing to a
  visible playback artifact under `visual_demos/`. Accepted formats are
  `.mp4`, `.webm`, `.gif`, and `.html`.
- Do not write final answers outside `/output`.


The agent must:

Software: mjlab
MuJoCo
PyTorch
wandb

Input files:
Title: KiCad Navswitch Library Integration
Domain: engineering — Electronics Engineering

Summary: Repair a SparkFun Qwiic Navigation Switch KiCad project by restoring the local symbol and footprint integration for U4 and producing release artifacts.

Task prompt:
You are repairing a KiCad project for the SparkFun Qwiic Navigation Switch board.

## Input
- Broken KiCad project: `input/project/SparkFun_Qwiic_Navigation.kicad_pro`
- Project files and local libraries: `input/project`
- Datasheets: `input/datasheets`
- KiCad launcher: `software/OpenKiCad.bat`

## Your Task
1. Open the project in the KiCad desktop UI.
2. Inspect U4 (`PCA9554`) and the project-local symbol/footprint libraries.
3. Restore U4's schematic Footprint field to the correct project-local footprint.
4. Update the PCB from the schematic so U4 is restored to the board.
5. Save the repaired KiCad project and leave it release-ready.
6. Do not change circuit intent, non-target component values, non-target footprint assignments, unrelated nets, board outline, connectors, or mounting holes.
7. Do not solve this by directly editing raw KiCad source text files.

## Required Deliverables
Save all deliverables under `output/`, including the repaired KiCad project files, local symbol and footprint libraries, ERC/DRC reports, netlist, fabrication outputs, `board.xml`, and `board.d356`.

The agent must:
Use KiCad UI to inspect and repair the project.
Restore U4's footprint assignment to the correct project-local footprint.
Update the PCB from the schematic and preserve unrelated design intent.
Export the required project, library, ERC/DRC, netlist, Gerber, drill, XML, and D356 deliverables.

Software: KiCad
Python

Input files:
name: SparkFun_Qwiic_Navigation project
format: KiCad project
path: input/project/
description: Broken KiCad project and local libraries.
name: datasheets
format: directory
path: input/datasheets/
description: Reference datasheets for the board components.
name: OpenKiCad.bat
format: batch
path: software/OpenKiCad.bat
description: Launcher for opening KiCad on the VM.
Title: OpenROAD SKY130 Ibex PnR Signoff
Domain: engineering — Semiconductor & Microelectronics Design

Summary: Tune the lowRISC Ibex SKY130HD OpenROAD-flow-scripts configuration, rerun the pinned Docker flow, and submit the final config plus pass-audit evidence needed for signoff review.

Task prompt:
You are working on Linux on an RTL-to-GDSII signoff-closure task for lowRISC ibex on sky130hd.

## Task Root
- `base`

## Visible Inputs
- Task brief: `base/input/task_instructions.md`
- Starter tree: `base/input/starter_project`
- Workspace helper: `base/software/prepare_workspace.sh`

## What You Should Do
1. Read `base/input/task_instructions.md`.
2. Create a writable workspace by running:
   `bash base/software/prepare_workspace.sh`
3. Work only inside `base/output/workspace`.
4. Tune only the allowed files described in the staged task brief.
5. When finished, copy the required deliverables into `base/output`.

## Final Deliverables
- `base/output/config.mk`
- `base/output/JOURNAL.md`
- `base/output/flow/logs/sky130hd/ibex/base/config.mk.pass*` if any completed pass exists
- `base/output/flow/logs/sky130hd/ibex/base/pass*.stamp` if any completed pass exists

Do not modify files under `base/input`.


The agent must:
Read the staged task brief and create a writable workspace with `software/prepare_workspace.sh`.
Edit only `output/workspace/flow/designs/sky130hd/ibex/config.mk` and `output/workspace/JOURNAL.md`.
Run the pinned OpenROAD-flow-scripts Docker flow from the writable workspace.
Copy `config.mk`, `JOURNAL.md`, and any completed-pass audit files into `output/`.

Software: OpenROAD-flow-scripts
Docker
Python

Input files:
name: task_instructions.md
format: Markdown
path: input/task_instructions.md
description: Staged task brief defining the allowed edits, pass budget, and required handoff files.
name: starter_project
format: directory
path: input/starter_project
description: Read-only OpenROAD starter tree copied into the agent's writable workspace before tuning.
name: prepare_workspace.sh
format: shell script
path: software/prepare_workspace.sh
description: Helper that creates `output/workspace/` from the staged starter tree.
Title: Mini Encabulator KiCad PCB Layout
Domain: engineering — Electronics Engineering

Summary: Create a routed KiCad PCB layout from the staged Mini Encabulator schematic.

Task prompt:
You are designing a KiCad PCB layout for a Mini Encabulator.

## Input
- Schematic: `base\input\mini_encabulator.kicad_sch`
- KiCad launcher: `base\software\OpenKiCad.bat`

## Your Task
1. Open the schematic in KiCad and create a PCB layout from it.
2. Import all assigned footprints from the schematic.
3. Place all components for a compact board sized for an SN25 Polycase enclosure.
4. Add exactly four M3 mounting holes on a 1.575 inch by 1.26 inch rectangular spacing pattern.
5. Draw the board outline on `Edge.Cuts`.
6. Route all electrical connections.
7. Add GND copper zones on both `F.Cu` and `B.Cu`, fill them, and add ground stitching vias.
8. Run KiCad DRC and resolve all errors and unconnected items.

## Output
Save the final board layout as:
`base\output\mini_encabulator.kicad_pcb`

The agent must:
Open the staged Mini Encabulator schematic in KiCad.
Create and complete a PCB layout from the assigned footprints.
Add the required board outline, mounting holes, routed traces, GND pours, and stitching vias.
Run DRC and save the final .kicad_pcb output.

Software: KiCad

Input files:
name: mini_encabulator.kicad_sch
format: KiCad schematic
path: input/mini_encabulator.kicad_sch
description: Agent-visible schematic with assigned footprints
Title: Blender Tabletop Workspace Reconstruction
Domain: engineering — 3D, Animation & Interactive Media

Summary: Reconstruct a tabletop robotic-manipulation workspace in Blender from a floor plan, a reference render, and staged mesh assets, then save the scene, render a verification image, and export the required OBJ files.

Task prompt:
You are a robotics-focused 3D scene artist using Blender.

Your task is to reconstruct a tabletop robotic-manipulation workspace from staged assets.

Agent-visible inputs:
- Export contract: `base\input\export_spec.json`
- Floor plan: `base\input\floor_plan.png`
- Reference render: `base\input\reference_render.png`
- Mesh assets: `base\input\meshes`

Software:
- Launch Blender through the staged task-local wrapper: `base\software\run_blender_portable.ps1`

Required outputs under `base\output`:
- `scene.blend`
- `verification_render.png`
- `mustard_bottle.obj`
- `mug.obj`
- `potted_meat_can.obj`
- `full_scene.obj`

Requirements:
- Use the floor plan for explicit spatial values and camera setup
- Infer rotations, materials, and lighting from the reference render
- Keep the coordinate system z-up and 1 Blender unit = 1 meter
- Save the rendered image as `verification_render.png`


The agent must:
Reconstruct the tabletop manipulation scene in Blender using the floor plan, reference render, and staged mesh assets.
Place the table and three YCB objects at the positions specified by the visible floor plan.
Infer rotations, materials, and lighting from the reference render.
Save `scene.blend`, render `verification_render.png`, and export `mustard_bottle.obj`, `mug.obj`, `potted_meat_can.obj`, and `full_scene.obj`.

Software: Blender

Input files:
name: export_spec.json
format: JSON
path: input/export_spec.json
description: Defines the required render and export filenames.
name: floor_plan.png
format: PNG image
path: input/floor_plan.png
description: Provides explicit spatial values for object placement, table dimensions, and camera setup.
name: reference_render.png
format: PNG image
path: input/reference_render.png
description: Visible visual target used to infer rotations, materials, and lighting.
name: meshes/
format: OBJ assets
path: input/meshes/
description: Source geometry for the table and three YCB objects.