Kk2406/Ll huggingface dataset:
Atwood 2022 Measles Vaccine Coefficient Reproduction
Domain: social_sciences — Economics & Quantitative Social Research

Summary: Reproduce the six Table 2 vaccination-effect coefficient estimates from Atwood (2022) using the published paper, appendix, and archived replication package.

Task prompt:
You are working on a Linux VM as an applied-economics replication analyst.

## Task Directory
`base`

## Visible Inputs
- Task prompt: `base/input/TASK_PROMPT.md`
- Published paper: `base/input/paper.pdf`
- Online appendix: `base/input/paper-online-appendix.pdf`
- Archived replication package: `base/input/replication_package.zip`
- Task metadata: `base/input/task.json`
- Environment manifest: `base/input/environment_manifest.json`
- Allowed repairs: `base/input/allowed_repairs.json`
- Output schemas/examples: `base/input/output_schemas`

## Your Task
Use the staged public materials to reproduce the coefficient report for Alicia Atwood (2022), Table 2, row "Vaccination effect".

Write all final files under `base/output`:
- `execution_log.txt`
- `repair_log.json`
- `paper_coefficients.json`
- `code_coefficients.json`
- `coefficient_matches.csv`
- `verdict.json`

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`.

Required actions:
Read the paper, online appendix, task metadata, and archived replication package.
Extract the six Table 2 "Vaccination effect" point estimates.
Inspect or run the replication package enough to report corresponding code coefficients.
Write the six required structured output files under the runtime output directory.

Software: Python
PDF tools
unzip

Input files:
name: TASK_PROMPT.md
format: md
description: Detailed solve-time instructions and output contract.
name: paper.pdf
format: pdf
description: Published Atwood (2022) paper.
name: paper-online-appendix.pdf
format: pdf
description: Online appendix for the paper.
name: replication_package.zip
format: zip
description: Archived author replication package.
name: output_schemas
format: json/csv
description: Schemas and sanitized examples for required deliverables.
Hangzhou Metro Passenger Simulation
Domain: transport_safety — Urban & Spatial Planning

Summary: Simulate one operating day of Hangzhou metro passenger trips from staged AFC demand, GIS, and network configuration inputs.

Task prompt:
You are working on a Linux VM to produce a one-day Hangzhou metro passenger simulation output bundle.\n\n## Variant\n`base`: Hangzhou metro daily AFC simulation bundle\n\n## Visible Input Files\n- task prompt: `base/input/task_prompt.md`\n- output contract: `base/input/output_contract.json`\n- AFC demand: `base/input/data/afc_hangzhou.csv`\n- line GeoJSON: `base/input/gis/hangzhou_lines.json`\n- station GeoJSON: `base/input/gis/hangzhou_stations.json`\n- station sequence CSV: `base/input/network_config/station_sequence.csv`\n- operation parameters JSON: `base/input/network_config/operation_parameters.json`\n- runtime manifest: `base/input/runtime_env/`\n\n## Runtime Entry Points\n- bootstrap helper: `base/software/bootstrap_uv_env.sh`\n- python helper: `base/software/python_with_task_deps.sh`\n\n## What You Must Do\n1. Read the staged task prompt and output contract.\n2. Use the staged AFC, GIS, and network configuration files to simulate metro passenger trips.\n3. Write `base/output/passenger_records.csv`.\n4. Write `base/output/validation_report.txt`.\n5. You may also write `base/output/scatter_plot.png`.\n\n## Output Requirements\n- `passenger_records.csv` columns must be exactly: `card_id,o_station,d_station,start_time,end_time_simulate,transfer_times,end_time_real,duration_simulation,duration_real`\n- keep trip identity aligned to the visible AFC rows\n- keep final deliverables at the output-directory root\n

Required actions:
Read the staged task prompt and output contract from `input/`.
Build a one-day Hangzhou metro passenger simulation from the AFC, GIS, and network configuration inputs.
Write `passenger_records.csv` and `validation_report.txt` into `output/` with the required schema.
Use the staged runtime manifest only if extra Python dependencies are needed.

Software: Python
uv
geopandas
matplotlib
networkx
numpy
pandas

Input files:
name: afc_hangzhou.csv
format: CSV
description: Visible AFC trip records for one operating day.
name: hangzhou_lines.json
format: GeoJSON
description: Hangzhou metro line geometry features.
name: hangzhou_stations.json
format: GeoJSON
description: Hangzhou metro station features.
name: station_sequence.csv
format: CSV
description: Ordered station sequences by line and direction.
name: operation_parameters.json
format: JSON
description: Simulation and routing parameters for the metro task.
name: runtime_env/
format: uv Python environment manifest
description: Agent-installable dependency manifest for optional Python tooling.
Capacitated Vehicle Routing Problems
Domain: transport_safety — Mathematical & Operations Research

Summary: Generate VRPLIB-format near-best-known CVRP solutions for three selected benchmark instances.

Task prompt:
You are working on a Linux VM.

## Your Task
Build a reproducible CVRP-solving workflow and generate VRPLIB-format solutions for exactly three selected instances.

## Visible Inputs
- Problem specification: `base/input/problem_spec.md`
- Instance directory: `base/input/instances/`
- Runtime manifest: `base/input/runtime_env/pyproject.toml`
- Runtime lockfile: `base/input/runtime_env/uv.lock`
- Python wrapper: `base/software/python_cvrp_env.sh`

## What You Must Produce
Write these required files:
- `base/output/solutions/M-n101-k10.sol`
- `base/output/solutions/X-n101-k25.sol`
- `base/output/solutions/X-n106-k14.sol`

You may also write helper scripts and logs anywhere under `base/output`.

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


Required actions:
Inspect the three staged `.vrp` files and implement a CVRP-solving workflow.
Use the staged wrapper if needed to run Python with the pinned task runtime.
Write the three required `.sol` files under `output/solutions/`.

Software: Python
uv
PyVRP
VRPLIB

Input files:
name: Problem specification
format: Markdown
description: Public benchmark instructions and output contract.
name: Selected CVRP instances
format: VRPLIB
description: Three benchmark instances that must all be solved.
name: Runtime manifest
format: pyproject.toml + uv.lock
description: Pinned Python runtime manifest for task-local solving.
name: Python wrapper
format: shell script
description: Runs Python with the staged runtime and keeps the resolved environment under output.
FDS Single-Compartment Detector Reconstruction
Domain: transport_safety — Fire Science & Public Safety

Summary: Complete a Linux Python CLI that reconstructs a synthetic single-compartment FDS/Smokeview detector-response case from visible fire-safety engineering inputs.

Task prompt:
You are acting as a senior fire protection engineer reconstructing a synthetic single-compartment detector-response incident on a Linux VM.

## Visible Starter Project
- Starter project directory: `base/input/project`
- Task prompt: `base/input/TASK_PROMPT.md`
- Visible scenario input: `base/input/project/input/visible`
- Starter CLI: `base/input/project/reconstruct_fire_case.py`

## Your Task
Complete the reconstruction CLI so it can run with this exact contract:

```bash
python reconstruct_fire_case.py --input-dir <scenario_input_dir> --output-dir <output_dir>
```

Use the visible project files and the documented reconstruction contract. Your implementation must generalize to scenario directories with the same schema; do not hard-code the visible case ID or output values.

## Required Final Submission
Write your completed submission package to:

`base/output`

At minimum, `base/output/reconstruct_fire_case.py` must exist. The evaluator will run that script against scenario input directories and check the generated FDS/Smokeview artifacts.

## Required CLI Outputs
For each scenario, your CLI must write these files into the CLI `--output-dir`:
- `completed_case.fds`
- `device_manifest.json`
- `hrr_reconstruction.csv`
- `detector_activation.csv`
- `tenability_summary.csv`
- `grid_sensitivity.csv`
- `engineering_memo.md`

## Important Rules
- Do not modify files under `base/input`.
- Use `base/output` only for your final submitted files.
- FDS/Smokeview are available at `base/software/fds` and `base/software/smokeview` for optional professional validation, but the submitted CLI must run offline with Python standard-library code.

Required actions:
Inspect the visible starter project and task prompt under input/project.
Infer the HRR ramp from the supplied field_sensor_traces.csv rather than hard-coding case IDs or output values.
Complete reconstruct_fire_case.py so it works for any same-schema scenario directory.
Place the completed reconstruct_fire_case.py at the root of the runtime output directory.

Software: Python 3.10
FDS 6.10.1
Smokeview 6.10.1

Input files:
name: Starter project
format: Python project directory
description: Visible starter CLI, visible scenario inputs, prompt, and reconstruction contract.
Atlas Outpost Graybox Navigation
Domain: visual_media — 3D, Animation & Interactive Media

Summary: Finish a Windows GPU Blender/Godot graybox level blockout so the exported Atlas Outpost layout supports the required visible navigation routes and review constraints.

Task prompt:
You are working on a Windows GPU VM.

## Variant
`base`: Atlas Outpost graybox navigation blockout

## Your Task
Finish the Atlas Outpost graybox level-design starter project. This is a level-blockout workflow: author route geometry, re-export the glTF, wire the Godot validation scene, and write the visible handoff metrics.

## Input Files
- Task prompt: `base\input\TASK_PROMPT.md`
- Starter project root: `base\input`
- Blender blockout: `base\input\blender\atlas_outpost_blockout.blend`
- Exported glTF starter: `base\input\exports\atlas_outpost_blockout.gltf`
- Godot validation scene: `base\input\godot\scenes\atlas_outpost_validation.tscn`
- Optional Blender launcher: `base\software\open_blender.bat`
- Optional Godot launcher: `base\software\open_godot.bat`

## What You Must Do
1. Read `base\input\TASK_PROMPT.md` and the visible specs under `base\input`.
2. Complete the graybox route layout in the project files.
3. Re-export `exports/atlas_outpost_blockout.gltf` and any referenced sidecar files.
4. Update `godot/scenes/atlas_outpost_validation.tscn` with the required review markers.
5. Fill `docs/layout_handoff.md` with the visible route metrics.
6. Save the completed project under `base\output` using the same relative paths as the starter.

## Required Output Paths
- `base\output\blender\atlas_outpost_blockout.blend`
- `base\output\exports\atlas_outpost_blockout.gltf`
- `base\output\exports\atlas_outpost_blockout.bin` if referenced by the exported glTF
- `base\output\godot\scenes\atlas_outpost_validation.tscn`
- `base\output\docs\layout_handoff.md`

## Important
- Keep your final deliverables under `base\output`.
- Do not modify `input\` or any non-output data.
- Do not rely on internet access.


Required actions:
Read the visible task prompt and starter project under `input/`.
Complete the Blender/Godot graybox project and exported glTF route geometry.
Update the Godot validation scene and visible handoff notes.
Save the completed project with the same relative paths under `output/`.

Software: Blender 4.5.1 LTS
Godot Engine 4.6.2
Python
Windows

Input files:
name: TASK_PROMPT.md
format: Markdown
description: Agent-visible task brief with visible route, zone, cover, and LOS requirements.
name: atlas_outpost_blockout.blend
format: Blender file
description: Starter graybox blockout file.
name: atlas_outpost_blockout.gltf
format: glTF
description: Starter exported geometry.
name: atlas_outpost_validation.tscn
format: Godot scene
description: Starter Godot review scene.
Blender Character Reconstruction From Multiview
Domain: visual_media — 3D, Animation & Interactive Media

Summary: Reconstruct a stylized full-body character in Blender from five fixed clay reference views plus scale/orientation metadata, then save the scene and export the required deliverables under the exact submission layout.

Task prompt:
You are a 3D artist using Blender on a Windows VM.

Reconstruct the provided stylized character from the staged multiview references.

Agent-visible input:
- Modeling brief: `base\input\modeling_brief.md`
- Scale/orientation guide: `base\input\scale_orientation_guide.json`
- Validation camera guide: `base\input\validation_views.json`
- Views: `view_front.png`, `view_side.png`, `view_back.png`, `view_front_three_quarter.png`, `view_back_three_quarter.png`
- Blender launcher: `base\software\open_blender.bat`

Required submission under `base\output\submission`:
- `final.blend`
- `reconstructed_character.glb`
- `reconstructed_character.obj`
- `modeling_report.md`

Requirements:
- Preserve the major full-body silhouette, proportions, and component structure.
- Match the coordinate and scale guidance from `scale_orientation_guide.json`.
- Treat the five staged views as the visual target.
- Write the required deliverables only under the designated `output/submission/` path.


Required actions:
Open Blender through the staged launcher and reconstruct the stylized full-body character from the five staged clay reference views.
Use `scale_orientation_guide.json` to keep the character upright, centered, and scaled to the intended world-space frame.
Use `validation_views.json` as the fixed camera/render contract that the final geometry must satisfy.
Save `final.blend` and export `reconstructed_character.glb`, `reconstructed_character.obj`, and `modeling_report.md` under `output/submission/`.

Software: Blender

Input files:
name: modeling_brief.md
format: Markdown
description: High-level modeling objective, required components, allowed simplifications, and required output files.
name: scale_orientation_guide.json
format: JSON
description: Visible world-space orientation, bounding-box, centering, and scale tolerances.
name: validation_views.json
format: JSON
description: Visible fixed camera, lighting, and render settings for the five validation views.
name: view_*.png
format: PNG images
description: Five clay-rendered multiview targets: front, side, back, front-three-quarter, and back-three-quarter.
name: open_blender.bat
format: BAT launcher
description: Stable agent-visible Blender launcher. Probes C:\Softwares\Blender-5.0.1\blender.exe first, then Program Files Blender 5.0 / 5.1.
butterfly_flap_animation
Domain: visual_media — 3D, Animation & Interactive Media

Summary: Animate a supplied butterfly image in Adobe After Effects with four wing-flap cycles and a smooth curved 2.5D flight path.

Task prompt:
Create a butterfly wing-flap animation in Adobe After Effects.

Remote workspace:
- Task folder: base

Software:
- Launch Adobe After Effects using: base\software\launch_after_effects.bat
- The installed After Effects version may differ from the original submission; use the available AE version opened by this launcher.

Visible inputs:
- Source butterfly artwork: base\input\butterfly.jpeg
- Detailed task spec: base\input\task_spec.md

What to do:
1. Import the butterfly image into After Effects.
2. Split or mask the butterfly into a central body plus left and right wings.
3. Set wing anchor points near the wing-body joints.
4. Animate the wings with repeated Y-rotation or equivalent perspective deformation.
5. Produce exactly 4 complete wing flap cycles: open -> closed -> open.
6. Move the butterfly along a smooth curved 2.5D-style path through the frame with at least 2 Y-direction turning points.
7. Keep the butterfly texture recognizably tied to the source image at fully open moments.
8. Use a plain dark or black background so the butterfly motion remains clear.

Export requirements:
- Export one H.264 MP4.
- Frame rate: 30 fps.
- Duration: 4.0 to 5.5 seconds.
- Save the final render exactly here: base\output\output.mp4

Do not modify files under input/. Write only the final MP4 under output/.


Required actions:
Launch Adobe After Effects from `software/launch_after_effects.bat`.
Import `input/butterfly.jpeg` and use it as the source butterfly artwork.
Split or mask the butterfly into a central body plus left and right wings.
Animate the wings with repeated Y-rotation or equivalent perspective deformation for exactly 4 complete flap cycles.
Move the butterfly along a smooth curved 2.5D-style path with at least 2 Y-direction turning points.
Use a plain dark or black background for clear motion detection.
Export one 30 fps H.264 MP4, 4.0 to 5.5 seconds long, to `output/output.mp4`.

Software: Adobe After Effects

Input files:
name: Butterfly artwork
format: JPEG image
description: Agent-visible source artwork to animate
name: Task specification
format: Markdown
description: Public animation and export requirements
chroma_key_from_reference
Domain: visual_media — 3D, Animation & Interactive Media

Summary: Composite the correct foreground subject into the target scene by removing the green screen and rebuilding the video in DaVinci Resolve.

Task prompt:
Goal: Remove the green-screen background from the source clip, create a new Resolve project yourself, composite the correct foreground subject into the intended target scene indicated by the first-frame target screenshot, and export the finished composite video.

Remote workspace:
- Task folder: crane_flyingsky

Software:
- Launch DaVinci Resolve using: crane_flyingsky\software\DaVinci Resolve.lnk
- No starter `.drp` project is packaged with this task. Create a new Resolve project yourself for the task run.

Inputs (already on remote desktop):
- Input assets live under: crane_flyingsky\input
- Foreground source clip with green background: crane_flyingsky\input\input.mp4
- First-frame target screenshot / disambiguation hint: crane_flyingsky\input\input.png

What to do:
- Create a new Resolve project and import the task assets from the task folder.
- Key out the green background from the foreground source clip.
- Build the composite yourself in Resolve so the result matches the intended target scene shown by the first-frame screenshot.
- Use the screenshot to determine which foreground subject to preserve and how the finished composite should look in placement, scale, and overall composition.
- Treat the screenshot as a visual specification for the background scene, framing, and composition that your final render should match.
- Do not export the untouched source clip and do not leave visible green-screen background in the final render.

Output:
- Export/render to: crane_flyingsky\output\output.mp4

Required actions:
Launch DaVinci Resolve from `software/DaVinci Resolve.lnk`
Create a new Resolve project for the task run
Key out the green background from `input/input.mp4`
Build the composite yourself in Resolve
Use `input/input.png` as the first-frame target screenshot that tells you which foreground subject to preserve and what the intended composite should look like Treat it as the visual spec for the background scene, framing, and composition your final render should match.
Export the final output to `output/output.mp4`

Software: DaVinci Resolve

Input files:
name: Input clip
format: `.mp4`
description: Foreground source clip
name: Input target screenshot
format: `.png`
description: First-frame target screenshot showing which foreground subject should be preserved and what the intended finished composite should look like; not a packaged project and not an output asset
Compress A 3D Gaussian Splatting Scene
Domain: visual_media — 3D, Animation & Interactive Media

Summary: Compress a pretrained 3D Gaussian Splatting scene while preserving rendering quality on hidden LLFF holdout views, then report the resulting quality metrics and compression ratio.

Task prompt:
You are working on a Windows GPU neural-rendering benchmark.

Read these staged inputs first:
- `base\input\task_prompt.md`
- `base\input\baseline_results.json`
- `base\input\scene_manifest.json`

Core visible asset roots:
- `base\input\scene\point_cloud_30000.ply`
- `base\input\scene\sparse\0`
- `base\input\scene\images`

Pre-installed 3DGS rendering runtime (software entry points):
- `base\software\python_3dgs.bat <script.py>` — Python with the official gaussian-splatting repo on PYTHONPATH and CUDA configured
- `base\software\render_3dgs.bat --model_path <path> [...]` — official render.py wrapper
- `base\software\README.md` — details on the installed runtime

Write your outputs only under `base\output`.
Required output files:
- `base\output\point_cloud_30000_compressed.ply`
- `base\output\rendered_test_views\<holdout filename>.jpg`
- `base\output\results.json`
- `base\output\compression_report.json`

Important:
- the holdout filenames are public
- the visible JPGs for those holdout names are placeholders only
- hidden evaluator images are used for scoring after you finish
- do not modify files under `base\input`


Required actions:
Read the staged prompt, baseline metrics, manifest, source PLY, sparse COLMAP bundle, and visible scene images.
Compress `input/scene/point_cloud_30000.ply` into `output/point_cloud_30000_compressed.ply`.
Render one holdout-view image for every filename listed in `input/scene_manifest.json` and save them under `output/rendered_test_views/`.
Write `output/results.json` with average PSNR, SSIM, LPIPS, and per-view PSNR/SSIM entries.
Write `output/compression_report.json` with the gaussian counts before and after compression.

Software: Gaussian Splatting
Python

Input files:
name: task_prompt.md
format: Markdown
description: Agent-facing task contract and reminders.
name: baseline_results.json
format: JSON
description: Baseline average metrics for the uncompressed source scene.
name: scene_manifest.json
format: JSON
description: Lists the holdout filenames, image counts, and source gaussian count.
name: point_cloud_30000.ply
format: PLY
description: Source 3D Gaussian scene to compress.
name: sparse/0/
format: COLMAP bundle
description: Camera intrinsics and poses for rendering the holdout views.
name: images/
format: JPG directory
description: Visible training images plus placeholder JPGs for the public holdout filenames.
Human Mesh Animation Reproduction
Domain: visual_media — 3D, Animation & Interactive Media

Summary: Rig and animate a provided human mesh in Blender so its exported per-frame OBJ sequence matches the motion in a reference video.

Task prompt:
You are a 3D artist using Blender 4.3 on a Windows VM.

Rig and animate the provided human mesh so it matches the motion shown in the reference video.

Agent-visible inputs:
- Mesh: `base\input\character.obj`
- Material sidecar: `base\input\character.mtl`
- Reference motion video: `base\input\reference.mp4`

Required submission:
- Save the Blender scene to `base\output\submission\final.blend`
- Export exactly 60 OBJ frames to `base\output\submission\mesh_seq`
- Use frame names `frame_0001.obj` through `frame_0060.obj`

Requirements:
- Animate at 30 fps.
- Export frames 1..60 inclusive.
- Preserve the character identity, proportions, topology, and overall geometry while reproducing the motion.

Required actions:
Rig and animate `input/character.obj` so the motion matches `input/reference.mp4`.
Work at 30 fps and export exactly 60 OBJ frames for frames 1 through 60 inclusive.
Save the authored Blender file as `output/submission/final.blend`.
Export `output/submission/mesh_seq/frame_0001.obj` through `frame_0060.obj`.

Software: Blender

Input files:
name: character.obj
format: OBJ mesh
description: Unrigged human mesh that the agent must animate
name: character.mtl
format: MTL material
description: Material sidecar for the input mesh
name: reference.mp4
format: MP4 video
description: Reference motion video the agent must reproduce