harnery 0.37.0 → 0.38.0

package/dist/core/events/v3/producers/recorder.js

@@ -329,7 +329,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             const durability = writeEventV3(input.coordRoot, pendingEvent, input.writerOptions);
             applyCommittedEvent(state, pendingEvent);
             state.pending = undefined;
-            publishProducerState(path, state);
+            publishProducerState(input.coordRoot, path, state);
             if (pendingSource && incomingSource === pendingSource) {
                 recovered = { state: "recorded", event: pendingEvent, durability, recovered: true };
             }
@@ -373,7 +373,16 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             state = newProducerState(input, sessionId, epochId, boundaryEventId, genesisId);
             const cursorPromptBootstrap = isCursorPromptBootstrap(input);
             const onboarding = buildMidFlightSessionStart(input, state, rootId, cursorPromptBootstrap);
-            commitEventLocked(input, state, path, onboarding);
+            // Onboarding commits eagerly even when the triggering hook defers its
+            // drain. The coordination view reads committed history only, so a
+            // spooled session.started leaves the session invisible to every
+            // authority command (set-task, status --end-turn, heal) until some other
+            // writer happens to drain the spool.
+            const onboardingInput = withEagerDrain(input);
+            commitEventLocked(onboardingInput, state, path, onboarding);
+            if (midFlightSignalImpliesOpenTurn(input.signal)) {
+                commitMidFlightTurnStart(onboardingInput, state, path, rootId);
+            }
             if (!cursorPromptBootstrap) {
                 writeProducerDiagnosticV3(input.coordRoot, "mid_flight_onboarding", {
                     adapter: input.adapter,
@@ -460,7 +469,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
                 span_id: state.current_turn_span?.span_id,
                 payload: input.payload,
             });
-            publishProducerState(path, state);
+            publishProducerState(input.coordRoot, path, state);
             return { state: "ignored" };
         }
         // Every event derived before the native signal has now been committed.
@@ -483,7 +492,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
                             ? "no_open_turn_span"
                             : "ritual_observation_missing",
                 });
-                publishProducerState(path, state);
+                publishProducerState(input.coordRoot, path, state);
                 return { state: "ignored" };
             }
             const observation = {
@@ -494,7 +503,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
                 status_box_present_strict: input.turn_ritual.status_box_present_strict,
             };
             state.cursor_response_ritual = observation;
-            publishProducerState(path, state);
+            publishProducerState(input.coordRoot, path, state);
             writeProducerDiagnosticV3(input.coordRoot, "cursor_response_ritual_observed", {
                 instance_id: state.instance_id,
                 generation_id: state.generation_id,
@@ -1259,16 +1268,107 @@ function commitRecoveredToolTurnStart(input, state, path, rootId, fingerprintCon
     assertEventV3(event);
     commitEventLocked(input, state, path, event);
 }
+/**
+ * Signals an adapter can only deliver while a turn is executing. A session
+ * onboarded mid-flight by one of these is provably inside a turn, so the
+ * generation opens with one instead of waiting for the next native prompt.
+ * The native prompt path opens its own turn, session boundaries carry no
+ * turn, and compaction can run between turns.
+ */
+function midFlightSignalImpliesOpenTurn(signal) {
+    switch (signal) {
+        case "session-start":
+        case "session-end":
+        case "user-prompt-submit":
+        case "pre-compact":
+        case "post-compact":
+            return false;
+        default:
+            return true;
+    }
+}
+/** Commit through the append path even when the hook asked to defer its drain. */
+function withEagerDrain(input) {
+    if (!input.writerOptions?.deferDrain)
+        return input;
+    return { ...input, writerOptions: { ...input.writerOptions, deferDrain: false } };
+}
+/**
+ * Open a derived turn for a session onboarded mid-flight (ADR 0078) by a
+ * signal that only an executing turn can deliver. Without it the fresh
+ * generation has no current turn: command telemetry refuses to join
+ * (`turn_not_started`), tool spans nest under the session span, and after an
+ * epoch rotation (ADR 0137) the live session cannot satisfy its end-of-turn
+ * gate until a human submits the next prompt. The payload's native turn id
+ * is kept when the adapter supplies one, so the turn already running keeps
+ * its identity across the boundary and later signals join it directly.
+ */
+function commitMidFlightTurnStart(input, state, path, rootId, recovery) {
+    const fingerprintContext = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
+    const clock = signalClock(input);
+    const span = openSpanStateV3({
+        span_id: spanIdV3(),
+        parent_span_id: state.session_span.span_id,
+        boot_id: state.boot_id,
+        clock,
+    });
+    state.current_turn_span = span;
+    const nativeTurnId = input.payload.turn_id;
+    state.current_native_turn_id = nativeTurnId;
+    const event = normalizeHookEventV3("user-prompt-submit", recoveryBoundaryPayload(input.payload), {
+        coordRoot: input.coordRoot,
+        adapter: input.adapter,
+        adapterVersion: input.adapterVersion,
+        harnessVersion: input.harnessVersion,
+        root_id: rootId,
+        run_id: input.run_id,
+        workflow_id: input.workflow_id,
+        workflow_agent_id: input.workflow_agent_id,
+        instance_id: state.instance_id,
+        generation_id: state.generation_id,
+        attestation_id: state.attestation_id,
+        producer_id: input.producer_id,
+        boot_id: state.boot_id,
+        sequence: state.next_sequence,
+        build_id: input.build_id,
+        platform: input.platform,
+        bridge: input.bridge,
+        capability_profile: state.capability_profile,
+        fingerprintContext,
+        turn_native_id: nativeTurnId ?? `mid-flight:${state.generation_id}:${state.turn_ordinal + 1}`,
+        span_id: span.span_id,
+        caused_by: state.last_event_id ? [state.last_event_id] : [],
+        observed_at: clock.observed_at,
+        monotonic_ns: orderedEventMonotonic(state, input.monotonic_ns),
+        clock_id: state.clock_id,
+    });
+    if (event?.event_type !== "turn.started") {
+        throw new Error("mid-flight turn start could not be normalized");
+    }
+    event.provenance = {
+        ...event.provenance,
+        source_event: recovery?.source_event ?? `${input.adapter}.recovery`,
+        attestation: "derived",
+        confidence: recovery?.confidence ?? (nativeTurnId ? "medium" : "low"),
+        attribution: {
+            method: recovery?.attribution_method ?? (nativeTurnId ? "native_payload" : "session_env"),
+            state: "verified",
+            subject_instance_id: state.instance_id,
+        },
+    };
+    assertEventV3(event);
+    commitEventLocked(input, state, path, event);
+}
 /** The single pending-publish/write/apply/publish cycle every locked event commit uses. */
 function commitEventLocked(input, state, path, event, sourceId) {
     markObservedClockRegressionV3(event, state.last_observed_at);
     assertEventV3(event);
     state.pending = { ...(sourceId ? { source_id: sourceId } : {}), event };
-    publishProducerState(path, state);
+    publishProducerState(input.coordRoot, path, state);
     const durability = writeEventV3(input.coordRoot, event, input.writerOptions);
     applyCommittedEvent(state, event);
     state.pending = undefined;
-    publishProducerState(path, state);
+    publishProducerState(input.coordRoot, path, state);
     return durability;
 }
 function commitTurnContextObservation(input, state, path, rootId, fingerprintContext, target, measurement, contextProvenance, observedAt) {
@@ -1287,7 +1387,7 @@ function commitContextObservation(input, state, path, rootId, fingerprintContext
     if (measurement.state === "observed" &&
         contextProvenance?.source_witness &&
         state.last_context_source_witness === contextProvenance.source_witness) {
-        publishProducerState(path, state);
+        publishProducerState(input.coordRoot, path, state);
         return;
     }
     if (measurement.state === "observed" && contextProvenance?.source_witness) {
@@ -1387,12 +1487,12 @@ function maybeCommitActiveRuntimeContextObservation(input, state, path, rootId,
         return;
     }
     if (input.adapter === "cursor" && state.cursor_mode === "cloud") {
-        publishProducerState(path, state);
+        publishProducerState(input.coordRoot, path, state);
         return;
     }
     const transcriptPath = runtimeTranscriptPath(input, state);
     if (!transcriptPath && input.adapter !== "cursor") {
-        publishProducerState(path, state);
+        publishProducerState(input.coordRoot, path, state);
         return;
     }
     const runtime = readRuntimeContextTelemetry({
@@ -1409,7 +1509,7 @@ function maybeCommitActiveRuntimeContextObservation(input, state, path, rootId,
     if (runtime.bytes_read > 0)
         recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
     if (runtime.state !== "observed") {
-        publishProducerState(path, state);
+        publishProducerState(input.coordRoot, path, state);
         return;
     }
     commitActiveContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent, runtimeContextObservation(runtime), {
@@ -1578,7 +1678,7 @@ function reconcilePendingRuntimeContexts(input, state, path, rootId, fingerprint
     if (state.pending_runtime_contexts?.length === 0) {
         state.pending_runtime_contexts = undefined;
     }
-    publishProducerState(path, state);
+    publishProducerState(input.coordRoot, path, state);
 }
 function reconcilePendingRuntimeContextsBeforeApprovedEnd(input, state, path, rootId, fingerprintContext) {
     if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length)
@@ -2234,7 +2334,7 @@ export function recordApprovedSessionEndV3(input) {
             const durability = writeEventV3(input.coordRoot, pending, input.writerOptions);
             applyCommittedEvent(state, pending);
             state.pending = undefined;
-            publishProducerState(record.path, state);
+            publishProducerState(input.coordRoot, record.path, state);
             recovered = true;
             if (pending.event_type === "session.ended") {
                 return { state: "recorded", event: pending, durability, recovered };
@@ -2317,11 +2417,11 @@ export function recordApprovedSessionEndV3(input) {
         markObservedClockRegressionV3(event, state.last_observed_at);
         assertEventV3(event);
         state.pending = { event };
-        publishProducerState(record.path, state);
+        publishProducerState(input.coordRoot, record.path, state);
         const durability = writeEventV3(input.coordRoot, event, input.writerOptions);
         applyCommittedEvent(state, event);
         state.pending = undefined;
-        publishProducerState(record.path, state);
+        publishProducerState(input.coordRoot, record.path, state);
         return { state: "recorded", event, durability, recovered };
     }
     finally {
@@ -2383,7 +2483,7 @@ export function salvageOpenSpansV3(input) {
             writeEventV3(input.coordRoot, pendingEvent, input.writerOptions);
             applyCommittedEvent(state, pendingEvent);
             state.pending = undefined;
-            publishProducerState(record.path, state);
+            publishProducerState(input.coordRoot, record.path, state);
         }
         const allowed = new Set(input.allowed_span_ids);
         const fingerprintContext = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
@@ -2445,6 +2545,126 @@ export function listHookProducerStateRecordsV3(coordRoot, options = {}) {
     return records.sort((left, right) => left.state.generation_id.localeCompare(right.state.generation_id) ||
         left.path.localeCompare(right.path));
 }
+/**
+ * Re-anchor every live archived hook producer into a newly activated epoch.
+ *
+ * The archive rename is the rotation's atomic snapshot: it includes every
+ * state published before the boundary without copying any old boot sequence
+ * or causal link into the successor. Each live session gets a fresh
+ * generation and attestation. Only a turn that was open at the boundary is
+ * reopened, which makes command telemetry joinable before another adapter
+ * hook fires while preserving the between-turn state for idle sessions.
+ */
+export function reanchorArchivedHookProducersV3(input) {
+    const control = readEventV3ControlState(input.coordRoot);
+    if (control.state !== input.mode) {
+        throw new Error(`event_v3_rotation_reanchor_gate_closed:${control.state}`);
+    }
+    const rootId = control.genesis.event.scope.root_id;
+    const epochId = control.genesis.profile.privacy_key_epoch;
+    const genesisId = control.genesis.event.payload.genesis_id;
+    const boundaryEventId = control.state === "candidate"
+        ? control.genesis.event.event_id
+        : control.activation.event.event_id;
+    const observedAt = input.observed_at ?? new Date().toISOString();
+    let sessions = 0;
+    let turns = 0;
+    for (const archived of listArchivedHookProducerStatesV3(input.archivedEpoch)) {
+        const previous = archived.state;
+        if (previous.terminal || !previous.started_event_id)
+            continue;
+        const path = producerStatePath(input.coordRoot, previous.adapter, archived.sessionHash);
+        const lease = acquireStateLeaseWithRetry(input.coordRoot, path, 40);
+        if (!lease) {
+            throw new Error(`event_v3_rotation_reanchor_busy:${previous.instance_id}`);
+        }
+        try {
+            if (existsSync(path)) {
+                const current = readProducerState(path);
+                if (current.epoch_genesis_id === genesisId)
+                    continue;
+            }
+            const sourceEvent = `${previous.adapter}.epoch-rotation-reanchor`;
+            const rotationInput = {
+                coordRoot: input.coordRoot,
+                mode: input.mode,
+                signal: "session-start",
+                payload: {
+                    raw: {},
+                    ...(previous.current_native_turn_id ? { turn_id: previous.current_native_turn_id } : {}),
+                    ...(previous.adapter === "cursor" && previous.cursor_mode
+                        ? { cursor_mode: previous.cursor_mode }
+                        : {}),
+                },
+                adapter: previous.adapter,
+                instance_id: previous.instance_id,
+                producer_id: "prd_agent-hook",
+                build_id: input.build_id,
+                platform: input.platform,
+                observed_at: observedAt,
+                writerOptions: { expectedGenesisId: genesisId },
+            };
+            const state = newProducerState(rotationInput, previous.session_id, epochId, boundaryEventId, genesisId);
+            const sessionStart = buildMidFlightSessionStart(rotationInput, state, rootId);
+            if (sessionStart.event_type !== "session.started") {
+                throw new Error("rotation re-anchor session start could not be normalized");
+            }
+            sessionStart.provenance = {
+                ...sessionStart.provenance,
+                source_event: sourceEvent,
+                attestation: "derived",
+                confidence: "high",
+                attribution: {
+                    method: "session_env",
+                    state: "verified",
+                    subject_instance_id: state.instance_id,
+                },
+            };
+            sessionStart.payload.resume = {
+                state: "unknown",
+                reason: "epoch_rotation_reanchor",
+            };
+            assertEventV3(sessionStart);
+            commitEventLocked(rotationInput, state, path, sessionStart);
+            sessions += 1;
+            if (previous.current_turn_id && previous.current_turn_span) {
+                commitMidFlightTurnStart(rotationInput, state, path, rootId, {
+                    source_event: sourceEvent,
+                    confidence: "high",
+                    attribution_method: "session_env",
+                });
+                turns += 1;
+            }
+        }
+        finally {
+            lease.release();
+        }
+    }
+    return { sessions, turns };
+}
+function listArchivedHookProducerStatesV3(archivedEpoch) {
+    const producerRoot = join(resolve(archivedEpoch), "private-producers");
+    if (!existsSync(producerRoot))
+        return [];
+    const records = [];
+    for (const adapter of ["claude-code", "codex", "cursor"]) {
+        const directory = join(producerRoot, adapter);
+        if (!existsSync(directory))
+            continue;
+        const metadata = lstatSync(directory);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+            throw new Error("V3 archived producer state directory is unsafe");
+        }
+        for (const name of readdirSync(directory).filter((entry) => /^hid_[a-f0-9]{64}\.json$/.test(entry))) {
+            records.push({
+                sessionHash: name.slice(0, -".json".length),
+                state: readProducerState(join(directory, name)),
+            });
+        }
+    }
+    return records.sort((left, right) => left.state.generation_id.localeCompare(right.state.generation_id) ||
+        left.sessionHash.localeCompare(right.sessionHash));
+}
 function hookSignalCapability(signal) {
     switch (signal) {
         case "session-start":
@@ -2895,7 +3115,11 @@ function acquireStateLease(coordRoot, statePath) {
     mkdirSync(directory, { recursive: true, mode: 0o700 });
     chmodSync(producerRoot, 0o700);
     chmodSync(directory, 0o700);
-    return acquireNoClobberLease({
+    const acquiredControl = readEventV3ControlState(coordRoot);
+    const acquiredGenesis = acquiredControl.state === "candidate" || acquiredControl.state === "active"
+        ? acquiredControl.genesis.event.payload.genesis_id
+        : undefined;
+    const lease = acquireNoClobberLease({
         path: `${statePath}.lease`,
         scope: "event-v3-hook-producer",
         authoritySha256: createHash("sha256")
@@ -2906,8 +3130,30 @@ function acquireStateLease(coordRoot, statePath) {
         staleAfterMs: 5_000,
         validateStaleOwner: (owner) => owner.host === hostname() && !pidIsAlive(owner.pid),
     });
+    return {
+        ...lease,
+        release() {
+            try {
+                lease.release();
+            }
+            catch (error) {
+                const current = readEventV3ControlState(coordRoot);
+                const epochReplaced = acquiredGenesis !== undefined &&
+                    (current.state === "candidate" || current.state === "active") &&
+                    current.genesis.event.payload.genesis_id !== acquiredGenesis;
+                if (error.code === "ENOENT" && epochReplaced)
+                    return;
+                throw error;
+            }
+        },
+    };
 }
-function publishProducerState(path, state) {
+function publishProducerState(coordRoot, path, state) {
+    const control = readEventV3ControlState(coordRoot);
+    if ((control.state === "candidate" || control.state === "active") &&
+        state.epoch_genesis_id !== control.genesis.event.payload.genesis_id) {
+        return;
+    }
     const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
     let fd;
     try {

package/dist/core/hooks/cli.js

@@ -25,8 +25,8 @@ import { resolveCoordRoot } from "../agents/coord-client.js";
 import { classifyWriteClaimFinalization, formatWriteClaimFinalizationDenial, } from "../agents/finalization.js";
 import { recordLiveClaimChangeV3, restoreLiveCoordinationStateAfterEpochV3, } from "../agents/live-authority-v3.js";
 import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-hook.js";
-import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, sessionNameDisplayInstruction, sessionNameDisplayPending, sessionNameDisplayRecoveryInstruction, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
-import { readHeartbeat, stampSessionNameSeen } from "../agents/state/heartbeat-writer.js";
+import { assistantTextStartsWithSessionNameBlock, isSessionNameRemediationCommand, matchSessionNameDisplay, sessionNameDisplayAcceptedNames, sessionNameDisplayInstruction, sessionNameDisplayPending, sessionNameDisplayRecoveryInstruction, toolResponseMintedSessionName, } from "../agents/session-name-display.js";
+import { readHeartbeat, setAssignedNameCache, stampSessionNameRequested, stampSessionNameSeen, } from "../agents/state/heartbeat-writer.js";
 import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.js";
 import { ensureLiveCoordinationHeartbeat } from "../agents/state/live-coordination-writer.js";
 import { assignName } from "../agents/state/names.js";
@@ -159,6 +159,29 @@ function assignNameInProcess(coordRoot, instanceId, kind, forkedFrom) {
         return null;
     }
 }
+/** Mid-flight sessions can emit tools before SessionStart assigns a pool name.
+ * Stamp the disposable cache so Codec does not render the 8-character id. */
+function ensureSessionDisplayName(coordRoot, instanceId, sessionId, adapter) {
+    if (coordEnv("WORKFLOW_CHILD") === "1")
+        return;
+    const row = readLiveCoordinationRow(coordRoot, instanceId) ?? readHeartbeat(coordRoot, instanceId);
+    if (row?.kind === "subagent" || row?.kind === "transient" || row?.workflow_run_id)
+        return;
+    if (row?.name?.trim())
+        return;
+    const assigned = assignNameInProcess(coordRoot, instanceId, "session");
+    if (!assigned?.name)
+        return;
+    if (!readHeartbeat(coordRoot, instanceId)) {
+        try {
+            ensureLiveCoordinationHeartbeat(coordRoot, instanceId, sessionId, adapter);
+        }
+        catch {
+            /* cache materialization is best-effort; history still holds the name */
+        }
+    }
+    setAssignedNameCache(coordRoot, instanceId, assigned.name, "session");
+}
 /**
  * Direct (in-process) pidmap write, avoiding the spawn overhead of going via
  * the agent-coord CLI for every session.started signal. Pid-map rows
@@ -270,11 +293,11 @@ function buildEventData(eventType, ctx) {
                 clean_exit: p?.clean_exit ?? true,
             };
         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) {
+            // Mid-flight onboarding (any adapter) can observe a turn before
+            // SessionStart. Mint durable display identity here so a later
+            // SessionStart remains idempotent and Codec is not stuck on the
+            // 8-character native id.
+            if (!readLiveCoordinationRow(ctx.coordRoot, ctx.instanceId)?.name) {
                 assignNameInProcess(ctx.coordRoot, ctx.instanceId, "session");
             }
             const prompt = p?.prompt ?? "";
@@ -559,14 +582,34 @@ async function main() {
             appendDebug(coordRoot, { ...debugBase, skipped: "no-owner-resolved" });
             return 0;
         }
-        const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
+        const row = readLiveCoordinationRow(coordRoot, owner.instance_id);
+        const name = sessionNameDisplayPending(row);
         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" });
+        const sighting = matchSessionNameDisplay(row, text);
+        if (sighting) {
+            stampSessionNameSeen(coordRoot, owner.instance_id, sighting.pending);
+            appendDebug(coordRoot, {
+                ...debugBase,
+                effect: "session-name-display-stamped",
+                session_name_pending: sighting.pending,
+                ...(sighting.displayed === sighting.pending
+                    ? {}
+                    : { session_name_displayed: sighting.displayed, session_name_drift: true }),
+            });
+        }
+        else if (!name) {
+            // Nothing was owed. Distinct from a miss: conflating the two is what made
+            // a latched Cursor session undiagnosable from this log.
+            appendDebug(coordRoot, { ...debugBase, skipped: "no-pending-session-name" });
         }
         else {
-            appendDebug(coordRoot, { ...debugBase, skipped: "no-session-name-sighting" });
+            appendDebug(coordRoot, {
+                ...debugBase,
+                skipped: "session-name-block-absent",
+                session_name_pending: name,
+                reply_bytes: text.length,
+                reply_leads_with_fence: /^\s*`{3,}/.test(text),
+            });
         }
         if (ledgerRoute.state === "blocked") {
             appendDebug(coordRoot, {
@@ -638,6 +681,14 @@ async function main() {
     hookHealthState.owner_id = owner.instance_id;
     const sessionId = payload?.session_id ?? payload?.conversation_id ?? owner.instance_id;
     const priorCoordination = readHeartbeat(coordRoot, owner.instance_id);
+    if (norm.event_type !== "session.ended" &&
+        coordEnv("WORKFLOW_CHILD") !== "1" &&
+        priorCoordination?.kind !== "subagent" &&
+        priorCoordination?.kind !== "transient" &&
+        !priorCoordination?.workflow_run_id &&
+        !priorCoordination?.name?.trim()) {
+        assignNameInProcess(coordRoot, owner.instance_id, "session");
+    }
     const data = buildEventData(norm.event_type, {
         coordRoot,
         payload,
@@ -723,6 +774,14 @@ async function main() {
             logError(coordRoot, error, { phase: "epoch-coordination-restore" });
         }
     }
+    if (norm.event_type !== "session.ended") {
+        try {
+            ensureSessionDisplayName(coordRoot, owner.instance_id, sessionId, adapter);
+        }
+        catch (error) {
+            logError(coordRoot, error, { phase: "session-display-name" });
+        }
+    }
     const v3EventId = v3Result && "event" in v3Result
         ? v3Result.event.event_id
         : v3Result && "event_id" in v3Result
@@ -1177,6 +1236,11 @@ async function main() {
         try {
             const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
             if (name && toolResponseMintedSessionName(payload?.tool_response, name)) {
+                // Record the title before asking for it. The suggestion can still
+                // change afterwards (an assigned-name rewrite, a lifecycle re-mint, a
+                // rebuilt cache), and the agent must not be stranded for displaying
+                // exactly what it was handed.
+                stampSessionNameRequested(coordRoot, owner.instance_id, name);
                 const { emitContext } = await import("./adapter/output.js");
                 emitContext(adapter, "PostToolUse", sessionNameDisplayInstruction(name));
             }
@@ -1241,21 +1305,7 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
     const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
     if (isSessionNameRemediationCommand(command, resolveBinName(coordRoot)))
         return true;
-    const inspection = adapter === "cursor" && payload?.agent_message !== undefined
-        ? {
-            state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
-                ? "present"
-                : "unavailable",
-        }
-        : inspectSessionNameDisplayImmediately(
-        // Codex hook payloads omit transcript_path on every event, which
-        // left this inspection permanently unavailable and the latch never
-        // stamped. Discover the rollout by session id; the scan only runs
-        // while a name is pending, so the latch closes after one success.
-        payload?.transcript_path ??
-            (adapter === "codex"
-                ? discoverCodexSessionTranscript(payload?.session_id ?? instanceId)
-                : undefined), name, assistantTextStartsWithSessionNameBlock);
+    const inspection = inspectDisplayEvidence(instanceId, adapter, payload, coordination);
     if (inspection.state === "present") {
         stampSessionNameSeen(coordRoot, instanceId, name);
         return true;
@@ -1268,10 +1318,53 @@ async function enforcePendingSessionNameDisplay(coordRoot, instanceId, adapter,
         // readable transcript can still verify it.
         return true;
     }
+    // Record the refusal. Without this the gate was the one enforcement path
+    // that left no trace, so a session reporting "the gate keeps denying me"
+    // could not be confirmed or refuted from the hook log.
+    appendDebug(coordRoot, {
+        ts: new Date().toISOString(),
+        event_name: "pre-tool-use",
+        adapter,
+        effect: "session-name-display-denied",
+        session_name_pending: name,
+        tool_name: payload?.tool_name,
+    });
     const { emitDeny } = await import("./adapter/output.js");
     emitDeny(adapter, sessionNameDisplayRecoveryInstruction(name, resolveBinName(coordRoot)));
     return false;
 }
+/**
+ * Evidence for the pending display, over every title whose display counts.
+ *
+ * Cursor supplies the current narration directly; Claude Code and Codex are
+ * resolved from their JSONL transcripts. Absent is the only state that denies,
+ * so a title is refused only when a readable surface positively shows some
+ * other opening text for every accepted title.
+ */
+function inspectDisplayEvidence(instanceId, adapter, payload, coordination) {
+    if (adapter === "cursor" && payload?.agent_message !== undefined) {
+        return matchSessionNameDisplay(coordination, payload.agent_message)
+            ? { state: "present" }
+            : { state: "unavailable", reason: "transcript_not_ready" };
+    }
+    // Codex hook payloads omit transcript_path on every event, which left this
+    // inspection permanently unavailable and the latch never stamped. Discover
+    // the rollout by session id; the scan only runs while a name is pending, so
+    // the latch closes after one success.
+    const transcriptPath = payload?.transcript_path ??
+        (adapter === "codex"
+            ? discoverCodexSessionTranscript(payload?.session_id ?? instanceId)
+            : undefined);
+    let verdict = { state: "absent" };
+    for (const candidate of sessionNameDisplayAcceptedNames(coordination)) {
+        const inspection = inspectSessionNameDisplayImmediately(transcriptPath, candidate, assistantTextStartsWithSessionNameBlock);
+        if (inspection.state === "present")
+            return inspection;
+        if (inspection.state === "unavailable")
+            verdict = inspection;
+    }
+    return verdict;
+}
 function generationBoundHeartbeat(heartbeat, generationId) {
     return generationId && heartbeat?.v3_generation_id === generationId ? heartbeat : null;
 }

package/dist/core/hooks/resolve/transcript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/transcript.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,wBAAc,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAQhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,GACb,OAAO,CAiCT;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,oBAAoB,EAAE,MAAM,GAAG,SAAS,GACvC,OAAO,CAKT;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgB9F;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,OAAO,CAIT;AAED,MAAM,MAAM,4BAA4B,GACpC;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GACpB;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GACnB;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,CAAA;CAAE,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,4BAA4B,CA0B9B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAUrF;AAwDD;4CAC4C;AAC5C,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd;+EAC2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,qBAAqB,GAAG,SAAS,CA8BnC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAkDpB"}
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/transcript.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,wBAAc,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAQhF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,GACb,OAAO,CAiCT;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,oBAAoB,EAAE,MAAM,GAAG,SAAS,GACvC,OAAO,CAKT;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAgB9F;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,OAAO,CAIT;AAED,MAAM,MAAM,4BAA4B,GACpC;IAAE,KAAK,EAAE,SAAS,CAAA;CAAE,GACpB;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,GACnB;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,oBAAoB,GAAG,sBAAsB,CAAA;CAAE,CAAC;AAEpF;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,GAC/D,4BAA4B,CAiC9B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,CAUrF;AAwDD;4CAC4C;AAC5C,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd;+EAC2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,qBAAqB,GAAG,SAAS,CA8BnC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAkDpB"}

package/dist/core/hooks/resolve/transcript.js

@@ -154,9 +154,16 @@ export function inspectSessionNameDisplayImmediately(transcriptPath, name, start
             awaitingReply = false;
         }
     }
-    return sawMintResult && awaitingReply
-        ? { state: "unavailable", reason: "transcript_not_ready" }
-        : { state: "absent" };
+    // Some adapter transcripts persist assistant messages and tool requests but
+    // omit tool-result rows entirely. A readable file with no mint result cannot
+    // establish the ordered verification boundary, so it is unavailable evidence
+    // rather than proof that the agent displayed the title incorrectly. Only a
+    // transcript that contains the mint followed by a non-matching assistant
+    // reply can safely deny the next tool.
+    if (!sawMintResult || awaitingReply) {
+        return { state: "unavailable", reason: "transcript_not_ready" };
+    }
+    return { state: "absent" };
 }
 /**
  * Resolve a transcript path at the adapter boundary. Windows-native Codex can

package/dist/core/hooks/session-name-presence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-name-presence.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/session-name-presence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,MAAM,WAAW,mBAAmB;IAClC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAC3C,mBAAmB,CAcrB"}
+{"version":3,"file":"session-name-presence.d.ts","sourceRoot":"","sources":["../../../src/core/hooks/session-name-presence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAMH,MAAM,WAAW,mBAAmB;IAClC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAC3C,mBAAmB,CAkBrB"}