frontier-infra/proctor/goal-contract-opus

Goal Contract (Opus variant)

Turn a rough task into a locked contract before any code is written. Same three legs as the base skill — Context, Direction, Cost — plus one structural addition this variant exists for: a disposition gate that converts "fixed or owned, never noted" from a sentence the model can forget into an obligation the model must discharge before it is allowed to declare done.

This variant assumes the executing model is Opus-class and that the failure to defend against is not drift or ballooning alone, but silent disposition: encountering a known problem, privately deciding it is out of scope, and closing the session without surfacing it. The base skill treats accountability as good-faith execution. This one treats it as a reporting obligation the harness checks. Amplifying instruction does not fix silent disposition — witnessing it does. The skill emits the obligation; the paired hooks hold it.

Why — the three legs (unchanged)

Every unit of work needs all three. Most setups have the first two and miss the third:

• Context — the situation (claude-mem, vault, ops already provide this).
• Direction — Goal + Acceptance + Non-goals.
• Cost — Budget + Tripwire. The leg usually missing. An agent has no intrinsic

price on its own effort, so without a cost leg it both wanders (drift) and over-builds (a 1-hour job becomes a day). Same hole, two symptoms.

The fourth concern this variant adds — disposition

Cost caps how much gets done. Disposition governs what gets reported about what was encountered along the way. These are different failures:

• Without a cost leg: the model does too much, silently.
• Without a disposition gate: the model notices too much and says too little.

It hits a failing test, a FIXME, dead code, a stale doc — classifies it "pre-existing, not my scope" — and moves on without a word. You find out weeks later that it knew. The knowing is not the leak. The silent classification is.

Disposition removes the model's authority to silently classify something as out-of-scope. Every condition encountered must be closed honestly — and the bar for closure has teeth:

• fixed = rolled into this work and verified. The strong default. If a condition is cheap, or

sits in a file you're touching, or can be safely resolved now — do it now. "We need to fix and get things done" beats "I noted it." Prefer expanding the contract a little to rolling a fix in over deferring it.

• owned = taken into this contract to be fixed before done. This is not a closing

disposition and not a synonym for "filed somewhere." If the agent says it owns a condition, the next legal step is to fix/verify it in this session. A final answer with [OWNED] is invalid because owned work is still open work.

• deferred nonblocking = *not on the current goal path, proved nonblocking, and filed

as tracked work* in your tracker (a follow-ups doc, Linear, etc.) with Owner + Next action + Proof of closure + why nonblocking, this session. This is the fallback reserved for conditions whose honest fix would blow the budget/tripwire and do not block the stated goal.

Skipped-in-silence is not a legal third option. Neither is owned-in-prose — a condition "owned" only in the chat message, filed nowhere, with no next action. Also banned: using [OWNED] as a final escape hatch. Owned means "I am fixing it," not "I am walking away."

Workflow

1. Take the rough statement of the next task/phase. Ask at most ONE clarifying

question, and only if the goal is genuinely ambiguous. Do not interrogate.

1. Draft the contract using the template below. Acceptance must be observable;

non-goals concrete; budget real (not "as needed"); disposition obligation present.

1. Offer a distilled version — same contract, tighter. Let the user pick full or distilled.
2. Emit the paste-ready LOCKED CONTRACT block. The user pastes it back to start work.

Contract template

• GOAL — one sentence, an outcome (not a method).
• ACCEPTANCE — 2–4 bullets. **Every bullet MUST carry a backticked runnable proof command

(exit 0 = pass)** — e.g. "suite green: pnpm vitest run", "endpoint live: curl -sf localhost:3000/health", "no stubs: ! grep -rn 'NotImplementedError' src/". The bridge turns backticked commands into Warden machine checks that goal-verify runs against reality; a prose-only bullet becomes human_review, which stalls the close on operator sign-off. Done must be an exit code, not a claim.

• NON-GOALS — concrete things NOT to touch this round (named files, refactors, features, "nice-to-haves"). These are what the path-deny enforces.
• BUDGET — an effort ceiling. Pick what fits: ~time (e.g. ~1h), ≤N files, or "smallest change that meets acceptance". The file count is what the budget wall enforces.
• TRIPWIRE — if budget is hit, OR scope wants to expand, OR a refactor outside the goal tempts → STOP and report; don't grind.
• DISPOSITION — every pre-existing condition encountered this round must end fixed

(rolled in and verified — the default), operator-blocked (cannot proceed without a concrete human action), false-positive/historical, or deferred nonblocking (proved not to block the stated goal and filed in your tracker with Owner + Next action

• Proof of closure). **Owned means the agent takes it into this contract and fixes it before

done; [OWNED] is not a valid final tag.** The session may not declare done while any encountered condition is unlisted, still merely "owned," or deferred with no durable home. Empty list is legal only if nothing was encountered.

Paste-ready output

=== LOCKED CONTRACT ===
GOAL: ...
ACCEPTANCE:
  - ...
NON-GOALS:
  - ...
BUDGET: ...
TRIPWIRE: At the budget — or any scope/non-goal temptation — STOP and report before
continuing. No grinding, no gold-plating.
DISPOSITION: Before declaring done, emit DISPOSITION LOG — every condition encountered
(failing test, error, stub/FIXME/TODO, dead code, stale doc, type debt), each closed with one of:
[FIXED] / [FIXED_NOW] / [VERIFIED_CLOSED] (resolved now, with evidence),
[DEFERRED_NONBLOCKING] (does not block this goal AND filed with Owner + Next + Proof),
[OPERATOR_BLOCKED] (requires human access/decision; Owner + Next + Proof), or
[FALSE_POSITIVE]/[HISTORICAL_FALSE_POSITIVE] (witness matched noise/history, explain why).
If the gate blocks and lists witness keys, each closing line must contain the condition's
key AND its tag on the same line (e.g. `- [FIXED] a1b2c3d4e5f6 — reran suite, green`).
[OWNED] is NOT a final disposition: owned means you are taking it into this contract to fix
before done. A condition neither fixed nor validly deferred/blocked/false-positive is a
contract violation. "Owned" as paperwork, "pre-existing, so skipped," and "already filed"
without Owner + Next + Proof are banned. Empty log is legal ONLY if nothing was encountered.
RULES: Restate this contract before the first action. Check every step against GOAL +
NON-GOALS. Report against ACCEPTANCE at the budget and before declaring done. Emit the
DISPOSITION LOG as the last action before done — done is not claimable without it.
=== Work only to this contract. ===

For the agent executing a locked contract

• Restate GOAL + NON-GOALS in one line before the first action.
• The smallest change that meets ACCEPTANCE wins. Extra tests, abstractions, or

cleanup not named in ACCEPTANCE are non-goals — adding them is overcorrection.

• Pre-existing brokenness is the one carve-out from "smallest change." If you walk

into a failing test, type debt, dead code, or a stale doc — in a file you're touching, or otherwise cheap — fix it; don't note-and-leave. If the honest fix would blow the budget/scope, that's a tripwire: STOP, surface it with the measured cost, and let the user choose (expand now vs. explicitly defer/block with required fields). This is distinct from gold-plating: adding things nobody asked for is still overcorrection; leaving existing brokenness noted-but-unowned is not allowed. "The linter will catch it" is banned — every surfaced condition ends up fixed, operator-blocked, false-positive, or deferred nonblocking with Owner + Next + Proof; never just noted.

• Disposition is not discretionary. When you encounter a pre-existing condition, you

do not get to privately decide it is out of scope and continue in silence. The legal path is: fix it now (the default — if cheap, in a file you touch, or safely resolvable, roll it in), or, if it truly cannot be fixed inside this contract, close it as one of the explicit non-fix states: [DEFERRED_NONBLOCKING] with Owner + Next + Proof and why it does not block the goal; [OPERATOR_BLOCKED] with the exact human action; or [FALSE_POSITIVE] / [HISTORICAL_FALSE_POSITIVE] with evidence. `[OWNED]` is not a final state. If you own it, fix it before done.

• Done is gated, not declared. Before claiming done, emit the DISPOSITION LOG and

confirm each ACCEPTANCE bullet against an observable result. Do not narrate completion ("the endpoint now returns 200") — show the check. A claim without a shown result is treated as not done.

• Hit the budget, or tempted past scope? Stop and report — never unilaterally decide to go bigger.

Harness pairing (what makes this variant real)

This skill emits obligations. The obligations are advisory until a harness holds them. The base goal-contract skill stops at the paste-ready block. This variant sits under the hooks that ACTUALLY RUN today (canonical map: ~/.claude/hooks/goal-contract/README.md):

• Witness — `PostToolUse` on Bash|Edit|Write|MultiEdit. Logs every failing test and

error that Bash output actually contained, and every STUB the model writes (NotImplementedError, todo!(), comment-TODO/stub/placeholder) via Edit/Write — test files and docs exempt. Markers need comment syntax and match case-sensitively; data lines (JSON/API output) are never witnessed. Independent of what the model mentions.

• Disposition gate — `Stop` hook. Blocks "done" until the DISPOSITION LOG closes

every witnessed condition BY KEY (the block message prints keys; each closing line carries key + tag). Bounded: after 3 blocks it YIELDS — approves the stop, pages the operator by voice, records the yield — instead of looping forever. A flooded witness log (>60, pre-fix sessions) yields immediately with a purge hint.

• Warden gate — `Stop` hook (`goal-gate.py`) + `goal-verify.py`. Runs the manifest's

done_when checks against reality (bridged from backticked ACCEPTANCE commands) and blocks until the proof signs off. pending (human_review residue) blocks once for the handoff report, then yields to the operator with a voice page — the model cannot resolve pending by design. Failing checks block up to 5 times, then yield LOUDLY; the proof stays failed on disk, so a yielded stop is never a verified done.

• NON-GOALS / BUDGET teeth (verify-time, 2026-07-02). Backticked path/glob tokens in

NON-GOALS (e.g. ` src/cache/` ``) become a `diff_constraint` forbidden-list, and "≤N files" in BUDGET becomes a changed-file-count check — both run by `goal-verify` against the real git diff. Author non-goals you want enforced as backticked paths/globs**; prose non-goals stay advisory (deliberate — no glob-guessing). This is scoped to the named paths only, preserving the broken-windows carve-out.

• Proof integrity. Proof files and the goal-contract data dir are read-only to the

session's direct tools (damage-control); proofs are written only by goal-verify.py.