strop-auto

---

name: strop-auto description: Closed-loop orchestrator — from a one-line brief straight through init → gold → freeze → check-loop → smoke-train → short train → report, in one command, at minimum cost. Infers everything inferable and compresses any remaining blocking questions into ONE AskUserQuestion round (data present + goal clear ⇒ zero questions). Defaults to machine-signing BOTH sign-off gates — rubric AND gold (fast, distillation-flavored: J-Score means agreement-with-teacher, not verified correctness) — so a default run reaches a real training round with no human touch; pass sign=human to stop at the human sign-off gate exactly like /strop-gold, byte-for-byte the same as before. Fails fast at every step — never silently retries. Use when the user types /strop-auto or asks to "一条龙跑一个 task / one-shot this task / fully automate a new task / close the loop end to end". Arguments: task name (required), the brief (free text), sign=human|machine (default machine), rounds=N (default 3).

You are running Strop's closed-loop orchestrator — the same structured discipline as the interactive commands (contract, frozen gold, sealed validation, sign-off), collapsed into ONE command that infers/asks the bare minimum, then runs unattended through to a report. Per design doc §5: "auto = 收集完必要信息后全自动，以最小成本走通整条 pipeline" (auto = fully automatic once the necessary information is collected, walking the whole pipeline at minimum cost).

⚠️ CRITICAL INVARIANT (design doc §1): like every harness file, this skill must NEVER reference a specific task's path or content. Everything below is written generically — <taskDir> — exactly as /strop-gold / /strop-check-loop / /strop-train already do; tasks/news-labeling/ is cited only as a STRUCTURAL precedent to read, never as a hardcoded default.

Parse arguments

• taskName — REQUIRED (kebab-case, becomes tasks/<taskName>/). Missing → ask.
• the brief — the rest of the user's free text.
• sign=human|machine — default machine (this is the whole point of "auto": unattended). sign=machine makes the gold gate behave like /strop-gold sign=machine (below). sign=human makes it behave exactly like plain /strop-gold: STOP before freeze for a human to review + sign.
• rounds=N — default 3 — a cost-minimized short run (/strop-train's own interactive default is 5). strop.workflow.mjs has no built-in dev-plateau early stop; a short default round count is today's practical substitute for that (report the ledger's trend honestly either way — do not imply an early stop happened if it didn't).

This skill is naturally resumable: init is no-clobber, gold's frozen-guard skips re-generation once GOLD_FROZEN.md exists, so re-invoking /strop-auto on a partially-completed task picks up after whichever phase already finished rather than redoing it.

runId — neither gold.workflow.mjs nor strop.workflow.mjs has a clock, so YOU supply the stamp for each launch below (same convention as /strop-gold and /strop-train): generate YYYY-MM-DD-<letter> from today's date, picking the first letter suffix not already present under that workflow's own .runs/... directory. Gold's runId and the training runId are independent stamps (different .runs/ subtrees) — do not reuse one for the other.

Phase 1 — Collect (init, compressed)

Same inference discipline as /strop-init (read that skill for the full six-node tree if you need it) — collapsed here to protect the "one command" promise:

1. Infer everything inferable: the brief text, any real rows already under tasks/<taskName>/data/{train,dev,heldout}/, whether ./.env is configured (grep NAMES only), tasks/news-labeling/ as a structural precedent.
2. Collect every remaining genuine decision — data source (if truly missing and unpromised), output schema fields, correctness-standard/rubric weights, student model, split policy — into ONE AskUserQuestion call carrying multiple questions, NOT the one-at-a-time grill /strop-init uses interactively (auto's contract is "minimum interaction", not "best interaction"). Recommended option FIRST, suffixed "(Recommended)", for every question.
3. Data present + goal clear ⇒ zero questions — if step 1 already resolved everything, skip AskUserQuestion entirely; proceed silently (log what you inferred, in the user's language).
4. If, after inference, there is genuinely no data and none promised — STOP exactly like /strop-init would: tell the user to place data under tasks/<taskName>/data/{train,dev,heldout}/ (entity-split) first, and do not proceed to any phase below (the harness never invents data).
5. Scaffold + run strop-init-agent with the completed brief, exactly as /strop-init does: mkdir the data dirs, copy the reference infer.py, no-clobber draft of task.md / skill.seed.md / rubric.md (θ₀ + a DRAFT rubric). Write the interview's decision record to tasks/<taskName>/design.md (same format as /strop-init), and — if tasks/<taskName>/README.md exists — add the one link line to it, no-clobber.
6. Sign the rubric (the fork is sign=, same flag Phase 3 uses for gold — checked here too, because the rubric is decided at init time, not at freeze time):
   • sign=machine (default): spawn strop-dev-agent to stamp the just-drafted tasks/<taskName>/rubric.md with a machine sign-off — add a MACHINE-SIGNED marker line (same convention/placement as the existing HUMAN-SIGNED line every signed rubric carries, e.g. next to the aggregate-score section) plus this watermark line, verbatim: ⚠ rubric: machine-signed (recommended weights auto-accepted, not human-reviewed) This is load-bearing, not cosmetic: it is what lets /strop-check-loop / /strop-train / /strop-eval pass their rubric-sign-off check without a human touching anything (all three now accept HUMAN-SIGNED OR MACHINE-SIGNED and report which). NEVER write the literal HUMAN-SIGNED string here — that would misrepresent an auto-accepted default as a human review, exactly what the watermark discipline exists to prevent.
   • sign=human: do NOT stamp anything here — leave rubric.md exactly as strop-init-agent drafted it (a DRAFT pending genuine human review, byte-for-byte the same behavior as /strop-init today). The human adds their own HUMAN-SIGNED line (same convention as every existing task); until they do, /strop-check-loop / /strop-train legitimately BLOCK a real run on this gate, same as always.

FAIL-FAST: if the init agent or (under sign=machine) the rubric-signing dev-agent dies, or the scaffold can't be written, STOP and report; do not retry silently.

Phase 2 — Gold (passNum=2, reconcile as arbiter)

Pre-flight exactly like /strop-gold: <taskDir>/gold.workflow.mjs and <taskDir>/rubric.md must exist (Phase 1 just drafted them). If <taskDir>/data/GOLD_FROZEN.md already exists, gold is already frozen (a resumed run) — skip straight to Phase 4.

Otherwise launch:

Workflow({ scriptPath: "<taskDir>/gold.workflow.mjs",
           args: { taskDir, passNum: 2, runId } })

passNum=2 is the cost floor — 2 independent passes is the minimum that can detect disagreement at all, and the reconcile step arbitrates disagreements itself (no third pass, no human triage of every row — reconcile's job IS the arbiter here, exactly as gold.workflow.mjs already implements for any run). FAIL-FAST: any workflow error stops the whole /strop-auto run here; diagnose from the transcript and report — do NOT auto-rerun.

Phase 3 — Freeze (gold's half of the fork; the rubric's half already happened in Phase 1)

After Phase 2 completes (drafts + review doc written, nothing frozen yet):

• sign=human: STOP here, exactly like plain /strop-gold does — do NOT merge or freeze. Tell the user BOTH signatures are still needed (byte-for-byte the same two-gate requirement as before this update): (a) add a HUMAN-SIGNED line to tasks/<taskName>/rubric.md themselves (Phase 1, step 6 left it untouched under sign=human), and (b) review the review doc (⚠️ items first) and either run the task's merge script + write GOLD_FROZEN.md themselves (signer: human) or ask for help doing so. Then either continue manually, or simply re-invoke /strop-auto <taskName> sign=human once both are done — the frozen-guard above will detect the gold freeze and resume straight into Phase 4 onward (which will now also find the rubric signed).
• sign=machine (default): proceed without a human gate — this is exactly /strop-gold sign=machine's freeze behavior (see that skill for the full mechanism; it concerns GOLD only — the rubric's machine signature was already written in Phase 1, step 6): spawn strop-dev-agent to (a) run the task's own merge/freeze script (conventionally <taskDir>/merge_gold.py) over every split's reconciled drafts, verifying a clean merge, and (b) write <taskDir>/data/GOLD_FROZEN.md keeping every section of the existing freeze-marker format (backward-compatible with any GOLD_FROZEN.md already in the repo) but with signer: machine plus this watermark line, verbatim: ⚠ gold: machine-signed (teacher-agreement metric, not human-verified) This is on-the-fly distillation semantics, not correctness: the reconciled teacher output becomes gold directly. FAIL-FAST: if the task has no merge/freeze mechanism, STOP and say the task's gold mechanism needs authoring first (do not attempt to invent one).

Phase 4 — Check-loop (audit, read-only)

Run the same audit /strop-check-loop performs (the full checklist, groups A–F, minus the optional live smoke — Phase 5 covers that with a real smoke train). Any BLOCK → STOP, report the blocker and which file/command fixes it, do NOT proceed to training on a loop that isn't closed.

Under the default sign=machine path, BOTH of /strop-check-loop's sign-off checks are satisfied by this point without a human touching anything: the rubric carries MACHINE-SIGNED (Phase 1, step 6) and gold is frozen with signer: machine (Phase 3) — /strop-check-loop's checklist item 10 (rubric) and item 11 (gold) both now accept either signer and report which one they found, so this phase is expected to pass straight through to a REAL (non-smoke) round, not just a smoke-tolerant one. Note in your own report which signer each gate found (machine for both, under the default path) — never present a machine-signed loop as if it were human-verified.

Under sign=human, this phase legitimately BLOCKs a real run until the human has actually added HUMAN-SIGNED to rubric.md and frozen gold with signer: human — that is correct, unchanged behavior (a smoke train is still tolerable per /strop-check-loop's own checklist), not a bug.

Phase 5 — Smoke train, then short train

Pick ONE training runId stamp (§ runId above) and reuse it for both calls below — pass the SAME runId to both; strop.workflow.mjs itself appends the -smoke suffix when smoke:true, so the two land in separate .runs/<task>/ dirs without you having to generate two stamps.

1. Workflow({ scriptPath: "strop.workflow.mjs", args: { taskDir, smoke: true, runId } }) — pipeline connectivity first, always, per the cost-minimization discipline (§5: "先 smoke 再全量" — smoke before full). FAIL-FAST: smoke failing stops the run here; report the diagnostic, do not proceed to the real run.
2. Smoke green → Workflow({ scriptPath: "strop.workflow.mjs", args: { taskDir, rounds, runId } }) (rounds default 3 — short, not the interactive default of 5). FAIL-FAST: any round's forward/judge/optimizer/dev-eval failing stops the run; report, do not auto-rerun.

Report

Relay the training run's report.md headline exactly as /strop-train would (selected round, dev trajectory, baseline-lift, harvest candidates). PLUS, always, check BOTH sign-off artifacts on disk yourself — do not just trust your own sign= flag, since a resumed run may have skipped phases, or a human may have hand-signed one of the two independently of the other:

• tasks/<taskName>/rubric.md — grep for MACHINE-SIGNED vs HUMAN-SIGNED;
• <taskDir>/data/GOLD_FROZEN.md — grep its signer: field for machine vs human.

Surface EVERY machine signature you find prominently in your OWN summary, never buried only in a file — lead with whichever watermark(s) apply, verbatim: ⚠ rubric: machine-signed (recommended weights auto-accepted, not human-reviewed) ⚠ gold: machine-signed (teacher-agreement metric, not human-verified) and state plainly what that means for the number below: under the default path (both machine-signed), the J-Score measures agreement against an auto-accepted rubric applied to auto-accepted (teacher-agreement) gold — a distillation-flavored metric, not a verified-correctness one. If a run is fully human-signed (both markers HUMAN-SIGNED / signer: human), say that too, briefly — that is when the J-Score is a correctness claim. A MIXED state (one human, one machine — e.g. a human hand-signed the rubric but gold was auto-frozen) is possible and must be reported exactly as found, never rounded to "fully signed" or "fully machine". Never omit either watermark even if the user doesn't ask — this is the whole reason the design calls the signatures, not the existence of gold or rubric, the thing that's optional (design doc §5).