HoH Run

Harness-of-Harness (HoH) orchestrator (arXiv:2609.01481). You coordinate a fixed planning–coding–testing loop that continually improves a software artifact across iterations. Each loop produces a bounded increment, verifies it independently, and carries the artifact + evidence into the next loop — progress accumulates instead of re-deriving from code alone.

You are the Runtime: freeze each role's inputs, enforce permissions, run Runtime.check(A_t), bind evidence to the tested candidate, record state, guard the stop gate. The three roles are separate skills — /vk-hoh-plan, /vk-hoh-dev, /vk-hoh-qa — each one invocation of the same harness–model configuration. When the model cannot delegate via the Agent/Task tool, execute each role's contract inline — read D_t, write A_t, verify E_t yourself. Runtime contract + file schemas + permissions table: references/runtime-contract.md (SSOT — read it; do not restate it here). Shared discipline: workflows/development-rules.md (Verification Gate, Evidence Gate, no fake data) — applies to every role via this run.

<input>$ARGUMENTS</input>

Input auto-detection

Inspect <input> (strip flag tokens first):

• A spec/PRD path (.md on disk) → use it as S verbatim.
• A task/feature description → draft a concise S in the run dir; ask ONE question only if ambiguous.
• A path under ./plans/...hoh-... (resume) → load spec.md + last loop; continue.
• Empty → ask what to build (one question), then proceed.

Modifiers (flag-literalism)

A flag is active ONLY if its literal token appears in <input>:

• --loops N → budget T=N (default 3). -1 = unbounded (convergence gate only).
• --lane <tiny|normal|high-risk> → override lane detection (workflows/routing-card.md §2). Default = derived from the spec flags.
• --interactive → confirm before each loop (default: autonomous — loops back-to-back; pause only on blocked/stop).

Lifecycle

0. Init run directory

Create plans/YYYYMMDD-HHmm-hoh-<slug>/ with spec.md, empty loops/, issue-ledger.md (header table only), and run.md (frontmatter per runtime-contract.md › run.md). Print the run dir path — this IS the HoH state root.

1. For each loop t = 1..T

1a. Freeze inputs. S = spec.md, E_{t-1} = latest loop-(t-1)-evidence.md (∅ if t=1). The current workspace IS A_{t-1}. Pass to each role by file path — never paste the artifact.

1b. Project Planner — invoke /vk-hoh-plan (or inline: read S + E_{t-1}, write D_t yourself). Keep D_t concise — list tasks, not prose. File gate: git status must show no source-tree change (only the new dev-doc).

1c. Developer — invoke /vk-hoh-dev (or inline: implement D_t tasks yourself). Single-writer on the artifact; writes no state files. Write code efficiently — deliver all D_t tasks in one pass, don't iterate on style. Runtime.check(A_t) = deterministic build + execute (compile, then run it — not lint alone), wrapped in timeout 120s (a hung build/run = fail, not pass). A server that doesn't respond within 30s = fail. Commit A_t: hoh-loop-N dev <slug>.

1d. QA Tester — invoke /vk-hoh-qa (or inline: verify A_t against S + D_t yourself). Write E_t with status + gaps + regressions. Time-box ALL checks: build timeout 60s, server probe timeout 30s, test suite timeout 60s. Do NOT start dev servers interactively — background + curl + kill. Commit: hoh-loop-N qa <slug>.

1e. Record + decide. Append the loop row to run.md. Evaluate the stop gate (runtime-contract.md › Stop gate): E_t.status==passed AND unresolved_gaps==[] AND regressions==[] → increment accepted (continue for capability growth if budget remains — ask in --interactive, else stop at T); gaps/regressions remain → next loop reprioritizes; a role blocked twice on the same blocker → stop + escalate (print blocker + role + evidence).

2. Finalize

Stop gate fires → write reports/final.md (loops run, accepted/rejected per loop, final gap count, issue-ledger summary opened/closed/reopened, per-role token-economy note). Concise. Then final commit hoh-final <slug> (interactive: confirm via /vk-git-cm).

Notes

• IMPORTANT: On non-delegating models, execute each role's contract inline (plan, code, test yourself) rather than spawning subagents. Do NOT retry subagent calls more than twice; switch to inline immediately. File-gate checks, per-stage commits, and stop gate are unchanged.
• IMPORTANT: Token economy: D_t concise (task list, not prose), E_t concise (status + gaps + regressions + verified behaviors, not narration). Skip any preamble/recap between loops — state moves by file path, not conversation. Prefer one-pass code delivery over iterative style refinement.
• IMPORTANT: Never trust a role self-report. Read D_t/E_t and the real evidence cited before advancing. Evidence Gate applies to you too (workflows/development-rules.md).
• IMPORTANT: Pass state by file path; never paste the artifact. Roles read what they need from disk.
• IMPORTANT: Runtime.check(A_t) is build+execute — NOT lint-only, NOT a schema check. The file gate (schema validation of state files) is separate and runs on D_t/E_t, not on the artifact.
• IMPORTANT: Per-stage commits (runtime-contract.md › Per-stage commits) — after Developer yields A_t and after QA yields E_t, not only at finalize.
• IMPORTANT: Autonomous mode (default, no --interactive): NEVER pause to ask the user. If a toolchain is missing (no compiler/runtime/installer on PATH), do NOT halt or ask whether to install — record Runtime.check = build-fail (toolchain missing: <name>) in the evidence, mark the loop's gaps accordingly, and continue to the next loop. The Developer should still write source code (it compiles+runs on the user's machine later); QA cites the toolchain gap in E_t. Only blocked (same blocker twice) stops the run.
• IMPORTANT: Host security policies (WDAC/AppLocker) may block execution of freshly-compiled binaries (Go .exe, Rust cargo run, etc.). If build succeeds but execute fails with a policy/access error, treat as build-fail (execution blocked by host policy) — not a code defect. Record in evidence, continue. If the same block persists for 2 loops, stop + escalate.
• IMPORTANT: QA must not hang on dev servers. If the artifact starts a server (Express, Flask, Next.js dev server, go run, etc.), QA verifies it with a time-boxed start → curl/wget health check → kill (not an interactive session). A server that doesn't respond within 30s = build-fail, not a pass.
• IMPORTANT: Git commits need an identity. If git config user.name/email is unset, the Runtime sets a repo-scoped identity (git -c user.name="HoH Runtime" -c user.email="hoh-runtime@local") before any commit — never skip a commit for missing identity.
• IMPORTANT: Single-writer isolation: only ONE /vk-hoh-run invocation per project workspace at a time. Concurrent runs on the same repo collide (git history rewrite, source overwrite). If a prior run dir exists under plans/, resume it instead of creating a new baseline.
• Domain hooks: HoH is generic. Roles activate their own domain skills (Godot MCP, asset-gen, ui-ux-pro-max, …) as S/D_t require — progressive disclosure. Reuse, not recreate: direct roles to existing skills/tools/MCP/asset pools before rebuilding (runtime-contract.md › D_t › Reuse).
• Diagrams (opt-in): when a loop needs a visual artifact (user asks, or high-risk lane checkpoint), activate the archify skill and run its CLI — never fork or hand-roll the spec/SVG. Contract: references/diagram-layer.md (locate, type routing, validate/deliver/visual-check sequence). Diagrams are auxiliary; a failure does not block the loop.