harnery 0.33.0 → 0.34.1

package/dist/commands/init.js

@@ -16,12 +16,18 @@
  * already wired, so it's safe to re-run. `--dry-run` previews without writing.
  */
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_BIN_NAME, pinnedBinName, stripJsonComments } from "../core/config.js";
+import { canonicalJsonV3 } from "../core/events/v3/canonical.js";
+import { ADAPTER_CAPABILITY_PROFILES_V3 } from "../core/events/v3/capabilities.js";
+import { EVENT_V3_SCHEMA_DIGEST } from "../core/events/v3/generated.js";
+import { initializeEventLedgerV3, readEventV3ControlState, sha256V3, } from "../core/events/v3/index.js";
+import { liveEventV3BuildId } from "../core/events/v3/live-routing.js";
 import { ADAPTER_SPECS } from "../core/hooks/adapter/events.js";
-import { commandWiresSubcommand, groupCommands, makeEntry, } from "../core/hooks/adapter/wiring.js";
+import { agentHookPathForProject, commandWiresSubcommand, diffWiring, groupCommands, hookCommand, isAgentHookCommand, makeEntry, } from "../core/hooks/adapter/wiring.js";
 import { applyInstructions, checkInstructions, } from "../lib/instructions/apply.js";
 import { applyGitHooks, checkGitHooks } from "../lib/instructions/git-hooks.js";
 import { HostAddendumError } from "../lib/instructions/host-addendum.js";
@@ -53,15 +59,76 @@ export function registerInitCommand(program, emit, binName) {
         // init inside any checkout). Without this, re-running init from a host
         // CLI re-stamps the host's name into committed agent-facing surfaces.
         const bin = pinnedBinName(projectRoot) ?? (binName?.trim() ? binName : DEFAULT_BIN_NAME);
-        // ── --check: read-only drift report on the block + skills ──────────────
+        // ── --check: read-only drift report on every init-managed surface ─────
         if (opts.check === true) {
             const { status, issues } = checkInstructions(projectRoot, { binName: bin, adapter });
+            let hookCheckError = false;
+            let hookDrift = false;
+            const settingsPath = resolve(projectRoot, spec.settingsFile);
+            const agentHook = agentHookPathForProject(projectRoot, HARNERY_ROOT);
+            if (!existsSync(settingsPath)) {
+                hookDrift = true;
+                issues.push(`${spec.settingsFile}: missing (re-run init)`);
+            }
+            else {
+                try {
+                    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+                    const hookDiff = diffWiring(settings, spec, { agentHookPath: agentHook, adapter });
+                    hookDrift =
+                        hookDiff.missing.length > 0 ||
+                            hookDiff.stale.length > 0 ||
+                            hookDiff.duplicates.length > 0 ||
+                            hookDiff.misplaced.length > 0 ||
+                            hookDiff.orphans.length > 0 ||
+                            hookDiff.invalidTopLevelKeys.length > 0 ||
+                            hookDiff.invalidEventKeys.length > 0;
+                    if (hookDiff.missing.length > 0) {
+                        issues.push(`${spec.settingsFile}: missing hooks (${hookDiff.missing.map((e) => e.settingsKey).join(", ")})`);
+                    }
+                    if (hookDiff.stale.length > 0) {
+                        issues.push(`${spec.settingsFile}: stale hook commands (${hookDiff.stale.map((e) => e.settingsKey).join(", ")})`);
+                    }
+                    if (hookDiff.duplicates.length > 0) {
+                        issues.push(`${spec.settingsFile}: duplicate hooks (${hookDiff.duplicates.map((e) => e.settingsKey).join(", ")})`);
+                    }
+                    if (hookDiff.misplaced.length > 0) {
+                        issues.push(`${spec.settingsFile}: hooks under the wrong event (${hookDiff.misplaced.map((e) => e.subcommand).join(", ")})`);
+                    }
+                    if (hookDiff.orphans.length > 0) {
+                        issues.push(`${spec.settingsFile}: obsolete hooks (${hookDiff.orphans.join(", ")})`);
+                    }
+                    if (hookDiff.invalidTopLevelKeys.length > 0) {
+                        issues.push(`${spec.settingsFile}: invalid fields (${hookDiff.invalidTopLevelKeys.join(", ")})`);
+                    }
+                    if (hookDiff.invalidEventKeys.length > 0) {
+                        issues.push(`${spec.settingsFile}: unsupported events (${hookDiff.invalidEventKeys.join(", ")})`);
+                    }
+                }
+                catch (error) {
+                    hookCheckError = true;
+                    issues.push(`${spec.settingsFile}: invalid JSON (${error.message})`);
+                }
+            }
             const gitHooks = checkGitHooks(projectRoot);
             if (gitHooks.status !== "fresh")
                 issues.push(...gitHooks.issues);
-            const merged = status === "error" ? "error" : gitHooks.status !== "fresh" ? "drift" : status;
+            const ledger = readEventV3ControlState(projectRoot);
+            if (ledger.state !== "active")
+                issues.push(`event ledger V3 is ${ledger.state}`);
+            const ledgerRuntimeIssues = eventLedgerV3RuntimeIssues(ledger, gitBuild(HARNERY_ROOT));
+            if (ledgerRuntimeIssues.length > 0) {
+                issues.push(`event ledger V3 is runtime-stale (${ledgerRuntimeIssues.join(", ")})`);
+            }
+            const merged = status === "error" || hookCheckError
+                ? "error"
+                : hookDrift ||
+                    gitHooks.status !== "fresh" ||
+                    ledger.state !== "active" ||
+                    ledgerRuntimeIssues.length > 0
+                    ? "drift"
+                    : status;
             const head = merged === "fresh"
-                ? "harn init --check: instructions + skills + git hooks are current"
+                ? "harn init --check: hooks + instructions + skills + event ledger V3 are current"
                 : merged === "drift"
                     ? "harn init --check: drift found (re-run `init` to refresh)"
                     : "harn init --check: error";
@@ -109,9 +176,37 @@ export function registerInitCommand(program, emit, binName) {
             if (stamp)
                 actions.push(stamp);
         }
+        // ── 1d. universal V3 event ledger ────────────────────────────────────
+        if (dryRun) {
+            const ledger = readEventV3ControlState(projectRoot);
+            const runtimeIssues = eventLedgerV3RuntimeIssues(ledger, gitBuild(HARNERY_ROOT));
+            actions.push(ledger.state === "active" && runtimeIssues.length === 0
+                ? "· event ledger V3 is active"
+                : ledger.state === "active"
+                    ? `+ would refresh event ledger V3 runtime profile (${runtimeIssues.join(", ")})`
+                    : `+ would initialize event ledger V3 (current state: ${ledger.state})`);
+        }
+        else {
+            const harneryBuild = gitBuild(HARNERY_ROOT);
+            const ledgerBefore = readEventV3ControlState(projectRoot);
+            const runtimeIssues = eventLedgerV3RuntimeIssues(ledgerBefore, harneryBuild);
+            const initialized = initializeEventLedgerV3({
+                coordRoot: projectRoot,
+                harneryBuild,
+                hostBuild: gitBuild(projectRoot),
+                configDigest: digestConfig(resolve(coordDir, "config.jsonc")),
+                approvalRecordId: "harnery-init-v3-universal",
+                forceNewEpoch: runtimeIssues.length > 0,
+            });
+            actions.push(initialized.archived_epoch
+                ? `+ refreshed event ledger V3 runtime profile (${runtimeIssues.join(", ")}); archived the prior epoch intact`
+                : initialized.initialized
+                    ? "+ initialized event ledger V3"
+                    : "· event ledger V3 already active");
+        }
         // ── 2. adapter hooks ───────────────────────────────────────────────────
         const settingsPath = resolve(projectRoot, spec.settingsFile);
-        const agentHook = relative(projectRoot, resolve(HARNERY_ROOT, "bin", "agent-hook"));
+        const agentHook = agentHookPathForProject(projectRoot, HARNERY_ROOT);
         let settings;
         if (existsSync(settingsPath)) {
             try {
@@ -133,13 +228,13 @@ export function registerInitCommand(program, emit, binName) {
         }
         else if (dryRun) {
             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)`);
+                `${removed} obsolete/duplicate command(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), upgraded ${upgraded} stale command(s), and removed ` +
-                `${removed} legacy hook(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
+                `${removed} obsolete/duplicate command(s) in ${rel(projectRoot, settingsPath)} (${already} already present)`);
         }
         const authorizationReview = codexHookReviewAction(adapter);
         if (authorizationReview)
@@ -169,6 +264,43 @@ export function registerInitCommand(program, emit, binName) {
         emit.text(render(projectRoot, dryRun, actions, [...applied.warnings, ...gitHooks.warnings]));
     });
 }
+function gitBuild(root) {
+    const result = spawnSync("git", ["-C", root, "rev-parse", "HEAD"], {
+        encoding: "utf8",
+        timeout: 5000,
+    });
+    const commit = result.status === 0 ? result.stdout.trim() : "";
+    return /^[0-9a-f]{40,64}$/.test(commit)
+        ? commit
+        : createHash("sha256").update(resolve(root)).digest("hex");
+}
+function digestConfig(path) {
+    return sha256V3(existsSync(path) ? readFileSync(path) : Buffer.from("{}\n"));
+}
+/**
+ * Runtime gates bound into an immutable V3 epoch. `init` is the explicit
+ * upgrade boundary: when code or capability profiles change, it archives the
+ * old epoch intact and activates a compatible one instead of letting upgraded
+ * hooks fail closed against stale approvals.
+ */
+export function eventLedgerV3RuntimeIssues(control, harneryBuild) {
+    if (control.state !== "active")
+        return [];
+    const issues = [];
+    const profile = control.genesis.profile;
+    if (profile.initial_schema_digest !== EVENT_V3_SCHEMA_DIGEST)
+        issues.push("schema digest");
+    if (profile.contract_source_digest !== EVENT_V3_SCHEMA_DIGEST)
+        issues.push("contract digest");
+    if (!profile.producer_build_ids.includes(liveEventV3BuildId(harneryBuild))) {
+        issues.push("producer build");
+    }
+    const expectedCapabilities = Object.values(ADAPTER_CAPABILITY_PROFILES_V3).map((value) => sha256V3(canonicalJsonV3(value)));
+    if (expectedCapabilities.some((digest) => !profile.adapter_capability_profile_digests.includes(digest))) {
+        issues.push("adapter capabilities");
+    }
+    return issues;
+}
 export function codexHookReviewAction(adapter) {
     if (adapter !== "codex")
         return null;
@@ -185,8 +317,7 @@ export function codexHookReviewAction(adapter) {
  * `{ command }`) and ensures the root `version` key when the adapter 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`.
+ * Token-aware matching keeps `stop` from matching `stop-failure`.
  */
 export function wireHooks(settings, spec, agentHookPath, adapter) {
     if (spec.rootVersion !== undefined && settings.version === undefined) {
@@ -198,30 +329,41 @@ export function wireHooks(settings, spec, agentHookPath, adapter) {
     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)));
-        removed += groups.length - kept.length;
-        if (kept.length === 0)
-            delete settings.hooks[settingsKey];
-        else
-            settings.hooks[settingsKey] = kept;
+    for (const { subcommand } of spec.legacyEvents ?? []) {
+        for (const settingsKey of Object.keys(settings.hooks)) {
+            removed += removeCommandsFromKey(settings, settingsKey, (command) => commandWiresSubcommand(command, subcommand));
+        }
     }
     for (const { settingsKey, subcommand } of spec.events) {
         const command = hookCommand(spec, agentHookPath, subcommand, adapter);
-        const groups = settings.hooks[settingsKey] ?? [];
         let present = false;
+        for (const key of Object.keys(settings.hooks)) {
+            if (key === settingsKey)
+                continue;
+            removed += removeCommandsFromKey(settings, key, (candidate) => commandWiresSubcommand(candidate, subcommand));
+        }
+        const groups = settings.hooks[settingsKey] ?? [];
+        const nextGroups = [];
         for (const group of groups) {
-            upgraded += rewriteStaleCommands(group, subcommand, command, () => {
+            const normalized = normalizeEventGroup(group, subcommand, command, present);
+            if (normalized.found && !present)
                 present = true;
-            });
+            upgraded += normalized.upgraded;
+            removed += normalized.removed;
+            if (normalized.group)
+                nextGroups.push(normalized.group);
         }
+        if (nextGroups.length > 0)
+            settings.hooks[settingsKey] = nextGroups;
+        else
+            delete settings.hooks[settingsKey];
         if (present) {
             already++;
             continue;
         }
-        groups.push(makeEntry(spec.entryShape, command));
-        settings.hooks[settingsKey] = groups;
+        const current = settings.hooks[settingsKey] ?? [];
+        current.push(makeEntry(spec.entryShape, command));
+        settings.hooks[settingsKey] = current;
         wired++;
     }
     return { wired, already, removed, upgraded };
@@ -236,40 +378,79 @@ export function wireHooks(settings, spec, agentHookPath, adapter) {
  * 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, adapter) {
-    const anchor = spec.projectDirEnv ? `"\${${spec.projectDirEnv}:-.}"/` : "";
-    return `bash ${anchor}${agentHookPath} ${subcommand} --adapter ${adapter}`;
-}
-/**
- * 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;
+function normalizeEventGroup(group, subcommand, canonical, alreadyFound) {
+    let found = false;
+    let upgraded = 0;
+    let removed = 0;
     if ("command" in group && typeof group.command === "string") {
         if (commandWiresSubcommand(group.command, subcommand)) {
-            onPresent();
+            if (alreadyFound)
+                return { group: null, found: true, upgraded: 0, removed: 1 };
+            found = true;
             if (group.command !== canonical) {
                 group.command = canonical;
-                rewritten++;
+                upgraded++;
             }
         }
     }
     if ("hooks" in group && Array.isArray(group.hooks)) {
+        const kept = [];
         for (const hook of group.hooks) {
-            if (typeof hook.command !== "string")
+            if (typeof hook.command !== "string" || !commandWiresSubcommand(hook.command, subcommand)) {
+                kept.push(hook);
                 continue;
-            if (!commandWiresSubcommand(hook.command, subcommand))
+            }
+            if (alreadyFound || found) {
+                removed++;
                 continue;
-            onPresent();
+            }
+            found = true;
             if (hook.command !== canonical) {
                 hook.command = canonical;
-                rewritten++;
+                upgraded++;
             }
+            kept.push(hook);
         }
+        group.hooks = kept;
+        if (group.hooks.length === 0)
+            return { group: null, found, upgraded, removed };
     }
-    return rewritten;
+    return { group, found, upgraded, removed };
+}
+/** Remove matching command handlers while preserving unrelated handlers in a mixed group. */
+function removeCommandsFromKey(settings, settingsKey, predicate) {
+    const groups = settings.hooks?.[settingsKey];
+    if (!Array.isArray(groups))
+        return 0;
+    let removed = 0;
+    const kept = [];
+    for (const group of groups) {
+        if ("command" in group && typeof group.command === "string") {
+            if (predicate(group.command))
+                removed++;
+            else
+                kept.push(group);
+            continue;
+        }
+        if ("hooks" in group && Array.isArray(group.hooks)) {
+            const handlers = group.hooks.filter((hook) => {
+                if (typeof hook.command !== "string" || !predicate(hook.command))
+                    return true;
+                removed++;
+                return false;
+            });
+            group.hooks = handlers;
+            if (handlers.length > 0)
+                kept.push(group);
+            continue;
+        }
+        kept.push(group);
+    }
+    if (kept.length === 0)
+        delete settings.hooks?.[settingsKey];
+    else
+        settings.hooks[settingsKey] = kept;
+    return removed;
 }
 /**
  * Inverse of {@link wireHooks}: strip every harnery-owned hook entry from a
@@ -286,21 +467,12 @@ export function unwireHooks(settings) {
         return { removed: 0, remaining: 0 };
     let removed = 0;
     for (const key of Object.keys(settings.hooks)) {
-        const groups = settings.hooks[key];
-        if (!Array.isArray(groups))
-            continue;
-        const kept = groups.filter((g) => !groupCommands(g).some((c) => c.includes("agent-hook ")));
-        removed += groups.length - kept.length;
-        // removing the emptied hook key is the intent (tiny one-shot object)
-        if (kept.length === 0)
-            delete settings.hooks[key];
-        else
-            settings.hooks[key] = kept;
+        removed += removeCommandsFromKey(settings, key, isAgentHookCommand);
     }
     let remaining = 0;
     for (const groups of Object.values(settings.hooks)) {
         if (Array.isArray(groups))
-            remaining += groups.length;
+            remaining += groups.flatMap(groupCommands).length;
     }
     // drop the now-empty hooks object so callers see a clean shape
     if (Object.keys(settings.hooks).length === 0)

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

@@ -1 +1 @@
-{"version":3,"file":"journal.d.ts","sourceRoot":"","sources":["../../src/commands/journal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA6BnD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI,CA2RrF"}
+{"version":3,"file":"journal.d.ts","sourceRoot":"","sources":["../../src/commands/journal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA8BnD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI,CAgRrF"}

package/dist/commands/journal.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync, statSync, unlinkSync, watch } from "node:fs";
 import { resolve as resolvePath } from "node:path";
-import { emitCanonical, normalizeAdapter, readHeartbeat } from "../core/agents/index.js";
+import { monorepoRoot } from "../core/agents/index.js";
+import { readLiveCoordinationRow } from "../core/agents/state/live-coordination-view.js";
 import { resolveBinName } from "../core/config.js";
 import { appendEntry, archiveJournal, currentOwnerOrThrow, JOURNAL_CATEGORIES, journalDir, journalPath, lintJournal, listArchives, loadJournal, parseJournal, pruneArchives, resolveOwnerByName, sweepOrphanJournals, } from "../core/journal/index.js";
 /**
@@ -30,17 +31,6 @@ export function registerJournalCommand(program, emitParam) {
         try {
             const owner = currentOwnerOrThrow();
             const doc = appendEntry(owner, cat, body);
-            const hb = readHeartbeat(owner);
-            emitCanonical({
-                type: "state.journal_append",
-                owner,
-                session: hb?.session_id ?? owner,
-                adapter: normalizeAdapter(hb?.platform),
-                data: {
-                    category: cat,
-                    body_summary: body.length > 1000 ? `${body.slice(0, 997)}...` : body,
-                },
-            });
             emit.data({
                 instance_id: owner,
                 name: doc.header.name,
@@ -313,7 +303,8 @@ function runRead(opts) {
         });
         process.exit(1);
     }
-    const hb = readHeartbeat(owner);
+    const root = monorepoRoot();
+    const hb = root ? readLiveCoordinationRow(root, owner) : null;
     const staleBanner = renderStaleBannerIfNeeded(hb?.last_heartbeat);
     process.stdout.write(`${staleBanner + renderJournal(doc, limit)}\n`); // lint-ok-emission: pretty render, multi-line markdown for direct TTY/pipe consumption
 }

package/dist/commands/ledger-v3.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+/** Inspect or initialize the universal V3 event ledger. */
+export declare function registerLedgerV3Command(program: Command, emit: EmitContext, context?: HarneryProgramContext): void;
+//# sourceMappingURL=ledger-v3.d.ts.map

package/dist/commands/ledger-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger-v3.d.ts","sourceRoot":"","sources":["../../src/commands/ledger-v3.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAQ1E,2DAA2D;AAC3D,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CA+DN"}

package/dist/commands/ledger-v3.js

@@ -0,0 +1,91 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { initializeEventLedgerV3, readEventV3ControlState, recoverInvalidEventLedgerV3, sha256V3, } from "../core/events/v3/index.js";
+/** Inspect or initialize the universal V3 event ledger. */
+export function registerLedgerV3Command(program, emit, context) {
+    const command = program
+        .command("ledger-v3")
+        .description("Inspect or initialize the universal event-ledger V3 epoch");
+    command
+        .command("status")
+        .description("Read the V3 control boundary without changing it")
+        .action(() => {
+        try {
+            emit.data(readEventV3ControlState(coordRoot(context)));
+        }
+        catch (error) {
+            emitFailure(emit, "ledger_v3_status_failed", error);
+        }
+    });
+    command
+        .command("initialize")
+        .description("Create V3 control state, or archive and replace the current V3 epoch")
+        .option("--root <path>", "Explicit coordination root")
+        .requiredOption("--approval-record-id <id>", "Durable approval record identifier")
+        .option("--force-new-epoch", "Archive the current V3 epoch and create a new one")
+        .action((options) => {
+        try {
+            const root = resolve(options.root ?? coordRoot(context));
+            emit.data(initializeEventLedgerV3({
+                coordRoot: root,
+                harneryBuild: repositoryBuild(resolve(import.meta.dir, "..", "..")),
+                hostBuild: repositoryBuild(root),
+                configDigest: configDigest(root),
+                approvalRecordId: options.approvalRecordId,
+                forceNewEpoch: options.forceNewEpoch === true,
+            }));
+        }
+        catch (error) {
+            emitFailure(emit, "ledger_v3_initialize_failed", error);
+        }
+    });
+    command
+        .command("recover")
+        .description("Quarantine one invalid active authority and start a clean V3 epoch")
+        .option("--root <path>", "Explicit coordination root")
+        .requiredOption("--approval-record-id <id>", "Durable approval record identifier")
+        .option("--yes", "Confirm the failed authority should be quarantined")
+        .action((options) => {
+        try {
+            if (!options.yes)
+                throw new Error("--yes is required to recover an invalid V3 authority");
+            const root = resolve(options.root ?? coordRoot(context));
+            emit.data(recoverInvalidEventLedgerV3({
+                coordRoot: root,
+                harneryBuild: repositoryBuild(resolve(import.meta.dir, "..", "..")),
+                hostBuild: repositoryBuild(root),
+                configDigest: configDigest(root),
+                approvalRecordId: options.approvalRecordId,
+            }));
+        }
+        catch (error) {
+            emitFailure(emit, "ledger_v3_recovery_failed", error);
+        }
+    });
+}
+function coordRoot(context) {
+    return resolve(context?.resolveCoordRoot?.() ??
+        context?.repoRoot ??
+        process.env.HARNERY_COORD_ROOT ??
+        process.cwd());
+}
+function repositoryBuild(root) {
+    const result = spawnSync("git", ["-C", root, "rev-parse", "HEAD"], {
+        encoding: "utf8",
+        timeout: 5000,
+    });
+    const commit = result.status === 0 ? result.stdout.trim() : "";
+    if (/^[0-9a-f]{40,64}$/.test(commit))
+        return commit;
+    return createHash("sha256").update(resolve(root)).digest("hex");
+}
+function configDigest(root) {
+    const path = resolve(root, ".harnery", "config.jsonc");
+    return sha256V3(existsSync(path) ? readFileSync(path) : Buffer.from("{}\n"));
+}
+function emitFailure(emit, code, error) {
+    emit.error({ code, message: error instanceof Error ? error.message : String(error) });
+    throw error;
+}

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;AA0BnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA8KjF"}
+{"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;AAsBnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA8KjF"}

package/dist/commands/presence.js

@@ -1,5 +1,6 @@
 import { monorepoRoot } from "../core/agents/coord-client.js";
-import { emitCanonical, normalizeAdapter, readHeartbeat, resolveOwner, } from "../core/agents/index.js";
+import { emitEventV3, normalizeAdapter, resolveOwner } from "../core/agents/index.js";
+import { readLiveCoordinationRow } from "../core/agents/state/live-coordination-view.js";
 import { fetchPresence, publishPresence, readRemoteMachines, relayDaemonStatus, runRelayDaemon, } from "../core/presence/index.js";
 import { ageSeconds, applyDetection, clearPresence, formatAge, presenceFilePath, readPresence, writePresence, } from "../lib/presence.js";
 /**
@@ -198,12 +199,17 @@ function emitPresenceChange(from, to, source) {
     const owner = resolveOwner();
     if (!owner)
         return;
-    const hb = readHeartbeat(owner);
-    emitCanonical({
-        type: "state.presence_change",
+    const root = monorepoRoot();
+    const hb = root ? readLiveCoordinationRow(root, owner) : null;
+    emitEventV3({
         owner,
         session: hb?.session_id ?? owner,
         adapter: normalizeAdapter(hb?.platform),
-        data: { from, to, source },
+        observation: {
+            event_type: "coord.presence_changed",
+            prior_state: from,
+            new_state: to,
+            reason: `presence_${source}`,
+        },
     });
 }

package/dist/commands/sync.d.ts

@@ -4,7 +4,7 @@
  *
  * Scope: a deliberately small set of file types: durable identities,
  * archived journals, council manifests. The high-churn machine-local
- * stuff (events.ndjson, .pid-map/, active/, .last-intent.*) stays put.
+ * state (ledgers/, .pid-map/, active/, .last-intent.*) stays put.
  *
  * Subcommands:
  *   init:    interactive: `rclone config` walks through Google OAuth, then

package/dist/commands/sync.js

@@ -4,7 +4,7 @@
  *
  * Scope: a deliberately small set of file types: durable identities,
  * archived journals, council manifests. The high-churn machine-local
- * stuff (events.ndjson, .pid-map/, active/, .last-intent.*) stays put.
+ * state (ledgers/, .pid-map/, active/, .last-intent.*) stays put.
  *
  * Subcommands:
  *   init:    interactive: `rclone config` walks through Google OAuth, then

package/dist/commands/web.d.ts

@@ -19,5 +19,11 @@ export declare function resolveMaxOldSpaceMb(flag?: string): number;
  * wins without clobbering flags the caller set (source maps, inspector, …).
  */
 export declare function nodeOptionsWithHeapCap(mb: number): string | undefined;
+/**
+ * Probe the exact localhost socket Next will claim. This is deliberately a
+ * check-and-report step, not an alternate-port allocator: Harnery keeps one
+ * memorable URL and asks the caller to resolve a real conflict explicitly.
+ */
+export declare function isWebPortAvailable(port: number): Promise<boolean>;
 export declare function registerWebCommand(program: Command, emit: EmitContext): void;
 //# sourceMappingURL=web.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/commands/web.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAgCnD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAM1D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKrE;AA8BD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA2J5E"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/commands/web.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAiCnD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAM1D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKrE;AA8BD;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAevE;AAsBD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA0K5E"}