harnery 0.9.0 → 0.10.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;AA0BnD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA+FjF"}

package/dist/commands/workflow.js

@@ -1,7 +1,9 @@
 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.");
@@ -12,7 +14,7 @@ export function registerWorkflowCommand(program, emit) {
         .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,

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"}

package/dist/core/agents/canonical-emit.js

@@ -11,8 +11,38 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { monorepoRoot } from "./coord-client.js";
+/**
+ * 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 function resolveEmitRoot(start = process.cwd()) {
+    const override = process.env.HARNERY_COORD_ROOT_OVERRIDE;
+    if (override)
+        return override;
+    // Memoized per start-dir: the session-tee middleware resolves once per
+    // emitted event, and monorepoRoot() spawns git — cache so a streaming
+    // command doesn't pay 1-3 subprocess spawns per output line.
+    if (cachedRoot && cachedRoot.start === start)
+        return cachedRoot.root;
+    const gitRoot = monorepoRoot();
+    const root = gitRoot && existsSync(join(gitRoot, ".harnery")) ? gitRoot : findRepoRoot(start);
+    cachedRoot = { start, root };
+    return root;
+}
+let cachedRoot;
 export function emitCanonical(input) {
-    const root = findRepoRoot();
+    const root = resolveEmitRoot();
     if (!root)
         return;
     const binary = resolve(root, "harnery", "bin", "agent-coord");
@@ -38,11 +68,19 @@ export function emitCanonical(input) {
             args.push("--parent-session-id", input.parentSessionId);
         if (input.parentTurnId)
             args.push("--parent-turn-id", input.parentTurnId);
-        spawnSync(binary, args, {
+        // Pin cwd + HARNERY_COORD_ROOT_OVERRIDE so the child writes to the SAME
+        // stream we resolved, regardless of where the caller's shell is cd'd.
+        const result = spawnSync(binary, args, {
             encoding: "utf8",
             stdio: "ignore",
             timeout: 3000,
+            cwd: root,
+            env: { ...process.env, HARNERY_COORD_ROOT_OVERRIDE: root },
         });
+        if (result.error || result.status !== 0) {
+            const why = result.error ? result.error.message : `exit ${result.status}`;
+            process.stderr.write(`emitCanonical: ${input.type} emit failed (${why})\n`); // lint-ok-emission: soft-fail diagnostic promised by the module doc; silent drops cost blocked turns
+        }
     }
     catch {
         /* never break the caller */
@@ -59,7 +97,7 @@ export function normalizeHarness(platform) {
         return "codex";
     return "claude-code";
 }
-function findRepoRoot(start = process.cwd()) {
+function findRepoRoot(start) {
     let dir = resolve(start);
     while (true) {
         if (existsSync(join(dir, ".harnery")))

package/dist/core/agents/cli.js

@@ -188,7 +188,9 @@ async function handleStateAction(root, action, rest) {
             const task = args.join(" ");
             const hb = writer.setTask(root, owner, task);
             if (!hb) {
-                process.stderr.write(`agent-coord set-task: no heartbeat at .harnery/active/${owner}.json\n`);
+                // Name the RESOLVED root: when a nested .harnery/ shadows the real
+                // coordination home, the full path is what makes that diagnosable.
+                process.stderr.write(`agent-coord set-task: no heartbeat at ${root}/.harnery/active/${owner}.json\n`);
                 return 1;
             }
             process.stdout.write(`${JSON.stringify({ instance_id: owner, task: hb.task ?? null, cleared: !task })}\n`);
@@ -664,7 +666,7 @@ async function handleResolveName(root, rest) {
         process.stdout.write(`${JSON.stringify({ instance_id: owner, name: null, kind: null })}\n`);
         return 0;
     }
-    process.stdout.write(`${JSON.stringify({ instance_id: owner, name: resolved.name, kind: resolved.kind })}\n`);
+    process.stdout.write(`${JSON.stringify({ instance_id: owner, name: resolved.name, kind: resolved.kind, agent_id: resolved.agent_id ?? null })}\n`);
     return 0;
 }
 async function handleEmitEvent(root, rest) {

package/dist/core/agents/render/prompt-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAgCH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;iDAC6C;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAqBnE"}
+{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAiCH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;iDAC6C;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAqBnE"}