harnery 0.9.0 → 0.11.0

package/dist/commands/harness.js

@@ -0,0 +1,118 @@
+import { createBuiltinHarnessRegistry, runHarnessBench, } from "../core/harnesses/index.js";
+const registry = createBuiltinHarnessRegistry();
+export function registerHarnessCommand(program, emit) {
+    const command = program
+        .command("harness")
+        .description("Inspect registered harness capabilities and run their conformance bench.");
+    command
+        .command("list")
+        .description("List registered harness adapters and their high-signal capability claims.")
+        .option("--json", "Machine-readable profile catalog")
+        .action((opts) => {
+        const profiles = registry.list().map((adapter) => adapter.profile);
+        if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data({ harnesses: profiles });
+        }
+        else {
+            emit.text(renderProfileTable(profiles));
+        }
+    });
+    command
+        .command("show <id>")
+        .description("Show one harness's complete capability declaration.")
+        .option("--json", "Machine-readable profile")
+        .action((id, opts) => {
+        const adapter = registry.get(id);
+        if (!adapter) {
+            emit.error({
+                code: "unknown_harness",
+                message: `unknown harness ${JSON.stringify(id)} (registered: ${registry.ids().join(", ")})`,
+            });
+            emit.setExitCode(1);
+            return;
+        }
+        if (opts.json) {
+            emit.config({ format: "json" });
+            emit.data(adapter.profile);
+        }
+        else {
+            emit.text(renderProfile(adapter.profile));
+        }
+    });
+    command
+        .command("bench [harnesses...]")
+        .description("Run the offline adapter-contract bench (no model calls); drift exits non-zero.")
+        .option("--require-installed", "Also fail when a registered vendor CLI is missing")
+        .option("--json", "Machine-readable conformance report")
+        .action((harnesses, opts) => {
+        try {
+            const report = runHarnessBench(registry, { harnesses });
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(report);
+            }
+            else {
+                emit.text(renderBenchReport(report));
+            }
+            emit.setExitCode(report.drift || (opts.requireInstalled && report.skipped) ? 1 : 0);
+        }
+        catch (error) {
+            emit.error({ code: "harness_bench_failed", message: error.message });
+            emit.setExitCode(1);
+        }
+    });
+}
+export function renderProfileTable(profiles) {
+    const rows = profiles.map((profile) => [
+        profile.id,
+        profile.binary,
+        profile.capabilities.modelSelection.support,
+        profile.capabilities.effortSelection.support,
+        profile.capabilities.sessionId.support,
+        profile.capabilities.cost.support,
+    ]);
+    return renderTable(["HARNESS", "BINARY", "MODEL", "EFFORT", "SESSION", "COST"], rows);
+}
+export function renderProfile(profile) {
+    const lines = [
+        `${profile.displayName} (${profile.id})`,
+        `binary: ${profile.binary}`,
+        `integration: ${profile.integrationMode}`,
+        `auth: ${profile.authModel}`,
+        `model family: ${profile.modelFamily}`,
+        `effort values: ${profile.effortValues.join(", ") || "none"}`,
+        profile.verified
+            ? `verified: ${profile.verified.date} (${profile.verified.version})`
+            : "verified: not recorded",
+        "",
+        "capabilities:",
+    ];
+    for (const [dimension, claim] of Object.entries(profile.capabilities)) {
+        lines.push(`  ${dimension.padEnd(18)} ${claim.support}${claim.note ? ` — ${claim.note}` : ""}`);
+    }
+    return lines.join("\n");
+}
+export function renderBenchReport(report) {
+    const rows = report.results.map((result) => [
+        result.harness,
+        result.dimension,
+        result.declared,
+        result.observed,
+        result.verdict,
+    ]);
+    const table = renderTable(["HARNESS", "DIMENSION", "DECLARED", "OBSERVED", "VERDICT"], rows);
+    const summary = Object.entries(report.summary)
+        .filter(([, count]) => count > 0)
+        .map(([verdict, count]) => `${verdict}=${count}`)
+        .join(", ");
+    return `${table}\n\nmode: ${report.mode} (no model calls)\n${summary}`;
+}
+function renderTable(headers, rows) {
+    const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
+    const line = (cells) => cells
+        .map((cell, index) => cell.padEnd(widths[index]))
+        .join("  ")
+        .trimEnd();
+    return [line(headers), line(widths.map((width) => "-".repeat(width))), ...rows.map(line)].join("\n");
+}

package/dist/commands/presence.d.ts

@@ -1,12 +1,17 @@
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.js";
 /**
- * `presence`: mobile/office state for agents (~/.claude/presence).
+ * `presence`: two related surfaces under one name.
+ *
+ *   1. Mobile/office state for agents (~/.claude/presence): get / set /
+ *      clear / detect. The state file path is Claude-Code-specific but the
+ *      logic is generic.
+ *   2. Cross-machine session presence (ADR 0016): publish / fetch / peers —
+ *      the git-refs transport that lets sessions on other machines show up
+ *      in the peer table via `refs/harnery/presence/<machine>` on origin.
  *
  * Uses the injected EmitContext so composed and standalone consumers share
- * one code path. The state file path is Claude-Code-specific (lives under
- * ~/.claude/) but the detect/set/clear logic is generic: any agent harness
- * can adopt the same convention.
+ * one code path.
  */
 export declare function registerPresenceCommand(program: Command, emit: EmitContext): void;
 //# sourceMappingURL=presence.d.ts.map

package/dist/commands/presence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../../src/commands/presence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAkBnD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAoFjF"}
+{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../../src/commands/presence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA0BnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAwKjF"}

package/dist/commands/presence.js

@@ -1,17 +1,24 @@
+import { monorepoRoot } from "../core/agents/coord-client.js";
 import { emitCanonical, normalizeHarness, readHeartbeat, resolveOwner, } from "../core/agents/index.js";
+import { fetchPresence, publishPresence, readRemoteMachines, relayDaemonStatus, runRelayDaemon, } from "../core/presence/index.js";
 import { ageSeconds, applyDetection, clearPresence, formatAge, presenceFilePath, readPresence, writePresence, } from "../lib/presence.js";
 /**
- * `presence`: mobile/office state for agents (~/.claude/presence).
+ * `presence`: two related surfaces under one name.
+ *
+ *   1. Mobile/office state for agents (~/.claude/presence): get / set /
+ *      clear / detect. The state file path is Claude-Code-specific but the
+ *      logic is generic.
+ *   2. Cross-machine session presence (ADR 0016): publish / fetch / peers —
+ *      the git-refs transport that lets sessions on other machines show up
+ *      in the peer table via `refs/harnery/presence/<machine>` on origin.
  *
  * Uses the injected EmitContext so composed and standalone consumers share
- * one code path. The state file path is Claude-Code-specific (lives under
- * ~/.claude/) but the detect/set/clear logic is generic: any agent harness
- * can adopt the same convention.
+ * one code path.
  */
 export function registerPresenceCommand(program, emit) {
     const cmd = program
         .command("presence")
-        .description("Mobile/office state for agents (~/.claude/presence)")
+        .description("Presence: mobile/office state (get/set/clear/detect) + cross-machine session presence (publish/fetch/peers)")
         .action(() => {
         printStatus(emit);
     });
@@ -62,6 +69,74 @@ export function registerPresenceCommand(program, emit) {
             path: presenceFilePath(),
         });
     });
+    // ---- cross-machine session presence (ADR 0016) ----
+    cmd
+        .command("publish")
+        .description("Publish this machine's live sessions to refs/harnery/presence/<machine> on origin. " +
+        "Change-batched with a keepalive; --force pushes regardless. Synchronous (errors report).")
+        .option("--force", "Push even if unchanged / within throttle windows")
+        .action((opts) => {
+        const root = requireRoot(emit);
+        const r = publishPresence(root, { force: opts.force, sync: true });
+        if (r.status === "error") {
+            emit.error({ code: "publish_failed", message: r.error });
+            process.exit(1);
+        }
+        emit.data(r);
+    });
+    cmd
+        .command("fetch")
+        .description("Fetch peer machines' presence refs from origin (throttled; --force bypasses). Synchronous.")
+        .option("--force", "Fetch even within the throttle interval")
+        .action((opts) => {
+        const root = requireRoot(emit);
+        const r = fetchPresence(root, { force: opts.force, sync: true });
+        if (r.status === "error") {
+            emit.error({ code: "fetch_failed", message: r.error });
+            process.exit(1);
+        }
+        emit.data(r);
+    });
+    cmd
+        .command("relay-daemon")
+        .description("Run the relay client daemon in the foreground (normally spawned detached by the hooks " +
+        "when presence.relay is configured; holds the WebSocket, publishes on heartbeat change, " +
+        "caches peers' blobs for the renderers, exits when the machine goes idle).")
+        .action(async () => {
+        const root = requireRoot(emit);
+        process.exit(await runRelayDaemon(root));
+    });
+    cmd
+        .command("peers")
+        .description("Show sessions on other machines (merged from presence refs + the relay daemon's cache)")
+        .option("--json", "JSON output")
+        .option("--stale", "Include machines past the stale window")
+        .action((opts) => {
+        const root = requireRoot(emit);
+        const machines = readRemoteMachines(root, { includeStale: opts.stale });
+        const daemon = relayDaemonStatus(root);
+        if (opts.json)
+            emit.config({ format: "json" });
+        if (opts.json || !process.stdout.isTTY) {
+            emit.data({ machines, relay_daemon: daemon });
+            return;
+        }
+        emit.text(daemon.running
+            ? `relay daemon: running (pid ${daemon.pid}, ${daemon.url})\n`
+            : "relay daemon: not running (git-refs transport only)\n");
+        if (machines.length === 0) {
+            emit.text("no remote sessions known (try `presence fetch --force`)\n");
+            return;
+        }
+        for (const m of machines) {
+            emit.text(`${m.machine}  (published ${formatAge(m.age_secs)} ago)\n`);
+            for (const a of m.agents) {
+                const task = a.task ? `  "${a.task.slice(0, 70)}"` : "";
+                const files = a.files_touched?.length ? `  [${a.files_touched.length} files]` : "";
+                emit.text(`  agent-${a.name ?? a.instance_id.slice(0, 8)}${task}${files}\n`);
+            }
+        }
+    });
     cmd
         .command("detect")
         .description("Internal: read prompt text from stdin, apply detection rules, update state if signal is clear")
@@ -85,6 +160,14 @@ export function registerPresenceCommand(program, emit) {
         }
     });
 }
+function requireRoot(emit) {
+    const root = monorepoRoot();
+    if (!root) {
+        emit.error({ code: "not_in_repo", message: "coord root not found (no .harnery/ upward)" });
+        process.exit(1);
+    }
+    return root;
+}
 function printStatus(emit) {
     const r = readPresence();
     emit.data({

package/dist/commands/relay.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.js";
+/** Start the relay server. Exported for in-process integration tests. */
+export declare function startRelayServer(port: number): {
+    port: number;
+    stop: () => void;
+};
+export declare function registerRelayCommand(program: Command, emit: EmitContext): void;
+//# sourceMappingURL=relay.d.ts.map

package/dist/commands/relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.d.ts","sourceRoot":"","sources":["../../src/commands/relay.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAgCnD,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,IAAI,CAAA;CAAE,CAkGjF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAyB9E"}

package/dist/commands/relay.js

@@ -0,0 +1,143 @@
+import { MAX_FRAME_BYTES } from "../core/presence/relay-protocol.js";
+/**
+ * `relay serve`: the Bun self-host of the presence relay (ADR 0016 phase 2).
+ * Same wire protocol as the Cloudflare Durable Objects host in relay/worker/ —
+ * one in-memory room per opaque room id, warm-join cache, fan-out, rate
+ * limits. For teams who'd rather run their own box than use the public
+ * relay.harnery.com; point clients at it via `.harnery/config.jsonc` →
+ * `{ "presence": { "relay": "ws://host:port" } }`.
+ *
+ * Bun-only (Bun.serve WebSockets), like `harn tunnel` — fails fast with a
+ * clear message on a Bun-free host.
+ */
+const MAX_SOCKETS_PER_ROOM = 64;
+const RATE_BURST = 10;
+const RATE_REFILL_MS = 2000;
+const CACHE_TTL_MS = 15 * 60 * 1000;
+const ROOM_ID_RE = /^[0-9a-f]{32}$/;
+/** Start the relay server. Exported for in-process integration tests. */
+export function startRelayServer(port) {
+    if (typeof Bun === "undefined" || typeof Bun.serve !== "function") {
+        throw new Error("relay serve requires Bun (Bun.serve WebSockets)");
+    }
+    const rooms = new Map();
+    const roomOf = (roomId) => {
+        let r = rooms.get(roomId);
+        if (!r) {
+            r = { sockets: new Set(), cache: new Map() };
+            rooms.set(roomId, r);
+        }
+        return r;
+    };
+    const server = Bun.serve({
+        port,
+        fetch(req, srv) {
+            const url = new URL(req.url);
+            if (url.pathname === "/" || url.pathname === "/healthz") {
+                return Response.json({ ok: true, service: "harnery-presence-relay", v: 1 });
+            }
+            const m = /^\/v1\/room\/([0-9a-f]{32})$/.exec(url.pathname);
+            if (!m || !ROOM_ID_RE.test(m[1]))
+                return new Response("not found", { status: 404 });
+            const room = roomOf(m[1]);
+            if (room.sockets.size >= MAX_SOCKETS_PER_ROOM) {
+                return new Response("room full", { status: 429 });
+            }
+            const ok = srv.upgrade(req, {
+                data: { roomId: m[1], bucketTokens: RATE_BURST, bucketAt: Date.now() },
+            });
+            return ok ? undefined : new Response("expected websocket", { status: 426 });
+        },
+        websocket: {
+            open(ws) {
+                const room = roomOf(ws.data.roomId);
+                room.sockets.add(ws);
+                const now = Date.now();
+                for (const [sender, entry] of room.cache) {
+                    if (now - entry.at > CACHE_TTL_MS) {
+                        room.cache.delete(sender);
+                        continue;
+                    }
+                    ws.send(entry.raw);
+                }
+                ws.send(JSON.stringify({ t: "hello", peers: room.sockets.size }));
+            },
+            message(ws, message) {
+                if (typeof message !== "string" || message.length > MAX_FRAME_BYTES)
+                    return;
+                // Rate limit (token bucket per socket).
+                const d = ws.data;
+                const now = Date.now();
+                const refill = Math.floor((now - d.bucketAt) / RATE_REFILL_MS);
+                if (refill > 0) {
+                    d.bucketTokens = Math.min(RATE_BURST, d.bucketTokens + refill);
+                    d.bucketAt = now;
+                }
+                if (d.bucketTokens <= 0)
+                    return;
+                d.bucketTokens -= 1;
+                let frame;
+                try {
+                    frame = JSON.parse(message);
+                }
+                catch {
+                    return;
+                }
+                if (frame.t !== "pub" ||
+                    typeof frame.sender !== "string" ||
+                    !/^[0-9a-f]+$/.test(frame.sender) ||
+                    frame.sender.length > 64) {
+                    return;
+                }
+                const room = roomOf(d.roomId);
+                room.cache.set(frame.sender, { raw: message, at: now });
+                for (const peer of room.sockets) {
+                    if (peer === ws)
+                        continue;
+                    try {
+                        peer.send(message);
+                    }
+                    catch {
+                        /* dead socket */
+                    }
+                }
+            },
+            close(ws) {
+                const room = rooms.get(ws.data.roomId);
+                if (!room)
+                    return;
+                room.sockets.delete(ws);
+                if (room.sockets.size === 0 && room.cache.size === 0)
+                    rooms.delete(ws.data.roomId);
+            },
+        },
+    });
+    return {
+        port: server.port ?? port,
+        stop: () => server.stop(true),
+    };
+}
+export function registerRelayCommand(program, emit) {
+    const cmd = program
+        .command("relay")
+        .description("Self-host the presence relay (see also relay/worker/ for the Cloudflare host)");
+    cmd
+        .command("serve")
+        .description("Run the presence relay on this machine (Bun-only; same protocol as relay/worker/)")
+        .option("--port <n>", "Port to listen on", "8787")
+        .action((opts) => {
+        let server;
+        try {
+            server = startRelayServer(Number.parseInt(opts.port, 10));
+        }
+        catch (e) {
+            emit.error({
+                code: "relay_serve_failed",
+                message: e instanceof Error ? e.message : String(e),
+            });
+            process.exit(1);
+        }
+        emit.log(`presence relay listening on :${server.port} (ws path: /v1/room/<room-id>)`, "info");
+        // Foreground service: run until interrupted.
+    });
+}

package/dist/commands/sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAgHnD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAuK7E"}
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAoHnD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAuK7E"}

package/dist/commands/sync.js

@@ -22,6 +22,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { syncJsoncConfig } from "../core/config.js";
 // What we sync. Anything matching one of these (relative to .harnery/) is
 // considered part of the sync set. Everything else stays local-only.
 const SYNC_PATHS = ["identities/", "scratch/archived/", "councils/"];
@@ -29,10 +30,14 @@ function configPath() {
     return path.join(os.homedir(), ".config", "harnery", "sync.json");
 }
 function loadConfig() {
+    // Precedence: env → .harnery/config.jsonc `sync` → ~/.config/harnery/sync.json.
     const envRemote = process.env.HARNERY_SYNC_REMOTE;
     const envPrefix = process.env.HARNERY_SYNC_PREFIX ?? "harnery";
     if (envRemote)
         return { remote: envRemote, prefix: envPrefix };
+    const jsonc = syncJsoncConfig();
+    if (jsonc)
+        return jsonc;
     const p = configPath();
     if (!existsSync(p))
         return null;

package/dist/commands/workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/commands/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA2BnD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAuGjF"}
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/commands/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA8BnD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA+IjF"}

package/dist/commands/workflow.js

@@ -1,18 +1,20 @@
 import { workflowSubscriptionOnly } from "../core/config.js";
+import { createBuiltinHarnessRegistry } from "../core/harnesses/index.js";
 import { findCoordRoot } from "../core/hooks/resolve/coord-root.js";
-const HARNESSES = ["claude-code", "codex", "cursor"];
 export function registerWorkflowCommand(program, emit) {
+    const registry = createBuiltinHarnessRegistry();
+    const harnesses = registry.ids();
     const workflow = program
         .command("workflow")
         .description("Run bounded, schema-gated multi-subagent workflow scripts.");
     workflow
         .command("run <script>")
-        .description("Execute a workflow script (plain JS: `export default async ({agent, parallel, stage, log}) => …`). " +
+        .description("Execute a workflow script (plain JS: `export default async ({agent, parallel, stage, log, evidence}) => …`). " +
         "Subagents spawn as headless harness-CLI subprocesses, coordination-registered.")
         .option("--max-agents <n>", "Total-agent ceiling for the run (default 50)")
         .option("--concurrency <n>", "Concurrent-subagent cap (default 4)")
         .option("--cwd <dir>", "Working directory children spawn in (default: coord root)")
-        .option("--harness <name>", `Default harness for agent() calls: ${HARNESSES.join(" | ")} (default claude-code); scripts can override per agent via opts.harness`)
+        .option("--harness <name>", `Default harness for agent() calls: ${harnesses.join(" | ")} (default claude-code); scripts can override per agent via opts.harness`)
         .option("--resume-from <run-id>", "Reuse completed agent results from a prior run's journal; only changed/failed calls re-run")
         .option("--subscription-only", "Guarantee subscription billing: scrub API-key vars from child envs; fail loud when a " +
         "harness has no stored login (repo default via config.jsonc workflow.subscriptionOnly)")
@@ -28,10 +30,10 @@ export function registerWorkflowCommand(program, emit) {
             });
             process.exit(1);
         }
-        if (opts.harness && !HARNESSES.includes(opts.harness)) {
+        if (opts.harness && !registry.get(opts.harness)) {
             emit.error({
                 code: "bad_harness",
-                message: `unknown harness "${opts.harness}" (expected: ${HARNESSES.join(" | ")})`,
+                message: `unknown harness "${opts.harness}" (expected: ${harnesses.join(" | ")})`,
             });
             process.exit(1);
         }
@@ -46,19 +48,10 @@ export function registerWorkflowCommand(program, emit) {
             process.exit(1);
         }
         try {
-            const [{ runWorkflow }, { claudeCodeSpawner }, { codexSpawner }, { cursorSpawner }] = await Promise.all([
-                import("../core/workflow/engine.js"),
-                import("../core/workflow/spawn-claude.js"),
-                import("../core/workflow/spawn-codex.js"),
-                import("../core/workflow/spawn-cursor.js"),
-            ]);
+            const { runWorkflow } = await import("../core/workflow/engine.js");
             const report = await runWorkflow(script, {
                 coordRoot,
-                spawners: {
-                    "claude-code": claudeCodeSpawner,
-                    codex: codexSpawner,
-                    cursor: cursorSpawner,
-                },
+                spawners: registry.spawners(),
                 defaultHarness: opts.harness,
                 resumeFrom: opts.resumeFrom,
                 subscriptionOnly,
@@ -66,6 +59,12 @@ export function registerWorkflowCommand(program, emit) {
                 maxAgents: opts.maxAgents ? Number.parseInt(opts.maxAgents, 10) : undefined,
                 concurrency: opts.concurrency ? Number.parseInt(opts.concurrency, 10) : undefined,
                 cwd: opts.cwd,
+                harnessEvidence: Object.fromEntries(registry
+                    .list()
+                    .map((adapter) => [
+                    adapter.profile.id,
+                    { toolEvidence: adapter.profile.capabilities.toolEvidence },
+                ])),
             });
             if (opts.json) {
                 emit.config({ format: "json" });
@@ -78,11 +77,48 @@ export function registerWorkflowCommand(program, emit) {
                 : "";
             emit.text(`run ${report.runId} (${report.name}) finished: ${report.agentsSpawned} agent(s)${cachedPart}, ` +
                 `$${report.costUsd.toFixed(4)}, ${Math.round(report.durationMs / 1000)}s\n${billingPart}` +
+                `acceptance: ${report.acceptance.satisfied} satisfied, ${report.acceptance.unsatisfied} unsatisfied, ` +
+                `${report.acceptance.unknown} unknown\n` +
                 `journal: ${report.journalPath}\n` +
+                `proof: ${report.proofPath}\n` +
                 `result: ${typeof report.result === "string" ? report.result : JSON.stringify(report.result, null, 2)}\n`);
         }
         catch (err) {
-            emit.error({ code: "workflow_failed", message: err.message });
+            const proofPath = typeof err === "object" && err !== null && "proofPath" in err
+                ? String(err.proofPath)
+                : undefined;
+            emit.error({
+                code: "workflow_failed",
+                message: `${err.message}${proofPath ? `\nproof: ${proofPath}` : ""}`,
+            });
+            process.exit(1);
+        }
+    });
+    workflow
+        .command("proof <run-id>")
+        .description("Show the bounded proof packet for a completed workflow run.")
+        .option("--json", "Emit the stored proof packet as JSON")
+        .action(async (runId, opts) => {
+        const coordRoot = findCoordRoot();
+        if (!coordRoot) {
+            emit.error({
+                code: "no_coord_root",
+                message: "no .harnery/ coordination root found; run `init` first",
+            });
+            process.exit(1);
+        }
+        try {
+            const { readWorkflowProof, renderWorkflowProof } = await import("../core/workflow/proof.js");
+            const proof = readWorkflowProof(coordRoot, runId);
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(proof);
+                return;
+            }
+            emit.text(renderWorkflowProof(proof));
+        }
+        catch (err) {
+            emit.error({ code: "workflow_proof_failed", message: err.message });
             process.exit(1);
         }
     });

package/dist/core/agents/canonical-emit.d.ts

@@ -18,6 +18,21 @@ export interface CanonicalEmitInput {
     parentSessionId?: string;
     parentTurnId?: string;
 }
+/**
+ * Resolve the coord root for a canonical emit.
+ *
+ * Order: explicit `HARNERY_COORD_ROOT_OVERRIDE` → git-superproject-aware
+ * `monorepoRoot()` (must actually carry `.harnery/`) → cwd walk (non-git
+ * hosts). The git-aware step is load-bearing: a shell cd'd into a nested
+ * directory that carries its own `.harnery/` (e.g. an embedded harnery
+ * checkout) made the old cwd-walk resolve the NESTED root, from which
+ * `<root>/harnery/bin/agent-coord` doesn't exist — so `agents status` /
+ * `set-task` emits silently vanished and the Stop-hook's rule 1/3
+ * (`state.status_checked` in-turn) blocked turns that had done the ritual.
+ * Same bug class as the coordHelperOpts root-pin fix; this closes the
+ * emitCanonical instance of it.
+ */
+export declare function resolveEmitRoot(start?: string): string | null;
 export declare function emitCanonical(input: CanonicalEmitInput): void;
 /**
  * Normalize the heartbeat's `platform` field (which uses snake_case

package/dist/core/agents/canonical-emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonical-emit.d.ts","sourceRoot":"","sources":["../../../src/core/agents/canonical-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CA8B7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,CAIjG"}
+{"version":3,"file":"canonical-emit.d.ts","sourceRoot":"","sources":["../../../src/core/agents/canonical-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,aAAa,GAAG,QAAQ,GAAG,OAAO,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAW5E;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAsC7D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,QAAQ,GAAG,OAAO,CAIjG"}