harnery 0.8.0 → 0.10.0

package/dist/commands/harness.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.js";
+import { type BenchResult, type HarnessBenchReport } from "../core/harnesses/index.js";
+import type { HarnessProfile } from "../core/harnesses/types.js";
+export declare function registerHarnessCommand(program: Command, emit: EmitContext): void;
+export declare function renderProfileTable(profiles: readonly HarnessProfile[]): string;
+export declare function renderProfile(profile: HarnessProfile): string;
+export declare function renderBenchReport(report: HarnessBenchReport): string;
+/** Kept exported so command tests can assert row semantics without model calls. */
+export type { BenchResult };
+//# sourceMappingURL=harness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../../src/commands/harness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,kBAAkB,EAExB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAYjE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA6DhF;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAU9E;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAkB7D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAcpE;AAgBD,mFAAmF;AACnF,YAAY,EAAE,WAAW,EAAE,CAAC"}

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/init.d.ts

@@ -23,11 +23,12 @@ export type { HookGroup, SettingsFile };
 export declare function registerInitCommand(program: Command, emit: EmitContext, binName?: string): void;
 /**
  * Merge agent-hook entries into a harness settings object in place, idempotently.
- * Preserves every existing hook; skips events already wired to
- * `agent-hook <subcommand>`. Honors the harness's entry shape (Claude/Codex nest
- * under an inner `hooks` array; Cursor uses a flat `{ command }`) and ensures the
- * root `version` key when the harness requires one. Pure (no fs/git) so it's
- * unit-testable.
+ * Preserves every existing hook; rewrites events already wired to
+ * `agent-hook <subcommand>` when their command string is stale (e.g. an older
+ * harnery wired a bare relative path). Honors the harness's entry shape
+ * (Claude/Codex nest under an inner `hooks` array; Cursor uses a flat
+ * `{ command }`) and ensures the root `version` key when the harness requires
+ * one. Pure (no fs/git) so it's unit-testable.
  *
  * The trailing space in the match (`agent-hook ${subcommand} `) is load-bearing:
  * it keeps `stop` from matching `stop-failure`.
@@ -36,6 +37,7 @@ export declare function wireHooks(settings: SettingsFile, spec: HarnessSpec, age
     wired: number;
     already: number;
     removed: number;
+    upgraded: number;
 };
 /**
  * Inverse of {@link wireHooks}: strip every harnery-owned hook entry from a
@@ -61,4 +63,12 @@ export declare function unwireHooks(settings: SettingsFile): {
  *   - key absent → splice it in as the first key (comment-safe).
  */
 export declare function stampBinName(configPath: string, binName: string, dryRun: boolean): string | null;
+/**
+ * Idempotently pin `workflow.subscriptionOnly: true` in `.harnery/config.jsonc`
+ * (see `workflowSubscriptionOnly()` in core/config.ts and the `workflow run`
+ * billing safeguards). Same comment-preserving discipline as `stampBinName`.
+ * A `workflow` key of ANY shape (including `subscriptionOnly: false`) is a
+ * deliberate project choice and is left alone.
+ */
+export declare function stampWorkflowDefaults(configPath: string, dryRun: boolean): string | null;
 //# sourceMappingURL=init.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAClG,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,YAAY,EAClB,MAAM,iCAAiC,CAAC;AAKzC,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;AAYxC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAsH/F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,EACjB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,SAAS,GACjB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAiCrD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAmB1F;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmDhG"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAClG,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,YAAY,EAClB,MAAM,iCAAiC,CAAC;AAKzC,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;AAYxC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAiI/F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,EACjB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,SAAS,GACjB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAqCvE;AAyDD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,YAAY,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAmB1F;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmDhG;AASD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAkCxF"}

package/dist/commands/init.js

@@ -92,6 +92,17 @@ export function registerInitCommand(program, emit, binName) {
             if (stamp)
                 actions.push(stamp);
         }
+        // ── 1c. workflow billing default ───────────────────────────────────────
+        // Every init'd project gets `workflow.subscriptionOnly: true`: workflow
+        // children ride the logged-in (subscription) harness auth, and the pin
+        // makes per-token API billing structurally impossible unless the project
+        // deliberately flips it. A committed `workflow` key of any shape is a
+        // deliberate choice and is never touched.
+        {
+            const stamp = stampWorkflowDefaults(resolve(coordDir, "config.jsonc"), dryRun);
+            if (stamp)
+                actions.push(stamp);
+        }
         // ── 2. harness hooks ───────────────────────────────────────────────────
         const settingsPath = resolve(projectRoot, spec.settingsFile);
         const agentHook = relative(projectRoot, resolve(HARNERY_ROOT, "bin", "agent-hook"));
@@ -110,19 +121,19 @@ export function registerInitCommand(program, emit, binName) {
         else {
             settings = {};
         }
-        const { wired, already, removed } = wireHooks(settings, spec, agentHook, harness);
-        if (wired === 0 && removed === 0) {
+        const { wired, already, removed, upgraded } = wireHooks(settings, spec, agentHook, harness);
+        if (wired === 0 && removed === 0 && upgraded === 0) {
             actions.push(`· all ${spec.events.length} ${harness} hooks already wired in ${rel(projectRoot, settingsPath)}`);
         }
         else if (dryRun) {
-            actions.push(`+ would wire ${wired} hook(s) and remove ${removed} legacy hook(s) in ` +
-                `${rel(projectRoot, settingsPath)} (${already} already present)`);
+            actions.push(`+ would wire ${wired} hook(s), upgrade ${upgraded} stale command(s), and remove ` +
+                `${removed} legacy hook(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
         }
         else {
             mkdirSync(dirname(settingsPath), { recursive: true });
             writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
-            actions.push(`+ wired ${wired} hook(s) and removed ${removed} legacy hook(s) in ` +
-                `${rel(projectRoot, settingsPath)} (${already} already present)`);
+            actions.push(`+ wired ${wired} hook(s), upgraded ${upgraded} stale command(s), and removed ` +
+                `${removed} legacy hook(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
         }
         // ── 3. agent-facing instructions block + skills ────────────────────────
         const applied = applyInstructions(projectRoot, { binName: bin, harness, dryRun });
@@ -132,11 +143,12 @@ export function registerInitCommand(program, emit, binName) {
 }
 /**
  * Merge agent-hook entries into a harness settings object in place, idempotently.
- * Preserves every existing hook; skips events already wired to
- * `agent-hook <subcommand>`. Honors the harness's entry shape (Claude/Codex nest
- * under an inner `hooks` array; Cursor uses a flat `{ command }`) and ensures the
- * root `version` key when the harness requires one. Pure (no fs/git) so it's
- * unit-testable.
+ * Preserves every existing hook; rewrites events already wired to
+ * `agent-hook <subcommand>` when their command string is stale (e.g. an older
+ * harnery wired a bare relative path). Honors the harness's entry shape
+ * (Claude/Codex nest under an inner `hooks` array; Cursor uses a flat
+ * `{ command }`) and ensures the root `version` key when the harness requires
+ * one. Pure (no fs/git) so it's unit-testable.
  *
  * The trailing space in the match (`agent-hook ${subcommand} `) is load-bearing:
  * it keeps `stop` from matching `stop-failure`.
@@ -150,6 +162,7 @@ export function wireHooks(settings, spec, agentHookPath, harness) {
     let wired = 0;
     let already = 0;
     let removed = 0;
+    let upgraded = 0;
     for (const { settingsKey, subcommand } of spec.legacyEvents ?? []) {
         const groups = settings.hooks[settingsKey] ?? [];
         const kept = groups.filter((group) => !groupCommands(group).some((command) => commandWiresSubcommand(command, subcommand)));
@@ -160,9 +173,14 @@ export function wireHooks(settings, spec, agentHookPath, harness) {
             settings.hooks[settingsKey] = kept;
     }
     for (const { settingsKey, subcommand } of spec.events) {
-        const command = `bash ${agentHookPath} ${subcommand} --harness ${harness}`;
+        const command = hookCommand(spec, agentHookPath, subcommand, harness);
         const groups = settings.hooks[settingsKey] ?? [];
-        const present = groups.some((g) => groupCommands(g).some((c) => commandWiresSubcommand(c, subcommand)));
+        let present = false;
+        for (const group of groups) {
+            upgraded += rewriteStaleCommands(group, subcommand, command, () => {
+                present = true;
+            });
+        }
         if (present) {
             already++;
             continue;
@@ -171,7 +189,52 @@ export function wireHooks(settings, spec, agentHookPath, harness) {
         settings.hooks[settingsKey] = groups;
         wired++;
     }
-    return { wired, already, removed };
+    return { wired, already, removed, upgraded };
+}
+/**
+ * The canonical hook command for one event. When the harness exports a
+ * project-dir env var to hook processes (Claude Code's CLAUDE_PROJECT_DIR),
+ * anchor the agent-hook path on it: hook processes inherit the session
+ * shell's cwd, which follows `cd` away from the project root — a bare
+ * relative path silently fails to spawn from there (no events, no image
+ * capture, no guards). `:-.` keeps the command working on harness versions
+ * that don't set the var. Only the env expansion is quoted so the
+ * `agent-hook <subcommand> ` wiring match stays byte-identical.
+ */
+function hookCommand(spec, agentHookPath, subcommand, harness) {
+    const anchor = spec.projectDirEnv ? `"\${${spec.projectDirEnv}:-.}"/` : "";
+    return `bash ${anchor}${agentHookPath} ${subcommand} --harness ${harness}`;
+}
+/**
+ * Rewrite any harnery-owned command for `subcommand` inside one hook group to
+ * the canonical form, in place. Returns the number of commands rewritten and
+ * calls `onPresent` when the subcommand is wired in this group at all.
+ */
+function rewriteStaleCommands(group, subcommand, canonical, onPresent) {
+    let rewritten = 0;
+    if ("command" in group && typeof group.command === "string") {
+        if (commandWiresSubcommand(group.command, subcommand)) {
+            onPresent();
+            if (group.command !== canonical) {
+                group.command = canonical;
+                rewritten++;
+            }
+        }
+    }
+    if ("hooks" in group && Array.isArray(group.hooks)) {
+        for (const hook of group.hooks) {
+            if (typeof hook.command !== "string")
+                continue;
+            if (!commandWiresSubcommand(hook.command, subcommand))
+                continue;
+            onPresent();
+            if (hook.command !== canonical) {
+                hook.command = canonical;
+                rewritten++;
+            }
+        }
+    }
+    return rewritten;
 }
 /**
  * Inverse of {@link wireHooks}: strip every harnery-owned hook entry from a
@@ -270,6 +333,54 @@ export function stampBinName(configPath, binName, dryRun) {
     writeFileSync(configPath, next);
     return `+ added binName "${binName}" to ${rel(configPath)}`;
 }
+/** The commented workflow-billing default block init stamps into config.jsonc. */
+const WORKFLOW_DEFAULT_BLOCK = `  // Workflow children ride the logged-in (subscription) harness auth; this pin\n` +
+    `  // scrubs API-key vars from child envs so runs can never bill per-token rates.\n` +
+    `  // Key-only hosts (CI): set false, or HARNERY_WORKFLOW_SUBSCRIPTION_ONLY=0.\n` +
+    `  "workflow": { "subscriptionOnly": true }`;
+/**
+ * Idempotently pin `workflow.subscriptionOnly: true` in `.harnery/config.jsonc`
+ * (see `workflowSubscriptionOnly()` in core/config.ts and the `workflow run`
+ * billing safeguards). Same comment-preserving discipline as `stampBinName`.
+ * A `workflow` key of ANY shape (including `subscriptionOnly: false`) is a
+ * deliberate project choice and is left alone.
+ */
+export function stampWorkflowDefaults(configPath, dryRun) {
+    const rel = (p) => relative(dirname(dirname(configPath)), p) || p;
+    if (!existsSync(configPath)) {
+        if (dryRun)
+            return `+ would pin workflow.subscriptionOnly in ${rel(configPath)}`;
+        writeFileSync(configPath, `{\n${WORKFLOW_DEFAULT_BLOCK}\n}\n`);
+        return `+ pinned workflow.subscriptionOnly: true in ${rel(configPath)}`;
+    }
+    let raw;
+    try {
+        raw = readFileSync(configPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stripJsonComments(raw)) ?? {};
+    }
+    catch {
+        return `· ${rel(configPath)} isn't valid JSONC; skipped workflow.subscriptionOnly pin`;
+    }
+    if ("workflow" in parsed)
+        return null; // deliberate config; never touch
+    const at = firstBraceIndex(raw);
+    if (at < 0)
+        return `· ${rel(configPath)} has no object literal; skipped workflow pin`;
+    const keys = Object.keys(parsed);
+    const next = keys.length === 0
+        ? `{\n${WORKFLOW_DEFAULT_BLOCK}\n}\n`
+        : `${raw.slice(0, at + 1)}\n${WORKFLOW_DEFAULT_BLOCK},${raw.slice(at + 1)}`;
+    if (dryRun)
+        return `+ would pin workflow.subscriptionOnly in ${rel(configPath)}`;
+    writeFileSync(configPath, next);
+    return `+ pinned workflow.subscriptionOnly: true in ${rel(configPath)}`;
+}
 /** Index of the first structural `{`, skipping leading whitespace + comments. */
 function firstBraceIndex(raw) {
     let i = 0;

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