# data-science-cv-repro-lab

Adopt this skill: https://proskills.md/skills/other/zack-dev-cm-agentic-cv-repro-lab-skill-skill-data-science-cv-repro-lab

Page: https://proskills.md/skills/other/zack-dev-cm-agentic-cv-repro-lab-skill-skill-data-science-cv-repro-lab
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skill/data-science-cv-repro-lab/SKILL.md
size: 8000
upstream: https://github.com/zack-dev-cm/agentic-cv-repro-lab-skill/blob/main/skill/data-science-cv-repro-lab/SKILL.md

```text
---
name: data-science-cv-repro-lab
description: Data Science CV Repro Lab is a public ClawHub CV repro-lab skill. Use it when the user says "cv repro lab", "computer vision reproducibility", "CV experiment evidence", or wants execution-grade CV experiments and evidence capture across Colab, Kaggle, browser automation, and GPU VMs.
version: 1.9.3
homepage: https://zack-dev-cm.github.io/
user-invocable: true
metadata: {"openclaw":{"homepage":"https://zack-dev-cm.github.io/","skillKey":"data-science-cv-repro-lab","requires":{"anyBins":["python3","python"]}}}
---

# Data Science CV Repro Lab

Search intent: `cv repro lab`, `computer vision reproducibility`, `cv experiment evidence`, `colab kaggle cv workflow`

## Goal

Turn CV work into a reproducible decision loop:

- fixed inputs
- explicit metrics
- durable artifacts
- bounded browser automation
- long-run health monitoring
- promotion only on verified benchmark wins

This skill is the execution and evidence layer, not the full score-improvement stack.
If the real ask is "beat the baseline", "escape a plateau", or "find a better recipe",
pair it with `sota-agent` and a fixed improvement harness before spending more compute.

## Use This Skill When

- the user asks to debug CV training, segmentation, detection, or runtime behavior
- the workflow includes OpenClaw, Colab, Kaggle, or browser-only notebook actions
- you need preprocessing, augmentation, or label-alignment review
- the task requires checkpoint comparisons, export comparisons, or promotion gating
- the user wants VM or GPU watchdog logic, heartbeat files, or auto-stop behavior
- the user wants a general third-party CV workflow, not only repo-specific advice

If the primary goal is benchmark improvement rather than clean execution, route the search loop
through `sota-agent` and use this skill as the execution lane.

## Quick Start

1. Lock the objective before touching code.
   - Write the product problem in one sentence.
   - Name the primary metric.
   - Name the non-regression surfaces.
   - State what blocks promotion.

2. Initialize the durable records immediately.
   - Use `python3 {baseDir}/scripts/init_cv_dataset_manifest.py --out <json> --dataset-id <id>`.
   - Use `python3 {baseDir}/scripts/init_cv_run_card.py --out <json> --candidate-id <id> --task-id <task> --baseline-id <baseline>`.
   - If the task is plateau recovery or benchmark improvement, use `python3 {baseDir}/scripts/init_cv_improvement_harness.py --out <json> --task-id <task> --candidate-family <family>`.
   - If the workflow mixes runtime sweeps, QA runs, benchmark panels, or synced VM artifacts, use `python3 {baseDir}/scripts/init_cv_review_dashboard_manifest.py --out <json> --dashboard-id <id> --title <title>`.
   - If a browser lane matters, use `python3 {baseDir}/scripts/init_cv_browser_run_card.py --out <json> --target-url <url>`.
   - If browser-visible overlays or prompt variants are part of the hypothesis, use `python3 {baseDir}/scripts/init_cv_validation_scorecard.py --out <json> --scorecard-id <id> --surface <surface>`.
   - If a long VM run is involved, use `python3 {baseDir}/scripts/init_cv_vm_bootstrap_manifest.py --out <json> --output-root <run_root> --model-family <name> --command python train.py --epochs 40`.

3. Capture the current state immediately.
   - Use `python3 {baseDir}/scripts/capture_cv_run_context.py --repo-root <repo> --out <json> --markdown-out <md> --param key=value`.
   - Record git state, module versions, GPU state, and experiment params before launch.
   - Use the dataset, artifact, and browser manifest helpers for any additional evidence instead of broad host inspection.

4. Pick the right orchestration lane.
   - Local debug lane: tiny overfit, transform audits, shape and dtype checks.
   - Browser notebook lane: Colab or Kaggle steps that must happen in a real browser or notebook UI.
   - Colab GPU lane: runtime selection, smoke validation, artifact export, and browser evidence.
   - Custom VM or cluster lane: long runs with heartbeats, watchdogs, stall detection, sync, and auto-stop.
   - Review dashboard lane: one local or synced surface for runtime sweeps, QA runs, curated comparisons, and benchmark panels.
   - Promotion lane: fixed benchmark matrix plus customer-facing surface checks.

5. Work the debug ladder in order.
   - `Harness review`: fixed split, primary metric, slice table, rerun rule, and stop condition.
   - `Validation scorecard`: browser or notebook visual QA with per-image pass or fail notes when the UI is part of the release story.
   - `Data audit`: split integrity, label normalization, image-mask pairing, resize geometry.
   - `Preview audit`: at least one augmentation preview and one transformed batch preview.
   - `Failure-set review`: keep 20-50 representative overlays with short notes instead of trusting one scalar metric.
   - `Tiny overfit`: 4-16 shared samples with `no_aug`.
   - `Short resumed run`: continue from the best trusted checkpoint.
   - `Long run`: only after the short loop is healthy.

6. Keep agentic work bounded.
   - External browser LLM output is hypothesis generation, not release evidence.
   - Keep the main thread on the benchmark contract and improvement harness.
   - Use bounded Codex subagents for scouting, data audits, patch proposals, and per-case review.
   - For repeated case review, batch over a manifest or CSV instead of free-form chat drift.
   - Browser steps must emit screenshots, machine-readable scores, and explicit success markers.
   - Hard-fail on unavailable browser modes, dead CDP sessions, or ambiguous notebook state.
   - Keep planner, executor, reviewer, and promoter responsibilities distinct even if one agent performs more than one role.

7. Promote only on full-surface wins.
   - Raw checkpoint quality
   - Exported or runtime quality
   - User-facing render, service, or product surface
   - Runtime cost or throughput if deployment matters
   - Adjacent-seed or rerun stability if the claimed delta is small
   - Generate a promotion bundle with `python3 {baseDir}/scripts/init_cv_promotion_bundle.py --out <json> --candidate-id <id>` before the final decision.

## Operating Rules

### Research before edits

- Keep separate files or sections for `research`, `plan`, `journal`, and `evidence`.
- Summaries are not evidence. Preserve the artifact paths.
- If a workflow uses both code changes and browser actions, record both.

### Agentic orchestration rules

- Planner: defines the question, benchmark, stop condition, and chosen execution lane.
- Executor: runs the browser, notebook, local, or VM steps and preserves artifacts.
- Reviewer: checks whether the evidence actually answers the question and catches regressions.
- Promoter: makes the final hold or promote decision from the run card, not from memory.
- If one agent performs all roles, keep the outputs separated anyway.

### Browser automation rules

- Prefer stable URLs over uploads.
- Start with a short smoke run before full training.
- When the hypothesis depends on visible overlays, grids, or prompt variants, capture a validation scorecard before the long run.
- Capture at least two screenshots when the browser UI is part of the validation path.
- Pull artifacts back locally as files, not only screenshots.
- Use explicit timeout and marker logic; do not rely on visual guesswork.
- Record browser profile aliases and session aliases in durable artifacts; keep raw CDP URLs in ephemeral local debug logs only.

### Colab GPU rules

- Select the accelerator explicitly before running expensive cells.
- Verify GPU readiness from inside the notebook before the long run.
- Use a smoke cell that proves the runtime, imports, and data mounts all work.
- Export all required artifacts to one stable bundle directory.
- Create an artifact manifest for that export bundle before pulling it back locally.
- Pull the artifact manifest plus at least one preview image back to local storage.

### Custom VM and cluster rules

- Creat
```

## File: README.md
upstream: https://github.com/zack-dev-cm/agentic-cv-repro-lab-skill/blob/main/README.md

````text
# CV Repro Lab Skills

**Run CV experiments reproducibly across Colab, Kaggle, browser workflows, and GPU VMs, then decide whether a result is strong enough to promote.**

CV Repro Lab Skills packages two public OpenClaw/Codex skills:

- `data-science-cv-repro-lab`: run experiments, capture browser and notebook evidence, and bundle results for review
- `sota-agent`: define the benchmark, rank candidates, and decide whether a claimed gain is real

Use both together when you want one planning lane and one execution lane:

- `sota-agent` freezes the benchmark, candidate list, rerun policy, and claim rules before more compute gets spent
- `data-science-cv-repro-lab` executes runs across Colab, Kaggle, browser-heavy workflows, or VMs and captures the evidence needed to promote or reject the result

## Which Skill Should I Use?

### `data-science-cv-repro-lab`

Use it when you need:

- Colab, Kaggle, or VM execution discipline
- browser evidence and validation scorecards
- dataset manifests, run cards, and promotion bundles
- reproducible artifact capture for a real training or export lane

### `sota-agent`

Use it when you need:

- a fixed benchmark before spending more compute
- literature triage and candidate ranking
- ablation discipline and rerun policy for small deltas
- an honest claim decision instead of benchmark theater

## Quick Start

Install from ClawHub or copy the skill folders into `$CODEX_HOME/skills/`.

```bash
mkdir -p "$CODEX_HOME/skills"
rsync -a skill/data-science-cv-repro-lab/ "$CODEX_HOME/skills/data-science-cv-repro-lab/"
rsync -a skill/sota-agent/ "$CODEX_HOME/skills/sota-agent/"
```

## Live Packages

- [CV Repro Lab on ClawHub](https://clawhub.ai/zack-dev-cm/data-science-cv-repro-lab) (`v1.9.1`)
- [SOTA Agent on ClawHub](https://clawhub.ai/zack-dev-cm/sota-agent) (`v1.4.4`)
- [Portfolio entry](https://zack-dev-cm.github.io/projects/cv-repro-lab-skills.md)

## What Changed In This Release

- added an explicit improvement harness for plateau recovery and score-improvement work
- added a review-dashboard manifest for synced QA runs, benchmark panels, runtime sweeps, and audit surfaces
- expanded run cards and candidate/program records with reruns, slices, agent threads, and auth policy
- added explicit dashboard, source-audit, and leakage-audit references to the SOTA claim surface
- added redacted public summary rendering for the richer machine-readable records
- made local-first planning and public artifact review the default public story instead of API-key-first tooling

## Good Public Fit

These skills are strongest when the user already has a real CV or DS workflow and wants a drop-in
research harness around it. Good fits include:

- derm or segmentation plateau recovery
- browser-heavy notebook workflows
- benchmark campaigns that need stronger promotion gates
- public or reusable experiment-management patterns across repos

## Public Safety

ClawHub is public. Keep the published skill bundles free of:

- absolute local paths
- browser profile names
- private notebook URLs
- secrets, tokens, and customer identifiers
- internal hostnames or VM labels

Private specializations should stay in local override skills, not in the public package.

Report security issues privately using the contact path in [SECURITY.md](SECURITY.md) instead of filing a public issue with sensitive details.

## Local Validation

```bash
python3 -m py_compile \
  skill/data-science-cv-repro-lab/scripts/*.py \
  skill/sota-agent/scripts/*.py

python3 skill/data-science-cv-repro-lab/scripts/init_cv_improvement_harness.py \
  --out /tmp/cv-harness.json \
  --task-id demo \
  --candidate-family baseline-recovery

python3 skill/data-science-cv-repro-lab/scripts/init_cv_review_dashboard_manifest.py \
  --out /tmp/cv-dashboard.json \
  --dashboard-id demo-dashboard \
  --title "Demo review dashboard"

python3 skill/sota-agent/scripts/init_sota_program.py \
  --out /tmp/sota-program.json \
  --campaign-id demo \
  --task demo \
  --metric score
```

## References

The public bundle is informed by:

- [karpathy/autoresearch](https://github.com/karpathy/autoresearch)
- [algorithmicsuperintelligence/openevolve](https://github.com/algorithmicsuperintelligence/openevolve)
- [algorithmicsuperintelligence/optillm](https://github.com/algorithmicsuperintelligence/optillm)
- [openai/symphony](https://github.com/openai/symphony)
- [OpenAI harness engineering](https://openai.com/index/harness-engineering/)
- [OpenClaw skills docs](https://docs.openclaw.ai/tools/skills)
````
