harnery 0.35.0 → 0.37.0

package/dist/core/hooks/cli.js

@@ -16,24 +16,28 @@
  * `.harnery/debug/agent-hook.errors.ndjson` for audit but never break the
  * adapter flow.
  */
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { coordEnv } from "../../lib/env.js";
 import { buildInstructionBundle } from "../../lib/instructions/bundle.js";
-import { coordBinPath } from "../agents/coord-bin.js";
+import { resolveCoordRoot } from "../agents/coord-client.js";
 import { classifyWriteClaimFinalization, formatWriteClaimFinalizationDenial, } from "../agents/finalization.js";
+import { recordLiveClaimChangeV3, restoreLiveCoordinationStateAfterEpochV3, } from "../agents/live-authority-v3.js";
 import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-hook.js";
 import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, sessionNameDisplayInstruction, sessionNameDisplayPending, sessionNameDisplayRecoveryInstruction, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
-import { stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
-import { ensureLiveCoordinationHeartbeat, readLiveCoordinationRow, } from "../agents/state/live-coordination-view.js";
+import { readHeartbeat, stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
+import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.js";
+import { ensureLiveCoordinationHeartbeat } from "../agents/state/live-coordination-writer.js";
+import { assignName } from "../agents/state/names.js";
 import { writePidmapRow } from "../agents/state/pidmap.js";
 import { agentsRequireGitFinalization, resolveBinName } from "../config.js";
 import { checkpointContext, completeContextRecovery, extractContextSample, markContextCompactionCompleted, prepareContextRecovery, readContextState, recordContextSample, } from "../context/index.js";
 import { tryWriteLiveDisplayV3 } from "../events/v3/live-feed.js";
-import { liveHookSignalDefersDrainV3, recordLiveDelegatedChildSessionV3, recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { liveHookSignalDefersDrainV3, reconcileLivePendingRuntimeContextV3, recordLiveDelegatedChildSessionV3, recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
 import { captureSpanClockV3 } from "../events/v3/span-state.js";
-import { fetchPresence } from "../presence/index.js";
+import { ensureRelayDaemon, fetchPresence, publishPresence } from "../presence/index.js";
+import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.js";
 import { stableScopeId } from "../workflow/scope-id.js";
 import { detectAdapter, shouldSkipHookAdapter } from "./adapter/detect.js";
 import { extractBashCommand, extractToolDescription, normalizeEventName, parsePayload, } from "./adapter/parse.js";
@@ -42,13 +46,14 @@ import { codexWslFileLinkTelemetry, inspectCodexWslBridge, isWslUncPath, renderC
 import { captureImages, detectPresence, imageJanitor, journalArchive, journalJanitor, journalRecoveryCue, playSound, recordImageArtifactsV3, resetSoundCounters, runSessionSyncExtension, soundForEvent, } from "./effects/index.js";
 import { toolInputHash, toolTargetHash } from "./events/input-hash.js";
 import { canonicalize } from "./guard-path.js";
+import { beginHookHealth, observeHookDebug, observeHookError, writeHookHealthCompletion, } from "./health.js";
 import { adapterPidFromEnv, parsePsChainLine, selectAnchorPid } from "./resolve/anchor.js";
-import { findCoordRoot } from "./resolve/coord-root.js";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.js";
 import { resolveOwner } from "./resolve/owner.js";
-import { inspectSessionNameDisplayImmediately, scanAssistantTextIncludes, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptRuntime, } from "./resolve/transcript.js";
+import { inspectSessionNameDisplayImmediately, scanAssistantStatusBoxPresent, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptRuntime, } from "./resolve/transcript.js";
 import { sessionNamePresence } from "./session-name-presence.js";
 import { unsafeCrossShellReason } from "./unsafe-cross-shell.js";
+let hookHealthState;
 function parseArgv(argv) {
     const out = { eventName: null, extra: [] };
     for (let i = 0; i < argv.length; i++) {
@@ -68,6 +73,10 @@ function parseArgv(argv) {
     }
     return out;
 }
+function extraArg(extra, name) {
+    const index = extra.indexOf(name);
+    return index >= 0 ? extra[index + 1] : undefined;
+}
 async function readStdin() {
     if (process.stdin.isTTY)
         return "";
@@ -83,16 +92,24 @@ async function readStdin() {
     }
 }
 /**
- * Env for child agent-coord spawns, with the coord root pinned. The hook
- * process may be running with the session shell's cwd (inside a submodule or
- * journal dir), and agent-coord resolves its root from cwd unless overridden —
- * without the pin a child could write state to a different .harnery than the
- * one this hook resolved.
+ * Env for a detached hook retry worker, with the coord root pinned. The hook
+ * may run with the session shell's cwd (inside a submodule or journal dir), so
+ * the worker must retain the root this process already resolved.
  */
 function childEnv(coordRoot) {
     return { ...process.env, HARNERY_COORD_ROOT_OVERRIDE: coordRoot };
 }
 function appendDebug(coordRoot, entry) {
+    observeHookDebug(hookHealthState, entry);
+    if (coordEnv("SHARED_LOGS") !== "0") {
+        try {
+            processLogger(coordRoot, "agent-hook").debug("agent_hook.diagnostic", legacyLogFields(entry));
+            return;
+        }
+        catch {
+            /* fall through to the rollback writer */
+        }
+    }
     const path = join(coordRoot, ".harnery", "debug", "agent-hook.ndjson");
     try {
         mkdirSync(dirname(path), { recursive: true });
@@ -103,8 +120,18 @@ function appendDebug(coordRoot, entry) {
     }
 }
 function logError(coordRoot, err, context) {
+    observeHookError(hookHealthState, context.phase);
     if (!coordRoot)
         return;
+    if (coordEnv("SHARED_LOGS") !== "0") {
+        try {
+            processLogger(coordRoot, "agent-hook").error("agent_hook.error", legacyLogFields(context), err);
+            return;
+        }
+        catch {
+            /* fall through to the rollback writer */
+        }
+    }
     const path = join(coordRoot, ".harnery", "debug", "agent-hook.errors.ndjson");
     try {
         mkdirSync(dirname(path), { recursive: true });
@@ -120,33 +147,13 @@ function logError(coordRoot, err, context) {
     }
 }
 /**
- * Spawn `agent-coord assign-name <owner> <kind>` to mint or recover the
- * hurricane-style name for this owner. Returns null on any failure so
- * session.started emission never breaks the adapter flow.
- *
- * Lives at agent-hooks side (not agent-coord) to keep emitter/consumer
- * separation: we spawn rather than import.
+ * Mint or recover the hurricane-style name for this owner in-process. Returns
+ * null on any failure so session.started emission never breaks adapter flow.
  */
-function assignNameViaAgentCoord(coordRoot, instanceId, kind, forkedFrom) {
-    const binary = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (!existsSync(binary))
-        return null;
+function assignNameInProcess(coordRoot, instanceId, kind, forkedFrom) {
     try {
-        const args = ["assign-name", instanceId, kind];
-        if (forkedFrom)
-            args.push("--forked-from", forkedFrom);
-        const result = spawnSync(binary, args, {
-            encoding: "utf8",
-            timeout: 2000,
-            env: childEnv(coordRoot),
-        });
-        if (result.status !== 0 || !result.stdout)
-            return null;
-        const parsed = JSON.parse(result.stdout.trim());
-        if (parsed.name && parsed.kind) {
-            return { name: parsed.name, kind: parsed.kind };
-        }
-        return null;
+        const name = assignName(coordRoot, instanceId, kind, forkedFrom ? { forkedFrom } : undefined);
+        return { name, kind };
     }
     catch {
         return null;
@@ -202,9 +209,9 @@ function buildEventData(eventType, ctx) {
             // tool.requested heal path instead. The forkedFrom plumbing below stays
             // for adapters that DO report a parent at session start.
             const forkedFrom = undefined;
-            // Assign (or recover) name + kind via agent-coord. Idempotent: resume
+            // Assign (or recover) name + kind in-process. Idempotent: resume
             // returns the original name; new owner consumes a counter slot.
-            const assigned = assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "session", forkedFrom);
+            const assigned = assignNameInProcess(ctx.coordRoot, ctx.instanceId, "session", forkedFrom);
             // Write the adapter pid-map row so `harn agents whoami` ppid-walks find
             // this owner. Prefer the payload pid (the actual claude binary), then the
             // anchor walk (the `node` ancestor for Cursor, which has no payload pid),
@@ -268,7 +275,7 @@ function buildEventData(eventType, ctx) {
             // a later SessionStart remains idempotent.
             if (ctx.adapter === "cursor" &&
                 !readLiveCoordinationRow(ctx.coordRoot, ctx.instanceId)?.name) {
-                assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "session");
+                assignNameInProcess(ctx.coordRoot, ctx.instanceId, "session");
             }
             const prompt = p?.prompt ?? "";
             const { value, truncated } = clampString(prompt, 4000);
@@ -304,8 +311,7 @@ function buildEventData(eventType, ctx) {
                 // assistant text only (same window, same scanner as the session-name
                 // detection). The Stop verdict enforces this field; the loose field is
                 // retained as diagnostic telemetry for the measured detector divergence.
-                status_box_present_strict: scanAssistantTextIncludes(p?.transcript_path, "┌─ agent-") ||
-                    lastAssistantMessage.includes("┌─ agent-"),
+                status_box_present_strict: scanAssistantStatusBoxPresent(p?.transcript_path, lastAssistantMessage),
                 // Whether the session's suggested name is satisfied as of this turn,
                 // and which name that refers to. Reported on every stop while a name
                 // exists (the stop-hook.session_name verdict reads it per turn); the
@@ -327,7 +333,7 @@ function buildEventData(eventType, ctx) {
             // (agent-coord/state/names.ts → kind=transient). Use the call ID as the
             // instance_id input; assignName falls through to transient.
             const childInstanceId = subagentCallId ?? ctx.instanceId;
-            const assigned = assignNameViaAgentCoord(ctx.coordRoot, childInstanceId, "subagent");
+            const assigned = assignNameInProcess(ctx.coordRoot, childInstanceId, "subagent");
             return {
                 agent_type: p?.raw.agent_type ??
                     p?.raw.subagent_type ??
@@ -442,10 +448,18 @@ function numberField(value) {
 }
 async function main() {
     const hookStartedAt = performance.now();
+    const hookStartedRss = process.memoryUsage().rss;
     const hookClock = captureSpanClockV3();
     const { eventName, extra } = parseArgv(process.argv.slice(2));
     const adapter = detectAdapter(process.argv.slice(2));
     const raw = await readStdin();
+    hookHealthState = beginHookHealth({
+        started_at_ms: hookStartedAt,
+        started_rss_bytes: hookStartedRss,
+        event_name: eventName,
+        adapter,
+        payload_bytes: raw.length,
+    });
     // Cursor executes the Claude Code project hooks too on hosts wired for both
     // adapters, piping them its own payload (identifiable by the top-level
     // cursor_version envelope field). That stray `--adapter claude-code`
@@ -454,8 +468,9 @@ async function main() {
     // `--adapter cursor` dispatch of the same payload carries the session.
     if (shouldSkipHookAdapter(adapter, raw)) {
         if (coordEnv("AGENT_COORD_OFF") !== "1") {
-            const coordRoot = findCoordRoot(process.cwd());
+            const coordRoot = resolveCoordRoot(process.cwd());
             if (coordRoot) {
+                hookHealthState.coord_root = coordRoot;
                 appendDebug(coordRoot, {
                     ts: new Date().toISOString(),
                     event_name: eventName,
@@ -478,7 +493,7 @@ async function main() {
     if (adapter === "claude-code" && eventName) {
         const s = soundForEvent(eventName);
         if (s) {
-            const repoRoot = findCoordRoot(process.cwd());
+            const repoRoot = resolveCoordRoot(process.cwd());
             if (repoRoot) {
                 let sid = "";
                 let stopContinuation = false;
@@ -505,9 +520,13 @@ async function main() {
     // bypass during incident triage.
     if (coordEnv("AGENT_COORD_OFF") === "1")
         return 0;
-    const coordRoot = findCoordRoot(process.cwd());
+    const coordRoot = resolveCoordRoot(process.cwd());
     if (!coordRoot)
         return 0;
+    hookHealthState.coord_root = coordRoot;
+    if (eventName === "runtime-context-retry") {
+        return runRuntimeContextRetryWorker(coordRoot, adapter, extra);
+    }
     const ledgerRoute = resolveLiveEventLedgerRouteV3(coordRoot);
     // Always log a breadcrumb, useful when an event_type maps to null or owner
     // resolution fails. Stays cheap (one append) and self-prunes via repo log
@@ -526,6 +545,78 @@ async function main() {
         appendDebug(coordRoot, { ...debugBase, skipped: "missing-event-or-adapter" });
         return 0;
     }
+    // Cursor's preToolUse `agent_message` is only the current narration before
+    // that tool. It is not a transcript and therefore cannot prove that an
+    // earlier assistant response omitted the required session-name block.
+    // afterAgentResponse is the one native boundary that carries the completed
+    // assistant text. Preserve only privacy-safe ritual booleans in the V3
+    // producer's open-turn state; Stop consumes them into the authoritative
+    // turn.completed event. The response body never enters V3 or heartbeat.
+    if (adapter === "cursor" && eventName === "after-agent-response") {
+        const payload = parsePayload(raw, adapter);
+        const owner = resolveOwner({ payload: payload?.raw ?? null, coordRoot });
+        if (!owner) {
+            appendDebug(coordRoot, { ...debugBase, skipped: "no-owner-resolved" });
+            return 0;
+        }
+        const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
+        const text = typeof payload?.raw.text === "string" ? payload.raw.text : "";
+        if (name && assistantTextStartsWithSessionNameBlock(text, name)) {
+            stampSessionNameSeen(coordRoot, owner.instance_id, name);
+            appendDebug(coordRoot, { ...debugBase, effect: "session-name-display-stamped" });
+        }
+        else {
+            appendDebug(coordRoot, { ...debugBase, skipped: "no-session-name-sighting" });
+        }
+        if (ledgerRoute.state === "blocked") {
+            appendDebug(coordRoot, {
+                ...debugBase,
+                skipped: "v3-control-blocked",
+                reason: ledgerRoute.reason,
+                owner_source: owner.source,
+            });
+            return 0;
+        }
+        const statusBoxPresentStrict = scanAssistantStatusBoxPresent(undefined, text);
+        // The hook parser needs the completed reply long enough to scan it, but
+        // durable hook intake must never retain that body. Keep every other native
+        // field so turn correlation remains available to the producer.
+        const { text: _completedReply, ...privacySafeRaw } = payload?.raw ?? {};
+        const privacySafePayload = payload ? { ...payload, raw: privacySafeRaw } : null;
+        const v3Result = recordLiveHookSignalV3({
+            coordRoot,
+            route: ledgerRoute,
+            eventName,
+            payload: privacySafePayload,
+            adapter,
+            instanceId: owner.instance_id,
+            hook_name: eventName,
+            hook_duration_ms: Math.max(0, Math.floor(performance.now() - hookStartedAt)),
+            monotonic_ns: hookClock.monotonic_ns,
+            turn_ritual: {
+                status_box_present: statusBoxPresentStrict,
+                status_box_present_strict: statusBoxPresentStrict,
+                session_name_required: name !== undefined,
+                session_name_present: name ? assistantTextStartsWithSessionNameBlock(text, name) : false,
+            },
+        });
+        observeHookDebug(hookHealthState, { event_v3_state: v3Result.state });
+        appendDebug(coordRoot, {
+            ...debugBase,
+            effect: "cursor-response-ritual-observed",
+            owner_source: owner.source,
+            event_v3_state: v3Result.state,
+            ...(v3Result.state === "observed"
+                ? {
+                    generation_id: v3Result.generation_id,
+                    turn_id: v3Result.turn_id,
+                    response_observed_at: v3Result.observed_at,
+                    status_box_present_strict: statusBoxPresentStrict,
+                }
+                : {}),
+        });
+        return 0;
+    }
     const norm = normalizeEventName(eventName);
     if (!norm) {
         appendDebug(coordRoot, { ...debugBase, skipped: "non-canonical-event" });
@@ -544,7 +635,9 @@ async function main() {
         });
         return 0;
     }
+    hookHealthState.owner_id = owner.instance_id;
     const sessionId = payload?.session_id ?? payload?.conversation_id ?? owner.instance_id;
+    const priorCoordination = readHeartbeat(coordRoot, owner.instance_id);
     const data = buildEventData(norm.event_type, {
         coordRoot,
         payload,
@@ -609,6 +702,27 @@ async function main() {
         ...(turnRitual ? { turn_ritual: turnRitual } : {}),
         ...(deferV3Drain ? { defer_drain: true } : {}),
     });
+    observeHookDebug(hookHealthState, {
+        ...(v3Result ? { event_v3_state: v3Result.state } : {}),
+    });
+    const recordedGenerationId = v3Result && "event" in v3Result && "generation_id" in v3Result.event.scope
+        ? v3Result.event.scope.generation_id
+        : undefined;
+    if (v3Result?.state === "recorded" || v3Result?.state === "already_started") {
+        try {
+            restoreLiveCoordinationStateAfterEpochV3({
+                coordRoot,
+                owner: owner.instance_id,
+                nativeSessionId: sessionId,
+                adapter,
+                prior: priorCoordination,
+                currentGenerationId: recordedGenerationId,
+            });
+        }
+        catch (error) {
+            logError(coordRoot, error, { phase: "epoch-coordination-restore" });
+        }
+    }
     const v3EventId = v3Result && "event" in v3Result
         ? v3Result.event.event_id
         : v3Result && "event_id" in v3Result
@@ -642,7 +756,7 @@ async function main() {
     }
     if (v3Result?.state === "recorded" && capturedImages.length > 0) {
         try {
-            recordImageArtifactsV3(coordRoot, v3Result.event, capturedImages);
+            recordImageArtifactsV3(coordRoot, v3Result.event, capturedImages, ledgerRoute.genesis_id);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "image-artifact-observation" });
@@ -733,6 +847,44 @@ async function main() {
         if (adapter === "claude-code")
             journalJanitor(coordRoot);
         imageJanitor(coordRoot);
+        // Session start is the only caller of the artifact janitor and the storage
+        // maintenance pass, so both load here instead of on every tool call.
+        const { autoCleanArtifacts } = await import("../artifacts/index.js");
+        const { autoCleanEventV3Archives } = await import("../events/v3/archive-retention.js");
+        const { createAutomaticMaintenanceComposition, runAutomaticMaintenancePass } = await import("../storage/maintenance-providers.js");
+        // Effect: throttled daily sweep of expired artifact workspaces (guarded,
+        // managed-expired only; see autoCleanArtifacts). Best-effort like every
+        // janitor here: a failure logs and never blocks session start.
+        try {
+            autoCleanArtifacts(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "artifact-auto-clean" });
+        }
+        // Effect: apply the same daily throttle to closed V3 epochs. The newest
+        // recovery epochs remain protected by the archive retention policy.
+        try {
+            autoCleanEventV3Archives(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "event-v3-archive-auto-clean" });
+        }
+        // Plan one bounded, claim-first global slice from cached pressure only.
+        // Existing owner janitors above remain the only active executors until
+        // each provider receives a separate production activation.
+        try {
+            await runAutomaticMaintenancePass(createAutomaticMaintenanceComposition(coordRoot, {
+                journal: () => {
+                    if (adapter === "claude-code")
+                        journalJanitor(coordRoot);
+                },
+                images: () => imageJanitor(coordRoot),
+                artifacts: () => autoCleanArtifacts(coordRoot),
+            }));
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "storage-maintenance-auto" });
+        }
         let recovery = null;
         if (payload?.source === "compact") {
             try {
@@ -759,10 +911,13 @@ async function main() {
         catch (err) {
             logError(coordRoot, err, { phase: "session-start-systemMessage" });
         }
-        // Pull advisory cross-machine presence. V3 never publishes from the
-        // disposable heartbeat cache.
+        // Cross-machine presence is derived from the authority-safe V3 projection,
+        // not the disposable heartbeat cache. Announce this session, pull peers,
+        // and keep the optional live relay connected.
         try {
+            publishPresence(coordRoot);
             fetchPresence(coordRoot);
+            ensureRelayDaemon(coordRoot);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "session-start-presence" });
@@ -772,7 +927,7 @@ async function main() {
     // agnostic since v0.5.0.
     if (norm.event_type === "session.ended") {
         try {
-            cleanupSessionEnd(coordRoot, owner.instance_id, data.reason ?? "unknown");
+            cleanupSessionEnd(coordRoot, owner.instance_id);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "session-end-cleanup" });
@@ -783,6 +938,14 @@ async function main() {
             journalArchive(coordRoot, owner.instance_id);
             runSessionSyncExtension(coordRoot, true);
         }
+        // Publish the post-cleanup V3 projection so remote machines see this
+        // session disappear without waiting for the stale window.
+        try {
+            publishPresence(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "session-end-presence" });
+        }
     }
     // Phase 8: SubagentStart: the child generation was opened above from the
     // native delegation identity. Refresh its disposable projection, log the
@@ -790,40 +953,17 @@ async function main() {
     if (norm.event_type === "agent.started") {
         try {
             const childInstanceId = data.agent_id ?? owner.instance_id;
-            const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-            if (existsSync(agentCoordBin)) {
-                spawnSync(agentCoordBin, ["project"], {
-                    encoding: "utf8",
-                    timeout: 3000,
-                    env: childEnv(coordRoot),
-                });
-                spawnSync(agentCoordBin, [
-                    "log",
-                    `SUBAGENT_START  agent_type=${data.agent_type ?? "unknown"} agent_id=${childInstanceId.slice(0, 8)} platform=${adapterPlatform(adapter)}`,
-                    "--instance",
-                    childInstanceId,
-                ], { encoding: "utf8", timeout: 2000, env: childEnv(coordRoot) });
-            }
-            emitSubagentStartContext(coordRoot, childInstanceId, sessionId, data, adapter);
+            await emitSubagentStartContext(coordRoot, childInstanceId, sessionId, data, adapter);
         }
         catch (err) {
-            logError(coordRoot, err, { phase: "subagent-start-project" });
+            logError(coordRoot, err, { phase: "subagent-start-context" });
         }
     }
     // Phase 8: SubagentStop: delete subagent heartbeat + log.
     if (norm.event_type === "agent.completed") {
         try {
             const childInstanceId = payload?.subagent_id ?? payload?.agent_id ?? owner.instance_id;
-            cleanupSessionEnd(coordRoot, childInstanceId, data.reason ?? "unknown");
-            const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-            if (existsSync(agentCoordBin)) {
-                spawnSync(agentCoordBin, [
-                    "log",
-                    `SUBAGENT_STOP   agent_id=${childInstanceId.slice(0, 8)} platform=${adapterPlatform(adapter)}`,
-                    "--instance",
-                    childInstanceId,
-                ], { encoding: "utf8", timeout: 2000, env: childEnv(coordRoot) });
-            }
+            cleanupSessionEnd(coordRoot, childInstanceId);
             const { reconcileSessionFinalizationV3 } = await import("../agents/session-finalizer-v3.js");
             reconcileSessionFinalizationV3(coordRoot, { archive_observations: [] });
         }
@@ -885,6 +1025,16 @@ async function main() {
         if (adapter === "claude-code") {
             runSessionSyncExtension(coordRoot, false);
         }
+        // Publish after the canonical turn event has landed so the blob carries
+        // current task, activity, and claim state. Re-ensure the relay here because
+        // its daemon intentionally exits when a machine has no live sessions.
+        try {
+            publishPresence(coordRoot);
+            ensureRelayDaemon(coordRoot);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "stop-presence" });
+        }
         // Stop verdict (V3 ritual + task/status gate). Direct in-process call: the
         // rule lives in Harnery. agent-hook already emitted this turn.completed
         // with privacy-safe ritual observations, so the evidence is in the stream.
@@ -893,6 +1043,8 @@ async function main() {
             instance_id: owner.instance_id,
             session_id: sessionId,
             adapter,
+            stop_hook_active: payload?.stop_hook_active === true,
+            status_box_present_strict: data.status_box_present_strict === true,
             bypass: coordEnv("AGENT_COORD_BYPASS_STOP") === "1",
             workflow_child: coordEnv("WORKFLOW_CHILD") === "1",
         });
@@ -902,13 +1054,16 @@ async function main() {
             // `cap` consecutive blocked stops in one cycle, allow the stop instead
             // of bouncing the model forever. Cycle boundaries come from the
             // adapter's continuation flag, so adapters without one are unaffected.
-            const { remediationCapExceeded } = await import("./remediation-cap.js");
-            if (remediationCapExceeded(sessionId, payload?.stop_hook_active === true)) {
+            const { recordRemediationBlock } = await import("./remediation-cap.js");
+            const remediation = recordRemediationBlock(sessionId, payload?.stop_hook_active === true);
+            if (remediation.exceeded) {
                 appendDebug(coordRoot, {
                     ...debugBase,
                     skipped: "stop-remediation-cap-exhausted",
                     blocked_rule: verdict.rule,
+                    blocked_count: remediation.count,
                     session_id: sessionId,
+                    remediation_cycle_anchor: verdict.remediation_cycle_anchor,
                 });
             }
             else {
@@ -937,6 +1092,8 @@ async function main() {
         catch (err) {
             logError(coordRoot, err, { phase: "stop-explicit-session-finalization" });
         }
+        if (adapter === "codex")
+            scheduleCodexRuntimeContextRetry(coordRoot, sessionId);
     }
     // Phase 7: PreToolUse: heartbeat + pid-map self-heal on every tool call.
     // Adapter-agnostic: both writes have the same shape regardless of who fired.
@@ -964,10 +1121,13 @@ async function main() {
         // runs before a name exists; every later tool waits until the exact block
         // is the first assistant text after the mint result. Cursor supplies
         // agent_message directly; Claude Code and Codex are resolved from their
-        // JSONL transcripts. Later commentary must not erase an already-correct
-        // display, and an unreadable transcript must not deadlock every tool.
+        // JSONL transcripts. Cursor's current narration can provide positive
+        // evidence, but cannot disprove an earlier response; afterAgentResponse
+        // stamps that durable sighting. Later commentary must not erase an
+        // already-correct display, and unavailable evidence must not deadlock
+        // every tool.
         try {
-            const displayAllowed = await enforcePendingSessionNameDisplay(coordRoot, owner.instance_id, adapter, payload);
+            const displayAllowed = await enforcePendingSessionNameDisplay(coordRoot, owner.instance_id, adapter, payload, generationBoundHeartbeat(readHeartbeat(coordRoot, owner.instance_id), recordedGenerationId));
             if (!displayAllowed)
                 return 0;
         }
@@ -1037,8 +1197,45 @@ async function main() {
     }
     return 0;
 }
-async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter, payload) {
-    const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, instanceId));
+function scheduleCodexRuntimeContextRetry(coordRoot, nativeSessionId) {
+    const modulePath = process.argv[1];
+    if (!modulePath)
+        return;
+    try {
+        const child = spawn(process.execPath, [modulePath, "runtime-context-retry", "--adapter", "codex", "--session-id", nativeSessionId], {
+            cwd: coordRoot,
+            detached: true,
+            stdio: "ignore",
+            env: childEnv(coordRoot),
+        });
+        child.unref();
+    }
+    catch (err) {
+        logError(coordRoot, err, { phase: "runtime-context-retry-spawn" });
+    }
+}
+async function runRuntimeContextRetryWorker(coordRoot, adapter, extra) {
+    const nativeSessionId = extraArg(extra, "--session-id");
+    if (adapter !== "codex" || !nativeSessionId)
+        return 0;
+    for (const [index, delayMs] of [400, 1_000].entries()) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        const route = resolveLiveEventLedgerRouteV3(coordRoot);
+        if (route.state !== "v3")
+            return 0;
+        const result = reconcileLivePendingRuntimeContextV3({
+            coordRoot,
+            route,
+            nativeSessionId,
+            finalAttempt: index === 1,
+        });
+        if (result.state !== "pending" && result.state !== "busy")
+            return 0;
+    }
+    return 0;
+}
+async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter, payload, coordination) {
+    const name = sessionNameDisplayPending(coordination);
     if (!name)
         return true;
     const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
@@ -1048,7 +1245,7 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
         ? {
             state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
                 ? "present"
-                : "absent",
+                : "unavailable",
         }
         : inspectSessionNameDisplayImmediately(
         // Codex hook payloads omit transcript_path on every event, which
@@ -1075,6 +1272,9 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
     emitDeny(adapter, sessionNameDisplayRecoveryInstruction(name, resolveBinName(coordRoot)));
     return false;
 }
+function generationBoundHeartbeat(heartbeat, generationId) {
+    return generationId && heartbeat?.v3_generation_id === generationId ? heartbeat : null;
+}
 async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapter) {
     const toolName = data.tool_name ?? "";
     const rawTargets = collectGuardTargets(toolName, data);
@@ -1103,40 +1303,19 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
     }
     if (targets.length === 0)
         return true;
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (!existsSync(agentCoordBin)) {
-        if (agentsRequireGitFinalization(coordRoot)) {
-            const { emitDeny } = await import("./adapter/output.js");
-            emitDeny(adapter, "Harnery denied the write before mutation because the claim coordinator is unavailable; repair the project's Harnery installation and retry.");
-            return false;
-        }
-        return true;
-    }
+    const { evaluateClaim } = await import("../agents/rules/claim-conflict.js");
     // For apply_patch (multi-file), collect siblings so the deny reason names
     // them. For single-file tools the array has one entry.
     for (const target of targets) {
-        const verdictReq = JSON.stringify({
-            rule: "claim",
-            instance_id: instanceId,
-            session_id: sessionId,
-            path: target.path,
-        });
-        const result = spawnSync(agentCoordBin, ["verdict"], {
-            input: verdictReq,
-            encoding: "utf8",
-            timeout: 3000,
-            env: childEnv(coordRoot),
-        });
-        if (result.status !== 0 || !result.stdout)
-            continue;
-        let parsed = {};
         try {
-            parsed = JSON.parse(result.stdout.trim());
-        }
-        catch {
-            continue;
-        }
-        if (parsed.allow === false) {
+            const parsed = evaluateClaim(coordRoot, {
+                rule: "claim",
+                instance_id: instanceId,
+                session_id: sessionId,
+                path: target.path,
+            });
+            if (parsed.allow !== false)
+                continue;
             let reason = parsed.reason ?? `Path ${target.path} is currently being edited by another agent.`;
             if (targets.length > 1) {
                 const siblings = targets
@@ -1152,6 +1331,7 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
             emitDeny(adapter, reason);
             return false;
         }
+        catch { }
     }
     return true;
 }
@@ -1350,16 +1530,23 @@ function releaseClaimOnFailure(coordRoot, instanceId, data, rawPayload) {
     const row = readLiveCoordinationRow(coordRoot, instanceId);
     if (!row?.files_touched?.includes(canonical))
         return;
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (!existsSync(agentCoordBin))
-        return;
-    spawnSync(agentCoordBin, ["release-claim", instanceId, canonical], {
-        encoding: "utf8",
-        timeout: 2000,
-        env: childEnv(coordRoot),
-    });
+    const before = readHeartbeat(coordRoot, instanceId);
+    try {
+        recordLiveClaimChangeV3({
+            coordRoot,
+            owner: instanceId,
+            nativeSessionId: before?.session_id ?? instanceId,
+            adapter: adapterFromPlatform(before?.platform),
+            operation: "released",
+            path: canonical,
+            access: "write",
+        });
+    }
+    catch {
+        /* best-effort release must not break adapter flow */
+    }
 }
-function cleanupSessionEnd(coordRoot, instanceId, reason) {
+function cleanupSessionEnd(coordRoot, instanceId) {
     // Sweep pid-map entries pointing to this instance
     const pidmapDir = join(coordRoot, ".harnery", "pid-map");
     if (existsSync(pidmapDir)) {
@@ -1383,36 +1570,20 @@ function cleanupSessionEnd(coordRoot, instanceId, reason) {
             /* swallow */
         }
     }
-    // Activity log
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (existsSync(agentCoordBin)) {
-        spawnSync(agentCoordBin, ["log", `SESSION_END     reason=${reason}`, "--instance", instanceId], { encoding: "utf8", timeout: 2000 });
-    }
 }
 async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionId, adapter, workspaceCwd, recoveryBriefing = "") {
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    let additionalContext = "";
-    if (existsSync(agentCoordBin)) {
-        const args = ["prompt-context", "--instance", instanceId, "--session", sessionId];
-        // Every human-facing adapter gets the first-session naming reminder from
-        // the shared hook path. Cursor + Codex additionally get ongoing set-task
-        // staleness nudges; Claude Code enforces those via its Stop transcript.
-        // Codex gets a fresh status-footer reminder on every prompt. Its Stop hook
-        // stays observe-only, so missing the footer never replaces the answer.
-        // Claude Code + Cursor (the Stop-ENFORCING adapters) get a fresh per-turn
-        // ritual reminder: satisfying the contract up front is far cheaper than
-        // the bounce-and-retry the Stop hook otherwise forces.
-        args.push("--session-name-nudge");
-        if (adapter === "cursor" || adapter === "codex")
-            args.push("--task-nudge");
-        if (adapter === "codex")
-            args.push("--status-footer-nudge");
-        if (adapter === "claude-code" || adapter === "cursor")
-            args.push("--turn-ritual-nudge", adapter);
-        const result = spawnSync(agentCoordBin, args, { encoding: "utf8", timeout: 3000 });
-        if (result.status === 0 && result.stdout)
-            additionalContext = result.stdout.trim();
-    }
+    const { renderPromptContext } = await import("../agents/render/prompt-context.js");
+    let additionalContext = renderPromptContext({
+        coordRoot,
+        instanceId,
+        sessionId,
+        adapter,
+        sessionNameNudge: true,
+        taskNudge: adapter === "cursor" || adapter === "codex",
+        hostPromptReminder: adapter === "codex",
+        statusFooterNudge: adapter === "codex",
+        turnRitualNudge: adapter === "claude-code" ? adapter : undefined,
+    }).trim();
     if (adapter === "codex") {
         const fileLinkContext = renderCodexWslFileLinkContext(coordRoot, workspaceCwd);
         if (fileLinkContext) {
@@ -1428,8 +1599,8 @@ async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionI
     emitContext(adapter, "UserPromptSubmit", additionalContext);
     return true;
 }
-function emitSubagentStartContext(coordRoot, instanceId, sessionId, data, adapter) {
-    // Look up the subagent's assigned name (just-written by agent-coord assignName
+async function emitSubagentStartContext(coordRoot, instanceId, sessionId, data, adapter) {
+    // Look up the subagent's assigned name (just-written by the in-process name
     // in session.started data) + the parent's short id for the "you are a subagent
     // of X" framing.
     const subagentName = data.name ?? "";
@@ -1441,69 +1612,55 @@ function emitSubagentStartContext(coordRoot, instanceId, sessionId, data, adapte
     // Render peer table inline since the subagent might want to know who else
     // is around. Reuse prompt-context (which dedups against the per-owner hash);
     // first call will always emit.
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
     let combined = message;
-    if (existsSync(agentCoordBin)) {
-        const result = spawnSync(agentCoordBin, ["prompt-context", "--instance", instanceId, "--session", sessionId, "--name", subagentName], { encoding: "utf8", timeout: 3000 });
-        const ctx = (result.stdout ?? "").trim();
-        if (ctx)
-            combined = `${message}\n\n${ctx}`;
-    }
+    const { renderPromptContext } = await import("../agents/render/prompt-context.js");
+    const context = renderPromptContext({
+        coordRoot,
+        instanceId,
+        sessionId,
+        agentName: subagentName,
+    }).trim();
+    if (context)
+        combined = `${message}\n\n${context}`;
     // Use SubagentStart event-name in CC's hookSpecificOutput shape; cursor's
     // flat `additional_context` works the same way.
-    void import("./adapter/output.js").then(({ emitContext }) => {
-        emitContext(adapter, "SubagentStart", combined);
-    });
+    const { emitContext } = await import("./adapter/output.js");
+    emitContext(adapter, "SubagentStart", combined);
 }
 function adapterPlatform(adapter) {
     if (adapter === "claude-code")
         return "claude-code";
     return adapter;
 }
+function adapterFromPlatform(platform) {
+    if (platform === "cursor")
+        return "cursor";
+    if (platform === "codex")
+        return "codex";
+    return "claude-code";
+}
 async function emitSessionStartSystemMessage(coordRoot, instanceId, sessionId, emittedData, adapter, recoveryBriefing = "") {
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
     const workflowChild = coordEnv("WORKFLOW_CHILD") === "1";
     let additionalContext = "";
-    if (existsSync(agentCoordBin)) {
-        // Sync-project so the heartbeat exists for downstream readers (peer table,
-        // wiring check, council invites).
-        spawnSync(agentCoordBin, ["project"], { encoding: "utf8", timeout: 3000 });
-        // Opportunistic reconciliation makes normal session starts a failsafe for
-        // archive, idle, cascade, and host lifecycle observations.
-        spawnSync(agentCoordBin, ["reconcile-finalization"], {
-            encoding: "utf8",
-            timeout: 5000,
-            env: { ...process.env, HARNERY_COORD_ROOT_OVERRIDE: coordRoot },
-        });
-        // SESSION_START activity log line, fired across all adapters.
-        const model = emittedData.model ?? "unknown";
-        const source = emittedData.source ?? "startup";
-        const platform = adapterPlatform(adapter);
-        spawnSync(agentCoordBin, [
-            "log",
-            `SESSION_START   model=${model} source=${source} platform=${platform}`,
-            "--instance",
+    // Opportunistic reconciliation makes normal session starts a failsafe for
+    // archive, idle, cascade, and host lifecycle observations. It also runs the
+    // stale cache sweep through the shared ADR 0077 composition.
+    const { reconcileCoordinationV3 } = await import("../agents/reconcile-coordination-v3.js");
+    reconcileCoordinationV3(coordRoot);
+    // Workflow children retain lifecycle/event capture but do not receive
+    // operator-facing peer, council, or init-remediation context. Injecting
+    // that context can make a bounded child follow housekeeping instructions
+    // instead of its assigned prompt.
+    if (!workflowChild) {
+        const agentName = emittedData.name ?? "";
+        const { renderSessionContext } = await import("../agents/render/session-context.js");
+        additionalContext = renderSessionContext({
+            coordRoot,
             instanceId,
-        ], { encoding: "utf8", timeout: 2000 });
-        // Workflow children retain lifecycle/event capture but do not receive
-        // operator-facing peer, council, or init-remediation context. Injecting
-        // that context can make a bounded child follow housekeeping instructions
-        // instead of its assigned prompt.
-        if (!workflowChild) {
-            const agentName = emittedData.name ?? "";
-            const args = ["session-context", "--instance", instanceId, "--session", sessionId];
-            if (agentName)
-                args.push("--name", agentName);
-            // The "You are agent-X." prefix in session-context renders unqualified by
-            // default (claude-code-style). For cursor/codex the bash dispatchers add
-            // a "(Cursor)" / "(Codex)" suffix; pass it through as --platform-label.
-            if (adapter !== "claude-code") {
-                args.push("--platform-label", platform === "cursor" ? "Cursor" : "Codex");
-            }
-            const result = spawnSync(agentCoordBin, args, { encoding: "utf8", timeout: 3000 });
-            if (result.status === 0 && result.stdout)
-                additionalContext = result.stdout.trim();
-        }
+            sessionId,
+            agentName: agentName || undefined,
+            platformLabel: adapter === "claude-code" ? undefined : adapter === "cursor" ? "Cursor" : "Codex",
+        }).trim();
     }
     // Effect (claude-code): merge the journal recovery cue into the session-start
     // context. Was a standalone additionalContext emission from the previous
@@ -1543,11 +1700,27 @@ function completeRecoveryInjection(coordRoot, instanceId, sessionId, recovery) {
     void recovery;
 }
 main()
-    .then((code) => process.exit(code))
-    .catch((err) => {
-    logError(findCoordRoot(process.cwd()), err, {
+    .then(async (code) => {
+    writeHookHealthCompletion(hookHealthState, {
+        finished_at_ms: performance.now(),
+        finished_rss_bytes: process.memoryUsage().rss,
+        pid: process.pid,
+    });
+    await closeProcessLoggers();
+    process.exit(code);
+})
+    .catch(async (err) => {
+    logError(resolveCoordRoot(process.cwd()), err, {
         argv: process.argv.slice(2),
         pid: process.pid,
+        phase: "top-level",
+    });
+    writeHookHealthCompletion(hookHealthState, {
+        finished_at_ms: performance.now(),
+        finished_rss_bytes: process.memoryUsage().rss,
+        pid: process.pid,
+        faulted: true,
     });
+    await closeProcessLoggers();
     process.exit(0);
 });