Kk2406/Ll huggingface dataset:
HST ACS/WFC Visit Reduction
Domain: physical_sciences — Astronomy & Astrophysics

Summary: Implement a reproducible Python reduction workflow for synthetic HST ACS/WFC imaging visits, including masking, alignment, drizzling, source photometry, astrometry, and QC reporting.

Task prompt:
You are reducing synthetic HST ACS/WFC visit data on a Linux VM. Read the full
instructions in `base/input/TASK_PROMPT.md` and use the visible visit data under:
`base/input/acs_visit_f606w_lockman`.

## Goal
Implement a reusable ACS/WFC visit-reduction script at:
`base/output/reduce_visit.py`

Your script must accept:
`python reduce_visit.py --input <visit_root_or_parent_input_dir> --output <output_dir>`

For each visit in the input, write a folder directly under the supplied output
directory, for example `<output_dir>/<visit_id>/`, containing:
- `drizzled_image.csv`
- `source_catalog.csv`
- `alignment_solution.csv`
- `photometry_qc.json`
- `reduction_report.md`

The starter implementation is at `base/input/starter_project/reduce_visit.py`. The runtime manifest is
under `base/input/runtime_env`, and the helper wrapper is:
`base/software/python_with_task_deps.sh`

Do not modify files under `base/input`. Write your final implementation and
any scratch artifacts only under `base/output`.


Required actions:
Read the sanitized task prompt, starter project, visible ACS/WFC visit, and runtime manifest under `input/`.
Implement `output/reduce_visit.py` as a reusable command-line reducer for any visit folder with the staged schema.
Mask cosmic-ray and hot-pixel DQ pixels, align the dithered exposures, and create a 72x72 count-rate drizzled mosaic.
Detect sources and write the required source catalog with pixel, sky, flux, magnitude, SNR, sharpness, and flag columns.
Write alignment, photometry QC, and methods report artifacts for each visit directly under the supplied output directory.

Software: Python
NumPy
Astropy
Photutils

Input files:
name: Task prompt
format: `.md`
description: Sanitized agent-facing instructions and required output contract.
name: Starter reducer
format: `.py`
description: Incomplete baseline implementation that parses the CLI and writes placeholder outputs.
name: Visible ACS/WFC visit
format: FITS, CSV, JSON
description: Visible synthetic visit with exposure images, DQ masks, association table, calibration context, and Gaia-like astrometric anchors.
name: Runtime manifest
format: `.toml`
description: Declares the Python packages available through the task runtime helper.
Ketcher SMILES Reproduction
Domain: physical_sciences — Chemistry & Materials Computation

Summary: Recreate the target molecule in Ketcher from a staged structure image and export the result as a SMILES file.

Task prompt:
You are a chemistry researcher reproducing a molecular structure in Ketcher.

## Your Task
Recreate molecule **7YY** from the provided SVG image and export it as a SMILES file.

## Input Files
- Molecule structure image: `7yy\input\structure.svg`

## Software
- Launch Ketcher from: `7yy\software\Ketcher.lnk`
- The shortcut opens the verified Ketcher web app URL:
  `https://lifescience.opensource.epam.com/ketcher/`

## What You Must Do
1. Open Ketcher from the shortcut in `software/`
2. Reproduce the molecular structure shown in `7yy\input\structure.svg`
3. Preserve the intended bonding and ring connectivity
4. Export the result as a SMILES file
5. Save the exported file exactly to:
   `7yy\output\submission.smi`

## Output Requirements
- Output format must be `.smi`
- The file must contain exactly one non-comment SMILES entry
- Do not save screenshots, extra files, or alternate molecule versions
- The exported molecule must preserve the intended chemical identity of the SVG structure

Required actions:
Open the task-local Ketcher shortcut from `software/`.
Inspect the source molecule drawing in `input/structure.svg`.
Recreate the molecule in Ketcher while preserving atom identities, bond orders, and ring connectivity.
Export a single-entry SMILES file.
Save the exported file exactly to `output/submission.smi`.

Software: Ketcher

Input files:
name: Molecule structure image
format: `.svg`
description: Reference drawing for molecule 7YY
Lenacapavir SAR Table2 Extraction
Domain: physical_sciences — Biomolecular Structure & Design

Summary: Extract every compound row from Table 2 of the staged manuscript, reconstruct the full molecules, and deliver a CSV with SMILES and potency values.

Task prompt:
You are a medicinal chemistry researcher extracting one SAR table from a staged paper PDF.

## Your Task
Use the provided manuscript PDF to extract every compound in **Table 2** and reconstruct a full-molecule SMILES string for each row.

## Input Files
- Manuscript PDF: `table2\input\source_paper.pdf`

## Software
- PDF/browser shortcut: `table2\software\Microsoft Edge.lnk`
- Editor shortcut: `table2\software\Visual Studio Code.lnk`
- Python helper: `table2\software\python.bat`

## What You Must Do
1. Open `table2\input\source_paper.pdf`
2. Go to Table 2, titled `SAR for R1 Analogs`
3. Use the scaffold shown above the table together with each row's R1 drawing
4. Reconstruct the full molecule for every compound row in Table 2
5. Save one CSV exactly to:
   `table2\output\submission.csv`

## Output Requirements
- The file must be CSV
- The columns must be exactly:
  `Ligand_ID,SMILES,EC50_MT4`
- Include one row for every compound listed in Table 2
- `SMILES` must describe the full molecule, not only the R1 fragment
- `EC50_MT4` should be the nM value reported in the table
- Do not save extra files

## Important Constraints
- Use the staged paper PDF as your source of truth
- Do not rely on web search or external answer sources

Required actions:
Open the manuscript PDF from `input/source_paper.pdf`.
Locate Table 2, titled `SAR for R1 Analogs`, on page 8 of the paper and use the scaffold drawn immediately above that table together with the per-row R1 substituent drawings.
Reconstruct the full molecule for each listed ligand in Table 2 and write a CSV to `output/submission.csv`.
The CSV must contain exactly the columns `Ligand_ID,SMILES,EC50_MT4` and include every Table 2 compound from the staged paper variant.

Software: Microsoft Edge
Visual Studio Code
Python

Input files:
name: Source paper
format: `.pdf`
description: Full lenacapavir medicinal chemistry paper containing Table 2 and the scaffold figure
Molecular Structure Plausibility
Domain: physical_sciences — Chemistry & Materials Computation

Summary: Inspect a set of molecular XYZ files and identify the structures that are physically implausible under basic chemistry and geometry constraints.

Task prompt:
You are filtering molecular structure files based on physical plausibility.

## Variant
`base`: Molecular structure plausibility filtering

## Input Files
- Structure directory: `base/input/xyz_files`
- Task brief: `base/input/task_brief.md`
- Optional Python dependency manifest: `base/input/runtime_env`

## Optional Python Setup
If you want RDKit and scientific Python tools, use the staged runtime manifest:

```bash
cd "base/input/runtime_env"
uv sync --frozen
```

## What You Must Do
1. Read `base/input/task_brief.md`.
2. Inspect the `.xyz` molecular structures in `base/input/xyz_files`.
3. Identify every structure that is physically implausible under the task brief.
4. Save one text file at `base/output/problematic_structures.txt`.

## Output Requirements
- Write one `.xyz` filename per line.
- Use filenames exactly as they appear in `base/input/xyz_files`.
- Do not include paths.
- Save the final answer only at `base/output/problematic_structures.txt`.


Required actions:
Read `input/task_brief.md` and inspect the 54 molecular `.xyz` files under `input/xyz_files/`.
Identify every file whose molecular structure is physically implausible under the brief, using chemistry and geometry sanity checks.
Write `output/problematic_structures.txt` with one exact `.xyz` filename per line and no paths.

Software: Python
RDKit
NumPy
SciPy

Input files:
name: task_brief.md
format: Markdown
description: Agent-visible instructions for the molecular plausibility filtering task.
name: xyz_files
format: XYZ molecule directory
description: Directory containing 54 molecular structure files to inspect.
name: runtime_env
format: uv Python environment
description: Optional locked Python environment with RDKit and scientific Python dependencies.
Mose2 Bse Absorption Soc
Domain: physical_sciences — Chemistry & Materials Computation

Summary: Your Task Compute the SOC enabled GW BSE optical response of monolayer MoSe2 from the staged structure and pseudopotentials.

Task prompt:
You are a computational materials scientist working on a Linux VM.

## Your Task
Compute the SOC-enabled GW-BSE optical response of monolayer MoSe2 from the staged structure and pseudopotentials.

## Input Files
- MoSe2 structure: `base/input/MoSe2.vasp`
- Mo pseudopotential: `base/input/Mo.soc.upf`
- Se pseudopotential: `base/input/Se.soc.upf`

## Software
Use the task-local command-line tools staged here:
- `base/software/bin/pw.x`
- `base/software/bin/mpirun`
- `base/software/bin/epsilon.cplx.x`
- `base/software/bin/sigma.cplx.x`
- `base/software/bin/kernel.cplx.x`
- `base/software/bin/absorption.cplx.x`

## What You Must Do
1. Create the missing Quantum ESPRESSO and BerkeleyGW input decks from scratch.
2. Run the monolayer MoSe2 QE workflow with explicit SOC / noncollinear settings.
3. Run the BerkeleyGW workflow needed for the required BSE absorption output, including the 2D truncation treatment.
4. Save the required outputs exactly under `base/output`.

## Required Output Files
- `base/output/MoSe2_bands.dat.gnu`
- `base/output/MoSe2_bands.png`
- `base/output/absorption_eh.dat`
- `base/output/exciton_absorption_spectra_avg.png`

Do not write outputs outside `base/output`.

Required actions:
Read the staged input files under `input/`.
Create the missing QE and BerkeleyGW input decks from scratch. At minimum this includes QE SCF and NSCF inputs with explicit SOC/noncollinear settings plus BerkeleyGW inputs for `epsilon`, `sigma`, `kernel`, and `absorption`.
Run the QE mean-field workflow for monolayer MoSe2 with explicit SOC to generate the charge density and wavefunctions.
Run the BerkeleyGW GW+BSE workflow for monolayer MoSe2, including the 2D truncation treatment and benchmark-scale reference settings from the original prompt such as `16x16x1` k-point sampling, about `2500` GW summation bands, `32x32x1` fine-grid interpolation, and screened Coulomb cutoff near `25 Ry`.
Produce the required band and absorption outputs with the filenames expected by the hidden reference.
Write the required output files under `output/` with the same filenames as the staged hidden reference data.

Software: NumPy
Python

Input files:
name: MoSe2 structure
format: `vasp`
description: Monolayer MoSe2 structure
name: Mo pseudopotential
format: `UPF`
description: SOC-enabled Mo pseudopotential
name: Se pseudopotential
format: `UPF`
description: SOC-enabled Se pseudopotential
2D Hexagonal Lattice Phonon Dispersion And Thermodynamics
Domain: physical_sciences — Physics

Summary: Construct the dynamical matrix for a two-atom 2D hexagonal lattice, then compute the staged 1D validation, high-symmetry phonon dispersion, phonon DOS, and thermodynamic observables.

Task prompt:
You are working on a Linux VM.

## Variant
`base`: Phonon dispersion and thermodynamics for a 2D hexagonal lattice

## Your Task
Use the staged problem statement to compute the phonon dispersion relation, phonon density of states, and thermodynamic properties for the specified 2D hexagonal lattice.

## Input Files
- Problem specification: `base/input/problem_spec.md`
- Optional runtime manifest: `base/input/runtime_env/pyproject.toml`

## Optional Python Setup
If you want a clean scientific Python environment, run:

```bash
cd "base/input/runtime_env"
uv sync
```

## What You Must Do
1. Read `base/input/problem_spec.md` carefully and follow its lattice geometry, path discretization, and output contract exactly.
2. Construct the dynamical matrix yourself; do not use phonon or materials-science frameworks such as phonopy or ASE.
3. Write the five required deliverables under `base/output`:
   - `diatomic_1d.npz`
   - `dispersion_2d.npz`
   - `dos.npz`
   - `thermodynamics.npz`
   - `results.json`
4. Keep all final deliverables inside `base/output`.


Required actions:
Read the staged problem specification at input/problem_spec.md.
Construct the lattice dynamical matrix without using phonon or materials-science frameworks.
Produce diatomic_1d.npz, dispersion_2d.npz, dos.npz, thermodynamics.npz, and results.json under output/.
Match the staged file formats, array keys, and summary schema exactly.
Keep all final deliverables inside output/.

Software: Python
uv

Input files:
name: problem_spec.md
format: Markdown
description: Public task statement with lattice parameters, required numerical workflow, and exact output contract.
name: pyproject.toml
format: TOML
description: Optional runtime manifest for numpy and scipy.
Silicon Bse Absorption
Domain: physical_sciences — Chemistry & Materials Computation

Summary: Your Task Compute the GW BSE absorption spectrum of bulk silicon from the staged structure and pseudopotential.

Task prompt:
You are a computational materials scientist working on a Linux VM.

## Your Task
Compute the GW-BSE absorption spectrum of bulk silicon from the staged structure and pseudopotential.

## Input Files
- Silicon structure: `base/input/silicon.vasp`
- Silicon pseudopotential: `base/input/Si.UPF`

## Software
Use the task-local command-line tools staged here:
- `base/software/bin/pw.x`
- `base/software/bin/mpirun`
- `base/software/bin/epsilon.cplx.x`
- `base/software/bin/sigma.cplx.x`
- `base/software/bin/kernel.cplx.x`
- `base/software/bin/absorption.cplx.x`
- `base/software/bin/inteqp.cplx.x`

## What You Must Do
1. Create the missing Quantum ESPRESSO and BerkeleyGW input decks from scratch.
2. Run the silicon QE mean-field workflow.
3. Run the BerkeleyGW GW+BSE workflow needed for both quasiparticle and absorption outputs.
4. Save the required outputs exactly under `base/output`.

## Required Output Files
- `base/output/bandstructure.dat`
- `base/output/eqp.dat`
- `base/output/eqp_q.dat`
- `base/output/absorption_eh.dat`
- `base/output/absorption_noeh.dat`
- `base/output/eigenvalues.dat`
- `base/output/eigenvalues_noeh.dat`
- `base/output/bandstructure_inteqp.png`
- `base/output/absorption.png`

Do not write outputs outside `base/output`.

Required actions:
Read the staged input files under `input/`.
Create the missing QE and BerkeleyGW input decks from scratch. At minimum this includes QE SCF and NSCF inputs plus BerkeleyGW inputs for `epsilon`, `sigma`, `kernel`, `absorption`, and `inteqp`.
Run the QE mean-field workflow for bulk silicon to generate the charge density and wavefunctions.
Run the BerkeleyGW GW+BSE workflow for bulk silicon (`epsilon` -> `sigma` -> `kernel` -> `absorption`, with `inteqp` for the quasiparticle band outputs), targeting the benchmark-scale reference settings from the original prompt such as `5x5x5` wavefunction k-point sampling, `10 Ry` dielectric cutoff, and about `39` bands in the GW sum-over-states.
Produce the absorption outputs with and without electron-hole interaction, plus the required quasiparticle band outputs.
Write the required output files under `output/` with the same filenames as the staged hidden reference data.

Software: NumPy
Python

Input files:
name: Silicon structure
format: `vasp`
description: Bulk Si structure for the optical task
name: Silicon pseudopotential
format: `UPF`
description: Norm-conserving Si pseudopotential
C. elegans Neuron Tracking
Domain: psychology_neuro — Computational Neuroscience

Summary: Complete sparse whole-brain neuron trajectories in a staged HDF5 recording by preserving neuron identity across time and writing the finished track file for one of four variants.

Task prompt:
You are completing a C. elegans neuron-tracking task on Linux.

## Task Directory
`137`

## Visible Inputs
- Task file: `137/input/137.h5`
- Solve guide: `137/input/AGENT_README.md`
- Variant metadata: `137/input/variant_manifest.json`
- Staged runtime manifest: `137/input/runtime_env/pyproject.toml`
- Staged lockfile: `137/input/runtime_env/uv.lock`
- GUI launcher: `137/software/open_points_on_output.sh`
- Programmatic Python wrapper: `137/software/python_with_task_deps.sh`

## Your Task
1. Read `137/input/AGENT_README.md`.
2. Work from `137/input/137.h5` for variant `137`.
3. Either launch the GUI with `137/software/open_points_on_output.sh` or edit the file programmatically with `137/software/python_with_task_deps.sh`.
4. Fill the `points[t, 1..30, :]` trajectories across frames while preserving neuron identity.
5. Save the completed result only to `137/output/137.h5`.

## Output Requirements
- Preserve the existing image data and root attrs.
- Keep `points[:, 0, :]` as `NaN`.
- Do not rename datasets or change array shapes.
- Do not modify files under `137/input`.


Required actions:
Read the staged solve guide and variant manifest for the selected recording.
Open the sparse task HDF5 through the POINTS GUI launcher or the staged Python wrapper.
Fill `points[t, 1..30, :]` across time while preserving neuron identity and leaving uncertain coordinates as `NaN`.
Write the completed HDF5 only to `output/<variant>.h5`.

Software: POINTS
Python
h5py
PyQt5

Input files:
name: <variant>.h5
format: HDF5
description: Sparse whole-brain neuron-tracking task file with 3 seeded frames and volumetric image data.
name: AGENT_README.md
format: Markdown
description: Agent-visible solve guide for POINTS usage, coordinate conventions, and output rules.
name: variant_manifest.json
format: JSON
description: Per-variant metadata including `T`, seed frames, selected neuron ids, and `pixel_scale`.
name: runtime_env
format: uv Python environment
description: Pinned Python dependency manifest and lockfile for programmatic edits and evaluation.
name: open_points_on_output.sh
format: Shell launcher
description: Stable GUI launcher that opens POINTS on a writable output copy of the task file.
Reddit AI Post Codebook Boolean Coding
Domain: psychology_neuro — Economics & Quantitative Social Research

Summary: Read a psychology codebook PDF and complete a boolean-coded Reddit-post annotation workbook in LibreOffice Calc.

Task prompt:
You are completing a psychology coding workbook on a Windows VM.

## Input Files
- Dataset workbook: `base\input\ai_addiction_dataset_n95.xlsx`
- Codebook PDF: `base\input\ai_addiction_codebook.pdf`

## Software
- Open the workbook with `base\software\open_dataset.bat`
- Open the codebook with `base\software\open_codebook.bat`
- Or open both with `base\software\open_inputs.bat`

## What You Must Do
1. Read the codebook and inspect the Reddit post workbook.
2. For each nonempty post row (Excel rows 2 through 96), fill the annotation columns F through AR.
3. Choose exactly one focus label in columns F through H for each post row.
4. Save the completed workbook exactly to `base\output\ai_addiction_annotations_output.xlsx`.

## Rules
- Keep the existing post metadata in columns A through E intact.
- Use boolean annotations in columns F through AR.
- Do not modify files under `input\`.


Required actions:
Open the staged Reddit-post workbook and the staged codebook PDF.
Read the codebook definitions and skip rules.
Fill the boolean coding columns F through AR for Excel rows 2 through 96.
Choose exactly one focus label in columns F through H for each post row.
Save the completed workbook to `output/ai_addiction_annotations_output.xlsx`.

Software: LibreOffice Calc
Microsoft Edge PDF Viewer

Input files:
name: ai_addiction_dataset_n95.xlsx
format: Excel workbook
description: Visible Reddit-post dataset workbook with post metadata plus blank coding columns
name: ai_addiction_codebook.pdf
format: PDF
description: Visible two-page annotation codebook describing focus labels, symptoms, motivations, features, and post purpose categories
name: output_contract.json
format: JSON
description: Visible output filename and scored-range contract
name: task_prompt.md
format: Markdown
description: Visible helper prompt kept in exact lockstep with the benchmark runtime prompt
Scene2 Resample
Domain: psychology_neuro — Experimental Psychology & Neuroimaging

Summary: Resample a 1 mm ROI mask onto the 2 mm statistical-map grid and save the required aligned output.

Task prompt:
You are a neuroimaging analyst completing a GUI workflow in 3D Slicer 5.0.3.

## Your Task
Workflow 2: resample a 1mm ROI mask to the 2mm statistical-map grid

Goal:
1. Open the staged ROI mask and statistical map in 3D Slicer.
2. Resample roi_mask_1mm.nii.gz onto statmap_z_2mm.nii.gz using nearest-neighbor interpolation.
3. Save the resampled mask as roi_mask_2mm_nn.nii.gz.
4. Export a screenshot of the resample settings as resample_settings.png.
5. Compute the ROI statistics on the resampled mask and save them to scene2_stats.csv.

Required outputs:
- output/roi_mask_2mm_nn.nii.gz
- output/resample_settings.png
- output/scene2_stats.csv

## Input Files
All task inputs are staged in:
- `base/input`

Key staged files:
- `base/input/statmap_z_2mm.nii.gz`
- `base/input/roi_mask_1mm.nii.gz`

## Software
Launch the correct GUI workflow with:
- `base/software/launch_gui.sh`

The Desktop task folder is a symlink into `/media/user/data/agenthle/...`, so write all outputs under the staged task directory only.

## Required Output Files
Save these outputs exactly under `base/output`:
- `base/output/roi_mask_2mm_nn.nii.gz`
- `base/output/resample_settings.png`
- `base/output/scene2_stats.csv`

## Evaluation
You only pass if all required output files exist, are readable, and satisfy the task-specific correctness checks against hidden reference data.
Focus on this correctness target:
- The output mask must truly land on the 2 mm stat-map grid, the CSV must reflect that mask, and the settings screenshot must be readable.


Required actions:
Launch 3D Slicer from `software/launch_gui.sh`.
Open the staged `roi_mask_1mm.nii.gz` and `statmap_z_2mm.nii.gz` volumes.
Resample the 1 mm ROI mask onto the 2 mm stat-map grid using nearest-neighbor interpolation.
Save the resampled mask to `output/roi_mask_2mm_nn.nii.gz` and export a readable screenshot of the resample settings to `output/resample_settings.png`.
Compute ROI statistics on the resampled mask and save them to `output/scene2_stats.csv`.

Software: Python

Input files:
name: statmap_z_2mm.nii.gz
format: NIfTI volume
description: Reference 2 mm grid that the output mask must match.
name: roi_mask_1mm.nii.gz
format: NIfTI mask
description: Correct source mask to resample with nearest-neighbor interpolation.