Goal

Goal-gated cooking. A frontmatter Stop hook is the completion gate — it reads the ## VK_GOAL_STATUS footer you print each turn and forces a new turn (no user input needed) until it reports status:COMPLETE with every clause evidenced, or a legitimate terminal state (BLOCKED_ABORT/AWAITING_USER_INPUT). You (Opus) distill the completion condition, execute via /vk-cook-router, and independently re-verify each clause before ever printing COMPLETE — the hook trusts your printed status, it does not re-run anything itself, so never print COMPLETE without genuine verification. Autonomous by default — no per-step pauses; run to completion. Follow the Orchestration Protocol and Development Rules (workflows/*) — shared lifecycle, Verification Gate, Decision Classification, Voice. Do not re-derive them here.

<input>$ARGUMENTS</input>

How the gate works here (read this — it drives every turn)

This command's frontmatter declares a Stop hook (confirmed working, CLI v2.1.207) that fires whenever you finish a turn. It reads the ## VK_GOAL_STATUS block in your last message and decides: status:COMPLETE with every clause evidenced (or BLOCKED_ABORT/AWAITING_USER_INPUT) → approves the stop; anything else (INIT/EXECUTE/VERIFY, or COMPLETE missing evidence) → forces you to continue, with no new user message. This makes autonomous cross-turn execution work without the user typing anything.

Built-in /goal is a separate, optional mechanism — reach for it only when you need something this hook doesn't provide: more than 8 consecutive forced continuations (the harness caps custom Stop hooks at 8 blocks in a row), the built-in ◎ /goal active status indicator, turn/token accounting, /goal clear, or resume-across-session-restart safety. For a normal /vk-goal run, you do not need it.

Note: chaining /goal /vk-goal … in one prompt still doesn't work — built-in /goal swallows all trailing text as its own condition string rather than dispatching a second command. This is no longer the primary concern it once was (the Stop hook above covers the common case), but if you do want built-in /goal layered on top for one of the reasons above, arm it separately: run /vk-goal <input> first, then /goal <condition> as its own prompt.

Input auto-detection

Inspect <input> (strip flag tokens first):

• A goal.md file path (output of /vk-plan-goal) → read Success Criteria + Verification; distill condition. HoH default ON: route by the HoH flow marker.
  • Marker present (> **Execution flow: /vk-hoh-run**) → read spec = + loops = from the marker; S = spec.md, T = loops (default 3); go to Step 3-HoH. (/vk-plan-goal emits this marker by default.)
  • Marker absent → legacy goal.md. If a sibling spec.md exists → still Step 3-HoH; else Step 3 (router). --no-hoh forces Step 3 (router) regardless.
• References an existing plan (path under ./plans, or "the plan / latest plan") → distill the condition from that plan; run router in Execute mode.
• A task/feature description → distill the condition from the task; run router in Full mode (it plans first).
• Empty → ask the user what to build (one question), then proceed.

Modifiers (flag-literalism)

A flag is active ONLY if its literal token appears in <input>. Pass matched flags THROUGH to /vk-cook-router verbatim:

• Default = autonomous (--auto behavior): no per-step pauses; run to completion with no user input. --auto is implied even when not typed — forward it to the router by default.
• --interactive → opt BACK into pauses: confirm the drafted condition (Step 1), and honor the router's Chunk-Plan approval + pre-commit confirmation. Use when you want checkpoints.
• --no-test → skip the router's Testing step (use sparingly). If set, DROP any test-based clause from the condition — never hold a gate the run cannot satisfy.
• --no-worktree → forward to the router: skip its session worktree isolation + auto-PR (workflows/worktree-session.md §1-§2). Default (absent) = router's worktree isolation stays ON, so a /vk-goal run also gets an isolated branch + auto-PR at finalize unless this is set.
• --no-hoh → forward to whichever executor runs (router OR /vk-hoh-run): opt out of HoH default. When the goal.md has no HoH marker OR --no-hoh is set → Step 3 runs /vk-cook-router with --no-hoh forwarded. --loops N → HoH iteration budget (forward when HoH runs).

Step 1 — Distill the completion condition (the core step)

Turn the task/plan into ONE condition you can evaluate from real evidence. Rules:

• Verifiable end-states only — tests pass, typecheck/lint clean, /code-review reports 0 criticals, a named file/route exists, an exit code. NEVER subjective ("clean code", "works well").
• Evidence-backed — judgeable from artifacts the router already produces (Evidence Gate = real test output; the mandatory /code-review turn = criticals count; git diff).
• Map to the router's gates so completion and the condition agree — e.g. acceptance criteria met AND tests green AND /code-review shows 0 criticals.
• Keep it one tight sentence with explicit AND-clauses.

Example: all tests in the affected suite pass, typecheck is clean, and /code-review reports 0 critical findings for the JWT-auth change.

Default (autonomous): print the condition and proceed without pausing. --interactive: show the drafted condition and get one-line confirmation (this sets the run's stop line — a User-Challenge decision) before proceeding.

Step 2 — INIT: adopt the condition, start executing immediately

State the condition explicitly in the transcript ("Completion gate: <condition>"). Print the ## VK_GOAL_STATUS footer with status: INIT — but do NOT end the turn here just because initialization is done. In the SAME turn, proceed straight to Step 3 (EXECUTE). Ending a turn on INIT alone burns one of the hook's limited forced-continuation cycles for zero progress.

Step 3 — EXECUTE: run the router (no HoH marker)

Invoke /vk-cook-router <task-or-plan-path> [--auto] [--no-test] [--no-worktree] via the Skill tool (it is a custom command, not a built-in). Forward --auto by default (autonomous is this command's default); omit --auto only when --interactive was typed. Forward --no-test and --no-worktree only if present in the original input. The router prints its Chunk Plan table, routes each chunk by tier, and validates every chunk via real git diff — you do not re-implement that here.

Step 3-HoH — EXECUTE: run the HoH loop (default when marker OR spec.md present)

Invoke /vk-hoh-run <spec-path> --loops N [--interactive if not --auto] via the Skill tool. S = spec.md from the marker, or the plan-path (/vk-hoh-run drafts the spec). Forward --no-worktree if present; do NOT forward --no-test (HoH QA always verifies). HoH runs plan→dev→qa for T loops, yields reports/final.md. Re-verify the completion condition against HoH's final evidence + git diff exactly like the router path — the Evidence Gate and Stop hook treat HoH's evidence identically. At HoH checkpoints (only with --interactive), emit ## VK_GOAL_STATUS with status: AWAITING_USER_INPUT + next: and yield.

Step 4 — VERIFY: re-check the gate before ever printing COMPLETE (the invariant)

When the router reports done, do not accept its self-report as completion. Re-verify the condition clause-by-clause against real evidence you can see (git diff, pasted test output, the /code-review result).

• All clauses met → print ## VK_GOAL_STATUS with status: COMPLETE, every clause [x] with its evidence citation → go to Step 5.
• Any clause unmet → print ## VK_GOAL_STATUS with status: EXECUTE or VERIFY (whichever applies), name the exact gap, increment cycle:, and — in the same turn where possible — re-route ONLY that gap back through /vk-cook-router (or fix inline if it is a one-line trivial). Never end a turn on a bare status report when there is a known next action to take (the 8-consecutive-block cap makes idle turns expensive). Bound this to 3 cycles; if still unmet after 3, print status: BLOCKED_ABORT naming exactly which clause fails and why (never fake completion — the hook approves BLOCKED_ABORT as a legitimate terminal state).
• Never self-declare completion — the Stop hook trusts your printed COMPLETE status at face value; it has no tools of its own to double-check you (transcript-only, no file/tool access). Printing COMPLETE without genuine verification defeats the entire point of this gate.

Step 5 — Finalize

When status: COMPLETE is printed (and the hook approves the stop): concise report — the condition used, met/unmet per clause with the evidence line, cycles taken, deviations, remaining risks, and the router's per-tier token-economy note. With the autonomous default, the router auto-commits when tests pass and its code-review turn is clean; with --interactive the pre-commit confirmation still waits (emit AWAITING_USER_INPUT there too, per Step 3). If the user separately armed built-in /goal per the note above, remind them to run /goal clear to disarm it.

VK_GOAL_STATUS Footer (print at the end of every gated turn)

## VK_GOAL_STATUS
- status: INIT | EXECUTE | VERIFY | COMPLETE | BLOCKED_ABORT | AWAITING_USER_INPUT
- condition: <the one-sentence condition from Step 1>
- cycle: <N>/3
- clauses:
  - [ ] <clause text> - <evidence so far, or "pending">
  - [x] <clause text> - <evidence citation: command + result>
- next: <one line: what happens next turn, or "none - stopping">

This block must be the LAST content of your message — nothing printed after it — and must appear exactly once, never inside a code fence. The Stop hook only trusts a block meeting all three structural rules (last, single, unfenced); anything else is treated as if no status were printed at all.

Notes

• IMPORTANT: Autonomous by default — run to completion with no per-step pauses. Add --interactive only when you want confirmation checkpoints.
• IMPORTANT: Every gated turn must front-load real work (INIT+EXECUTE together, EXECUTE+VERIFY together) — the harness caps forced continuations at 8 in a row; a turn that only prints status without also acting burns that budget for nothing.
• IMPORTANT: The ## VK_GOAL_STATUS footer is the contract the Stop hook reads — always print it last, once, unfenced.
• IMPORTANT: The condition is the contract — hold only clauses the run can actually satisfy (respect --no-test). A clause the run can never meet burns cycles for nothing.
• IMPORTANT: Never fabricate that the condition is met — the hook cannot verify your evidence itself; confirm it from real evidence before ever printing COMPLETE.
• IMPORTANT: Chaining /goal /vk-goal … still doesn't work (built-in /goal swallows trailing text as its condition) — arm built-in /goal separately if you want its extra features layered on top of this hook.