harnery 0.32.0 → 0.34.0

package/dist/core/hooks/cli.js

@@ -8,7 +8,7 @@
  *   4. Resolve instance_id (env → payload → pid-map walk).
  *   5. Map event-name → canonical event_type.
  *   6. Build event data from payload + resolvers (intent, transcript scan).
- *   7. Append envelope to .harnery/events.ndjson via emit() under flock.
+ *   7. Record the normalized observation in the canonical V3 ledger.
  *   8. (Still also writes a debug breadcrumb to .harnery/debug/ for visibility.)
  *
  * Phase 2 ship criterion: confirms parser correctness across thousands of
@@ -20,28 +20,32 @@ import { 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 { replayCodexJsonl } from "../agents/codex-replay.js";
+import { buildInstructionBundle } from "../../lib/instructions/bundle.js";
 import { coordBinPath } from "../agents/coord-bin.js";
-import { consumeSince, writeCursor } from "../agents/events/consume.js";
 import { classifyWriteClaimFinalization, formatWriteClaimFinalizationDenial, } from "../agents/finalization.js";
-import { evaluateStopHook } from "../agents/rules/stop-hook.js";
-import { projectHeartbeats } from "../agents/state/heartbeat-projector.js";
+import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-hook.js";
+import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, sessionNameDisplayInstruction, sessionNameDisplayPending, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
+import { stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
+import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.js";
 import { writePidmapRow } from "../agents/state/pidmap.js";
-import { shellMutationPaths } from "../agents/state/shell-mutation.js";
 import { agentsRequireGitFinalization, resolveBinName } from "../config.js";
 import { checkpointContext, completeContextRecovery, extractContextSample, markContextCompactionCompleted, prepareContextRecovery, readContextState, recordContextSample, } from "../context/index.js";
-import { ensureRelayDaemon, fetchPresence, publishPresence } from "../presence/index.js";
-import { detectAdapter } from "./adapter/detect.js";
+import { tryWriteLiveDisplayV3 } from "../events/v3/live-feed.js";
+import { recordLiveHookSignalV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { captureSpanClockV3 } from "../events/v3/span-state.js";
+import { fetchPresence } from "../presence/index.js";
+import { stableScopeId } from "../workflow/scope-id.js";
+import { detectAdapter, shouldSkipHookAdapter } from "./adapter/detect.js";
 import { extractBashCommand, extractToolDescription, normalizeEventName, parsePayload, } from "./adapter/parse.js";
 import { codexWslFileLinkTelemetry, inspectCodexWslBridge, isWslUncPath, renderCodexWslFileLinkContext, } from "./codex-wsl-bridge.js";
-import { captureImages, detectPresence, imageJanitor, journalArchive, journalJanitor, journalRecoveryCue, playSound, resetSoundCounters, runSessionSyncExtension, runTurnSummary, soundForEvent, } from "./effects/index.js";
-import { emit } from "./events/emit.js";
+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 { 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 { detectForkParent, scanAssistantTextIncludes, scanStatusBoxPresent, scanTranscriptModel, } from "./resolve/transcript.js";
+import { inspectSessionNameDisplayImmediately, scanAssistantTextIncludes, scanSessionNameDisplayedImmediately, scanStatusBoxPresent, scanTranscriptModel, } from "./resolve/transcript.js";
 import { sessionNamePresence } from "./session-name-presence.js";
 import { unsafeCrossShellReason } from "./unsafe-cross-shell.js";
 function parseArgv(argv) {
@@ -117,7 +121,7 @@ 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.start emission never breaks the adapter flow.
+ * 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.
@@ -149,7 +153,7 @@ function assignNameViaAgentCoord(coordRoot, instanceId, kind, forkedFrom) {
 }
 /**
  * Direct (in-process) pidmap write, avoiding the spawn overhead of going via
- * the agent-coord CLI for every session.start / subagent.start. Pid-map rows
+ * the agent-coord CLI for every session.started signal. Pid-map rows
  * are essential for `harn agents whoami` ppid resolution.
  *
  * This used to inline its own copy of the write to keep this module's
@@ -183,18 +187,18 @@ function summarizeOutput(value, headTail = 500) {
 function buildEventData(eventType, ctx) {
     const p = ctx.payload;
     switch (eventType) {
-        case "session.start": {
+        case "session.started": {
             const adapterPlatform = ctx.adapter === "claude-code"
                 ? "claude-code"
                 : ctx.adapter === "cursor"
                     ? "cursor"
                     : "codex";
             // Recorded fork lineage is NOT detected here. On claude-code a fork
-            // never fires its own session.start — SessionStart fires under the
+            // never fires its own session.started — SessionStart fires under the
             // PARENT's session id (source=resume) before the fork id is minted
             // (verified 2026-08-05) — so detection at this point can only mislabel
             // the resumed parent. The fork's new instance is caught by the
-            // tool.pre_use heal path instead. The forkedFrom plumbing below stays
+            // 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
@@ -210,12 +214,13 @@ function buildEventData(eventType, ctx) {
             if (adapterPid) {
                 writePidmapViaAgentCoord(ctx.coordRoot, adapterPid, ctx.instanceId, adapterPlatform);
             }
+            const bundle = safeInstructionBundle(ctx.coordRoot, p?.cwd ?? process.cwd(), ctx.adapter);
             return {
                 started_at: new Date().toISOString(),
                 cwd: p?.cwd ?? process.cwd(),
                 // Claude Code's SessionStart payload omits `model` (Codex + Cursor
                 // supply it). Fall back to the transcript, populated on `resume`, and
-                // backfilled later by `turn.stop` for a fresh `startup` session.
+                // backfilled later by `turn.completed` for a fresh startup session.
                 model: p?.model ?? scanTranscriptModel(p?.transcript_path),
                 pid: adapterPid,
                 source: p?.source,
@@ -223,6 +228,14 @@ function buildEventData(eventType, ctx) {
                 name: assigned?.name,
                 kind: "session",
                 agent_id: ctx.instanceId,
+                ...(bundle
+                    ? {
+                        instruction_bundle_id: bundle.instruction_bundle_id,
+                        instruction_source_id: bundle.canonical_source_id,
+                        instruction_profile_root: bundle.profile_root,
+                        instruction_component_count: bundle.components.length,
+                    }
+                    : {}),
                 // Recorded fork lineage rides the canonical event too, so full replay
                 // and derived readers converge on the same parent linkage that
                 // .name-history carries (the ADR 0017 dual-write pattern).
@@ -243,23 +256,30 @@ function buildEventData(eventType, ctx) {
                     : {}),
             };
         }
-        case "session.end":
+        case "session.ended":
             return {
                 ended_at: new Date().toISOString(),
                 clean_exit: p?.clean_exit ?? true,
             };
-        case "user_prompt.submit": {
+        case "turn.started": {
+            // Cursor can deliver beforeSubmitPrompt before sessionStart. Ensure that
+            // high-confidence prompt bootstrap also mints durable display identity;
+            // a later SessionStart remains idempotent.
+            if (ctx.adapter === "cursor" &&
+                !readLiveCoordinationRow(ctx.coordRoot, ctx.instanceId)?.name) {
+                assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "session");
+            }
             const prompt = p?.prompt ?? "";
             const { value, truncated } = clampString(prompt, 4000);
             return { prompt_text: value, ...(truncated ? { truncated: true } : {}) };
         }
-        case "turn.stop": {
+        case "turn.completed": {
             const lastAssistantMessage = p?.raw.last_assistant_message ?? "";
             const fileLinkTelemetry = ctx.adapter === "codex"
                 ? codexWslFileLinkTelemetry(ctx.coordRoot, p?.cwd, lastAssistantMessage)
                 : null;
             return {
-                // Backfill the model for adapters that omit it at session.start
+                // Backfill the model for adapters that omit it at session.started
                 // (Claude Code). The transcript is populated with assistant turns by
                 // Stop-hook time, so this resolves even for fresh `startup` sessions.
                 model: p?.model ?? scanTranscriptModel(p?.transcript_path),
@@ -273,7 +293,7 @@ function buildEventData(eventType, ctx) {
                 // Box present if the transcript scan finds it OR the final assistant
                 // message carries the `┌─ agent-` prefix. The latter covers codex's
                 // text-only stop (box in last_assistant_message, no transcript), which
-                // the verdict now sees because agent-hook emits this turn.stop itself
+                // the verdict now sees because agent-hook emits this turn.completed itself
                 // (the previous path passed those via the no-history fail-open).
                 status_box_present: scanStatusBoxPresent(p?.transcript_path) || lastAssistantMessage.includes("┌─ agent-"),
                 // Shadow measurement for the rule-2/3 detector: the loose scan above
@@ -291,12 +311,12 @@ function buildEventData(eventType, ctx) {
                 // 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
                 // transcript scan itself stops once the name has been sighted.
-                ...sessionNamePresence(ctx.coordRoot, ctx.instanceId, lastAssistantMessage, (name) => scanAssistantTextIncludes(p?.transcript_path, name)),
+                ...sessionNamePresence(ctx.coordRoot, ctx.instanceId, (name) => scanSessionNameDisplayedImmediately(p?.transcript_path, name, assistantTextStartsWithSessionNameBlock)),
                 ...(fileLinkTelemetry ?? {}),
                 stop_hook_active: p?.stop_hook_active,
             };
         }
-        case "subagent.start": {
+        case "agent.started": {
             const subagentCallId = p?.raw.subagent_id ?? p?.raw.agent_id;
             // Subagents inherit parent's name via the resolve-name session_id path
             // (agent-coord/state/names.ts → kind=transient). Use the call ID as the
@@ -314,12 +334,12 @@ function buildEventData(eventType, ctx) {
                 parent_session_id: p?.parent_session_id,
             };
         }
-        case "subagent.stop": {
+        case "agent.completed": {
             const status = p?.exit_status;
             const normalized = status === "error" || status === "interrupted" ? status : "ok";
             return { exit_status: normalized, reason: p?.reason };
         }
-        case "tool.pre_use": {
+        case "tool.requested": {
             const toolName = p?.tool_name ?? "unknown";
             const command = extractBashCommand(toolName, p?.tool_input);
             const description = extractToolDescription(p?.tool_input);
@@ -334,36 +354,44 @@ function buildEventData(eventType, ctx) {
             return {
                 tool_name: toolName,
                 tool_input: clamped.value,
+                input_hash: toolInputHash(toolName, p?.tool_input ?? null),
+                target_hash: toolTargetHash(toolName, p?.tool_input ?? null),
                 intent,
                 intent_source: source,
                 tool_use_id: p?.tool_use_id,
                 ...(clamped.truncated ? { truncated: true } : {}),
             };
         }
-        case "tool.post_use": {
-            const toolName = p?.tool_name ?? "unknown";
-            const summary = summarizeOutput(p?.tool_response);
+        case "wait.started": {
+            const description = extractToolDescription(p?.tool_input);
+            const reason = description ? clampString(description, 500).value : undefined;
             return {
-                tool_name: toolName,
-                output_summary: summary.summary,
-                exit_status: "ok",
-                duration_ms: 0, // Phase 3 pairs pre/post via tool_use_id
-                tool_use_id: p?.tool_use_id,
-                ...(summary.truncated ? { truncated: true } : {}),
+                request_kind: "permission",
+                tool_name: p?.tool_name,
+                ...(reason ? { reason } : {}),
             };
         }
-        case "tool.post_use_failure": {
+        case "tool.completed": {
             const toolName = p?.tool_name ?? "unknown";
             const summary = summarizeOutput(p?.tool_response);
-            return {
-                tool_name: toolName,
-                error: summary.summary,
-                duration_ms: 0,
-                tool_use_id: p?.tool_use_id,
-                ...(summary.truncated ? { truncated: true } : {}),
-            };
-        }
-        case "context.compaction.started": {
+            return ctx.eventName === "post-tool-use-failure"
+                ? {
+                    tool_name: toolName,
+                    error: summary.summary,
+                    duration_ms: 0,
+                    tool_use_id: p?.tool_use_id,
+                    ...(summary.truncated ? { truncated: true } : {}),
+                }
+                : {
+                    tool_name: toolName,
+                    output_summary: summary.summary,
+                    exit_status: "ok",
+                    duration_ms: 0,
+                    tool_use_id: p?.tool_use_id,
+                    ...(summary.truncated ? { truncated: true } : {}),
+                };
+        }
+        case "context.compaction_started": {
             const metadata = objectRecord(p?.raw.compact_metadata);
             return {
                 trigger: stringField(p?.raw.trigger) ?? stringField(metadata?.trigger),
@@ -372,7 +400,7 @@ function buildEventData(eventType, ctx) {
                     numberField(metadata?.pre_compact_tokens),
             };
         }
-        case "context.compaction.completed": {
+        case "context.compaction_completed": {
             const metadata = objectRecord(p?.raw.compact_metadata);
             return {
                 trigger: stringField(p?.raw.trigger) ?? stringField(metadata?.trigger),
@@ -386,6 +414,15 @@ function buildEventData(eventType, ctx) {
         }
     }
 }
+function safeInstructionBundle(coordRoot, cwd, adapter) {
+    try {
+        return buildInstructionBundle({ coordRoot, cwd, adapter });
+    }
+    catch (err) {
+        logError(coordRoot, err, { phase: "instruction-bundle-identity" });
+        return null;
+    }
+}
 function objectRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -398,9 +435,36 @@ function numberField(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
 async function main() {
+    const hookStartedAt = performance.now();
+    const hookClock = captureSpanClockV3();
     const { eventName, extra } = parseArgv(process.argv.slice(2));
     const adapter = detectAdapter(process.argv.slice(2));
     const raw = await readStdin();
+    // 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`
+    // dispatch must not record (twin generation) or play Claude-Code-only
+    // sounds, so it bails here, before every effect. Cursor's own
+    // `--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());
+            if (coordRoot) {
+                appendDebug(coordRoot, {
+                    ts: new Date().toISOString(),
+                    event_name: eventName,
+                    adapter,
+                    extra_argv: extra,
+                    payload_bytes: raw.length,
+                    cwd: process.cwd(),
+                    pid: process.pid,
+                    ppid: process.ppid,
+                    skipped: "cursor-payload-claude-adapter",
+                });
+            }
+        }
+        return 0;
+    }
     // Kill-switch-INDEPENDENT effects: notification sounds fire BEFORE the
     // HARNERY_AGENT_COORD_OFF gate so audible feedback survives incident-triage
     // bypass: sound playback happens before the kill-switch bailout.
@@ -431,6 +495,7 @@ async function main() {
     const coordRoot = findCoordRoot(process.cwd());
     if (!coordRoot)
         return 0;
+    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
     // rotation policy.
@@ -454,7 +519,10 @@ async function main() {
         return 0;
     }
     const payload = parsePayload(raw, adapter);
-    const owner = resolveOwner({ payload: payload?.raw ?? null, coordRoot });
+    const owner = resolveOwner({
+        payload: payload?.raw ?? null,
+        coordRoot,
+    });
     if (!owner) {
         appendDebug(coordRoot, {
             ...debugBase,
@@ -470,23 +538,97 @@ async function main() {
         raw,
         adapter,
         instanceId: owner.instance_id,
+        eventName,
     });
-    const envelope = emit(coordRoot, {
-        event_type: norm.event_type,
-        instance_id: owner.instance_id,
-        session_id: sessionId,
-        parent_session_id: payload?.parent_session_id,
-        turn_id: payload?.turn_id,
-        parent_turn_id: payload?.parent_turn_id,
+    const turnRitual = norm.event_type === "turn.completed"
+        ? {
+            status_box_present: data.status_box_present === true,
+            status_box_present_strict: data.status_box_present_strict === true,
+            session_name_required: typeof data.session_name_present_for === "string",
+            session_name_present: data.session_name_present === true,
+        }
+        : undefined;
+    const stopRemediation = norm.event_type === "turn.started" &&
+        typeof data.prompt_text === "string" &&
+        data.prompt_text.includes(STOP_REMEDIATION_MARKER);
+    if (ledgerRoute.state === "blocked") {
+        appendDebug(coordRoot, {
+            ...debugBase,
+            skipped: "v3-control-blocked",
+            reason: ledgerRoute.reason,
+            event_type: norm.event_type,
+            owner_source: owner.source,
+        });
+        return 0;
+    }
+    let capturedImages = [];
+    if (norm.event_type === "tool.requested" ||
+        (norm.event_type === "tool.completed" && eventName === "post-tool-use")) {
+        try {
+            capturedImages = captureImages(coordRoot, norm.event_type, payload);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "image-capture" });
+        }
+    }
+    const v3Result = recordLiveHookSignalV3({
+        coordRoot,
+        route: ledgerRoute,
+        eventName,
+        payload,
         adapter,
-        data,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        instanceId: owner.instance_id,
+        ...(coordEnv("WORKFLOW_CHILD") === "1" && coordEnv("WORKFLOW_RUN_ID")
+            ? {
+                run_id: stableScopeId("run", coordEnv("WORKFLOW_RUN_ID")),
+                workflow_id: stableScopeId("wf", coordEnv("WORKFLOW_RUN_ID")),
+                ...(coordEnv("WORKFLOW_AGENT_ID")
+                    ? { workflow_agent_id: coordEnv("WORKFLOW_AGENT_ID") }
+                    : {}),
+            }
+            : {}),
+        ...(adapter === "codex" && isWslUncPath(payload?.cwd) ? { bridge: "codex-wsl" } : {}),
+        hook_name: eventName,
+        hook_duration_ms: Math.max(0, Math.floor(performance.now() - hookStartedAt)),
+        monotonic_ns: hookClock.monotonic_ns,
+        ...(stopRemediation ? { stop_remediation: true } : {}),
+        ...(turnRitual ? { turn_ritual: turnRitual } : {}),
+        ...(coordEnv("EXPERIMENT_DEFER_V3_DRAIN") === "1" ? { defer_drain: true } : {}),
     });
+    const v3EventId = v3Result && "event" in v3Result
+        ? v3Result.event.event_id
+        : v3Result && "event_id" in v3Result
+            ? v3Result.event_id
+            : undefined;
+    if (v3Result?.state === "recorded" && capturedImages.length > 0) {
+        try {
+            recordImageArtifactsV3(coordRoot, v3Result.event, capturedImages);
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "image-artifact-observation" });
+        }
+    }
+    if (norm.event_type === "tool.requested" &&
+        v3Result &&
+        v3Result.state === "recorded" &&
+        "generation_id" in v3Result.event.scope) {
+        const intent = typeof data.intent === "string" ? data.intent : undefined;
+        if (intent && intent !== "(no intent)") {
+            tryWriteLiveDisplayV3(coordRoot, {
+                generation_id: v3Result.event.scope.generation_id,
+                event_id: v3Result.event.event_id,
+                ...(typeof data.tool_name === "string" ? { executable: data.tool_name } : {}),
+                intent_display: intent,
+            });
+        }
+    }
     appendDebug(coordRoot, {
         ...debugBase,
         event_type: norm.event_type,
         owner_source: owner.source,
-        event_id: envelope.event_id,
+        ...(v3EventId ? { event_v3_id: v3EventId } : {}),
+        ...(v3Result ? { event_v3_state: v3Result.state } : {}),
+        ...(v3Result && "reason" in v3Result ? { event_v3_reason: v3Result.reason } : {}),
     });
     // Context telemetry is opportunistic and truthful: only persist a sample
     // when the adapter payload actually exposes usage/window data. Identical
@@ -502,22 +644,7 @@ async function main() {
             });
             if (sample) {
                 const recorded = recordContextSample(coordRoot, owner.instance_id, sample);
-                if (recorded.changed) {
-                    emit(coordRoot, {
-                        event_type: "context.sampled",
-                        instance_id: owner.instance_id,
-                        session_id: sessionId,
-                        adapter,
-                        data: {
-                            model: sample.model,
-                            used_tokens: sample.used_tokens,
-                            window_tokens: sample.window_tokens,
-                            used_percent: sample.used_percent,
-                            telemetry_source: sample.source,
-                            confidence: sample.confidence,
-                        },
-                    });
-                }
+                void recorded;
             }
         }
         catch (err) {
@@ -527,7 +654,7 @@ async function main() {
     // A native pre-compaction signal is the safest available point to capture
     // external work state. The operation is idempotent until recovery, so a
     // adapter retry cannot create a storm of near-identical capsules.
-    if (norm.event_type === "context.compaction.started") {
+    if (norm.event_type === "context.compaction_started") {
         try {
             const checkpoint = checkpointContext(coordRoot, {
                 sessionId,
@@ -537,25 +664,13 @@ async function main() {
                 reason: "pre_compact",
                 model: payload?.model,
             });
-            emit(coordRoot, {
-                event_type: "context.checkpoint.created",
-                instance_id: owner.instance_id,
-                session_id: sessionId,
-                adapter,
-                data: {
-                    capsule_id: checkpoint.capsule.capsule_id,
-                    generation: checkpoint.capsule.generation,
-                    path: checkpoint.state.latest_capsule ?? "",
-                    reason: checkpoint.capsule.reason,
-                    reused: checkpoint.reused,
-                },
-            });
+            void checkpoint;
         }
         catch (err) {
             logError(coordRoot, err, { phase: "context-checkpoint" });
         }
     }
-    if (norm.event_type === "context.compaction.completed") {
+    if (norm.event_type === "context.compaction_completed") {
         try {
             markContextCompactionCompleted(coordRoot, {
                 sessionId,
@@ -571,31 +686,16 @@ async function main() {
     // systemMessage JSON (peer table + wiring check + council invites).
     // Adapter-agnostic since v0.5.0; replaces the previous bash UX layer
     // and the equivalent per-adapter bash session_start handlers.
-    if (norm.event_type === "session.start") {
+    if (norm.event_type === "session.started") {
         // Effect (claude-code): prune stale journal archives + sweep orphans.
         // The recovery-cue is merged into the
         // session-start additionalContext inside emitSessionStartSystemMessage.
         if (adapter === "claude-code")
             journalJanitor(coordRoot);
-        // Image-feed retention sweep (size + age cap on .harnery/images/). Adapter-
-        // agnostic, cheap (one readdir), fail-soft. Paired with journalJanitor as a
-        // session-start "tidy the coord layer" step.
-        try {
-            imageJanitor(coordRoot);
-        }
-        catch (err) {
-            logError(coordRoot, err, { phase: "session-start-image-janitor" });
-        }
+        imageJanitor(coordRoot);
         let recovery = null;
         if (payload?.source === "compact") {
             try {
-                emit(coordRoot, {
-                    event_type: "context.compaction.completed",
-                    instance_id: owner.instance_id,
-                    session_id: sessionId,
-                    adapter,
-                    data: { trigger: "auto" },
-                });
                 markContextCompactionCompleted(coordRoot, {
                     sessionId,
                     instanceId: owner.instance_id,
@@ -613,19 +713,16 @@ async function main() {
         try {
             const injected = await emitSessionStartSystemMessage(coordRoot, owner.instance_id, sessionId, data, adapter, recovery?.briefing ?? "");
             if (injected && recovery) {
-                completeRecoveryInjection(coordRoot, owner.instance_id, sessionId, adapter, recovery, "SessionStart");
+                completeRecoveryInjection(coordRoot, owner.instance_id, sessionId, recovery);
             }
         }
         catch (err) {
             logError(coordRoot, err, { phase: "session-start-systemMessage" });
         }
-        // Cross-machine presence (ADR 0016): announce this machine's sessions and
-        // pull peers'. Both are throttled + fail-silent; network runs detached.
-        // When a relay is configured, also make sure the live-socket daemon runs.
+        // Pull advisory cross-machine presence. V3 never publishes from the
+        // disposable heartbeat cache.
         try {
-            publishPresence(coordRoot);
             fetchPresence(coordRoot);
-            ensureRelayDaemon(coordRoot);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "session-start-presence" });
@@ -633,7 +730,7 @@ async function main() {
     }
     // Phase 8: SessionEnd cleanup: delete heartbeat + pid-map rows. Adapter-
     // agnostic since v0.5.0.
-    if (norm.event_type === "session.end") {
+    if (norm.event_type === "session.ended") {
         try {
             cleanupSessionEnd(coordRoot, owner.instance_id, data.reason ?? "unknown");
         }
@@ -646,19 +743,11 @@ async function main() {
             journalArchive(coordRoot, owner.instance_id);
             runSessionSyncExtension(coordRoot, true);
         }
-        // Presence: publish the post-cleanup state so peers see this session gone
-        // promptly rather than waiting out the remote-stale window.
-        try {
-            publishPresence(coordRoot);
-        }
-        catch (err) {
-            logError(coordRoot, err, { phase: "session-end-presence" });
-        }
     }
     // Phase 8: SubagentStart: sync-project to create the subagent heartbeat,
     // log the lifecycle event, and emit a context message announcing the
     // subagent (claude-code + cursor; codex doesn't fan out subagents today).
-    if (norm.event_type === "subagent.start") {
+    if (norm.event_type === "agent.started") {
         try {
             const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
             if (existsSync(agentCoordBin)) {
@@ -681,7 +770,7 @@ async function main() {
         }
     }
     // Phase 8: SubagentStop: delete subagent heartbeat + log.
-    if (norm.event_type === "subagent.stop") {
+    if (norm.event_type === "agent.completed") {
         try {
             cleanupSessionEnd(coordRoot, owner.instance_id, data.reason ?? "unknown");
             const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
@@ -700,7 +789,7 @@ async function main() {
     }
     // Phase 8: UserPromptSubmit: render dedup'd peer table + council pending
     // and emit the adapter-shaped systemMessage JSON. Adapter-agnostic since v0.5.0.
-    if (norm.event_type === "user_prompt.submit") {
+    if (norm.event_type === "turn.started") {
         // Effects (claude-code): reset per-turn sound rate-limit counters + run
         // presence detection on the prompt.
         if (adapter === "claude-code") {
@@ -735,74 +824,26 @@ async function main() {
         try {
             const injected = await emitUserPromptSubmitSystemMessage(coordRoot, owner.instance_id, sessionId, adapter, payload?.cwd, recovery?.briefing ?? "");
             if (injected && recovery) {
-                completeRecoveryInjection(coordRoot, owner.instance_id, sessionId, adapter, recovery, "UserPromptSubmit");
+                completeRecoveryInjection(coordRoot, owner.instance_id, sessionId, recovery);
             }
         }
         catch (err) {
             logError(coordRoot, err, { phase: "user-prompt-submit-systemMessage" });
         }
     }
-    // turn.stop: telemetry + turn-summary effects, then the stop verdict. The
+    // turn.completed: telemetry, then the stop verdict. The
     // verdict + codex-replay previously lived in the per-adapter shell adapters;
     // agent-hook owns them now. Runs on the normal "stop" event only;
     // "stop-failure" (API error) gets no gate, matching the previous
     // stop vs stop-failure split.
-    if (norm.event_type === "turn.stop" && eventName === "stop") {
-        // Codex: replay the JSONL transcript → canonical events so the verdict has
-        // the status_checked / task_set / status_box_present evidence (codex
-        // doesn't emit those live; this re-emits turn.stop after agent-hook's own,
-        // so the verdict reads the replay's box signal as the latest).
-        if (adapter === "codex" && payload?.transcript_path && existsSync(payload.transcript_path)) {
-            try {
-                replayCodexJsonl({
-                    coordRoot,
-                    jsonlPath: payload.transcript_path,
-                    sessionId,
-                    instanceId: owner.instance_id,
-                    lastAssistantMessage: payload.raw.last_assistant_message ?? "",
-                });
-            }
-            catch (err) {
-                logError(coordRoot, err, { phase: "codex-replay" });
-            }
-        }
-        // CC effects: rate-limited session-telemetry sync + turn-summary Haiku
-        // auto-summary.
+    if (norm.event_type === "turn.completed" && eventName === "stop") {
+        // Claude Code session telemetry sync remains an independent side effect.
         if (adapter === "claude-code") {
             runSessionSyncExtension(coordRoot, false);
-            runTurnSummary(coordRoot, owner.instance_id, sessionId, payload?.transcript_path);
-        }
-        // Master-state heartbeat projection. Drains events.ndjson since the last
-        // cursor → per-owner heartbeats. Was a SECOND binary (`agent-coord project`)
-        // pinned to Claude Code Stop only; folded in here so it (a) is one
-        // entry per event like everything else and (b) fires on EVERY adapter's stop,
-        // not just CC. Runs unconditionally before the verdict's possible exit-2 return
-        // (the events are real regardless of whether the agent gets nagged), and after
-        // codex-replay above so codex's replayed events are included in the drain.
-        // Not an emitter (consumes + writes heartbeats), so no emitter/consumer conflict.
-        try {
-            const result = consumeSince(coordRoot);
-            projectHeartbeats(coordRoot, result.events);
-            if (result.lastEventId)
-                writeCursor(coordRoot, result.lastEventId);
         }
-        catch (err) {
-            logError(coordRoot, err, { phase: "stop-projection" });
-        }
-        // Presence: publish AFTER the projection above so the blob carries this
-        // turn's fresh task/turn_summary/files. Change-batched + keepalive'd;
-        // the push itself runs detached. The relay daemon (when configured) is
-        // re-ensured here too — it self-exits on idle, and the next turn revives it.
-        try {
-            publishPresence(coordRoot);
-            ensureRelayDaemon(coordRoot);
-        }
-        catch (err) {
-            logError(coordRoot, err, { phase: "stop-presence" });
-        }
-        // Stop verdict (status-box + set-task gate). Direct in-process call: the
-        // rule lives in harnery. agent-hook already emitted this turn.stop (with
-        // status_box_present) above, so the evidence is in the stream.
+        // 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.
         const verdict = evaluateStopHook(coordRoot, {
             rule: "stop-hook",
             instance_id: owner.instance_id,
@@ -812,13 +853,26 @@ async function main() {
             workflow_child: coordEnv("WORKFLOW_CHILD") === "1",
         });
         if (!verdict.allow) {
-            // Adapter-aware enforcement channel: Claude Code / Codex honor exit-2 +
-            // stderr as a turn block; Cursor ignores exit codes (fail-open) and
-            // re-prompts only via a `followup_message` it auto-submits. emitStopBlock
-            // writes the right shape and returns the exit code to use.
+            // Adapter-aware enforcement channel: Claude Code honors exit-2 + stderr
+            // as a turn block; Cursor ignores exit codes and re-prompts only via a
+            // `followup_message` it auto-submits. Codex returned observe-only above.
+            // emitStopBlock writes the right shape and returns the exit code to use.
             const { emitStopBlock } = await import("./adapter/output.js");
             return emitStopBlock(adapter, verdict, coordRoot);
         }
+        // An explicit end requested from inside this turn cannot be authoritative
+        // until the adapter has committed turn.completed above. Reconcile only
+        // when such a request exists; any later real work cancels it in the
+        // finalizer instead of being terminated underneath the agent.
+        try {
+            const { hasPendingExplicitSessionEndV3, reconcileSessionFinalizationV3 } = await import("../agents/session-finalizer-v3.js");
+            if (hasPendingExplicitSessionEndV3(coordRoot)) {
+                reconcileSessionFinalizationV3(coordRoot);
+            }
+        }
+        catch (err) {
+            logError(coordRoot, err, { phase: "stop-explicit-session-finalization" });
+        }
     }
     // Phase 7: PreToolUse: heartbeat + pid-map self-heal on every tool call.
     // Adapter-agnostic: both writes have the same shape regardless of who fired.
@@ -829,40 +883,32 @@ async function main() {
     // side-by-side in the previous pre-tool-use adapter. The Phase 4-6 refactor
     // preserved the heartbeat half but dropped the pid-map half; the pid-map
     // call was restored here afterward.
-    if (norm.event_type === "tool.pre_use") {
+    if (norm.event_type === "tool.requested") {
         try {
             // Recorded fork lineage, heal-path flavor. A forked CC conversation
-            // never fires its own session.start (SessionStart fires under the
+            // never fires its own session.started (SessionStart fires under the
             // PARENT's session id with source=resume, before the fork id is
             // minted; verified 2026-08-05), so the fork's new instance first
             // materializes right here. Gate detection on "no heartbeat yet" so the
             // transcript scan runs once per instance lifetime, not per tool call.
-            let forkedFrom;
-            if (adapter === "claude-code" &&
-                payload?.transcript_path &&
-                !existsSync(join(coordRoot, ".harnery", "active", `${owner.instance_id}.json`))) {
-                forkedFrom = detectForkParent(payload.transcript_path, owner.instance_id);
-            }
-            healHeartbeatViaCli(coordRoot, owner.instance_id, sessionId, adapter, forkedFrom);
             refreshPidmap(coordRoot, owner.instance_id, adapter, payload?.pid);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "pre-tool-use-heal" });
         }
-        // Image feed: a Read on an image file is the "agent viewed this" signal.
-        // Capture the bytes (content-addressed, dedup'd) + emit image.captured.
+        // The suggested name is a pending display latch. The set-task call itself
+        // 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.
         try {
-            captureImages(coordRoot, {
-                eventType: "tool.pre_use",
-                data,
-                payload,
-                instanceId: owner.instance_id,
-                sessionId,
-                adapter,
-            });
+            const displayAllowed = await enforcePendingSessionNameDisplay(coordRoot, owner.instance_id, adapter, payload);
+            if (!displayAllowed)
+                return 0;
         }
         catch (err) {
-            logError(coordRoot, err, { phase: "pre-tool-use-image-capture" });
+            logError(coordRoot, err, { phase: "pre-tool-use-session-name" });
         }
         // Windows-native Codex + WSL UNC only: block the one cross-shell shape
         // proven to corrupt argument boundaries. Normal WSL argv calls, literal
@@ -875,13 +921,6 @@ async function main() {
             toolInput: payload?.tool_input,
         });
         if (unsafeShellReason) {
-            emit(coordRoot, {
-                event_type: "decision.block",
-                instance_id: owner.instance_id,
-                session_id: sessionId,
-                adapter,
-                data: { rule: "unsafe_cross_shell", reason: unsafeShellReason },
-            });
             const { emitDeny } = await import("./adapter/output.js");
             emitDeny(adapter, unsafeShellReason);
             return 0;
@@ -894,77 +933,36 @@ async function main() {
         // apply_patch (codex) parses paths from the patch body and runs verdict
         // per-path; Edit/Write/NotebookEdit resolve a single target. Non-write tools
         // (incl. Agent) yield no targets and pass through with no deny.
+        let guardAllowed = true;
         try {
-            await runPreToolUseGuard(coordRoot, owner.instance_id, sessionId, data, adapter);
+            guardAllowed = await runPreToolUseGuard(coordRoot, owner.instance_id, sessionId, data, adapter);
         }
         catch (err) {
             logError(coordRoot, err, { phase: "pre-tool-use-guard" });
         }
-        // Shell-mutation warn (warn-only, never blocks). Was the cursor
-        // beforeShellExecution + codex preToolUse-Bash shell-mutation-claim-log in
-        // the per-adapter shell adapters. Cursor sends the command at payload.command;
-        // codex Bash at tool_input.command. Emits a decision.warn per candidate-mutated
-        // path so a peer sees the write in events.ndjson. (CC never did this,
-        // preserved; it emits with its own hooks-side emitter per the
-        // independent-emitter rule.)
-        const shellCmd = eventName === "before-shell-execution"
-            ? (payload?.raw.command ?? "")
-            : adapter === "codex" && data.tool_name === "Bash"
-                ? (payload?.raw.tool_input?.command ?? "")
-                : "";
-        if (shellCmd) {
-            try {
-                const paths = shellMutationPaths(shellCmd, coordRoot);
-                const truncated = shellCmd.length > 80 ? shellCmd.slice(0, 80) : shellCmd;
-                const platform = adapterPlatform(adapter);
-                for (const p of paths) {
-                    emit(coordRoot, {
-                        event_type: "decision.warn",
-                        instance_id: owner.instance_id,
-                        session_id: sessionId,
-                        adapter,
-                        data: {
-                            rule: "shell_mutation_candidate",
-                            reason: `path=${p} cmd=${truncated} platform=${platform}`,
-                        },
-                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    });
-                }
-            }
-            catch (err) {
-                logError(coordRoot, err, { phase: "shell-mutation-warn" });
-            }
-        }
+        if (!guardAllowed)
+            return 0;
     }
-    // Phase 7: PostToolUse: stamp last_tool + last_tool_target on heartbeat.
-    // Adapter-agnostic for the same reason as tool.pre_use above.
-    if (norm.event_type === "tool.post_use") {
+    if (norm.event_type === "tool.completed" && eventName === "post-tool-use") {
+        // Inject only at the successful tool boundary that actually minted a name:
+        // the first non-empty set-task or the transition to lifecycle done. The
+        // coordination row intentionally remains pending until transcript evidence
+        // catches up; reading that latch alone here would re-inject after every
+        // later tool and make the agent print the same block repeatedly.
         try {
-            stampToolActivity(coordRoot, owner.instance_id, data);
-        }
-        catch (err) {
-            logError(coordRoot, err, { phase: "post-tool-use-stamp" });
-        }
-        // Image feed: a Bash command that wrote an image (harn browse, harn image,
-        // --diff, …) is the "agent produced this" signal. Scan the command + its
-        // output for freshly-written image paths and capture them.
-        try {
-            captureImages(coordRoot, {
-                eventType: "tool.post_use",
-                data,
-                payload,
-                instanceId: owner.instance_id,
-                sessionId,
-                adapter,
-            });
+            const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
+            if (name && toolResponseMintedSessionName(payload?.tool_response, name)) {
+                const { emitContext } = await import("./adapter/output.js");
+                emitContext(adapter, "PostToolUse", sessionNameDisplayInstruction(name));
+            }
         }
         catch (err) {
-            logError(coordRoot, err, { phase: "post-tool-use-image-capture" });
+            logError(coordRoot, err, { phase: "post-tool-use-session-name" });
         }
     }
     // Phase 7: PostToolUseFailure: release claim on failed Edit (the file
     // never landed; the claim is stale). Adapter-agnostic.
-    if (norm.event_type === "tool.post_use_failure") {
+    if (norm.event_type === "tool.completed" && eventName === "post-tool-use-failure") {
         try {
             releaseClaimOnFailure(coordRoot, owner.instance_id, data, payload?.raw);
         }
@@ -974,11 +972,38 @@ async function main() {
     }
     return 0;
 }
+async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter, payload) {
+    const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, instanceId));
+    if (!name)
+        return true;
+    const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
+    if (isSessionNameRemediationCommand(command, resolveBinName(coordRoot)))
+        return true;
+    const inspection = payload?.agent_message !== undefined
+        ? {
+            state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
+                ? "present"
+                : "absent",
+        }
+        : inspectSessionNameDisplayImmediately(payload?.transcript_path, name, assistantTextStartsWithSessionNameBlock);
+    if (inspection.state === "present") {
+        stampSessionNameSeen(coordRoot, instanceId, name);
+        return true;
+    }
+    if (inspection.state === "unavailable") {
+        const { emitContext } = await import("./adapter/output.js");
+        emitContext(adapter, "PreToolUse", "Harnery could not verify the pending session-name display because the adapter transcript is unavailable or not flushed yet. This tool is allowed so the session cannot deadlock; display the requested block before later work. Verification remains pending.");
+        return true;
+    }
+    const { emitDeny } = await import("./adapter/output.js");
+    emitDeny(adapter, sessionNameDisplayInstruction(name));
+    return false;
+}
 async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapter) {
     const toolName = data.tool_name ?? "";
     const rawTargets = collectGuardTargets(toolName, data);
     if (rawTargets.length === 0)
-        return;
+        return true;
     let targets;
     if (agentsRequireGitFinalization(coordRoot)) {
         const decisions = rawTargets.map((path) => classifyWriteClaimFinalization(coordRoot, path));
@@ -986,7 +1011,7 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
         if (denied && !denied.allow) {
             const { emitDeny } = await import("./adapter/output.js");
             emitDeny(adapter, formatWriteClaimFinalizationDenial(denied, resolveBinName(coordRoot)));
-            return;
+            return false;
         }
         const allowed = decisions.filter((decision) => decision.allow);
         targets = allowed.map((decision) => ({
@@ -1001,14 +1026,15 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
             .map((path) => ({ path }));
     }
     if (targets.length === 0)
-        return;
+        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;
+        return true;
     }
     // For apply_patch (multi-file), collect siblings so the deny reason names
     // them. For single-file tools the array has one entry.
@@ -1048,26 +1074,10 @@ async function runPreToolUseGuard(coordRoot, instanceId, sessionId, data, adapte
             }
             const { emitDeny } = await import("./adapter/output.js");
             emitDeny(adapter, reason);
-            return;
-        }
-        // The verdict mutates the live heartbeat immediately, but that file is a
-        // projection and can be rebuilt at any later hook. Persist the acquisition
-        // in the canonical stream too. This matters most for Codex apply_patch:
-        // one tool call can claim several files, and tool.pre_use's clamped payload
-        // is not a durable ownership representation for those targets.
-        emit(coordRoot, {
-            event_type: "claim.acquire",
-            instance_id: instanceId,
-            session_id: sessionId,
-            adapter,
-            source: "agent-hooks",
-            data: {
-                path: target.path,
-                mode: "write",
-                ...(target.finalization ? { finalization: target.finalization } : {}),
-            },
-        });
+            return false;
+        }
     }
+    return true;
 }
 /** Canonicalize a path to monorepo-relative form. Absolute paths under
  * coordRoot get the prefix stripped; relative paths pass through (assumed
@@ -1125,28 +1135,10 @@ function parseApplyPatchPaths(data) {
     }
     return out;
 }
-function healHeartbeatViaCli(coordRoot, instanceId, sessionId, adapter, forkedFrom) {
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (!existsSync(agentCoordBin))
-        return;
-    // Pass the detected adapter so a pruned Cursor/Codex heartbeat is recreated
-    // with the correct platform; without it, healHeartbeat defaults to
-    // claude-code and the dashboard mislabels the agent. See
-    // heartbeat-writer.healHeartbeat. --forked-from carries detected fork
-    // lineage for an instance that never session.started (the CC fork flow).
-    const args = ["heal-heartbeat", instanceId, sessionId, `--adapter=${adapter}`];
-    if (forkedFrom)
-        args.push(`--forked-from=${forkedFrom}`);
-    spawnSync(agentCoordBin, args, {
-        encoding: "utf8",
-        timeout: 2000,
-        env: childEnv(coordRoot),
-    });
-}
 /**
  * Walk up the ppid chain on Linux/WSL looking for the adapter anchor PID,
  * the PID of the claude / cursor / codex binary. Finds the agent PID. Used by
- * `tool.pre_use`'s pid-map self-heal so a re-parented adapter binary (the
+ * `tool.requested` pid-map self-heal so a re-parented adapter binary (the
  * VS Code 2.1.x sibling-claude spawn case) gets its pid-map row rewritten on
  * the next tool call rather than going invisible until SessionStart fires
  * again, which it may never do.
@@ -1219,9 +1211,7 @@ function findAdapterAnchorPid(adapter) {
     return selectAnchorPid(chain, adapter);
 }
 /**
- * Pid-map self-heal for `tool.pre_use`. Symmetric counterpart to
- * `healHeartbeatViaCli`; the two were paired before the Phase 6 refactor split
- * them apart, then restored together afterward.
+ * Pid-map self-heal for `tool.requested`.
  *
  * The pid argument prefers the payload's `pid` (CC populates it on
  * SessionStart and may also send it on PreToolUse), then
@@ -1239,38 +1229,6 @@ function refreshPidmap(coordRoot, instanceId, adapter, payloadPid) {
         return;
     writePidmapViaAgentCoord(coordRoot, pid, instanceId, adapterPlatform(adapter));
 }
-function stampToolActivity(coordRoot, instanceId, data) {
-    const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-    if (!existsSync(agentCoordBin))
-        return;
-    const toolName = data.tool_name ?? "";
-    // Extract a 1-line target from the tool_input blob (file path / command head).
-    const toolInputRaw = data.tool_input;
-    let target = "";
-    if (typeof toolInputRaw === "string") {
-        try {
-            const parsed = JSON.parse(toolInputRaw);
-            target =
-                parsed.file_path ??
-                    parsed.path ??
-                    parsed.notebook_path ??
-                    parsed.command ??
-                    parsed.url ??
-                    parsed.pattern ??
-                    "";
-        }
-        catch {
-            /* skip */
-        }
-    }
-    if (target.length > 200)
-        target = target.slice(0, 200);
-    spawnSync(agentCoordBin, ["stamp-tool-activity", instanceId, toolName, target], {
-        encoding: "utf8",
-        timeout: 2000,
-        env: childEnv(coordRoot),
-    });
-}
 function releaseClaimOnFailure(coordRoot, instanceId, data, rawPayload) {
     const toolName = data.tool_name ?? "";
     if (toolName !== "Edit" && toolName !== "Write" && toolName !== "NotebookEdit")
@@ -1310,6 +1268,12 @@ function releaseClaimOnFailure(coordRoot, instanceId, data, rawPayload) {
             ? filePath.slice(coordRoot.length + 1)
             : filePath;
     }
+    // In V3 the release is an authority event, not a heartbeat mutation. Avoid
+    // creating a disposable cache for a failure that never acquired a claim,
+    // but release the exact path when the validated projection says it is held.
+    const row = readLiveCoordinationRow(coordRoot, instanceId);
+    if (!row?.files_touched?.includes(canonical))
+        return;
     const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
     if (!existsSync(agentCoordBin))
         return;
@@ -1320,16 +1284,6 @@ function releaseClaimOnFailure(coordRoot, instanceId, data, rawPayload) {
     });
 }
 function cleanupSessionEnd(coordRoot, instanceId, reason) {
-    // Remove heartbeat from the canonical .harnery/active/ dir.
-    const path = join(coordRoot, ".harnery", "active", `${instanceId}.json`);
-    try {
-        if (existsSync(path)) {
-            require("node:fs").unlinkSync(path);
-        }
-    }
-    catch {
-        /* swallow */
-    }
     // Sweep pid-map entries pointing to this instance
     const pidmapDir = join(coordRoot, ".harnery", "pid-map");
     if (existsSync(pidmapDir)) {
@@ -1363,32 +1317,22 @@ async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionI
     const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
     let additionalContext = "";
     if (existsSync(agentCoordBin)) {
-        // Look up the agent's name from its heartbeat (for council pending rendering).
-        let agentName = "";
-        try {
-            const fs = require("node:fs");
-            const hbPath = join(coordRoot, ".harnery", "active", `${instanceId}.json`);
-            if (fs.existsSync(hbPath)) {
-                const hb = JSON.parse(fs.readFileSync(hbPath, "utf8"));
-                agentName = hb.name ?? "";
-            }
-        }
-        catch {
-            /* fall through with empty name; peer table still renders */
-        }
         const args = ["prompt-context", "--instance", instanceId, "--session", sessionId];
-        if (agentName)
-            args.push("--name", agentName);
         // 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();
@@ -1410,7 +1354,7 @@ async function emitUserPromptSubmitSystemMessage(coordRoot, instanceId, sessionI
 }
 function emitSubagentStartContext(coordRoot, instanceId, sessionId, data, adapter) {
     // Look up the subagent's assigned name (just-written by agent-coord assignName
-    // in session.start data) + the parent's short id for the "you are a subagent
+    // in session.started data) + the parent's short id for the "you are a subagent
     // of X" framing.
     const subagentName = data.name ?? "";
     if (!subagentName)
@@ -1442,13 +1386,19 @@ function adapterPlatform(adapter) {
 }
 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 });
-        // Stale-sweep dead peers before rendering peer table.
-        spawnSync(agentCoordBin, ["stale-sweep"], { 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";
@@ -1459,34 +1409,39 @@ async function emitSessionStartSystemMessage(coordRoot, instanceId, sessionId, e
             "--instance",
             instanceId,
         ], { encoding: "utf8", timeout: 2000 });
-        // Render the systemMessage via agent-coord.
-        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");
+        // 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();
         }
-        const result = spawnSync(agentCoordBin, args, { encoding: "utf8", timeout: 3000 });
-        if (result.status === 0 && result.stdout)
-            additionalContext = result.stdout.trim();
     }
     // Effect (claude-code): merge the journal recovery cue into the session-start
     // context. Was a standalone additionalContext emission from the previous
     // journal-on-start adapter; now that agent-hook is the single SessionStart
     // entry, it folds in here.
-    if (adapter === "claude-code") {
+    if (adapter === "claude-code" && !workflowChild) {
         const cue = journalRecoveryCue(coordRoot);
         if (cue)
             additionalContext = [additionalContext, cue].filter(Boolean).join("\n\n");
     }
-    if (recoveryBriefing) {
+    if (recoveryBriefing && !workflowChild) {
         additionalContext = [additionalContext, recoveryBriefing].filter(Boolean).join("\n\n");
     }
-    if (adapter === "codex" && isWslUncPath(emittedData.cwd)) {
+    if (adapter === "codex" && !workflowChild && isWslUncPath(emittedData.cwd)) {
         const fileLinkContext = renderCodexWslFileLinkContext(coordRoot, emittedData.cwd);
         if (fileLinkContext) {
             additionalContext = [additionalContext, fileLinkContext].filter(Boolean).join("\n\n");
@@ -1507,19 +1462,9 @@ async function emitSessionStartSystemMessage(coordRoot, instanceId, sessionId, e
     emitContext(adapter, "SessionStart", additionalContext);
     return true;
 }
-function completeRecoveryInjection(coordRoot, instanceId, sessionId, adapter, recovery, injectionEvent) {
+function completeRecoveryInjection(coordRoot, instanceId, sessionId, recovery) {
     completeContextRecovery(coordRoot, { sessionId, instanceId });
-    emit(coordRoot, {
-        event_type: "context.recovery.injected",
-        instance_id: instanceId,
-        session_id: sessionId,
-        adapter,
-        data: {
-            capsule_id: recovery.capsule.capsule_id,
-            generation: recovery.capsule.generation,
-            injection_event: injectionEvent,
-        },
-    });
+    void recovery;
 }
 main()
     .then((code) => process.exit(code))