harness-starter

$ARGUMENTS

Handle the request above through the 5-stage harness. You are the orchestrator. Do not analyze or implement code yourself — delegate each stage to a dedicated subagent, hand off via artifacts, and schedule the task graph.

First, study references/artifacts.md (artifact contracts) and references/decomposition.md (decomposition criteria). If references/conventions.md is filled in, pass its contents into every delegation prompt.

0. Setup

• Choose a <slug> (kebab-case) to identify the task.
• Create .harness/{specs,context,plans,reports}/ if missing.

Stage procedure (judge skip before each stage)

Each stage is skipped when its artifact already exists (reuse outputs made by external tools or humans).

1. Clarify

• If .harness/specs/<slug>.spec.md exists → skip.
• Otherwise delegate to the harness-clarify agent → produces spec.md.
• If ambiguity is high, clarify may ask the user (questions are allowed in this stage only).

2. Context Gather

• If .harness/context/<slug>.context.md exists → skip.
• Otherwise give the spec to harness-context and delegate → produces context.md. (read-only)

3. Plan

• If .harness/plans/<slug>.plan.md exists → skip (treat as a validated plan).
• Otherwise give spec + context to harness-planner and delegate → produces plan.md (task graph).
• Check the returned plan against the decomposition checklist (decomposition.md): 3–6 nodes? per-node acceptanceCriteria? are parallel nodes file/module-scoped (no conflicts)? no cycles in blockedBy? If anything is off, ask the planner to fix it (up to 2 times).
• If human approval is desired, summarize the plan and confirm before proceeding (optional).

4. Implement — wavefront execution of the task graph

Execute plan.md nodes in parallel, wave by wave. No locks or scripts — the orchestrator schedules:

loop:
  1. ready = nodes whose blockedBy are all status=done AND whose own status=pending
  2. if ready is empty but unfinished nodes remain → deadlock (cycle/stuck). Stop and report.
  3. delegate the ready nodes in parallel within a single message:
     for each node, Task(harness-implementer, input = that node + spec + context + conventions)
     (nodes in the same wave are file/module-scoped, so there are no write conflicts — safe to parallelize)
  4. on each node completion, update its status in plan.md to done (or failed).
  5. when all nodes are done, finish.