Kk2406/Ll huggingface dataset:
Hybrid Recommender Cold-Start Benchmark
Domain: computing_math — Data & Analytics Engineering

Summary: Build a warm-plus-cold hybrid recommender on Linux, using temporal splitting, metadata/embedding cold-start ranking, and a combined output contract.

Task prompt:
You are building a hybrid recommender system on a Linux VM.

Visible inputs:
- `base/input/interactions.csv`
- `base/input/item_metadata.csv`
- `base/input/item_embeddings.json`
- `base/input/user_profiles.csv`
- `base/input/runtime_env/pyproject.toml`
- `base/input/runtime_env/uv.lock`
- `base/software/setup_runtime_env.sh`
- `base/software/run_recommender_env.sh`

Your task:
1. Build a warm-item recommender using both `rating` and `watch_percentage`.
2. Build a cold-start model from metadata and embeddings without interaction data for cold items.
3. Use the canonical per-user temporal split: 70% train, 10% validation, 20% test.
4. Produce a combined ranking that contains both warm and cold items.
5. Write exactly these files under `base/output`:
   - `predictions_warm.csv` — columns: `user_id, item_id, predicted_rating, rank`
   - `predictions_cold.csv` — columns: `user_id, item_id, predicted_score, rank`
   - `predictions_combined.csv` — columns: `user_id, item_id, predicted_score, rank, item_type` (item_type is "warm" or "cold")
   - `evaluation_report.json` — top-level keys: `warm_items`, `cold_items`, `combined`. `warm_items` must include `NDCG@10`, `HitRate@10`, `RMSE`.
   - `model_config.json` — must include keys: `warm_model`, `cold_model`, `hybrid`, `data_split`. `hybrid` must include a key named `method` or `combination` describing the merging strategy. `data_split` must include `method` (containing "temporal"), `train_ratio`, `val_ratio`, `test_ratio`.

Environment notes:
- Use `base/software/setup_runtime_env.sh` to materialize the staged task-local Python environment.
- Use `base/software/run_recommender_env.sh` to run Python inside that environment.
- Do not modify files under `base/input`.
- Do not modify hidden evaluator data.


Required actions:
Build a warm-item recommender that uses both `rating` and `watch_percentage`.
Build a cold-start model from `item_metadata.csv` and `item_embeddings.json` without using cold-item interactions.
Use the canonical per-user temporal split: `70%` train, `10%` validation, `20%` test.
Fuse warm and cold scores into one combined ranked recommendation surface.
Write the five required deliverables under `output/`.

Software: Python 3.10
uv
numpy
pandas
scikit-learn
scipy

Input files:
name: interactions.csv
format: csv
description: Warm-item user interaction history with rating, watch percentage, and timestamps.
name: item_metadata.csv
format: csv
description: Item features plus the `is_cold_start` label that defines warm vs. cold membership.
name: item_embeddings.json
format: json
description: Dense item embeddings used by the cold-start model.
name: user_profiles.csv
format: csv
description: Per-user profile attributes available at solve time.
name: runtime_env
format: directory
description: Pinned task-local `uv` manifest and lockfile for the agent-visible Python runtime.
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`.


Required actions:
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`
description: High-level wrapper with output path and runtime notes
name: Benchmark prompt
format: `.md`
description: Detailed public benchmark instructions with allowed labels and schema example
name: Sanitized manifest
format: `.json`
description: Lists the benchmark name and every required sanitized dataset id
name: Dataset bundle
format: directory
description: Forty dataset directories, each containing `synthetic.csv` and `task.json`
name: Runtime manifest
format: directory
description: Optional staged Python environment manifest and lockfile
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.

Required actions:
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
description: agent-visible target
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/`.


Required actions:
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
description: Problem set, rubric, solution key, protocol, and student submissions.
name: Starter scaffold
format: Python + JSON
description: Benchmark-owned helper scaffold for output formatting and manifest writing.
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 benchmark harness exposes only the intended input/software surface and the writable output directory while you solve; evaluator-only reference data is not part of the solve-time task.


Required actions:
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
description: Full agent-facing task prompt.
name: task_spec.md
format: Markdown
description: Harness-facing summary of the expected starter-copy workflow and output location.
name: starter_project
format: Python project directory
description: Editable starter project with public MARC/FOLIO case files and a stub remediation CLI.
name: README.txt
format: Text
description: Stage 1 software note stating that the workflow is Python stdlib-only.
name: python3.12
format: Shell wrapper
description: Stage 4-verified Python 3.12.13 runtime entry point.
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

Required actions:
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`
description: Explains the manuscript-inspection and reporting task.
name: Manuscript image
format: `.png`
description: Classical Yi manuscript image containing the glossed glyph.
name: Reference materials
format: directory of `.txt` files
description: Bundled source texts the agent may search and cite.
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.

Required actions:
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
description: Active-variant targets for VIN, VOUT, load current, ripple, and startup behavior
name: ltm4648_datasheet.pdf
format: PDF
description: Reference datasheet for the staged regulator
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`.


Required actions:
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
description: Visual and collision STL meshes for the ABB IRB6700 links.
name: link_manifest.json
format: json
description: Lists the required mesh-bearing and auxiliary links.
name: joint_manifest.json
format: json
description: Lists the required joints and their joint types.
name: kinematic_tree_hint.json
format: json
description: Defines the required parent-child tree edges.
name: joint_limits.csv
format: csv
description: Normalized joint limits for the actuated joints.
name: mimic_rules.json
format: json
description: Defines the required mimic-joint source and multiplier rules.
name: task_brief.md
format: markdown
description: Agent-visible solve-time brief with the output contract and constraints.
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`.


Required actions:
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
description: Full low-thrust LEO-to-GEO problem statement with formulas, state definitions, and output requirements.
name: task_prompt.md
format: md
description: Concise instruction listing the required output files and the task-scoped Python/uv entry points.
name: output_contract.json
format: json
description: Machine-readable schema for the required output files.
name: pyproject.toml
format: toml
description: Pinned runtime dependency manifest for NumPy and SciPy.
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`

Required actions:
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
description: Existing-ground TIN surface for the Cailian Road corridor.
name: open_civil3d_2024.bat
format: Windows batch script
description: Task-local launcher for the installed and licensed AutoCAD Civil 3D 2024 application.