@mikenguyen69/harness 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/cli.js

@@ -8,19 +8,45 @@
  * hook-install policy lives here.
  */
 import { buildDispatchRequest, dispatch } from "./dispatch.js";
-import { USAGE } from "./help.js";
+import { COMMAND_HELP, SESSION_HELP, SESSION_PHASES, USAGE, wantsHelp, } from "./help.js";
 import { resolveInternalClis } from "./paths.js";
 import { buildInternalArgv, resolveRoute } from "./routes.js";
 import { formatVersion } from "./version.js";
 export async function main(argv) {
-    if (argv.includes("--help") || argv.includes("-h")) {
-        process.stdout.write(USAGE);
-        return 0;
-    }
     if (argv.includes("--version") || argv.includes("-V")) {
         process.stdout.write(formatVersion());
         return 0;
     }
+    const first = argv[0];
+    const helpRequested = wantsHelp(argv);
+    // Bare `harness`, `harness --help`, `harness -h` — the operator-journey text.
+    // A help flag that is not the leading token belongs to a specific command.
+    if (first === undefined || first === "--help" || first === "-h") {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    // `harness session [<phase>]` — enumerate the phases, and classify an
+    // unrecognised one as an unknown *phase*, not an unknown command. Runs before
+    // the generic `<noun> --help` path so a bare `harness session` prints them too.
+    if (first === "session") {
+        const phase = argv[1];
+        if (phase === undefined || phase === "--help" || phase === "-h") {
+            process.stdout.write(SESSION_HELP + "\n");
+            return 0;
+        }
+        if (!SESSION_PHASES.includes(phase)) {
+            process.stderr.write(`harness session ${phase}: unknown phase — expected one of ${SESSION_PHASES.join(", ")}\n`);
+            return 2;
+        }
+    }
+    // `harness <noun> --help` / `harness <noun> -h` — that command's own usage.
+    if (helpRequested && (argv[1] === "--help" || argv[1] === "-h")) {
+        const synopsis = COMMAND_HELP[first];
+        if (synopsis !== undefined) {
+            process.stdout.write(synopsis + "\n");
+            return 0;
+        }
+    }
     const route = resolveRoute(argv);
     if (route === null) {
         process.stderr.write(argv.length === 0
@@ -28,10 +54,6 @@ export async function main(argv) {
             : `harness ${argv.join(" ")}: unknown command\nRun harness --help\n`);
         return argv.length === 0 ? 0 : 2;
     }
-    if (route === "status-skeleton") {
-        process.stderr.write("harness status: not implemented (skeleton)\n");
-        return 1;
-    }
     const clis = resolveInternalClis();
     const internalArgv = buildInternalArgv(route, argv);
     const request = buildDispatchRequest(route.product, internalArgv, {

package/dist/help.js

@@ -5,7 +5,7 @@ Operator journey:
   harness doctor               read-only preflight before a run
   harness run                  drive the spec DAG with an agent fleet
   harness resume               continue after a signed door approval
-  harness status               project run and lane status from RunState
+  harness status               read-only unit lanes from the ledger (+ run overlay)
   harness report run           render the end-of-run HTML report
   harness report calibration   aggregate verification envelopes (calibration input)
 
@@ -41,7 +41,86 @@ Integration (machine-facing, same binary):
 
 Usage:
   harness --help               this text
+  harness <command> --help     usage for one command
   harness --version            facade version and internal build identity
   harness <command> [args…]    dispatch to the owning internal CLI
 `;
+/**
+ * The phases `harness session <phase>` accepts. The facade routes each to
+ * `agent session <phase>`; anything else is an unknown phase, not an unknown
+ * command.
+ */
+export const SESSION_PHASES = [
+    "started",
+    "heartbeat",
+    "gate_fired",
+    "escalated",
+    "ended",
+];
+export const SESSION_HELP = `harness session <phase>  append session.<phase> evidence (event JSON on stdin)
+
+  phases: ${SESSION_PHASES.join(", ")}
+
+  e.g. harness session started  < event.json`;
+/**
+ * One synopsis per facade command noun, shown for `harness <noun> --help` /
+ * `harness <noun> -h` so subcommand help never falls through to the
+ * operator-journey text above. Keyed by the leading facade token.
+ */
+export const COMMAND_HELP = {
+    init: `harness init  scaffold component.toml, hooks, CI workflow, generated adapters
+  --audit             read-only brownfield inventory (writes nothing)
+  --mode ratchet      brownfield adoption against a frozen debt baseline`,
+    doctor: `harness doctor  read-only preflight before a run
+  --repo <dir> --routes <routes.toml> [--spool <dir>] [--json]`,
+    run: `harness run  drive the spec DAG with an agent fleet
+  --repo <dir> --config <orchestration.json> --routes <routes.toml> [--spool <dir>] [--report <html>]`,
+    resume: `harness resume  continue a run after a signed door approval
+  --unit <id> [--repo <dir>] [--routes <routes.toml>]`,
+    status: `harness status  read-only unit lanes from the ledger, with a run-status spool overlay
+  [--ledger <dir>] [--spool <dir>] [--json]`,
+    report: `harness report <run|calibration>
+  report run --state <state.json>   end-of-run HTML report (orchestration)
+  report calibration                aggregate verification envelopes (system)`,
+    verify: `harness verify  run all bound gates (cheap first, fail fast) and emit the signed envelope`,
+    gate: `harness gate --pre --file <path>  ring-0 cheap gates before tool use`,
+    spec: `harness spec <check|materialize|project>
+  check        lint specs, dep DAG, consumes/produces   [--specs <dir>] [--system <system.toml>]
+  materialize  write idempotent unit.planned facts       --specs <dir> --system <system.toml> [--ledger <dir>] [--json]
+  project      emit unit YAML from OpenSpec + projection  --change <dir> [--openspec <dir>] [--out <dir>] [--json]`,
+    next: `harness next  list units ready to claim (deps merged, unclaimed or stale)
+  [--only <id-prefix>] [--all | --in-review | --merged | --escalated] [--json]`,
+    claim: `harness claim <unit-id> --session <id>  atomically take a ready unit
+  [--specs <dir>] [--system <path>] [--ledger <dir>] [--json] [--resume | --resume-after-door]`,
+    heartbeat: `harness heartbeat <unit-id> --session <id>  keep a claim alive  [--ledger <dir>]`,
+    merge: `harness merge <unit-id> <--check | --landed <sha>>  authorize or record a landed merge
+  [--system <system.toml>] [facts…]`,
+    door: `harness door <list|show|approve|reject>  open-decision surface
+  list [--sweep]
+  show <id>
+  approve <id> --reason "<who>: <why>" [--who <w>]
+  reject <id> --reason <why>`,
+    ledger: `harness ledger <append|read|verify-chain>  the hash-chained record plane  [--dir <path>]
+  append        full event JSON document on stdin
+  read          print the chain
+  verify-chain  check hash linkage`,
+    board: `harness board <build|serve>  local live dashboard
+  build [--ledger <dir>] [--spool <dir>] [--out board.html]
+  serve [--root <dir>]… [--port 4317] [--refresh 2000]`,
+    attest: `harness attest  write/verify provenance attestations for a merge
+  write  --unit <id> --landed <sha> [--ledger <dir>] [--out <dir>]
+  verify --unit <id> [--ledger <dir>] [--dir <dir>]`,
+    calibrate: `harness calibrate  calibration jobs`,
+    digest: `harness digest  digest surfaces`,
+    route: `harness route  print the resolved route as JSON`,
+    escalate: `harness escalate  raise session.escalated for the current unit`,
+    hook: `harness hook pre-tool-use  agent PreToolUse handler (payload on stdin)`,
+    session: SESSION_HELP,
+};
+/** True when a `-h`/`--help` token appears before any bare `--` separator. */
+export function wantsHelp(argv) {
+    const sep = argv.indexOf("--");
+    const scan = sep === -1 ? argv : argv.slice(0, sep);
+    return scan.includes("--help") || scan.includes("-h");
+}
 //# sourceMappingURL=help.js.map

package/dist/internal/orchestration/analyze/index.js

@@ -186,7 +186,10 @@ export function findExploreBeforeEdit(unitEvents) {
 export function findVerifyHeavierThanImplement(unitEvents) {
     const implementTurns = unitEvents.filter((e) => IMPLEMENT_STEPS.has(e.step) && (e.kind === "tool" || e.kind === "text")).length;
     const reviewTurns = unitEvents.filter((e) => REVIEW_STEPS.has(e.step) && (e.kind === "tool" || e.kind === "text")).length;
-    if (reviewTurns <= implementTurns || reviewTurns === 0)
+    // implementTurns === 0 is structural (a resume starting mid-pipeline, no
+    // implement step at all) — there is nothing to compare review against, not
+    // an imbalance. Symmetric with the reviewTurns === 0 guard below.
+    if (reviewTurns <= implementTurns || reviewTurns === 0 || implementTurns === 0)
         return [];
     return [
         {

package/dist/internal/orchestration/harness/cli.js

@@ -238,6 +238,7 @@ export class CliHarness {
             system,
             actor: { kind: event.session ? "agent" : "harness", id: actorId },
             type: event.type,
+            ...(event.ts ? { ts: event.ts } : {}),
             body,
         });
         await this.callMutation(["ledger", "append", "--dir", this.opts.ledgerDir ?? join(this.opts.cwd, ".harness", "ledger")], payload);
@@ -260,6 +261,14 @@ export class CliHarness {
             ...(this.opts.specsDir ? ["--specs", workspacePath(this.opts.specsDir, workspace)] : []),
             ...(this.opts.profilesDir ? ["--profiles", workspacePath(this.opts.profilesDir, workspace)] : []),
             ...(this.opts.systemId ? ["--system-id", this.opts.systemId] : []),
+            // an agent-driven run must be distinguishable from an operator typing
+            // `harness verify` by hand (issue #50) — record this dispatched
+            // session's real identity rather than relying on verify's human/cli
+            // default.
+            "--agent-kind",
+            "agent",
+            "--agent-id",
+            session,
             "--json",
             ...this.base(),
         ]);
@@ -370,9 +379,10 @@ export function parseEnvelopeHash(stdout) {
  *   `⛔ merge blocked — door door-core-a-schema opened. Decide with: …`
  *   `⛔ merge blocked — door door-core-a-schema was REJECTED: …`
  *   `⛔ merge blocked — door door-core-a-schema awaits a decision`
+ *   `⛔ merge blocked — door door-core-a-schema is approved but <reason>`
  */
 export function parseDoorId(stderr) {
-    const m = stderr.match(/door\s+(\S+?)\s+(?:opened|was REJECTED|awaits)\b/);
+    const m = stderr.match(/door\s+(\S+?)\s+(?:opened|was REJECTED|awaits|is approved)\b/);
     return m ? m[1] : undefined;
 }
 //# sourceMappingURL=cli.js.map

package/dist/internal/orchestration/loop/index.js

@@ -1,6 +1,8 @@
 import { reconstructSessionEvents } from "../runners/telemetry.js";
 import { NULL_PUBLISHER } from "../runstate/publish.js";
 import picomatch from "picomatch";
+import { isUnparseableVerdict } from "../prompts/index.js";
+export const MAX_VERIFIER_REASKS = 2;
 function isRemoteTrackingRef(ref) {
     return ref.startsWith("refs/remotes/") || ref.startsWith("origin/");
 }
@@ -155,6 +157,7 @@ const needsYouKindFor = {
     "infrastructure-failure": "infrastructure-failure",
     "config-error": "budget",
     budget: "budget",
+    "unparseable-verdict": "escalation",
 };
 function recordHalt(log, halt) {
     log.append({
@@ -427,11 +430,21 @@ export async function step(unit, policy, deps) {
         catch (error) {
             return mutationFailure(unit.id, "heartbeat mutation", error, log);
         }
+        const implStartedAt = new Date().toISOString();
         const impl = await runner.run(briefing, policy, "implementer", workspace, onActivity);
+        const implEndedAt = new Date().toISOString();
         log.append({ t: "lane.cost", unitId: unit.id, delta: impl.cost });
         if (impl.telemetryError)
             return mutationFailure(unit.id, "implementer session telemetry", impl.telemetryError, log);
-        await emitReconstructedTelemetry(deps, { unitId: unit.id, session, runner: runner.name, model: policy.model, kind: "implementer" }, runner, impl);
+        await emitReconstructedTelemetry(deps, {
+            unitId: unit.id,
+            session,
+            runner: runner.name,
+            model: policy.model,
+            kind: "implementer",
+            startedAt: implStartedAt,
+            endedAt: implEndedAt,
+        }, runner, impl);
         if (impl.escalation) {
             log.append({
                 t: "unit.escalated",
@@ -530,11 +543,21 @@ export async function step(unit, policy, deps) {
         }
         // --- review (independent verifier session, read-only) -----------
         setStep("review");
-        const review = await runner.run(briefing, policy, "verifier", workspace, onActivity);
+        let reviewStartedAt = new Date().toISOString();
+        let review = await runner.run(briefing, policy, "verifier", workspace, onActivity);
+        let reviewEndedAt = new Date().toISOString();
         log.append({ t: "lane.cost", unitId: unit.id, delta: review.cost });
         if (review.telemetryError)
             return mutationFailure(unit.id, "verifier session telemetry", review.telemetryError, log);
-        await emitReconstructedTelemetry(deps, { unitId: unit.id, session, runner: runner.name, model: policy.model, kind: "verifier" }, runner, review);
+        await emitReconstructedTelemetry(deps, {
+            unitId: unit.id,
+            session,
+            runner: runner.name,
+            model: policy.model,
+            kind: "verifier",
+            startedAt: reviewStartedAt,
+            endedAt: reviewEndedAt,
+        }, runner, review);
         // a verifier that touches a file voids its verdict (M2 backstop). A
         // ClaudeRunner verifier structurally cannot write (no write tools); this
         // catches a runner that reports one anyway. Isolating a degraded-tier
@@ -546,6 +569,47 @@ export async function step(unit, policy, deps) {
                 continue;
             return exhausted(unit.id, config.retryBudget, log);
         }
+        let verifierReasks = 0;
+        while (isUnparseableVerdict(review.verdict)) {
+            if (verifierReasks >= MAX_VERIFIER_REASKS) {
+                const reasons = review.verdict?.reasons?.join("; ") || "no VERDICT line in the verifier output";
+                const halt = {
+                    kind: "unparseable-verdict",
+                    unitId: unit.id,
+                    message: `${unit.id}: verifier verdict unparseable after ${verifierReasks + 1} attempts (${reasons})`,
+                    unblock: `inspect the verifier transcript, check model output, and re-run`,
+                };
+                recordHalt(log, halt);
+                return { outcome: "halted", halt };
+            }
+            verifierReasks++;
+            log.append({
+                t: "lane.note",
+                unitId: unit.id,
+                note: `verifier verdict unparseable (${review.verdict?.reasons?.join("; ") || "no VERDICT line"}) — re-asking verifier session (re-ask ${verifierReasks}/${MAX_VERIFIER_REASKS})`,
+            });
+            reviewStartedAt = new Date().toISOString();
+            review = await runner.run(briefing, policy, "verifier", workspace, onActivity);
+            reviewEndedAt = new Date().toISOString();
+            log.append({ t: "lane.cost", unitId: unit.id, delta: review.cost });
+            if (review.telemetryError)
+                return mutationFailure(unit.id, "verifier session telemetry", review.telemetryError, log);
+            await emitReconstructedTelemetry(deps, {
+                unitId: unit.id,
+                session,
+                runner: runner.name,
+                model: policy.model,
+                kind: "verifier",
+                startedAt: reviewStartedAt,
+                endedAt: reviewEndedAt,
+            }, runner, review);
+            if (review.filesTouched.length > 0) {
+                const retry = registerRetryOrExhaust(unit.id, attempt, config.retryBudget, log, `verifier session wrote files (${review.filesTouched.join(", ")}) — verdict voided`);
+                if (retry)
+                    continue;
+                return exhausted(unit.id, config.retryBudget, log);
+            }
+        }
         if (review.verdict && !review.verdict.approved) {
             const retry = registerRetryOrExhaust(unit.id, attempt, config.retryBudget, log, `verifier rejected: ${review.verdict.reasons.join("; ")}`);
             if (retry)
@@ -786,11 +850,56 @@ export async function resumeAfterDoor(unitId, deps) {
             return exhausted(unitId, 0, log, ring2.evidence);
     }
     setStep("review");
-    const review = await runner.run(briefing, policy, "verifier", workspace, onActivity);
+    let reviewStartedAt = new Date().toISOString();
+    let review = await runner.run(briefing, policy, "verifier", workspace, onActivity);
+    let reviewEndedAt = new Date().toISOString();
     log.append({ t: "lane.cost", unitId, delta: review.cost });
     if (review.telemetryError)
         return mutationFailure(unitId, "door-resume verifier telemetry", review.telemetryError, log);
-    await emitReconstructedTelemetry(deps, { unitId, session, runner: runner.name, model: policy.model, kind: "verifier" }, runner, review);
+    await emitReconstructedTelemetry(deps, {
+        unitId,
+        session,
+        runner: runner.name,
+        model: policy.model,
+        kind: "verifier",
+        startedAt: reviewStartedAt,
+        endedAt: reviewEndedAt,
+    }, runner, review);
+    let verifierReasks = 0;
+    while (isUnparseableVerdict(review.verdict)) {
+        if (verifierReasks >= MAX_VERIFIER_REASKS) {
+            const reasons = review.verdict?.reasons?.join("; ") || "no VERDICT line in the verifier output";
+            const halt = {
+                kind: "unparseable-verdict",
+                unitId,
+                message: `${unitId}: verifier verdict unparseable during door resume after ${verifierReasks + 1} attempts (${reasons})`,
+                unblock: `inspect the verifier transcript and re-run orchestrate resume --unit ${unitId}`,
+            };
+            recordHalt(log, halt);
+            return { outcome: "halted", halt };
+        }
+        verifierReasks++;
+        log.append({
+            t: "lane.note",
+            unitId,
+            note: `verifier verdict unparseable during door resume (${review.verdict?.reasons?.join("; ") || "no VERDICT line"}) — re-asking verifier session (re-ask ${verifierReasks}/${MAX_VERIFIER_REASKS})`,
+        });
+        reviewStartedAt = new Date().toISOString();
+        review = await runner.run(briefing, policy, "verifier", workspace, onActivity);
+        reviewEndedAt = new Date().toISOString();
+        log.append({ t: "lane.cost", unitId, delta: review.cost });
+        if (review.telemetryError)
+            return mutationFailure(unitId, "door-resume verifier telemetry", review.telemetryError, log);
+        await emitReconstructedTelemetry(deps, {
+            unitId,
+            session,
+            runner: runner.name,
+            model: policy.model,
+            kind: "verifier",
+            startedAt: reviewStartedAt,
+            endedAt: reviewEndedAt,
+        }, runner, review);
+    }
     if (!review.ok || review.filesTouched.length || review.verdict?.approved === false) {
         const evidence = review.filesTouched.length
             ? `verifier wrote files: ${review.filesTouched.join(", ")}`

package/dist/internal/orchestration/prompts/index.js

@@ -170,7 +170,12 @@ ${diff.trim() || "(empty diff)"}
 \`\`\`
 `;
 }
-/** Parse the verifier's final `VERDICT:` line. Absent / malformed → reject. */
+export function isUnparseableVerdict(verdict) {
+    if (!verdict)
+        return true;
+    return verdict.unparseable === true;
+}
+/** Parse the verifier's final `VERDICT:` line. Absent / malformed → unparseable. */
 export function parseVerdict(text) {
     // Strip leading markdown emphasis / quote / list / heading markers and
     // surrounding `**`/`__`/backticks — agents routinely bold the verdict line
@@ -182,18 +187,29 @@ export function parseVerdict(text) {
         .filter((l) => l.toUpperCase().startsWith("VERDICT:"))
         .at(-1);
     if (!line) {
-        return { approved: false, reasons: ["no VERDICT line in the verifier output"] };
+        return {
+            approved: false,
+            reasons: ["no VERDICT line in the verifier output"],
+            unparseable: true,
+        };
     }
     const body = line.slice(line.indexOf(":") + 1).trim();
     if (/^APPROVE\b/i.test(body))
         return { approved: true, reasons: [] };
-    const dash = body.search(/[—-]/);
-    const reasonText = dash >= 0 ? body.slice(dash + 1).trim() : "";
+    if (/^REJECT\b/i.test(body)) {
+        const dash = body.search(/[—-]/);
+        const reasonText = dash >= 0 ? body.slice(dash + 1).trim() : "";
+        return {
+            approved: false,
+            reasons: reasonText
+                ? reasonText.split(",").map((r) => r.trim()).filter(Boolean)
+                : ["verifier rejected without stated reasons"],
+        };
+    }
     return {
         approved: false,
-        reasons: reasonText
-            ? reasonText.split(",").map((r) => r.trim()).filter(Boolean)
-            : ["verifier rejected without stated reasons"],
+        reasons: [`unparseable VERDICT line: "${line}"`],
+        unparseable: true,
     };
 }
 //# sourceMappingURL=index.js.map

package/dist/internal/orchestration/runners/telemetry.js

@@ -16,11 +16,12 @@ export function reconstructSessionEvents(p) {
             ? "ok"
             : "failed";
     return [
-        { type: "session.started", unitId: p.unitId, ...common },
+        { type: "session.started", unitId: p.unitId, ts: p.startedAt, ...common },
         {
             type: "session.ended",
             unitId: p.unitId,
             session: p.session,
+            ts: p.endedAt,
             body: {
                 ...common.body,
                 outcome,

package/dist/internal/system/agentops/scope.js

@@ -10,6 +10,23 @@ export function checkScope(changedFiles, effectiveScope) {
     const matches = picomatch(effectiveScope.map(norm), { dot: true });
     return changedFiles.map(norm).filter((path) => !matches(path));
 }
+/** Path-like tokens in a gate's `run =` command — e.g. `node packages/x/gates.mjs size` → `["packages/x/gates.mjs"]`. */
+function pathTokensIn(run) {
+    return run
+        .split(/\s+/)
+        .filter((tok) => tok.includes("/") || tok.includes("\\"))
+        .map(norm);
+}
+/**
+ * Which of the resolved profile's own bound-gate script paths this diff
+ * touches — a unit editing the referee that judges it (issue #55). Visibility
+ * only: this never changes the verdict by itself.
+ */
+export function gateFilesTouched(changedFiles, boundGates) {
+    const scriptPaths = new Set(boundGates.flatMap((g) => pathTokensIn(g.run)));
+    const changed = new Set(changedFiles.map(norm));
+    return [...scriptPaths].filter((p) => changed.has(p)).sort();
+}
 /** Derive both sides of the scope assertion from git + the accepted spec. */
 export function attestScope(opts) {
     if (!opts.baseRef || !opts.specsDir) {
@@ -35,7 +52,11 @@ export function attestScope(opts) {
                 reason: `no accepted spec found for unit "${unitId}" under ${opts.specsDir}`,
             };
         }
-        const stdout = execFileSync("git", ["diff", "--name-only", `${opts.baseRef}...HEAD`, "--"], { cwd: opts.componentDir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        const stdout = execFileSync("git", ["diff", "--name-only", `${opts.baseRef}...HEAD`, "--"], {
+            cwd: opts.componentDir,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
         const changedFiles = stdout
             .split(/\r?\n/)
             .map((path) => norm(path.trim()))
@@ -49,7 +70,9 @@ export function attestScope(opts) {
             effectiveScope,
             violations,
             ...(violations.length > 0
-                ? { reason: `changed paths outside declared scope: ${violations.join(", ")}` }
+                ? {
+                    reason: `changed paths outside declared scope: ${violations.join(", ")}`,
+                }
                 : {}),
         };
     }

package/dist/internal/system/cli.js

@@ -26,6 +26,8 @@ import { initCommand } from "./init/index.js";
 import { claimCommand, heartbeatCommand, nextCommand, } from "./sequencer/cli.js";
 import { specCommand } from "./spec/cli.js";
 import { verifyCommand } from "./verify/cli.js";
+import { attestCommand } from "./provenance/cli.js";
+import { statusCommand } from "./status/cli.js";
 const USAGE = `harness — deterministic scaffolding around nondeterministic agents
 
 Usage:
@@ -45,7 +47,11 @@ Usage:
                     project   emit harness unit YAML from OpenSpec + harness.projection.yaml
                               --change <dir> [--openspec <dir>] [--out <dir>] [--json]
   harness next      list units ready to claim (deps merged, unclaimed or stale)
+  harness status    read-only unit lanes from the ledger, with a run-status
+                    spool overlay  [--ledger <dir>] [--spool <dir>] [--json]
   harness claim     <unit-id> --session <id>   atomically take a ready unit
+                    --release                   hand an executing claim straight back
+                                                 (refused unless --session holds it)
   harness heartbeat <unit-id> --session <id>   keep a claim alive
   harness door      list [--sweep] | show <id> | approve <id> --reason … | reject …
   harness merge     <unit-id> <--check | --landed <sha>> [facts…] authorize/record
@@ -65,6 +71,7 @@ const COMMANDS = [
     "gate",
     "spec",
     "next",
+    "status",
     "claim",
     "heartbeat",
     "door",
@@ -103,6 +110,9 @@ if (cmd === "spec") {
 if (cmd === "next") {
     process.exit(nextCommand(process.argv.slice(3)));
 }
+if (cmd === "status") {
+    process.exit(statusCommand(process.argv.slice(3)));
+}
 if (cmd === "door") {
     process.exit(doorCommand(process.argv.slice(3)));
 }
@@ -169,6 +179,9 @@ if (cmd === "gate") {
         process.exit(code);
     // fall through: a bare `harness gate <name>` (not --pre) is still a skeleton
 }
+if (cmd === "attest") {
+    process.exit(attestCommand(process.argv.slice(3)));
+}
 process.stderr.write(`harness ${cmd}: not implemented (skeleton)\n`);
 process.exit(1);
 //# sourceMappingURL=cli.js.map