harnery 0.34.1 → 0.36.0

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

@@ -3,17 +3,19 @@ import { chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, open
 import { hostname } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { extractBashCommand } from "../../../hooks/adapter/parse.js";
+import { discoverCodexSessionTranscript, readRuntimeContextTelemetry, readRuntimeTuning, } from "../../../hooks/adapter/runtime-telemetry.js";
 import { fsyncParentDirectory } from "../../../workflow/durable-record.js";
 import { acquireNoClobberLease } from "../../../workflow/workspaces/leases.js";
 import { buildEventV3 } from "../builder.js";
-import { fingerprintV3, normalizeNativeIdV3 } from "../canonical.js";
+import { canonicalJsonV3, fingerprintV3, normalizeNativeIdV3 } from "../canonical.js";
 import { adapterCapabilityProfileDigestV3, adapterSignalSupportV3, cursorToolChannelSupportV3, } from "../capabilities.js";
 import { capabilityDriftPayloadsV3 } from "../capability-drift.js";
 import { markObservedClockRegressionV3 } from "../clock-order.js";
 import { readEventV3ControlState } from "../control.js";
 import { fingerprintContextV3 } from "../fingerprint-keys.js";
-import { attestationIdV3, clockIdV3, delegationIdV3, generationIdV3, spanIdV3 } from "../ids.js";
+import { attestationIdV3, clockIdV3, delegationIdV3, eventIdV3, generationIdV3, spanIdV3, } from "../ids.js";
 import { readLedgerV3 } from "../reader.js";
+import { effectiveRuntimeTelemetryCapabilitiesV3, } from "../runtime-telemetry-capabilities.js";
 import { closeSpanStateV3, openSpanStateV3, recoverSpanUpperBoundV3, } from "../span-state.js";
 import { extractTurnTelemetryV3, } from "../turn-telemetry.js";
 import { assertEventV3, validateEventV3 } from "../validate.js";
@@ -27,6 +29,14 @@ const CLOSED_SPAN_TURN_RETENTION = 2;
 const CLOSED_SPAN_MEMORY_CAP = 512;
 const CLOSED_TURN_MEMORY_CAP = 16;
 const SPAN_SOFT_WATERMARK = 128;
+const PENDING_RUNTIME_CONTEXT_CAP = 4;
+const RUNTIME_CONTEXT_RETRY_LIMIT = 2;
+/** Active turns pay for at most one bounded adapter telemetry read per interval. */
+const ACTIVE_RUNTIME_CONTEXT_PROBE_INTERVAL_MS = 15_000;
+/** Codex can flush the terminal row just after Stop; keep this grace bounded and off other hooks. */
+const STOP_RUNTIME_CONTEXT_RETRY_DELAYS_MS = [75, 175];
+/** Finalization is off the interactive hook path; briefly cover Codex's delayed transcript flush. */
+const APPROVED_END_RUNTIME_CONTEXT_RETRY_DELAYS_MS = [0, 250, 250];
 /**
  * Adapters whose turn-boundary recovery and mid-flight onboarding are enabled.
  * Kept in code, outside the digested capability profiles, so tuning recovery
@@ -88,7 +98,14 @@ function hookSignalGate(control, adapter, signal) {
     return undefined;
 }
 function sessionHashForSignal(input, context) {
-    const nativeSession = input.payload.session_id ?? input.payload.conversation_id ?? input.payload.agent_id;
+    const nativeChild = input.payload.subagent_id ?? input.payload.agent_id;
+    const childOwnsSignal = input.signal !== "sub-agent-start" &&
+        input.signal !== "sub-agent-stop" &&
+        nativeChild !== undefined &&
+        input.instance_id === asLiveInstanceId(nativeChild);
+    const nativeSession = childOwnsSignal
+        ? nativeChild
+        : (input.payload.session_id ?? input.payload.conversation_id ?? input.payload.agent_id);
     if (nativeSession !== undefined) {
         return normalizeNativeIdV3(context, `${input.adapter}.session`, nativeSession);
     }
@@ -130,6 +147,7 @@ function intakeRecord(input) {
             : {}),
         ...(input.stop_remediation !== undefined ? { stop_remediation: input.stop_remediation } : {}),
         ...(input.turn_ritual ? { turn_ritual: input.turn_ritual } : {}),
+        ...(input.delegated_child ? { delegated_child: input.delegated_child } : {}),
     };
 }
 function inputForIntakeRecord(coordRoot, record) {
@@ -152,6 +170,7 @@ function inputForIntakeRecord(coordRoot, record) {
         ...(record.hook_duration_ms !== undefined ? { hook_duration_ms: record.hook_duration_ms } : {}),
         ...(record.stop_remediation !== undefined ? { stop_remediation: record.stop_remediation } : {}),
         ...(record.turn_ritual ? { turn_ritual: record.turn_ritual } : {}),
+        ...(record.delegated_child ? { delegated_child: record.delegated_child } : {}),
     };
 }
 /**
@@ -268,8 +287,23 @@ function processHookSignalLocked(control, input, sessionHash, path) {
         : control.activation.event.event_id;
     const rootFingerprintContext = fingerprintContextV3(input.coordRoot, rootId, undefined, epochId);
     const sessionId = `sid_${sessionHash.slice(4)}`;
+    const genesisId = control.genesis.event.payload.genesis_id;
+    // Every write below carries the epoch fence: an event produced for this
+    // epoch is refused (or quarantined from the spool) once the epoch has been
+    // replaced, instead of poisoning the successor's authority.
+    input = {
+        ...input,
+        writerOptions: { ...input.writerOptions, expectedGenesisId: genesisId },
+    };
     try {
         let state = existsSync(path) ? readProducerState(path) : undefined;
+        if (state && state.epoch_genesis_id !== genesisId) {
+            // A producer state from a replaced epoch (or one that predates the
+            // field) is never adopted: its boot sequences and causal links only
+            // validate inside the epoch that recorded them. The session re-onboards
+            // below exactly as it does after an automatic epoch refresh.
+            state = undefined;
+        }
         if (state &&
             (state.adapter !== input.adapter ||
                 state.session_id !== sessionId ||
@@ -292,7 +326,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             const pendingSource = state.pending.source_id;
             const incomingSource = sourceIdForSignal(input, rootFingerprintContext);
             const pendingEvent = state.pending.event;
-            const durability = writeEventV3(input.coordRoot, pendingEvent);
+            const durability = writeEventV3(input.coordRoot, pendingEvent, input.writerOptions);
             applyCommittedEvent(state, pendingEvent);
             state.pending = undefined;
             publishProducerState(path, state);
@@ -306,10 +340,11 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             if (state && !state.terminal && state.started_event_id) {
                 return { state: "already_started", event_id: state.started_event_id };
             }
-            if (input.session_start_derivation && !state?.terminal) {
+            if ((input.session_start_derivation === "approved_lifecycle_reopen" && !state?.terminal) ||
+                (input.session_start_derivation === "validated_current_session_heal" && state?.terminal)) {
                 return { state: "missing_session_start" };
             }
-            state = newProducerState(input, sessionId, epochId, boundaryEventId);
+            state = newProducerState(input, sessionId, epochId, boundaryEventId, genesisId);
         }
         else if (!state || state.terminal) {
             // Mid-flight onboarding (ADR 0078): a live session with no producer
@@ -335,7 +370,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
                 });
                 return { state: "missing_session_start" };
             }
-            state = newProducerState(input, sessionId, epochId, boundaryEventId);
+            state = newProducerState(input, sessionId, epochId, boundaryEventId, genesisId);
             const cursorPromptBootstrap = isCursorPromptBootstrap(input);
             const onboarding = buildMidFlightSessionStart(input, state, rootId, cursorPromptBootstrap);
             commitEventLocked(input, state, path, onboarding);
@@ -345,6 +380,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
                     instance_id: input.instance_id,
                     signal: input.signal,
                     session_hash: sessionHash,
+                    ...(input.adapter === "codex" ? codexMidFlightDiagnosticContext(input.payload) : {}),
                 });
             }
         }
@@ -386,6 +422,9 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             (cursorPromptWithinOpenTurn ||
                 (nativeTid !== undefined && state.current_turn_id === nativeTid));
         recordTurnHarnessTiming(state, input, !duplicateOpenTurnStart);
+        reconcilePendingRuntimeContexts(input, state, path, rootId, fingerprintContext, {
+            finalAttempt: input.signal === "session-end",
+        });
         closeResolvedWaits(input, state, path, rootId, fingerprintContext, nativeTid);
         if (input.signal === "permission-request") {
             const waitId = waitIdForInput(input, fingerprintContext);
@@ -435,6 +474,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
                 boot_id: state.boot_id,
                 clock: eventClock,
             });
+            state.current_native_turn_id = input.payload.turn_id;
         }
         let sourceId = sourceIdForSignal(input, rootFingerprintContext);
         const semanticKey = cursorShellSemanticKey(input, rootFingerprintContext);
@@ -628,7 +668,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             })
             : undefined;
         const turnTelemetry = input.signal === "stop" || input.signal === "stop-failure"
-            ? extractTurnTelemetryV3(input.adapter, input.payload.raw, eventClock.observed_at)
+            ? turnTelemetryForTerminal(input, state, eventClock.observed_at)
             : undefined;
         const cursorToolChannelSupport = input.adapter === "cursor"
             ? cursorToolChannelSupportV3(state.cursor_mode ?? "unknown")
@@ -642,6 +682,9 @@ function processHookSignalLocked(control, input, sessionHash, path) {
         }
         const toolCallCountScopeMismatch = (input.signal === "stop" || input.signal === "stop-failure") &&
             (!state.current_turn_id || state.tool_call_count_turn_id !== state.current_turn_id);
+        // Before the signal's own event: the tool call or turn that carries the
+        // new effort already ran under it, so it must ride the new attestation.
+        maybeAttestTuningChange(input, state, path, rootId);
         const event = normalizeHookEventV3(input.signal, eventInput.payload, {
             coordRoot: input.coordRoot,
             adapter: input.adapter,
@@ -665,6 +708,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             platform: input.platform,
             bridge: input.bridge,
             capability_profile: state.capability_profile,
+            cursor_mode: state.cursor_mode,
             fingerprintContext,
             turn_id: state.current_turn_id,
             span_id: openingSpan?.span_id ?? closingSpan?.span_id,
@@ -703,11 +747,53 @@ function processHookSignalLocked(control, input, sessionHash, path) {
         if (!event)
             return { state: "ignored" };
         if (input.signal === "session-start" &&
-            input.session_start_derivation === "approved_lifecycle_reopen" &&
+            input.delegated_child &&
             event.event_type === "session.started") {
+            event.links = {
+                caused_by: [input.delegated_child.caused_by_event_id],
+                parent_generation_id: input.delegated_child.parent_generation_id,
+                delegation_id: input.delegated_child.delegation_id,
+            };
+            event.provenance = {
+                ...event.provenance,
+                source_event: `${input.adapter}.subagent-start.child-generation`,
+                attestation: "derived",
+                confidence: "high",
+                attribution: {
+                    method: "native_payload",
+                    state: "verified",
+                    subject_instance_id: state.instance_id,
+                },
+            };
+            assertEventV3(event);
+        }
+        if (input.signal === "user-prompt-submit" &&
+            input.delegated_child &&
+            event.event_type === "turn.started") {
+            event.links = { caused_by: [input.delegated_child.caused_by_event_id] };
             event.provenance = {
                 ...event.provenance,
-                source_event: `${input.adapter}.approved-lifecycle-reopen`,
+                source_event: `${input.adapter}.subagent-start.child-turn`,
+                attestation: "derived",
+                confidence: "high",
+                attribution: {
+                    method: "native_payload",
+                    state: "verified",
+                    subject_instance_id: state.instance_id,
+                },
+            };
+            assertEventV3(event);
+        }
+        if (input.signal === "session-start" &&
+            input.session_start_derivation &&
+            event.event_type === "session.started") {
+            const lifecycleReopen = input.session_start_derivation === "approved_lifecycle_reopen";
+            const reason = lifecycleReopen
+                ? "approved_lifecycle_reopen"
+                : "validated_current_session_heal";
+            event.provenance = {
+                ...event.provenance,
+                source_event: `${input.adapter}.${reason.replaceAll("_", "-")}`,
                 attestation: "derived",
                 confidence: "high",
                 attribution: {
@@ -718,7 +804,7 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             };
             event.payload.resume = {
                 state: "unknown",
-                reason: "approved_lifecycle_reopen",
+                reason,
             };
             assertEventV3(event);
         }
@@ -727,7 +813,13 @@ function processHookSignalLocked(control, input, sessionHash, path) {
             span.open_event_id = event.event_id;
             stampSpanTurn(span, event, eventInput, state);
         }
+        // A turn terminal clears current_native_turn_id when it commits. Retain the
+        // native identity long enough to seed a delayed context retry afterward.
+        const nativeTurnIdForContext = input.payload.turn_id ?? state.current_native_turn_id;
         const durability = commitEventLocked(input, state, path, event, sourceId);
+        if (event.event_type === "context.compaction_started" && input.signal === "pre-compact") {
+            maybeCommitNativeHookContextObservation(input, state, path, rootId, fingerprintContext, event);
+        }
         if (event.event_type === "tool.requested" && sourceId) {
             const explicitWait = explicitNativeWait(input);
             if (explicitWait) {
@@ -741,8 +833,13 @@ function processHookSignalLocked(control, input, sessionHash, path) {
         if (progressKind) {
             commitProgressObservation(input, state, path, rootId, event, progressKind);
         }
+        if (event.event_type === "tool.completed" && input.signal === "post-tool-use") {
+            maybeCommitActiveRuntimeContextObservation(input, state, path, rootId, fingerprintContext, event);
+        }
         if (turnTelemetry) {
-            commitTurnContextObservation(input, state, path, rootId, event, turnTelemetry.context);
+            const contextTarget = turnContextTarget(event);
+            queuePendingRuntimeContext(input, state, contextTarget, turnTelemetry.context, nativeTurnIdForContext);
+            commitTurnContextObservation(input, state, path, rootId, fingerprintContext, contextTarget, turnTelemetry.context, turnTelemetry.context_provenance);
         }
         if (event.event_type === "session.ended") {
             commitCapabilityDriftEvents(input, state, path, rootId);
@@ -1101,9 +1198,28 @@ function commitEventLocked(input, state, path, event, sourceId) {
     publishProducerState(path, state);
     return durability;
 }
-function commitTurnContextObservation(input, state, path, rootId, turnTerminal, measurement) {
-    if (turnTerminal.event_type !== "turn.completed")
+function commitTurnContextObservation(input, state, path, rootId, fingerprintContext, target, measurement, contextProvenance, observedAt) {
+    if (!target)
         return;
+    commitContextObservation(input, state, path, rootId, fingerprintContext, {
+        caused_by_event_id: target.terminal_event_id,
+        observed_at: observedAt ?? target.terminal_observed_at,
+        turn_id: target.turn_id,
+        ...(target.run_id ? { run_id: target.run_id } : {}),
+        ...(target.workflow_id ? { workflow_id: target.workflow_id } : {}),
+        ...(target.workflow_agent_id ? { workflow_agent_id: target.workflow_agent_id } : {}),
+    }, measurement, contextProvenance);
+}
+function commitContextObservation(input, state, path, rootId, fingerprintContext, target, measurement, contextProvenance) {
+    if (measurement.state === "observed" &&
+        contextProvenance?.source_witness &&
+        state.last_context_source_witness === contextProvenance.source_witness) {
+        publishProducerState(path, state);
+        return;
+    }
+    if (measurement.state === "observed" && contextProvenance?.source_witness) {
+        state.last_context_source_witness = contextProvenance.source_witness;
+    }
     const event = buildEventV3("context.observed", {
         producer: {
             producer_id: input.producer_id,
@@ -1119,34 +1235,667 @@ function commitTurnContextObservation(input, state, path, rootId, turnTerminal,
             instance_id: state.instance_id,
             session_id: state.session_id,
             generation_id: state.generation_id,
-            turn_id: turnTerminal.scope.turn_id,
-            ...(input.run_id ? { run_id: input.run_id } : {}),
-            ...(input.workflow_id ? { workflow_id: input.workflow_id } : {}),
-            ...(input.workflow_agent_id ? { workflow_agent_id: input.workflow_agent_id } : {}),
+            turn_id: target.turn_id,
+            ...(target.run_id ? { run_id: target.run_id } : {}),
+            ...(target.workflow_id ? { workflow_id: target.workflow_id } : {}),
+            ...(target.workflow_agent_id ? { workflow_agent_id: target.workflow_agent_id } : {}),
         },
         attestation_id: state.attestation_id,
-        links: { caused_by: [turnTerminal.event_id] },
+        links: { caused_by: [target.caused_by_event_id] },
         provenance: {
-            source_event: `${input.adapter}.turn-context`,
+            source_event: safeRole([
+                contextProvenance?.source_event ?? `${input.adapter}.turn-context`,
+                contextProvenance?.runtime_version,
+            ]
+                .filter(Boolean)
+                .join(".")),
+            attestation: contextProvenance?.attestation ?? "native",
+            confidence: contextProvenance?.confidence ?? "exact",
+            ...(contextProvenance?.source_witness
+                ? {
+                    source_record_id: normalizeNativeIdV3(fingerprintContext, `${input.adapter}.runtime-context`, contextProvenance.source_witness),
+                }
+                : {}),
+            attribution: {
+                method: "native_payload",
+                state: "verified",
+                subject_instance_id: state.instance_id,
+            },
+        },
+        // The source sample may precede the hook boundary that admits it.
+        // measurement.measured_at preserves the sample clock without creating a
+        // causal wall-clock regression in the producer event chain.
+        observed_at: target.observed_at,
+        monotonic_ns: orderedEventMonotonic(state, input.monotonic_ns),
+        clock_id: state.clock_id,
+        payload: {
+            measurement,
+        },
+    });
+    commitEventLocked(input, state, path, event);
+    maybeAttestContextCapabilityChange(input, state, path, rootId, measurement, contextProvenance);
+}
+/**
+ * Admit fresh adapter-native or bounded runtime context while a turn is open.
+ * Tool completions are safe sampling boundaries. Persistent owner-only cadence
+ * state prevents short-lived hook processes from reading on every request,
+ * and the source witness prevents duplicate public events.
+ */
+function maybeCommitActiveRuntimeContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent) {
+    if (input.signal !== "post-tool-use" || state.terminal || !state.current_turn_id) {
+        return;
+    }
+    const nativeSessionId = input.payload.session_id ?? input.payload.conversation_id;
+    const nativeTurnId = input.payload.turn_id ?? state.current_native_turn_id;
+    if (!nativeSessionId || (!nativeTurnId && input.adapter !== "cursor"))
+        return;
+    const now = Date.now();
+    const configuredInterval = input.runtimeTelemetryOptions?.activeContextProbeIntervalMs;
+    const intervalMs = configuredInterval !== undefined && Number.isFinite(configuredInterval)
+        ? Math.max(0, Math.floor(configuredInterval))
+        : ACTIVE_RUNTIME_CONTEXT_PROBE_INTERVAL_MS;
+    const prior = state.active_runtime_context_probe;
+    const priorAttempt = prior ? Date.parse(prior.attempted_at) : Number.NaN;
+    if (prior?.turn_id === state.current_turn_id &&
+        prior.boundary === "tool_completed" &&
+        Number.isFinite(priorAttempt) &&
+        now - priorAttempt >= 0 &&
+        now - priorAttempt < intervalMs) {
+        return;
+    }
+    state.active_runtime_context_probe = {
+        turn_id: state.current_turn_id,
+        attempted_at: new Date(now).toISOString(),
+        boundary: "tool_completed",
+    };
+    const native = extractTurnTelemetryV3(input.adapter, input.payload.raw, sourceEvent.time.observed_at).context;
+    if (native.state === "observed") {
+        commitActiveContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent, native, nativeContextProvenance(input, state, native));
+        return;
+    }
+    if (input.adapter === "cursor" && state.cursor_mode === "cloud") {
+        publishProducerState(path, state);
+        return;
+    }
+    const transcriptPath = runtimeTranscriptPath(input, state);
+    if (!transcriptPath && input.adapter !== "cursor") {
+        publishProducerState(path, state);
+        return;
+    }
+    const runtime = readRuntimeContextTelemetry({
+        adapter: input.adapter,
+        session_id: nativeSessionId,
+        ...(nativeTurnId ? { turn_id: nativeTurnId } : {}),
+        ...(state.current_turn_span?.opened_at
+            ? { turn_started_at: state.current_turn_span.opened_at }
+            : {}),
+        transcript_path: transcriptPath,
+        observed_at: sourceEvent.time.observed_at,
+        mode: "active_turn",
+    }, input.runtimeTelemetryOptions);
+    if (runtime.bytes_read > 0)
+        recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
+    if (runtime.state !== "observed") {
+        publishProducerState(path, state);
+        return;
+    }
+    commitActiveContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent, runtimeContextObservation(runtime), {
+        source_event: runtime.source_event,
+        source_witness: runtime.source_witness,
+        ...(input.adapterVersion ? { runtime_version: input.adapterVersion } : {}),
+        attestation: runtime.attestation,
+        confidence: runtime.confidence,
+    });
+}
+function commitActiveContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent, measurement, provenance) {
+    if (!state.current_turn_id)
+        return;
+    const scope = sourceEvent.scope;
+    commitContextObservation(input, state, path, rootId, fingerprintContext, {
+        caused_by_event_id: sourceEvent.event_id,
+        observed_at: sourceEvent.time.observed_at,
+        turn_id: state.current_turn_id,
+        ...(scope.run_id ? { run_id: scope.run_id } : {}),
+        ...(scope.workflow_id ? { workflow_id: scope.workflow_id } : {}),
+        ...(scope.workflow_agent_id ? { workflow_agent_id: scope.workflow_agent_id } : {}),
+    }, measurement, provenance);
+}
+function nativeContextProvenance(input, state, measurement) {
+    const { measured_at: _measuredAt, ...stableValue } = measurement.value;
+    const witness = canonicalJsonV3({
+        adapter: input.adapter,
+        session_id: state.session_id,
+        turn_id: state.current_turn_id,
+        value: stableValue,
+    });
+    return {
+        source_event: `${input.adapter}.native_context`,
+        source_witness: createHash("sha256").update(witness).digest("hex"),
+        ...(input.adapterVersion ? { runtime_version: input.adapterVersion } : {}),
+        attestation: measurement.attestation,
+        confidence: measurement.confidence,
+    };
+}
+function maybeCommitNativeHookContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent) {
+    const measurement = extractTurnTelemetryV3(input.adapter, input.payload.raw, sourceEvent.time.observed_at).context;
+    if (measurement.state !== "observed")
+        return;
+    commitActiveContextObservation(input, state, path, rootId, fingerprintContext, sourceEvent, measurement, nativeContextProvenance(input, state, measurement));
+}
+function maybeAttestContextCapabilityChange(input, state, path, rootId, measurement, provenance) {
+    const context = measurement.state === "observed"
+        ? {
+            state: "observed",
+            source: provenance?.source_event ?? `${input.adapter}.turn_context`,
+            attestation: provenance?.attestation ?? measurement.attestation,
+            confidence: provenance?.confidence ?? measurement.confidence,
+            completeness: "used_percent" in measurement.value
+                ? "percentage_only"
+                : (provenance?.attestation ?? measurement.attestation) === "inferred"
+                    ? "inferred"
+                    : "exact",
+        }
+        : measurement.state === "expected_but_missing"
+            ? { state: "partial", reason: measurement.reason }
+            : { state: "unsupported" };
+    const telemetry = effectiveRuntimeTelemetryCapabilitiesV3({
+        adapter: input.adapter,
+        ...(state.cursor_mode ? { cursor_mode: state.cursor_mode } : {}),
+        context,
+        canonical_turn_boundaries: true,
+    });
+    if (!state.last_attested_telemetry)
+        return;
+    if (canonicalJsonV3(telemetry) === canonicalJsonV3(state.last_attested_telemetry))
+        return;
+    if (!state.last_attested_model_observation || !state.last_attested_tuning_observation)
+        return;
+    commitRuntimeAttestationChange(input, state, path, rootId, {
+        model: state.last_attested_model_observation,
+        tuning: state.last_attested_tuning_observation,
+        telemetry,
+        reason: "runtime_telemetry_changed",
+        source_event: provenance?.source_event ?? `${input.adapter}.turn_context`,
+        attestation: provenance?.attestation ?? "derived",
+        confidence: provenance?.confidence ?? (measurement.state === "observed" ? "exact" : "high"),
+    });
+}
+function turnContextTarget(turnTerminal) {
+    if (turnTerminal.event_type !== "turn.completed")
+        return undefined;
+    const scope = turnTerminal.scope;
+    return {
+        terminal_event_id: turnTerminal.event_id,
+        terminal_observed_at: turnTerminal.time.observed_at,
+        turn_id: scope.turn_id,
+        ...(scope.run_id ? { run_id: scope.run_id } : {}),
+        ...(scope.workflow_id ? { workflow_id: scope.workflow_id } : {}),
+        ...(scope.workflow_agent_id ? { workflow_agent_id: scope.workflow_agent_id } : {}),
+    };
+}
+function queuePendingRuntimeContext(input, state, target, measurement, nativeTurnId) {
+    if (input.adapter !== "codex" ||
+        !target ||
+        measurement.state !== "expected_but_missing" ||
+        !retryableRuntimeContextReason(measurement.reason)) {
+        return;
+    }
+    const nativeSessionId = input.payload.session_id ?? input.payload.conversation_id;
+    if (!nativeSessionId || !nativeTurnId)
+        return;
+    const pending = {
+        ...target,
+        native_session_id: nativeSessionId,
+        native_turn_id: nativeTurnId,
+        ...((input.payload.transcript_path ?? state.runtime_transcript_path)
+            ? { transcript_path: input.payload.transcript_path ?? state.runtime_transcript_path }
+            : {}),
+        ...(input.adapterVersion ? { runtime_version: input.adapterVersion } : {}),
+        attempts: 0,
+    };
+    state.pending_runtime_contexts = [
+        ...(state.pending_runtime_contexts ?? []).filter((candidate) => candidate.turn_id !== target.turn_id),
+        pending,
+    ].slice(-PENDING_RUNTIME_CONTEXT_CAP);
+}
+function reconcilePendingRuntimeContexts(input, state, path, rootId, fingerprintContext, options = {}) {
+    if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length)
+        return;
+    for (const pending of [...state.pending_runtime_contexts]) {
+        const runtime = readRuntimeContextTelemetry({
+            adapter: "codex",
+            session_id: pending.native_session_id,
+            turn_id: pending.native_turn_id,
+            transcript_path: pending.transcript_path,
+            mode: "turn",
+        }, input.runtimeTelemetryOptions);
+        if (runtime.bytes_read > 0)
+            recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
+        const queue = state.pending_runtime_contexts;
+        if (!queue)
+            break;
+        const index = queue.findIndex((candidate) => candidate.turn_id === pending.turn_id);
+        if (index < 0)
+            continue;
+        if (runtime.state === "observed") {
+            queue.splice(index, 1);
+            if (queue.length === 0) {
+                state.pending_runtime_contexts = undefined;
+            }
+            commitTurnContextObservation(input, state, path, rootId, fingerprintContext, pending, runtimeContextObservation(runtime), {
+                source_event: runtime.source_event,
+                source_witness: runtime.source_witness,
+                ...(pending.runtime_version ? { runtime_version: pending.runtime_version } : {}),
+                attestation: "derived",
+                confidence: "exact",
+            }, signalClock(input).observed_at);
+            continue;
+        }
+        const attempts = pending.attempts + 1;
+        if (options.finalAttempt ||
+            runtime.state === "unsupported" ||
+            !retryableRuntimeContextReason(runtime.reason) ||
+            (!options.deferRetryLimit && attempts >= RUNTIME_CONTEXT_RETRY_LIMIT)) {
+            queue.splice(index, 1);
+        }
+        else {
+            queue[index] = { ...pending, attempts };
+        }
+    }
+    if (state.pending_runtime_contexts?.length === 0) {
+        state.pending_runtime_contexts = undefined;
+    }
+    publishProducerState(path, state);
+}
+function reconcilePendingRuntimeContextsBeforeApprovedEnd(input, state, path, rootId, fingerprintContext) {
+    if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length)
+        return;
+    for (const [index, delayMs] of APPROVED_END_RUNTIME_CONTEXT_RETRY_DELAYS_MS.entries()) {
+        if (delayMs > 0)
+            sleepSync(delayMs);
+        reconcilePendingRuntimeContexts({
+            coordRoot: input.coordRoot,
+            mode: input.mode,
+            signal: "session-end",
+            payload: { raw: {} },
+            adapter: state.adapter,
+            instance_id: state.instance_id,
+            producer_id: "prd_agent-finalizer",
+            build_id: input.build_id,
+            platform: input.platform,
+            observed_at: new Date().toISOString(),
+            writerOptions: input.writerOptions,
+        }, state, path, rootId, fingerprintContext, {
+            deferRetryLimit: true,
+            finalAttempt: index === APPROVED_END_RUNTIME_CONTEXT_RETRY_DELAYS_MS.length - 1,
+        });
+        if (!state.pending_runtime_contexts?.length)
+            return;
+    }
+}
+function retryableRuntimeContextReason(reason) {
+    return (reason === "codex_transcript_turn_not_found" ||
+        reason === "codex_transcript_turn_not_terminal" ||
+        reason === "codex_transcript_token_count_missing");
+}
+function turnTelemetryForTerminal(input, state, observedAt) {
+    const native = extractTurnTelemetryV3(input.adapter, input.payload.raw, observedAt);
+    if (native.context.state === "observed")
+        return native;
+    if (input.adapter === "cursor" && state.cursor_mode === "cloud") {
+        return {
+            ...native,
+            context: { state: "unsupported", capability: "context_usage" },
+        };
+    }
+    const request = {
+        adapter: input.adapter,
+        session_id: input.payload.session_id ?? input.payload.conversation_id,
+        turn_id: input.payload.turn_id ?? state.current_native_turn_id,
+        transcript_path: runtimeTranscriptPath(input, state),
+        observed_at: observedAt,
+        mode: "turn",
+    };
+    let runtime = readRuntimeContextTelemetry(request, input.runtimeTelemetryOptions);
+    if (runtime.bytes_read > 0)
+        recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
+    if (input.adapter === "codex" &&
+        runtime.state === "partial" &&
+        retryableRuntimeContextReason(runtime.reason)) {
+        for (const delayMs of STOP_RUNTIME_CONTEXT_RETRY_DELAYS_MS) {
+            sleepSync(delayMs);
+            runtime = readRuntimeContextTelemetry(request, input.runtimeTelemetryOptions);
+            if (runtime.bytes_read > 0)
+                recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
+            if (runtime.state !== "partial" || !retryableRuntimeContextReason(runtime.reason))
+                break;
+        }
+    }
+    if (runtime.state === "unsupported")
+        return native;
+    return {
+        ...native,
+        context: runtimeContextObservation(runtime),
+        context_provenance: {
+            source_event: runtime.state === "observed" ? runtime.source_event : `${input.adapter}.runtime_context`,
+            ...(runtime.state === "observed" ? { source_witness: runtime.source_witness } : {}),
+            ...(input.adapterVersion ? { runtime_version: input.adapterVersion } : {}),
+            attestation: runtime.state === "observed" ? runtime.attestation : "derived",
+            confidence: runtime.state === "observed" ? runtime.confidence : "high",
+        },
+    };
+}
+/**
+ * Resolve Codex's rollout once, retain it in owner-only producer state, and
+ * verify the cached path against the native session before every reuse. Public
+ * events receive only numeric telemetry and an opaque source witness.
+ */
+function runtimeTranscriptPath(input, state) {
+    if (input.adapter !== "codex")
+        return input.payload.transcript_path;
+    const nativeSessionId = input.payload.session_id ?? input.payload.conversation_id;
+    if (!nativeSessionId)
+        return input.payload.transcript_path;
+    const supplied = input.payload.transcript_path;
+    if (supplied) {
+        const verified = discoverCodexSessionTranscript(nativeSessionId, supplied, input.runtimeTelemetryOptions);
+        if (verified)
+            state.runtime_transcript_path = verified;
+        // Preserve a supplied mismatch so the typed reader reports it honestly.
+        return verified ?? supplied;
+    }
+    if (state.runtime_transcript_path) {
+        const verified = discoverCodexSessionTranscript(nativeSessionId, state.runtime_transcript_path, input.runtimeTelemetryOptions);
+        if (verified)
+            return verified;
+        state.runtime_transcript_path = undefined;
+    }
+    const discovered = discoverCodexSessionTranscript(nativeSessionId, undefined, input.runtimeTelemetryOptions);
+    if (discovered)
+        state.runtime_transcript_path = discovered;
+    return discovered;
+}
+function runtimeContextObservation(runtime) {
+    if (runtime.state === "observed") {
+        if ("used_percent" in runtime) {
+            return {
+                state: "observed",
+                value: {
+                    used_percent: runtime.used_percent,
+                    remaining_percent: Math.max(0, 100 - runtime.used_percent),
+                    measured_at: runtime.measured_at,
+                    method: runtime.method,
+                },
+                attestation: runtime.attestation,
+                confidence: runtime.confidence,
+            };
+        }
+        return {
+            state: "observed",
+            value: {
+                used_tokens: runtime.used_tokens,
+                limit_tokens: runtime.limit_tokens,
+                remaining_tokens: Math.max(0, runtime.limit_tokens - runtime.used_tokens),
+                measured_at: runtime.measured_at,
+                method: runtime.method,
+            },
+            attestation: runtime.attestation,
+            confidence: runtime.confidence,
+        };
+    }
+    return {
+        state: "expected_but_missing",
+        capability: "context_usage",
+        reason: runtime.reason,
+    };
+}
+/** Seed the change-detection baseline from a committed session.started. */
+function seedAttestedTuning(state, event) {
+    const attestation = event.payload
+        .runtime_attestation;
+    if (!attestation)
+        return;
+    const tuning = attestation.tuning;
+    state.last_attested_tuning =
+        tuning?.state === "observed"
+            ? {
+                ...(tuning.value?.effort ? { effort: tuning.value.effort } : {}),
+                ...(tuning.value?.speed ? { speed: tuning.value.speed } : {}),
+            }
+            : {};
+    const model = attestation.model;
+    if (model.state === "observed") {
+        state.last_attested_model = { provider: model.value.provider, id: model.value.id };
+    }
+    state.last_attested_model_observation = model;
+    state.last_attested_tuning_observation = tuning;
+    state.last_attested_telemetry = attestation.telemetry;
+}
+/**
+ * Emit `session.attestation_changed` when the observed tuning moves.
+ *
+ * Detection channels are deliberately cheap: CC stamps `effort.level` on
+ * every tool hook and Stop (zero I/O), and Codex tuning is read from the
+ * rollout only at turn terminals, where the context enrichment already pays
+ * for a bounded tail read. A pre-upgrade state file (no baseline) seeds
+ * silently so existing sessions do not fire a spurious change on their next
+ * tool event; a fresh session's baseline comes from its session.started.
+ */
+function maybeAttestTuningChange(input, state, path, rootId) {
+    if (input.signal !== "pre-tool-use" &&
+        input.signal !== "post-tool-use" &&
+        input.signal !== "stop") {
+        return;
+    }
+    if (state.terminal)
+        return;
+    let candidate;
+    let attestationSource = "native";
+    let sourceEvent = `${input.adapter}.effort-payload`;
+    if (input.adapter === "claude-code" || input.adapter === "cursor") {
+        if (!input.payload.effort)
+            return;
+        candidate = { effort: input.payload.effort };
+    }
+    else if (input.adapter === "codex" &&
+        (input.signal === "stop" ||
+            // Early probe: without it, a Codex card shows no effort until the first
+            // turn terminal. One rollout read per turn while effort is unknown.
+            (input.signal === "post-tool-use" &&
+                !state.last_attested_tuning?.effort &&
+                state.current_turn_id !== undefined &&
+                state.tuning_probe_turn_id !== state.current_turn_id))) {
+        if (input.signal === "post-tool-use")
+            state.tuning_probe_turn_id = state.current_turn_id;
+        const runtime = readRuntimeTuning({
+            adapter: "codex",
+            session_id: input.payload.session_id ?? input.payload.conversation_id,
+            transcript_path: runtimeTranscriptPath(input, state),
+        }, input.runtimeTelemetryOptions);
+        if (runtime.bytes_read > 0)
+            recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
+        if (runtime.state !== "observed")
+            return;
+        candidate = {
+            ...(runtime.effort ? { effort: runtime.effort } : {}),
+            ...(runtime.speed ? { speed: runtime.speed } : {}),
+            ...(runtime.model ? { model: runtime.model } : {}),
+        };
+        attestationSource = "derived";
+        sourceEvent = runtime.source_event;
+    }
+    else {
+        return;
+    }
+    const baseline = state.last_attested_tuning;
+    const next = { effort: candidate.effort, speed: candidate.speed ?? baseline?.speed };
+    if (baseline === undefined || state.last_attested_telemetry === undefined) {
+        // Pre-upgrade state: adopt without emitting; there is no attested prior.
+        state.last_attested_tuning = { ...(next.effort ? { effort: next.effort } : {}) };
+        if (next.speed)
+            state.last_attested_tuning.speed = next.speed;
+        return;
+    }
+    if (baseline.effort === next.effort && (candidate.speed ?? baseline.speed) === baseline.speed) {
+        return;
+    }
+    // CC change detection rides the payload; the paired transcript row also
+    // carries speed and the (possibly swapped) model, so refresh from it.
+    if (input.adapter === "claude-code") {
+        const runtime = readRuntimeTuning({
+            adapter: "claude-code",
+            transcript_path: input.payload.transcript_path,
+        });
+        if (runtime.bytes_read > 0)
+            recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
+        if (runtime.state === "observed" && runtime.effort === candidate.effort) {
+            if (runtime.speed)
+                candidate.speed = runtime.speed;
+            if (runtime.model)
+                candidate.model = runtime.model;
+        }
+    }
+    const model = candidate.model
+        ? {
+            state: "observed",
+            value: { provider: modelProviderFor(input.adapter), id: safeRole(candidate.model) },
+            attestation: "derived",
+            confidence: "high",
+        }
+        : state.last_attested_model
+            ? {
+                state: "observed",
+                value: state.last_attested_model,
+                attestation: "derived",
+                confidence: "high",
+            }
+            : { state: "expected_but_missing", capability: "model_identity", reason: "not_reported" };
+    const tuning = candidate.effort || candidate.speed
+        ? {
+            state: "observed",
+            value: {
+                ...(candidate.effort ? { effort: candidate.effort } : {}),
+                ...(candidate.speed ? { speed: candidate.speed } : {}),
+            },
+            attestation: attestationSource,
+            confidence: "exact",
+        }
+        : { state: "unsupported", capability: "effort_selection" };
+    commitRuntimeAttestationChange(input, state, path, rootId, {
+        model,
+        tuning,
+        telemetry: state.last_attested_telemetry,
+        reason: "runtime_tuning_changed",
+        source_event: sourceEvent,
+        attestation: attestationSource,
+        confidence: attestationSource === "native" ? "exact" : "high",
+    });
+}
+function commitRuntimeAttestationChange(input, state, path, rootId, change) {
+    const priorAttestationId = state.attestation_id;
+    const nextAttestationId = attestationIdV3();
+    const eventId = eventIdV3();
+    const runtimeAttestation = {
+        attestation_id: nextAttestationId,
+        generation_id: state.generation_id,
+        adapter: {
+            state: "observed",
+            value: {
+                id: input.adapter,
+                ...(input.adapterVersion ? { version: input.adapterVersion } : {}),
+            },
             attestation: "native",
             confidence: "exact",
+        },
+        harness: {
+            state: "observed",
+            value: {
+                id: input.adapter,
+                ...(input.harnessVersion ? { version: input.harnessVersion } : {}),
+            },
+            attestation: "native",
+            confidence: "exact",
+        },
+        model: change.model,
+        tuning: change.tuning,
+        telemetry: change.telemetry,
+        capability_profile: state.capability_profile,
+        declared_by_event_id: eventId,
+    };
+    const event = buildEventV3("session.attestation_changed", {
+        event_id: eventId,
+        producer: {
+            producer_id: input.producer_id,
+            boot_id: state.boot_id,
+            sequence: state.next_sequence,
+            component: "agent-hook",
+            build_id: input.build_id,
+            platform: input.platform,
+            ...(input.bridge ? { bridge: input.bridge } : {}),
+        },
+        scope: {
+            root_id: rootId,
+            instance_id: state.instance_id,
+            session_id: state.session_id,
+            generation_id: state.generation_id,
+            ...(input.run_id ? { run_id: input.run_id } : {}),
+            ...(input.workflow_id ? { workflow_id: input.workflow_id } : {}),
+            ...(input.workflow_agent_id ? { workflow_agent_id: input.workflow_agent_id } : {}),
+        },
+        attestation_id: nextAttestationId,
+        links: { caused_by: state.last_event_id ? [state.last_event_id] : [] },
+        provenance: {
+            source_event: safeRole(change.source_event),
+            attestation: change.attestation,
+            confidence: change.confidence,
             attribution: {
                 method: "native_payload",
                 state: "verified",
                 subject_instance_id: state.instance_id,
             },
         },
-        observed_at: measurement.state === "observed"
-            ? measurement.value.measured_at
-            : turnTerminal.time.observed_at,
+        observed_at: input.observed_at ?? new Date().toISOString(),
         monotonic_ns: orderedEventMonotonic(state, input.monotonic_ns),
         clock_id: state.clock_id,
         payload: {
-            measurement,
+            prior_attestation_id: priorAttestationId,
+            runtime_attestation: runtimeAttestation,
+            reason: change.reason,
         },
     });
+    // Mutate BEFORE the commit: commitEventLocked publishes the state file, so
+    // post-commit mutations would be dropped by the next signal's fresh read.
+    // A crash between publishes replays the pending event against a state that
+    // already carries the new attestation id, which is the id the event declares.
+    state.attestation_id = nextAttestationId;
+    state.last_attested_model_observation = change.model;
+    state.last_attested_tuning_observation = change.tuning;
+    state.last_attested_telemetry = change.telemetry;
+    state.last_attested_model =
+        change.model.state === "observed" ? { ...change.model.value } : undefined;
+    state.last_attested_tuning = change.tuning.state === "observed" ? { ...change.tuning.value } : {};
     commitEventLocked(input, state, path, event);
 }
+function modelProviderFor(adapter) {
+    if (adapter === "claude-code")
+        return "anthropic";
+    if (adapter === "codex")
+        return "openai";
+    return "cursor";
+}
+function recordRuntimeTelemetryTiming(state, durationMs) {
+    const duration = Math.max(0, Math.ceil(durationMs));
+    if (!Number.isSafeInteger(duration))
+        return;
+    state.turn_harness = {
+        hook_time_ms: state.turn_harness.hook_time_ms + duration,
+        hook_count: state.turn_harness.hook_count + 1,
+        slowest_hook: duration >= state.turn_harness.slowest_hook_ms
+            ? "runtime-context"
+            : state.turn_harness.slowest_hook,
+        slowest_hook_ms: Math.max(duration, state.turn_harness.slowest_hook_ms),
+    };
+}
 function commitCapabilityDriftEvents(input, state, path, rootId) {
     const read = readLedgerV3(input.coordRoot);
     if (!read.complete)
@@ -1336,6 +2085,34 @@ function isCursorPromptBootstrap(input) {
         (input.payload.conversation_id !== undefined || input.payload.session_id !== undefined) &&
         input.payload.turn_id !== undefined);
 }
+/** Privacy-safe environment and recovery provenance for Codex mid-flight
+ * onboarding. WSLENV values are never recorded, only normalized variable
+ * names, and the native session identifier itself remains fingerprinted. */
+export function codexMidFlightDiagnosticContext(payload, env = process.env) {
+    const wslenv = env.WSLENV?.trim() ?? "";
+    const wslenvNames = [
+        ...new Set(wslenv
+            .split(":")
+            .map((entry) => entry.split("/", 1)[0]?.trim() ?? "")
+            .filter((name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name))),
+    ]
+        .sort()
+        .join(":")
+        .slice(0, 512);
+    const identityRecoverySource = payload.session_id
+        ? "native_session_id"
+        : payload.conversation_id
+            ? "native_conversation_id"
+            : payload.agent_id
+                ? "native_agent_id"
+                : "unavailable";
+    return {
+        thread_id_present: Boolean(env.CODEX_THREAD_ID?.trim()),
+        wslenv_present: wslenv.length > 0,
+        wslenv_names: wslenvNames,
+        identity_recovery_source: identityRecoverySource,
+    };
+}
 function suppressClosedSpanSignal(input, sessionHash, category) {
     writeProducerDiagnosticV3(input.coordRoot, category, {
         adapter: input.adapter,
@@ -1357,6 +2134,13 @@ export function recordApprovedSessionEndV3(input) {
     if (control.state !== input.mode) {
         return { state: "gate_closed", reason: control.state };
     }
+    input = {
+        ...input,
+        writerOptions: {
+            ...input.writerOptions,
+            expectedGenesisId: control.genesis.event.payload.genesis_id,
+        },
+    };
     const matches = listHookProducerStateRecordsV3(input.coordRoot, { includeTerminal: true }).filter(({ state }) => state.instance_id === input.instance_id && state.generation_id === input.generation_id);
     if (matches.length !== 1) {
         return {
@@ -1390,6 +2174,7 @@ export function recordApprovedSessionEndV3(input) {
         }
         const rootId = control.genesis.event.scope.root_id;
         const context = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
+        reconcilePendingRuntimeContextsBeforeApprovedEnd(input, state, record.path, rootId, context);
         const expected = [
             "session_started",
             "turn_closed",
@@ -1482,6 +2267,13 @@ export function salvageOpenSpansV3(input) {
     if (control.state !== input.mode) {
         return { state: "gate_closed", reason: control.state };
     }
+    input = {
+        ...input,
+        writerOptions: {
+            ...input.writerOptions,
+            expectedGenesisId: control.genesis.event.payload.genesis_id,
+        },
+    };
     const matches = listHookProducerStateRecordsV3(input.coordRoot).filter(({ state }) => state.instance_id === input.instance_id && state.generation_id === input.generation_id);
     if (matches.length !== 1) {
         return {
@@ -1568,6 +2360,10 @@ export function listHookProducerStateRecordsV3(coordRoot, options = {}) {
         for (const name of readdirSync(directory).filter((entry) => /^hid_[a-f0-9]{64}\.json$/.test(entry))) {
             const path = join(directory, name);
             const state = readProducerState(path);
+            // Skip authorities left behind by a replaced epoch: their sequences and
+            // causal links belong to the archived ledger, not this one.
+            if (state.epoch_genesis_id !== control.genesis.event.payload.genesis_id)
+                continue;
             if (!options.includeTerminal && state.terminal)
                 continue;
             records.push({ path, modified_at_ms: lstatSync(path).mtimeMs, state });
@@ -1612,7 +2408,66 @@ export function readHookProducerStateV3(coordRoot, adapter, nativeSessionId) {
     const context = fingerprintContextV3(coordRoot, rootId, undefined, control.genesis.profile.privacy_key_epoch);
     const sessionHash = normalizeNativeIdV3(context, `${adapter}.session`, nativeSessionId);
     const path = producerStatePath(coordRoot, adapter, sessionHash);
-    return existsSync(path) ? readProducerState(path) : undefined;
+    if (!existsSync(path))
+        return undefined;
+    const state = readProducerState(path);
+    // A state left behind by a replaced epoch is not this epoch's authority.
+    return state.epoch_genesis_id === control.genesis.event.payload.genesis_id ? state : undefined;
+}
+/**
+ * Retry one Codex session's owner-only context join without replaying its Stop
+ * signal. Codex appends `task_complete` only after the synchronous Stop hook
+ * exits, so this is invoked by a bounded detached worker after that exit.
+ */
+export function reconcilePendingRuntimeContextV3(input) {
+    const control = readEventV3ControlState(input.coordRoot);
+    if (control.state !== input.mode)
+        return { state: "gate_closed" };
+    if (control.state !== "candidate" && control.state !== "active") {
+        return { state: "gate_closed" };
+    }
+    const rootId = control.genesis.event.scope.root_id;
+    const rootContext = fingerprintContextV3(input.coordRoot, rootId, undefined, control.genesis.profile.privacy_key_epoch);
+    const sessionHash = normalizeNativeIdV3(rootContext, "codex.session", input.nativeSessionId);
+    const path = producerStatePath(input.coordRoot, "codex", sessionHash);
+    if (!existsSync(path))
+        return { state: "missing" };
+    const lease = acquireStateLeaseWithRetry(input.coordRoot, path, STATE_LEASE_RETRY_ATTEMPTS);
+    if (!lease)
+        return { state: "busy" };
+    try {
+        const state = readProducerState(path);
+        if (state.epoch_genesis_id !== control.genesis.event.payload.genesis_id) {
+            // The pending contexts belong to a replaced epoch; its archive already
+            // holds everything this producer durably recorded.
+            return { state: "missing" };
+        }
+        if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length) {
+            return { state: "not_pending" };
+        }
+        const context = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
+        reconcilePendingRuntimeContexts({
+            coordRoot: input.coordRoot,
+            mode: input.mode,
+            signal: "stop",
+            payload: { raw: {}, session_id: input.nativeSessionId },
+            adapter: "codex",
+            instance_id: state.instance_id,
+            producer_id: input.producer_id,
+            build_id: input.build_id,
+            platform: input.platform,
+            observed_at: new Date().toISOString(),
+            runtimeTelemetryOptions: input.runtimeTelemetryOptions,
+            writerOptions: {
+                ...input.writerOptions,
+                expectedGenesisId: control.genesis.event.payload.genesis_id,
+            },
+        }, state, path, rootId, context, { deferRetryLimit: true, finalAttempt: input.finalAttempt });
+        return state.pending_runtime_contexts?.length ? { state: "pending" } : { state: "settled" };
+    }
+    finally {
+        lease.release();
+    }
 }
 /** Resolve one terminal producer only when native session and instance identity agree. */
 export function readTerminalHookProducerStateV3(coordRoot, nativeSessionId, instanceId) {
@@ -1639,13 +2494,30 @@ export function readHookProducerStateByInstanceV3(coordRoot, instanceId) {
         }
         for (const name of readdirSync(directory).filter((entry) => /^hid_[a-f0-9]{64}\.json$/.test(entry))) {
             const state = readProducerState(join(directory, name));
+            if (state.epoch_genesis_id !== control.genesis.event.payload.genesis_id)
+                continue;
             if (state.instance_id === instanceId && !state.terminal)
                 matches.push(state);
         }
     }
     return matches.length === 1 ? matches[0] : undefined;
 }
-function newProducerState(input, sessionId, epochId, boundaryEventId) {
+/**
+ * Join a coordination actor to its hook producer.
+ *
+ * Native subagent commands can retain the parent's session id even after the
+ * child has its own canonical generation. Prefer the native session join, but
+ * when that points at a different instance accept only one exact live
+ * instance match for the same adapter.
+ */
+export function readJoinableHookProducerStateV3(coordRoot, adapter, nativeSessionId, instanceId) {
+    const direct = readHookProducerStateV3(coordRoot, adapter, nativeSessionId);
+    if (direct?.instance_id === instanceId && !direct.terminal)
+        return direct;
+    const byInstance = readHookProducerStateByInstanceV3(coordRoot, instanceId);
+    return byInstance?.adapter === adapter && !byInstance.terminal ? byInstance : undefined;
+}
+function newProducerState(input, sessionId, epochId, boundaryEventId, genesisId) {
     const bootId = `boot_${randomUUID()}`;
     return {
         format: STATE_FORMAT,
@@ -1653,11 +2525,12 @@ function newProducerState(input, sessionId, epochId, boundaryEventId) {
         adapter: input.adapter,
         instance_id: input.instance_id,
         session_id: sessionId,
-        generation_id: generationIdV3(),
+        generation_id: input.delegated_child?.generation_id ?? generationIdV3(),
         attestation_id: attestationIdV3(),
         capability_profile: adapterCapabilityProfileDigestV3(input.adapter),
         cursor_mode: input.adapter === "cursor" ? (input.payload.cursor_mode ?? "unknown") : undefined,
         privacy_epoch_id: epochId,
+        epoch_genesis_id: genesisId,
         boot_id: bootId,
         clock_id: clockIdV3(),
         next_sequence: 1,
@@ -1668,6 +2541,7 @@ function newProducerState(input, sessionId, epochId, boundaryEventId) {
             boot_id: bootId,
             clock: signalClock(input),
         }),
+        session_start_derivation: input.session_start_derivation,
         terminal: false,
         spans: [],
         delegations: [],
@@ -1694,10 +2568,12 @@ function applyCommittedEvent(state, event) {
     if (event.event_type === "session.started") {
         state.started_event_id = event.event_id;
         state.session_span.open_event_id = event.event_id;
+        seedAttestedTuning(state, event);
     }
     if (event.event_type === "turn.started") {
         const nextTurnId = event.scope.turn_id;
         state.current_turn_id = nextTurnId;
+        state.session_start_derivation = undefined;
         if (state.tool_call_count_turn_id !== nextTurnId) {
             state.tool_call_count = 0;
             state.tool_call_count_turn_id = nextTurnId;
@@ -1773,6 +2649,7 @@ function applyCommittedEvent(state, event) {
             }
         }
         state.current_turn_id = undefined;
+        state.current_native_turn_id = undefined;
         state.current_turn_span = undefined;
         state.tool_call_count = 0;
         state.tool_call_count_turn_id = undefined;
@@ -1918,6 +2795,14 @@ function safeRole(value) {
         .slice(0, 128);
     return /^[a-zA-Z0-9]/.test(normalized) ? normalized : "agent";
 }
+function asLiveInstanceId(nativeInstanceId) {
+    if (/^inst_[a-zA-Z0-9._-]{1,128}$/.test(nativeInstanceId)) {
+        return nativeInstanceId;
+    }
+    if (/^[a-zA-Z0-9._-]{1,128}$/.test(nativeInstanceId))
+        return `inst_${nativeInstanceId}`;
+    return `inst_${createHash("sha256").update(nativeInstanceId.normalize("NFC")).digest("hex")}`;
+}
 function safeTokenOrUndefined(value) {
     if (typeof value !== "string")
         return undefined;
@@ -1996,9 +2881,14 @@ function readProducerState(path) {
     state.waits ??= [];
     state.closed_turn_ids ??= [];
     state.turn_harness ??= emptyTurnHarnessTiming();
+    if (Array.isArray(state.pending_runtime_contexts) &&
+        state.pending_runtime_contexts.length === 0) {
+        state.pending_runtime_contexts = undefined;
+    }
     if (state.adapter === "cursor")
         state.cursor_mode ??= "unknown";
     const allowedKeys = new Set([
+        "active_runtime_context_probe",
         "adapter",
         "attestation_id",
         "boot_id",
@@ -2007,20 +2897,32 @@ function readProducerState(path) {
         "closed_spans",
         "closed_turn_ids",
         "current_turn_id",
+        "current_native_turn_id",
         "current_turn_span",
         "cursor_mode",
         "delegations",
+        "epoch_genesis_id",
         "format",
         "format_version",
         "generation_id",
         "instance_id",
+        "last_attested_model",
+        "last_attested_model_observation",
+        "last_attested_telemetry",
+        "last_attested_tuning",
+        "last_attested_tuning_observation",
+        "last_context_source_witness",
+        "tuning_probe_turn_id",
         "last_event_id",
         "last_monotonic_ns",
         "last_observed_at",
         "next_sequence",
         "pending",
+        "pending_runtime_contexts",
+        "runtime_transcript_path",
         "privacy_epoch_id",
         "session_id",
+        "session_start_derivation",
         "session_span",
         "spans",
         "started_event_id",
@@ -2043,6 +2945,7 @@ function readProducerState(path) {
         !/^att_[0-9a-f-]{36}$/.test(state.attestation_id) ||
         !/^cap_[a-f0-9]{64}$/.test(state.capability_profile) ||
         !/^pep_[a-zA-Z0-9._-]+$/.test(state.privacy_epoch_id) ||
+        (state.epoch_genesis_id !== undefined && !/^gex_[0-9a-f-]{36}$/.test(state.epoch_genesis_id)) ||
         !/^boot_[a-zA-Z0-9._-]+$/.test(state.boot_id) ||
         !/^clk_[0-9a-f-]{36}$/.test(state.clock_id) ||
         !Number.isSafeInteger(state.next_sequence) ||
@@ -2097,11 +3000,32 @@ function readProducerState(path) {
         !Number.isSafeInteger(state.turn_ordinal) ||
         state.turn_ordinal < 0 ||
         (state.current_turn_id !== undefined && !/^tid_[a-f0-9]{64}$/.test(state.current_turn_id)) ||
+        (state.current_native_turn_id !== undefined &&
+            (typeof state.current_native_turn_id !== "string" ||
+                state.current_native_turn_id.length === 0 ||
+                state.current_native_turn_id.length > 512)) ||
         (state.last_event_id !== undefined && !/^evt_[0-9a-f-]{36}$/.test(state.last_event_id)) ||
         (state.last_monotonic_ns !== undefined && !/^\d+$/.test(state.last_monotonic_ns)) ||
         (state.last_observed_at !== undefined &&
             !Number.isFinite(Date.parse(state.last_observed_at))) ||
         (state.started_event_id !== undefined && !/^evt_[0-9a-f-]{36}$/.test(state.started_event_id)) ||
+        (state.session_start_derivation !== undefined &&
+            state.session_start_derivation !== "approved_lifecycle_reopen" &&
+            state.session_start_derivation !== "validated_current_session_heal") ||
+        (state.pending_runtime_contexts !== undefined &&
+            (!Array.isArray(state.pending_runtime_contexts) ||
+                state.pending_runtime_contexts.length === 0 ||
+                state.pending_runtime_contexts.length > PENDING_RUNTIME_CONTEXT_CAP ||
+                state.pending_runtime_contexts.some((pending) => !validPendingRuntimeContext(pending)))) ||
+        (state.active_runtime_context_probe !== undefined &&
+            !validActiveRuntimeContextProbe(state.active_runtime_context_probe)) ||
+        (state.last_context_source_witness !== undefined &&
+            !/^[a-f0-9]{64}$/.test(state.last_context_source_witness)) ||
+        (state.runtime_transcript_path !== undefined &&
+            (typeof state.runtime_transcript_path !== "string" ||
+                state.runtime_transcript_path.length === 0 ||
+                state.runtime_transcript_path.length > 4096 ||
+                state.runtime_transcript_path.includes("\0"))) ||
         (state.pending?.source_id !== undefined &&
             !/^hid_[a-f0-9]{64}$/.test(state.pending.source_id)) ||
         (state.pending && !validateEventV3(state.pending.event).ok)) {
@@ -2163,6 +3087,47 @@ function validTurnHarnessTiming(value) {
         (value.slowest_hook === undefined ||
             /^[a-zA-Z0-9][a-zA-Z0-9._:/+-]{0,127}$/.test(value.slowest_hook)));
 }
+function validPendingRuntimeContext(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const pending = value;
+    return (typeof pending.terminal_event_id === "string" &&
+        /^evt_[0-9a-f-]{36}$/.test(pending.terminal_event_id) &&
+        typeof pending.terminal_observed_at === "string" &&
+        Number.isFinite(Date.parse(pending.terminal_observed_at)) &&
+        typeof pending.turn_id === "string" &&
+        /^tid_[a-f0-9]{64}$/.test(pending.turn_id) &&
+        (pending.run_id === undefined || /^run_[0-9a-f-]{36}$/.test(pending.run_id)) &&
+        (pending.workflow_id === undefined || /^wf_[0-9a-f-]{36}$/.test(pending.workflow_id)) &&
+        (pending.workflow_agent_id === undefined ||
+            /^[a-zA-Z0-9][a-zA-Z0-9._:/+-]{0,127}$/.test(pending.workflow_agent_id)) &&
+        typeof pending.native_session_id === "string" &&
+        pending.native_session_id.length > 0 &&
+        pending.native_session_id.length <= 512 &&
+        typeof pending.native_turn_id === "string" &&
+        pending.native_turn_id.length > 0 &&
+        pending.native_turn_id.length <= 512 &&
+        (pending.transcript_path === undefined ||
+            (typeof pending.transcript_path === "string" &&
+                pending.transcript_path.length > 0 &&
+                pending.transcript_path.length <= 4096)) &&
+        (pending.runtime_version === undefined ||
+            (typeof pending.runtime_version === "string" &&
+                /^[a-zA-Z0-9][a-zA-Z0-9._:/+-]{0,127}$/.test(pending.runtime_version))) &&
+        Number.isSafeInteger(pending.attempts) &&
+        pending.attempts >= 0 &&
+        pending.attempts < RUNTIME_CONTEXT_RETRY_LIMIT);
+}
+function validActiveRuntimeContextProbe(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const probe = value;
+    return (typeof probe.turn_id === "string" &&
+        /^tid_[a-f0-9]{64}$/.test(probe.turn_id) &&
+        typeof probe.attempted_at === "string" &&
+        Number.isFinite(Date.parse(probe.attempted_at)) &&
+        (probe.boundary === undefined || probe.boundary === "tool_completed"));
+}
 function pidIsAlive(pid) {
     if (!Number.isSafeInteger(pid) || pid < 1)
         return false;