harnery 0.33.0 → 0.34.0

package/dist/core/agents/cli.js

@@ -112,30 +112,25 @@ async function handleVerdict(root) {
     return 0;
 }
 async function handleProject(root, rest) {
-    const { consumeSince, writeCursor } = await import("./events/consume.js");
-    const { projectHeartbeats } = await import("./state/heartbeat-projector.js");
-    const replayAll = rest.includes("--replay-all");
-    const result = consumeSince(root, { replayAll });
-    const project = projectHeartbeats(root, result.events);
+    const { resolveLiveEventLedgerRouteV3 } = await import("../events/v3/live-routing.js");
+    const route = resolveLiveEventLedgerRouteV3(root);
+    if (route.state === "blocked") {
+        process.stderr.write(`agent-coord project: V3 route is unsafe (${route.reason})\n`);
+        return 1;
+    }
+    const { readCoordinationViewV3 } = await import("../events/v3/coordination-view.js");
+    const view = readCoordinationViewV3(root);
     const report = {
-        events_consumed: result.events.length,
-        stream_bytes: result.streamBytes,
-        owners_projected: project.written.length,
-        owners: project.written,
-        cursor: result.lastEventId,
-        replayed_all: replayAll,
+        contract_major: 2,
+        source_complete: view.source_complete,
+        authority_safe: view.authority_safe,
+        owners_projected: Object.keys(view.instances).length,
+        owners: Object.keys(view.instances).sort(),
+        diagnostics: view.diagnostics,
+        materialized: false,
     };
-    if (result.lastEventId)
-        writeCursor(root, result.lastEventId);
-    if (rest.includes("--json")) {
-        process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
-    }
-    else {
-        process.stdout.write(`projected ${report.events_consumed} events across ${report.owners_projected} owners\n  cursor → ${report.cursor ?? "<none>"}\n${report.owners.length
-            ? `  owners: ${report.owners.map((o) => o.slice(0, 8)).join(", ")}\n`
-            : ""}`);
-    }
-    return 0;
+    process.stdout.write(`${JSON.stringify(report, null, rest.includes("--json") ? 2 : 0)}\n`);
+    return view.authority_safe ? 0 : 1;
 }
 function adapterFromPlatform(platform) {
     if (platform === "cursor")
@@ -144,62 +139,6 @@ function adapterFromPlatform(platform) {
         return "codex";
     return "claude-code";
 }
-/**
- * Append a canonical `health.heartbeat_swept` event after an operator kill.
- * Same envelope stale-sweep emits, so the projector's terminal / ended_at
- * guards treat kill and sweep identically. Soft-fails: the unlink already
- * happened.
- */
-async function emitHeartbeatSwept(root, owner, hb) {
-    try {
-        const { emit } = await import("./events/emit.js");
-        let ageSecs;
-        if (hb.last_heartbeat) {
-            const ts = Date.parse(hb.last_heartbeat);
-            if (Number.isFinite(ts)) {
-                ageSecs = Math.max(0, Math.floor((Date.now() - ts) / 1000));
-            }
-        }
-        emit(root, {
-            event_type: "health.heartbeat_swept",
-            instance_id: owner,
-            session_id: hb.session_id ?? owner,
-            adapter: adapterFromPlatform(hb.platform),
-            source: "agent-coord",
-            data: {
-                reason: "killed",
-                ...(ageSecs !== undefined ? { age_secs: ageSecs } : {}),
-            },
-        });
-    }
-    catch {
-        /* soft-fail: never break the caller */
-    }
-}
-/**
- * Append a canonical `claim.release` event for a path dropped from an owner's
- * files_touched. The path is canonicalized to repo-relative (matching the
- * projector's normalization) so the subtraction matches on replay regardless
- * of the form the caller passed. Soft-fails: a failed emit must never break
- * the release/kill flow — the file mutation already happened.
- */
-async function emitClaimRelease(root, owner, hb, path, reason) {
-    try {
-        const { emit } = await import("./events/emit.js");
-        const canonical = path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
-        emit(root, {
-            event_type: "claim.release",
-            instance_id: owner,
-            session_id: hb.session_id ?? owner,
-            adapter: adapterFromPlatform(hb.platform),
-            source: "agent-coord",
-            data: { path: canonical, reason },
-        });
-    }
-    catch {
-        /* soft-fail: never break the caller */
-    }
-}
 async function handleStateAction(root, action, rest) {
     const writer = await import("./state/heartbeat-writer.js");
     const [owner, ...args] = rest;
@@ -210,7 +149,23 @@ async function handleStateAction(root, action, rest) {
     switch (action) {
         case "set-task": {
             const task = args.join(" ");
-            const hb = writer.setTask(root, owner, task);
+            const before = writer.readHeartbeat(root, owner);
+            let hb;
+            try {
+                const { recordLiveTaskChangeV3 } = await import("./live-authority-v3.js");
+                recordLiveTaskChangeV3({
+                    coordRoot: root,
+                    owner,
+                    nativeSessionId: before?.session_id ?? owner,
+                    adapter: adapterFromPlatform(before?.platform),
+                    task,
+                });
+                hb = writer.readHeartbeat(root, owner);
+            }
+            catch (error) {
+                process.stderr.write(`agent-coord set-task: V3 authority refused (${error instanceof Error ? error.message : String(error)})\n`);
+                return 1;
+            }
             if (!hb) {
                 // Name the RESOLVED root: when a nested .harnery/ shadows the real
                 // coordination home, the full path is what makes that diagnosable.
@@ -220,14 +175,6 @@ async function handleStateAction(root, action, rest) {
             process.stdout.write(`${JSON.stringify({ instance_id: owner, task: hb.task ?? null, cleared: !task })}\n`);
             return 0;
         }
-        case "set-turn-summary": {
-            const summary = args.join(" ");
-            const hb = writer.setTurnSummary(root, owner, summary);
-            if (!hb)
-                return 1;
-            process.stdout.write(`${JSON.stringify({ instance_id: owner, turn_summary: hb.turn_summary })}\n`);
-            return 0;
-        }
         case "release-claim": {
             const path = args[0];
             if (!path) {
@@ -235,46 +182,29 @@ async function handleStateAction(root, action, rest) {
                 return 2;
             }
             const before = writer.readHeartbeat(root, owner);
-            const hb = writer.releaseClaim(root, owner, path);
-            if (!hb)
+            let hb;
+            try {
+                const { recordLiveClaimChangeV3 } = await import("./live-authority-v3.js");
+                recordLiveClaimChangeV3({
+                    coordRoot: root,
+                    owner,
+                    nativeSessionId: before?.session_id ?? owner,
+                    adapter: adapterFromPlatform(before?.platform),
+                    operation: "released",
+                    path,
+                    access: "write",
+                });
+                hb = writer.readHeartbeat(root, owner);
+            }
+            catch (error) {
+                process.stderr.write(`agent-coord release-claim: V3 authority refused (${error instanceof Error ? error.message : String(error)})\n`);
                 return 1;
-            // Durability: the projector rebuilds files_touched by replaying the
-            // permanent Edit/Write events, so a file-only release is silently
-            // reverted by the next full replay. Emitting claim.release puts the
-            // subtraction into the stream so every future replay honors it. Only
-            // emit when the release actually removed a held path (idempotent
-            // re-releases stay quiet).
-            const heldBefore = before?.files_touched?.length ?? 0;
-            const heldAfter = hb.files_touched?.length ?? 0;
-            if (heldBefore > heldAfter) {
-                await emitClaimRelease(root, owner, before ?? hb, path, "explicit");
             }
+            if (!hb)
+                return 1;
             process.stdout.write(`${JSON.stringify({ instance_id: owner, files_touched: hb.files_touched })}\n`);
             return 0;
         }
-        case "kill-heartbeat": {
-            // Read held claims BEFORE the unlink so they can be released durably —
-            // killing only the file leaves the claims resurrectable from the
-            // permanent Edit/Write events on the next full replay (observed: a
-            // 6-day-dead agent's claims returning after its heartbeat was killed).
-            //
-            // Also emit health.heartbeat_swept so the stream records a terminal
-            // marker. Without it, a later drain that replays [session.start …
-            // tools … claim.release] treats the owner as still in-flight and
-            // re-creates the file (kill→resurrect loop observed 2026-08-03: 21
-            // killed zombies back within a minute via claim.release seeding +
-            // historical replay).
-            const before = writer.readHeartbeat(root, owner);
-            const ok = writer.killHeartbeat(root, owner);
-            if (ok && before) {
-                await emitHeartbeatSwept(root, owner, before);
-                for (const held of before.files_touched ?? []) {
-                    await emitClaimRelease(root, owner, before, held, "heal");
-                }
-            }
-            process.stdout.write(`${JSON.stringify({ instance_id: owner, removed: ok })}\n`);
-            return ok ? 0 : 1;
-        }
         case "heal-pidmap": {
             const pidArg = args[0];
             const pid = pidArg ? Number(pidArg) : process.ppid;
@@ -282,40 +212,54 @@ async function handleStateAction(root, action, rest) {
                 process.stderr.write(`agent-coord heal-pidmap: invalid pid ${pidArg}\n`);
                 return 2;
             }
-            writer.healPidmap(root, owner, pid);
+            try {
+                const { liveCoordinationWriteModeV3 } = await import("./live-authority-v3.js");
+                liveCoordinationWriteModeV3(root);
+                writer.healPidmap(root, owner, pid);
+            }
+            catch (error) {
+                process.stderr.write(`agent-coord heal-pidmap: V3 route refused (${error instanceof Error ? error.message : String(error)})\n`);
+                return 1;
+            }
             process.stdout.write(`${JSON.stringify({ instance_id: owner, pid })}\n`);
             return 0;
         }
-        case "heal-heartbeat": {
+        case "repair-coordination-cache": {
             // adapter arrives as a `--adapter=<h>` flag (not positional) so the live
-            // tool.pre_use heal and the manual `harn agents heal` path (which pass
+            // tool.requested repair and the manual `harn agents heal` path (which pass
             // different positional counts) can both supply it without arg-order
             // fragility. Positionals (sessionId, model) stay as-is once flags are
             // filtered out.
             const adapter = args.find((a) => a.startsWith("--adapter="))?.slice("--adapter=".length);
-            const forkedFrom = args
-                .find((a) => a.startsWith("--forked-from="))
-                ?.slice("--forked-from=".length);
             const positional = args.filter((a) => !a.startsWith("--"));
             const sessionId = positional[0];
             const model = positional[1];
-            const hb = writer.healHeartbeat(root, owner, sessionId, model, adapter, forkedFrom ? { forkedFrom } : undefined);
+            let hb;
+            try {
+                const { liveCoordinationWriteModeV3 } = await import("./live-authority-v3.js");
+                liveCoordinationWriteModeV3(root);
+                const { readCoordinationViewV3 } = await import("../events/v3/coordination-view.js");
+                const { liveInstanceIdV3 } = await import("../events/v3/live-routing.js");
+                const projected = readCoordinationViewV3(root).instances[liveInstanceIdV3(owner)];
+                if (projected?.provisional_termination) {
+                    const { recordLiveResumeObservationV3 } = await import("./live-lifecycle-v3.js");
+                    recordLiveResumeObservationV3({
+                        coordRoot: root,
+                        owner,
+                        nativeSessionId: sessionId ?? owner,
+                        adapter: adapterFromPlatform(adapter),
+                    });
+                }
+                const { ensureLiveCoordinationHeartbeat } = await import("./state/live-coordination-view.js");
+                hb = ensureLiveCoordinationHeartbeat(root, owner, sessionId ?? owner, adapterFromPlatform(adapter), model);
+            }
+            catch (error) {
+                process.stderr.write(`agent-coord repair-coordination-cache: V3 route refused (${error instanceof Error ? error.message : String(error)})\n`);
+                return 1;
+            }
             process.stdout.write(`${JSON.stringify({ instance_id: owner, recreated: !!hb })}\n`);
             return hb ? 0 : 1;
         }
-        case "stamp-tool-activity": {
-            const toolName = args[0] ?? "";
-            const target = args.slice(1).join(" ");
-            const hb = writer.stampToolActivity(root, owner, toolName, target);
-            if (!hb)
-                return 1;
-            process.stdout.write(`${JSON.stringify({
-                instance_id: owner,
-                last_tool: hb.last_tool,
-                last_tool_target: hb.last_tool_target,
-            })}\n`);
-            return 0;
-        }
         default:
             process.stderr.write(`agent-coord: unknown state action ${action}\n`);
             return 2;
@@ -507,33 +451,9 @@ async function handleShellMutationClaimLog(root, rest) {
     const platform = args.platform ?? "unknown";
     const owner = args.owner ?? null;
     const { shellMutationPaths } = await import("./state/shell-mutation.js");
-    const { emit } = await import("./events/emit.js");
-    const { readHeartbeat } = await import("./state/heartbeat-writer.js");
     const paths = shellMutationPaths(cmd, root);
     const truncated = cmd.length > 80 ? cmd.slice(0, 80) : cmd;
-    // Warn-only peer-shell-mutation signal. Formerly a SHELL_CLAIM_CANDIDATE line
-    // in a log file; now a canonical decision.warn so the
-    // signal survives in events.ndjson. (The blocking claim-conflict path is
-    // separate: claim.conflict / verdict, and unaffected.)
-    const adapter = platform === "cursor" ? "cursor" : platform === "codex" ? "codex" : "claude-code";
-    const hb = owner ? readHeartbeat(root, owner) : null;
-    for (const p of paths) {
-        try {
-            emit(root, {
-                event_type: "decision.warn",
-                instance_id: owner ?? "unknown",
-                session_id: hb?.session_id ?? owner ?? "unknown",
-                adapter,
-                data: {
-                    rule: "shell_mutation_candidate",
-                    reason: `path=${p} cmd=${truncated} platform=${platform}`,
-                },
-            });
-        }
-        catch {
-            /* telemetry only, never break the dispatcher */
-        }
-    }
+    process.stdout.write(`${JSON.stringify({ schema_version: 2, owner, platform, command_preview: truncated, paths })}\n`);
     return 0;
 }
 async function handleStaleSweep(root, _rest) {
@@ -542,6 +462,38 @@ async function handleStaleSweep(root, _rest) {
     process.stdout.write(`${JSON.stringify(result)}\n`);
     return 0;
 }
+async function handleReconcileFinalization(root) {
+    const { reconcileSessionFinalizationV3 } = await import("./session-finalizer-v3.js");
+    const result = reconcileSessionFinalizationV3(root);
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return result.diagnostics.some((item) => item === "ledger_not_authority_safe") ? 2 : 0;
+}
+async function handleEndSession(root, rest) {
+    const instanceId = rest[0];
+    if (!instanceId || !/^inst_[A-Za-z0-9._-]+$/.test(instanceId))
+        return 2;
+    const { listHookProducerStateRecordsV3 } = await import("../events/v3/producers/recorder.js");
+    const record = listHookProducerStateRecordsV3(root, { includeTerminal: false }).find(({ state }) => state.instance_id === instanceId);
+    if (!record)
+        return 2;
+    const { requestSessionEndExplicitV3 } = await import("./session-finalizer-v3.js");
+    const result = requestSessionEndExplicitV3({
+        coordRoot: root,
+        instance_id: record.state.instance_id,
+        generation_id: record.state.generation_id,
+        outcome: "interrupted",
+        coordination_finalized: false,
+    });
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return result.state === "recorded" ||
+        result.state === "already_ended" ||
+        result.state === "queued" ||
+        result.state === "already_requested"
+        ? 0
+        : result.state === "delegated_work_open"
+            ? 3
+            : 2;
+}
 async function handlePromptContext(root, rest) {
     const args = {};
     for (let i = 0; i < rest.length; i++) {
@@ -620,41 +572,6 @@ async function handleSessionContext(root, rest) {
     process.stdout.write(text);
     return 0;
 }
-async function handleCodexReplay(root, rest) {
-    const args = {};
-    for (let i = 0; i < rest.length; i++) {
-        const a = rest[i];
-        if (a.startsWith("--")) {
-            const key = a.slice(2);
-            const val = rest[i + 1];
-            if (val === undefined || val.startsWith("--")) {
-                args[key] = "true";
-            }
-            else {
-                args[key] = val;
-                i++;
-            }
-        }
-    }
-    const jsonlPath = args.jsonl;
-    const sessionId = args.session;
-    const instanceId = args.owner ?? sessionId;
-    const lastMsg = args["last-message"];
-    if (!jsonlPath || !sessionId) {
-        process.stderr.write("agent-coord codex-replay --jsonl <path> --session <id> [--owner <id>] [--last-message <text>]\n");
-        return 2;
-    }
-    const { replayCodexJsonl } = await import("./codex-replay.js");
-    const result = replayCodexJsonl({
-        coordRoot: root,
-        jsonlPath,
-        sessionId,
-        instanceId: instanceId,
-        lastAssistantMessage: lastMsg,
-    });
-    process.stdout.write(`${JSON.stringify({ session_id: sessionId, emitted: result.emitted })}\n`);
-    return 0;
-}
 async function handleResolveName(root, rest) {
     const { resolveName } = await import("./state/names.js");
     const [owner, session] = rest;
@@ -671,7 +588,6 @@ async function handleResolveName(root, rest) {
     return 0;
 }
 async function handleEmitEvent(root, rest) {
-    const { emitAndProject } = await import("./cli-emit.js");
     const args = {};
     for (let i = 0; i < rest.length; i++) {
         const a = rest[i];
@@ -691,9 +607,9 @@ async function handleEmitEvent(root, rest) {
     const instanceId = args.owner;
     const sessionId = args.session;
     const adapter = args.adapter;
-    const dataJson = args["data-json"] ?? "{}";
-    if (!eventType || !instanceId || !sessionId || !adapter) {
-        process.stderr.write("agent-coord emit-event --type <T> --owner <id> --session <id> --adapter <h> [--data-json '<json>']\n");
+    const dataJson = args["data-stdin"] === "true" ? await readStdin() : "";
+    if (!eventType || !instanceId || !sessionId || !adapter || !dataJson) {
+        process.stderr.write("agent-coord emit-event --type <V3_TYPE> --owner <id> --session <id> --adapter <h> --data-stdin\n");
         return 2;
     }
     let data;
@@ -703,30 +619,75 @@ async function handleEmitEvent(root, rest) {
             data = parsed;
         }
         else {
-            process.stderr.write("agent-coord emit-event: --data-json must encode an object\n");
+            process.stderr.write("agent-coord emit-event: stdin must encode an object\n");
             return 2;
         }
     }
     catch (err) {
-        process.stderr.write(`agent-coord emit-event: invalid --data-json (${err instanceof Error ? err.message : String(err)})\n`);
+        process.stderr.write(`agent-coord emit-event: invalid stdin JSON (${err instanceof Error ? err.message : String(err)})\n`);
         return 2;
     }
-    const result = emitAndProject({
-        event_type: eventType,
-        instance_id: instanceId,
-        session_id: sessionId,
-        adapter,
-        turn_id: args["turn-id"],
-        parent_session_id: args["parent-session-id"],
-        parent_turn_id: args["parent-turn-id"],
-        data,
-    }, { coordRoot: root });
-    if (!result) {
-        process.stderr.write("agent-coord emit-event: emission failed\n");
+    const { resolveLiveEventLedgerRouteV3 } = await import("../events/v3/live-routing.js");
+    const ledgerRoute = resolveLiveEventLedgerRouteV3(root);
+    if (ledgerRoute.state === "blocked") {
+        process.stderr.write(`agent-coord emit-event: V3 ledger route is unsafe (${ledgerRoute.reason})\n`);
         return 1;
     }
-    process.stdout.write(`${JSON.stringify(result.envelope)}\n`);
-    return 0;
+    if (data.event_type !== eventType) {
+        process.stderr.write("agent-coord emit-event: envelope type does not match stdin event_type\n");
+        return 2;
+    }
+    if (eventType === "coord.lifecycle_changed") {
+        const state = data.new_state;
+        if (state !== "active" && state !== "blocked" && state !== "done") {
+            process.stderr.write("agent-coord emit-event: invalid V3 lifecycle state\n");
+            return 2;
+        }
+        const { recordLiveLifecycleChangeV3 } = await import("./live-authority-v3.js");
+        try {
+            const routed = recordLiveLifecycleChangeV3({
+                coordRoot: root,
+                owner: instanceId,
+                nativeSessionId: sessionId,
+                adapter,
+                state,
+                reason: typeof data.reason === "string" && data.reason.length > 0 ? data.reason : undefined,
+                suggestedSessionName: typeof data.suggested_session_name === "string" && data.suggested_session_name.length > 0
+                    ? data.suggested_session_name
+                    : undefined,
+            });
+            process.stdout.write(`${JSON.stringify({ schema_version: 2, event_type: "coord.lifecycle_changed", state: routed.state })}\n`);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`agent-coord emit-event: V3 lifecycle authority refused (${error instanceof Error ? error.message : String(error)})\n`);
+            return 1;
+        }
+    }
+    if (eventType === "coord.status_observed" ||
+        eventType === "coord.presence_changed" ||
+        eventType === "coord.message_observed" ||
+        eventType === "council.state_changed" ||
+        eventType === "decision.state_changed") {
+        const { recordLiveCoordinationObservationV3 } = await import("./live-observation-v3.js");
+        try {
+            const routed = recordLiveCoordinationObservationV3({
+                coordRoot: root,
+                owner: instanceId,
+                nativeSessionId: sessionId,
+                adapter,
+                observation: data,
+            });
+            process.stdout.write(`${JSON.stringify({ schema_version: 2, event_type: routed.event.event_type, event_id: routed.event.event_id })}\n`);
+            return 0;
+        }
+        catch (error) {
+            process.stderr.write(`agent-coord emit-event: V3 observation refused (${error instanceof Error ? error.message : String(error)})\n`);
+            return 1;
+        }
+    }
+    process.stderr.write(`agent-coord emit-event: unsupported V3 event type ${eventType}\n`);
+    return 2;
 }
 /**
  * `agent-coord git-hook <event> [args]` — the single entry a host git hook
@@ -794,15 +755,27 @@ async function handleGitHook(fallbackRoot, rest) {
             if (paths.length === 0)
                 return 0;
             const { resolveOwner } = await import("../hooks/resolve/owner.js");
-            const owner = resolveOwner({ payload: null, coordRoot: root })?.instance_id;
+            const owner = resolveOwner({
+                payload: null,
+                coordRoot: root,
+            })?.instance_id;
             if (!owner)
                 return 0;
-            const { groupUnclaim } = await import("./state/heartbeat-writer.js");
-            const reason = event === "post-commit" ? "commit" : "checkout";
+            const { findGroupClaims } = await import("./state/heartbeat-writer.js");
+            const { recordLiveClaimChangeV3 } = await import("./live-authority-v3.js");
             for (const path of paths) {
                 try {
-                    for (const hit of groupUnclaim(root, owner, path)) {
-                        await emitClaimRelease(root, hit.instance_id, hit, path, reason);
+                    for (const hit of findGroupClaims(root, owner, path)) {
+                        recordLiveClaimChangeV3({
+                            coordRoot: root,
+                            owner,
+                            subject: hit.instance_id,
+                            nativeSessionId: hit.session_id ?? owner,
+                            adapter: adapterFromPlatform(hit.platform),
+                            operation: "released",
+                            path,
+                            access: "write",
+                        });
                     }
                 }
                 catch {
@@ -834,12 +807,9 @@ async function main() {
         return handleEmitEvent(root, rest);
     }
     if (subcommand === "set-task" ||
-        subcommand === "set-turn-summary" ||
         subcommand === "release-claim" ||
-        subcommand === "kill-heartbeat" ||
         subcommand === "heal-pidmap" ||
-        subcommand === "heal-heartbeat" ||
-        subcommand === "stamp-tool-activity") {
+        subcommand === "repair-coordination-cache") {
         return handleStateAction(root, subcommand, rest);
     }
     if (subcommand === "append-journal" || subcommand === "edit-journal") {
@@ -859,12 +829,15 @@ async function main() {
     if (subcommand === "resolve-name") {
         return handleResolveName(root, rest);
     }
-    if (subcommand === "codex-replay") {
-        return handleCodexReplay(root, rest);
-    }
     if (subcommand === "stale-sweep") {
         return handleStaleSweep(root, rest);
     }
+    if (subcommand === "reconcile-finalization") {
+        return handleReconcileFinalization(root);
+    }
+    if (subcommand === "end-session") {
+        return handleEndSession(root, rest);
+    }
     if (subcommand === "session-context") {
         return handleSessionContext(root, rest);
     }

package/dist/core/agents/codex-archive-v3.d.ts

@@ -0,0 +1,14 @@
+import type { SessionArchiveObservationV3 } from "./session-finalizer-v3.js";
+export interface CodexArchiveScanResultV3 {
+    observations: SessionArchiveObservationV3[];
+    diagnostics: string[];
+}
+/**
+ * Read only Codex's durable lifecycle columns. Conversation content, titles,
+ * working directories, and model metadata never leave the adapter database.
+ */
+export declare function readCodexArchiveObservationsV3(coordRoot: string, options?: {
+    databasePath?: string;
+    observedAt?: string;
+}): CodexArchiveScanResultV3;
+//# sourceMappingURL=codex-archive-v3.d.ts.map

package/dist/core/agents/codex-archive-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-archive-v3.d.ts","sourceRoot":"","sources":["../../../src/core/agents/codex-archive-v3.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAyB7E,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,2BAA2B,EAAE,CAAC;IAC5C,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3D,wBAAwB,CAmE1B"}