target · diff
git:20260803.c25becd to git:20260816.8c2b68d
26 added, 41 removed. Audit A to A.
---
name: target
- description: Define how unsupervised work will be judged before it runs. Use when execution is an autonomous loop or a long unbabysat agent run that optimizes toward a metric.
+ description: Define how unsupervised work is judged before it runs
+ when_to_use: work will run without a human watching, optimizing toward something
---
- Define the observer before unsupervised work runs, so the cheapest way to pass is the real work.
-
- - **INPUT**: a spec for work that will run unsupervised.
- - **GATE**: "Is the observer mechanical AND un-gameable?" Agent audits, user locks.
- - **OUTPUT**: a success contract (spec below), emitted in conversation.
+ ## Extract
- ## Success contract
+ From the conversation/context/user:
- Concrete and executable — exact commands, values, targets, not abstractions.
+ - The **path**, decided — shape's result, or as good — for work that will run without a human watching.
+ - What the run is **optimizing toward** — the success the contract must pin down before the run starts.
- - **Observable**: the single state or number that means done. One thing, not a dashboard.
- - **Verify command**: the literal command the run executes and surfaces in its output — exit code and score line in view — exiting non-zero on crash. An unsupervised run can claim a check it never ran.
- - **Direction and target**: higher or lower is better, and the value that ends the work.
- - **Bound**: a turn or wall-clock cap that ends the loop even unmet (`… or stop after N turns`).
- - **Baseline**: the observable's value now, from one dry run. Proves the command fires.
- - **Guards**: what must keep passing while optimizing. Check before reading the observable. A violation voids the score and the kept change — never just lowers the score.
- - **Cheats closed**: each cheap path to a false pass + its structural closure (`cheat: … / closed by: …`). Done when no listed cheat is cheaper than real work.
+ ## Gate
- ## Work loop
+ Proceed only when: the work will run without a human watching, and its success is not yet defined outside the run — the run never defines its own success.
- 1. **Extract**: from the spec, name the single observable that means done.
- 2. **Mechanize**: make it extractable, deterministic, fast. If success needs human judgment, it cannot be mechanized — stop and say so.
- 3. **Red-team**: start from the known-cheat catalog (`cheat-museum.md`), then hunt cheats specific to this target. Close each with a fence: a holdout the run can't see, an artifact cap, a cut to feedback resolution, a perturbation probe. Loop until no cheat is cheaper than real work.
- 4. **Baseline**: dry-run the verify command once, record the value, confirm it exits clean. A command that will not run is a gate FAIL.
- 5. **Gate**: audit below.
+ Anything else, say which in one plain line — never write the contract anyway:
- ### Decision prompts
+ - A human will watch each step → no contract needed; proceed with the decided path.
+ - Success cannot be made mechanical → the work is not ready to run unsupervised — say so and stop.
- <!-- f prompts -->
- Closing unknowns — three modes, one boundary:
+ ## Build
- - **EXPLORE** the accessible surface: any answer retrievable with certainty (repo reads, docs, web, parallel subagents) is retrieved, never asked. Return with decisions, not raw findings.
- - **ELICIT** the user: only judgment calls no accessible surface can settle (their goal, taste, a tie between viable paths). Each AskUserQuestion carries as many concrete candidate answers as the decision genuinely has, plus a uniform "Gather facts" escape hatch as a first-class option (never hidden behind Other). Everything needed to answer lives inside the question UI — question text, descriptions, previews — never in prose before the tool call (the dialog hides it).
- - **INTERVIEWING** is the anti-pattern: serial quizzing, generic checklists, asking what exploration could answer.
+ Build the contract by invoking each named skill with the Skill tool where its condition holds:
- Re-entry after a detour: if the detour made the answer obvious, state the decision and proceed; otherwise re-ask the same question with the new evidence inside the prompt.
- <!-- /f -->
+ - What "done" means reads two ways that would build different things → use **clarify** skill.
+ - The user holds a bar they can't yet state → use **elicit** skill.
+ - Nothing exists to react to yet → use **draft** skill on the contract itself: one observable that means done (not a dashboard), the literal command that reads it, which direction is better and the value that ends the work, a cap that ends it even unmet, what must keep passing while optimizing — every choice made on the user's behalf surfaced.
+ - Any part leans on someone's judgment — "clean", "better", "reasonable" → use **anchor** skill: replace it with a trigger a machine evaluates identically every time. The dry run is the anchored rule deciding one real case — record the value it reads now. A command that will not run fails here, loudly.
+ - The drafted contract → use **judge** skill, on the claim: the cheapest way to pass is the real work. Start from the known false-pass catalog in `cheat-museum.md`, then hunt false passes specific to this contract.
- ## Gate
+ Each open false pass judge finds re-enters as an amendment — back through the drafting and anchoring conditions above — until the verdict stands.
- - Deletion pass over the draft first: cut every cheat already closed by another, every guard that restates the observable, every line a command cannot check.
- - Present verdict-FIRST via AskUserQuestion: PASSES or FAILS, then the surviving cheats and how each is closed — proof the adversary ran.
- - On FAIL, name what is unmechanical or un-closeable. If success cannot be defined, stop — the work is not ready to run unsupervised. If a cheat cannot be closed, bounce to the user. Never pad the contract to look safe.
+ ## Output
- ## Pre-flight
+ The success contract is the result, locked by the user: the parts the drafting named, the dry-run value recorded, each cheap false pass closed. It locks only when judge's verdict stands and the user locks it.
- Only the human can, before the loop runs unsupervised:
+ Before the run starts, only the human can:
- - Issue a disposable API key with a provider-side spend cap. The contract bounds correctness; only the key bounds cost.
- - Babysit cycle one: watch what the run touches, confirm it uses the instruments the contract names, then leave.
+ - cap the spend — a disposable key: the contract bounds correctness, only the key bounds cost;
+ - watch the first cycle to see the run use what the contract names.
- ## Boundaries
+ If the running work later games the contract, the cheat is a bug in the contract — amend the contract here and rerun from the last honest point, never patch the worker.
- - The human owns and locks the contract. The optimizer never defines its own success.
- - When execution games the contract, fix the contract — widen the observable, add a guard, cap an artifact. Never fix the worker. A cheat is a bug in the target.
- - Resume from the last honest checkpoint and revert what the cheat produced.
+ Then return to the run the contract exists for. The contracting is spent once the user locks — anything further re-enters as an amendment to the contract, never as a new bar invented mid-run.