harnery 0.35.0 → 0.37.0

package/src/core/hooks/cli.ts

@@ -17,19 +17,23 @@
  * 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.ts";
 import { buildInstructionBundle } from "../../lib/instructions/bundle.ts";
 import type { Adapter } from "../adapter.ts";
-import { coordBinPath } from "../agents/coord-bin.ts";
+import { resolveCoordRoot } from "../agents/coord-client.ts";
 import {
   type ClaimFinalizationDecision,
   type ClaimFinalizationDescriptor,
   classifyWriteClaimFinalization,
   formatWriteClaimFinalizationDenial,
 } from "../agents/finalization.ts";
+import {
+  recordLiveClaimChangeV3,
+  restoreLiveCoordinationStateAfterEpochV3,
+} from "../agents/live-authority-v3.ts";
 import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-hook.ts";
 import {
   assistantTextStartsWithSessionNameBlock,
@@ -39,11 +43,11 @@ import {
   sessionNameDisplayRecoveryInstruction,
   toolResponseMintedSessionName,
 } from "../agents/session-name-display.ts";
-import { stampSessionNameSeen } from "../agents/state/heartbeat-writer.ts";
-import {
-  ensureLiveCoordinationHeartbeat,
-  readLiveCoordinationRow,
-} from "../agents/state/live-coordination-view.ts";
+import type { Heartbeat } from "../agents/state/heartbeat-reader.ts";
+import { readHeartbeat, stampSessionNameSeen } from "../agents/state/heartbeat-writer.ts";
+import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.ts";
+import { ensureLiveCoordinationHeartbeat } from "../agents/state/live-coordination-writer.ts";
+import { assignName } from "../agents/state/names.ts";
 import { writePidmapRow } from "../agents/state/pidmap.ts";
 import { agentsRequireGitFinalization, resolveBinName } from "../config.ts";
 import {
@@ -59,12 +63,14 @@ import {
 import { tryWriteLiveDisplayV3 } from "../events/v3/live-feed.ts";
 import {
   liveHookSignalDefersDrainV3,
+  reconcileLivePendingRuntimeContextV3,
   recordLiveDelegatedChildSessionV3,
   recordLiveHookSignalV3,
   resolveLiveEventLedgerRouteV3,
 } from "../events/v3/live-routing.ts";
 import { captureSpanClockV3 } from "../events/v3/span-state.ts";
-import { fetchPresence } from "../presence/index.ts";
+import { ensureRelayDaemon, fetchPresence, publishPresence } from "../presence/index.ts";
+import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
 import { stableScopeId } from "../workflow/scope-id.ts";
 import { detectAdapter, shouldSkipHookAdapter } from "./adapter/detect.ts";
 import {
@@ -97,13 +103,19 @@ import {
 } from "./effects/index.ts";
 import { toolInputHash, toolTargetHash } from "./events/input-hash.ts";
 import { canonicalize } from "./guard-path.ts";
+import {
+  beginHookHealth,
+  type HookHealthState,
+  observeHookDebug,
+  observeHookError,
+  writeHookHealthCompletion,
+} from "./health.ts";
 import { adapterPidFromEnv, parsePsChainLine, selectAnchorPid } from "./resolve/anchor.ts";
-import { findCoordRoot } from "./resolve/coord-root.ts";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.ts";
 import { resolveOwner } from "./resolve/owner.ts";
 import {
   inspectSessionNameDisplayImmediately,
-  scanAssistantTextIncludes,
+  scanAssistantStatusBoxPresent,
   scanSessionNameDisplayedImmediately,
   scanStatusBoxPresent,
   scanTranscriptRuntime,
@@ -116,6 +128,8 @@ interface Argv {
   extra: string[];
 }
 
+let hookHealthState: HookHealthState | undefined;
+
 function parseArgv(argv: string[]): Argv {
   const out: Argv = { eventName: null, extra: [] };
   for (let i = 0; i < argv.length; i++) {
@@ -134,6 +148,11 @@ function parseArgv(argv: string[]): Argv {
   return out;
 }
 
+function extraArg(extra: string[], name: string): string | undefined {
+  const index = extra.indexOf(name);
+  return index >= 0 ? extra[index + 1] : undefined;
+}
+
 async function readStdin(): Promise<string> {
   if (process.stdin.isTTY) return "";
   try {
@@ -148,17 +167,24 @@ async function readStdin(): Promise<string> {
 }
 
 /**
- * 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: string): NodeJS.ProcessEnv {
   return { ...process.env, HARNERY_COORD_ROOT_OVERRIDE: coordRoot };
 }
 
 function appendDebug(coordRoot: string, entry: Record<string, unknown>): void {
+  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 });
@@ -169,7 +195,20 @@ function appendDebug(coordRoot: string, entry: Record<string, unknown>): void {
 }
 
 function logError(coordRoot: string | null, err: unknown, context: Record<string, unknown>): void {
+  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 });
@@ -189,38 +228,18 @@ function logError(coordRoot: string | null, err: unknown, context: Record<string
 }
 
 /**
- * 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(
+function assignNameInProcess(
   coordRoot: string,
   instanceId: string,
   kind: "session" | "subagent" | "transient",
   forkedFrom?: string,
 ): { name: string; kind: string } | null {
-  const binary = coordBinPath("agent-coord", coordRoot) ?? "";
-  if (!existsSync(binary)) return null;
   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()) as {
-      name?: string;
-      kind?: string;
-    };
-    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;
   }
@@ -294,14 +313,9 @@ function buildEventData(
       // tool.requested heal path instead. The forkedFrom plumbing below stays
       // for adapters that DO report a parent at session start.
       const forkedFrom: string | undefined = 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),
@@ -369,7 +383,7 @@ function buildEventData(
         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);
@@ -408,9 +422,10 @@ function buildEventData(
         // 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
@@ -439,7 +454,7 @@ function buildEventData(
       // (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 as string | undefined) ??
@@ -569,10 +584,18 @@ function numberField(value: unknown): number | undefined {
 
 async function main(): Promise<number> {
   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
@@ -582,8 +605,9 @@ async function main(): Promise<number> {
   // `--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,
@@ -607,7 +631,7 @@ async function main(): Promise<number> {
   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;
@@ -638,8 +662,12 @@ async function main(): Promise<number> {
   // 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
@@ -661,6 +689,78 @@ async function main(): Promise<number> {
     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" });
@@ -680,8 +780,10 @@ async function main(): Promise<number> {
     });
     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,
@@ -756,6 +858,27 @@ async function main(): Promise<number> {
     ...(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 as `gen_${string}`)
+      : 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
@@ -795,7 +918,7 @@ async function main(): Promise<number> {
 
   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" });
     }
@@ -889,6 +1012,44 @@ async function main(): Promise<number> {
     // session-start additionalContext inside emitSessionStartSystemMessage.
     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.ts");
+    const { autoCleanEventV3Archives } = await import("../events/v3/archive-retention.ts");
+    const { createAutomaticMaintenanceComposition, runAutomaticMaintenancePass } = await import(
+      "../storage/maintenance-providers.ts"
+    );
+    // 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: PreparedContextRecovery | null = null;
     if (payload?.source === "compact") {
       try {
@@ -920,10 +1081,13 @@ async function main(): Promise<number> {
     } 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" });
     }
@@ -933,7 +1097,7 @@ async function main(): Promise<number> {
   // agnostic since v0.5.0.
   if (norm.event_type === "session.ended") {
     try {
-      cleanupSessionEnd(coordRoot, owner.instance_id, (data.reason as string) ?? "unknown");
+      cleanupSessionEnd(coordRoot, owner.instance_id);
     } catch (err) {
       logError(coordRoot, err, { phase: "session-end-cleanup" });
     }
@@ -943,6 +1107,13 @@ async function main(): Promise<number> {
       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
@@ -951,27 +1122,9 @@ async function main(): Promise<number> {
   if (norm.event_type === "agent.started") {
     try {
       const childInstanceId = (data.agent_id as string | undefined) ?? 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 as string) ?? "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" });
     }
   }
 
@@ -979,20 +1132,7 @@ async function main(): Promise<number> {
   if (norm.event_type === "agent.completed") {
     try {
       const childInstanceId = payload?.subagent_id ?? payload?.agent_id ?? owner.instance_id;
-      cleanupSessionEnd(coordRoot, childInstanceId, (data.reason as string) ?? "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.ts");
       reconcileSessionFinalizationV3(coordRoot, { archive_observations: [] });
     } catch (err) {
@@ -1061,6 +1201,16 @@ async function main(): Promise<number> {
       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.
@@ -1069,6 +1219,8 @@ async function main(): Promise<number> {
       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",
     });
@@ -1078,13 +1230,16 @@ async function main(): Promise<number> {
       // `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.ts");
-      if (remediationCapExceeded(sessionId, payload?.stop_hook_active === true)) {
+      const { recordRemediationBlock } = await import("./remediation-cap.ts");
+      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 {
         // Adapter-aware enforcement channel: Claude Code honors exit-2 + stderr
@@ -1113,6 +1268,7 @@ async function main(): Promise<number> {
     } 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.
@@ -1141,14 +1297,18 @@ async function main(): Promise<number> {
     // 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,
+        generationBoundHeartbeat(readHeartbeat(coordRoot, owner.instance_id), recordedGenerationId),
       );
       if (!displayAllowed) return 0;
     } catch (err) {
@@ -1225,13 +1385,56 @@ async function main(): Promise<number> {
   return 0;
 }
 
+function scheduleCodexRuntimeContextRetry(coordRoot: string, nativeSessionId: string): void {
+  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: string,
+  adapter: Adapter | null,
+  extra: string[],
+): Promise<number> {
+  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: string,
   instanceId: string,
   adapter: Adapter,
   payload: ParsedPayload | null,
+  coordination: Heartbeat | null,
 ): Promise<boolean> {
-  const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, instanceId));
+  const name = sessionNameDisplayPending(coordination);
   if (!name) return true;
 
   const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
@@ -1242,7 +1445,7 @@ async function enforcePendingSessionNameDisplay(
       ? {
           state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
             ? ("present" as const)
-            : ("absent" as const),
+            : ("unavailable" as const),
         }
       : inspectSessionNameDisplayImmediately(
           // Codex hook payloads omit transcript_path on every event, which
@@ -1275,6 +1478,13 @@ async function enforcePendingSessionNameDisplay(
   return false;
 }
 
+function generationBoundHeartbeat(
+  heartbeat: Heartbeat | null,
+  generationId: `gen_${string}` | undefined,
+): Heartbeat | null {
+  return generationId && heartbeat?.v3_generation_id === generationId ? heartbeat : null;
+}
+
 async function runPreToolUseGuard(
   coordRoot: string,
   instanceId: string,
@@ -1310,42 +1520,19 @@ async function runPreToolUseGuard(
   }
   if (targets.length === 0) return true;
 
-  const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-  if (!existsSync(agentCoordBin)) {
-    if (agentsRequireGitFinalization(coordRoot)) {
-      const { emitDeny } = await import("./adapter/output.ts");
-      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.ts");
 
   // 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: { allow?: boolean; reason?: string } = {};
     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) {
@@ -1361,7 +1548,7 @@ async function runPreToolUseGuard(
       const { emitDeny } = await import("./adapter/output.ts");
       emitDeny(adapter, reason);
       return false;
-    }
+    } catch {}
   }
   return true;
 }
@@ -1564,16 +1751,23 @@ function releaseClaimOnFailure(
   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: string, instanceId: string, reason: string): void {
+function cleanupSessionEnd(coordRoot: string, instanceId: string): void {
   // Sweep pid-map entries pointing to this instance
   const pidmapDir = join(coordRoot, ".harnery", "pid-map");
   if (existsSync(pidmapDir)) {
@@ -1595,15 +1789,6 @@ function cleanupSessionEnd(coordRoot: string, instanceId: string, reason: string
       /* 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(
@@ -1614,27 +1799,18 @@ async function emitUserPromptSubmitSystemMessage(
   workspaceCwd?: string,
   recoveryBriefing = "",
 ): Promise<boolean> {
-  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.ts");
+  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) {
@@ -1651,14 +1827,14 @@ async function emitUserPromptSubmitSystemMessage(
   return true;
 }
 
-function emitSubagentStartContext(
+async function emitSubagentStartContext(
   coordRoot: string,
   instanceId: string,
   sessionId: string,
   data: Record<string, unknown>,
   adapter: Adapter,
-): void {
-  // Look up the subagent's assigned name (just-written by agent-coord assignName
+): Promise<void> {
+  // 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 as string | undefined) ?? "";
@@ -1671,23 +1847,20 @@ function emitSubagentStartContext(
   // 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.ts");
+  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.ts").then(({ emitContext }) => {
-    emitContext(adapter, "SubagentStart", combined);
-  });
+  const { emitContext } = await import("./adapter/output.ts");
+  emitContext(adapter, "SubagentStart", combined);
 }
 
 function adapterPlatform(adapter: Adapter): string {
@@ -1695,6 +1868,12 @@ function adapterPlatform(adapter: Adapter): string {
   return adapter;
 }
 
+function adapterFromPlatform(platform: unknown): Adapter {
+  if (platform === "cursor") return "cursor";
+  if (platform === "codex") return "codex";
+  return "claude-code";
+}
+
 async function emitSessionStartSystemMessage(
   coordRoot: string,
   instanceId: string,
@@ -1703,53 +1882,29 @@ async function emitSessionStartSystemMessage(
   adapter: Adapter,
   recoveryBriefing = "",
 ): Promise<boolean> {
-  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 as string | undefined) ?? "unknown";
-    const source = (emittedData.source as string | undefined) ?? "startup";
-    const platform = adapterPlatform(adapter);
-    spawnSync(
-      agentCoordBin,
-      [
-        "log",
-        `SESSION_START   model=${model} source=${source} platform=${platform}`,
-        "--instance",
-        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 as string | undefined) ?? "";
-      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();
-    }
+  // 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.ts");
+  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 as string | undefined) ?? "";
+    const { renderSessionContext } = await import("../agents/render/session-context.ts");
+    additionalContext = renderSessionContext({
+      coordRoot,
+      instanceId,
+      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
@@ -1796,11 +1951,27 @@ function completeRecoveryInjection(
 }
 
 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);
   });