harnery 0.40.0 → 0.41.0

package/src/core/events/v3/producers/intake.ts

@@ -14,6 +14,7 @@ import {
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import type { ParsedPayload } from "../../../hooks/adapter/parse.ts";
+import { stateDirMode, stateFileMode, stateModeTooOpen } from "../../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../../workflow/durable-record.ts";
 import { EVENT_ADAPTER_IDS_V3, type EventAdapterIdV3 } from "../adapter-id.ts";
 import type { EventV3WriteMode } from "../control.ts";
@@ -152,14 +153,14 @@ function intakeOrderKey(): string {
 }
 
 function ensureOwnerOnlyDirectory(path: string): void {
-  mkdirSync(path, { recursive: true, mode: 0o700 });
-  chmodSync(path, 0o700);
+  mkdirSync(path, { recursive: true, mode: stateDirMode() });
+  chmodSync(path, stateDirMode());
 }
 
 function writeOwnerOnlyFileDurably(path: string, contents: string): void {
   let fd: number | undefined;
   try {
-    fd = openSync(path, "wx", 0o600);
+    fd = openSync(path, "wx", stateFileMode());
     writeFileSync(fd, contents, "utf8");
     fsyncSync(fd);
     closeSync(fd);
@@ -240,7 +241,7 @@ function readIntakeRecord(path: string): HookIntakeRecordV3 | undefined {
   try {
     const metadata = lstatSync(path);
     if (!metadata.isFile() || metadata.isSymbolicLink()) return undefined;
-    if ((metadata.mode & 0o077) !== 0) return undefined;
+    if (stateModeTooOpen(metadata.mode)) return undefined;
     parsed = JSON.parse(readFileSync(path, "utf8"));
   } catch {
     return undefined;
@@ -289,14 +290,25 @@ function validDelegatedChild(value: HookIntakeRecordV3["delegated_child"]): bool
 function validTurnRitual(value: TurnRitualEvidenceV3 | undefined): boolean {
   if (value === undefined) return true;
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const keys = Object.keys(value).sort();
+  const keys = Object.keys(value)
+    .filter((key) => key !== "session_name_unavailable_reason")
+    .sort();
   if (
     keys.join(",") !==
     "session_name_present,session_name_required,status_box_present,status_box_present_strict"
   ) {
     return false;
   }
-  return keys.every((key) => typeof value[key as keyof TurnRitualEvidenceV3] === "boolean");
+  return (
+    keys.every((key) => typeof value[key as keyof TurnRitualEvidenceV3] === "boolean") &&
+    (value.session_name_unavailable_reason === undefined ||
+      [
+        "missing_transcript",
+        "transcript_not_ready",
+        "transcript_parse_error",
+        "observation_error",
+      ].includes(value.session_name_unavailable_reason))
+  );
 }
 
 /**

package/src/core/events/v3/producers/recorder.ts

@@ -15,14 +15,16 @@ import {
 } from "node:fs";
 import { hostname } from "node:os";
 import { basename, join, resolve } from "node:path";
+import { normalizeAdapter } from "../../../adapter.ts";
+import { adapterBehavior } from "../../../hooks/adapter/behaviors/index.ts";
 import { extractBashCommand, type ParsedPayload } from "../../../hooks/adapter/parse.ts";
 import {
-  discoverCodexSessionTranscript,
   type RuntimeContextTelemetry,
   type RuntimeTelemetryOptions,
   readRuntimeContextTelemetry,
   readRuntimeTuning,
 } from "../../../hooks/adapter/runtime-telemetry.ts";
+import { stateDirMode, stateFileMode, stateModeTooOpen } from "../../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../../workflow/durable-record.ts";
 import { acquireNoClobberLease } from "../../../workflow/workspaces/leases.ts";
 import { EVENT_ADAPTER_IDS_V3, type EventAdapterIdV3 } from "../adapter-id.ts";
@@ -61,6 +63,7 @@ import {
   recoverSpanUpperBoundV3,
   type SpanClockV3,
 } from "../span-state.ts";
+import { type LineChanges, prepareToolLineChanges } from "../tool-line-changes.ts";
 import {
   type ContextMeasurementV3,
   type ContextTelemetryProvenanceV3,
@@ -103,19 +106,9 @@ const ACTIVE_RUNTIME_CONTEXT_PROBE_INTERVAL_MS = 15_000;
 const STOP_RUNTIME_CONTEXT_RETRY_DELAYS_MS = [75, 175] as const;
 /** 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] as const;
-/**
- * Adapters whose turn-boundary recovery and mid-flight onboarding are enabled.
- * Kept in code, outside the digested capability profiles, so tuning recovery
- * never changes an adapter capability digest (ADR 0078).
- */
-const RECOVERY_ENABLED_ADAPTERS: ReadonlySet<string> = new Set([
-  "claude-code",
-  "codex",
-  "cursor",
-  "openclaw",
-]);
 
 interface SpanStateV3 extends OpenSpanStateV3 {
+  line_changes?: LineChanges;
   source_id: `hid_${string}`;
   semantic_key?: `hid_${string}`;
   recovery_reason?: string;
@@ -467,11 +460,11 @@ function sessionHashForSignal(
     return normalizeNativeIdV3(context, `${input.adapter}.session`, nativeSession);
   }
 
-  // Cursor carries native session identity only on its start signal. Later
-  // hooks may still have an exact coordination instance, so reuse its single
-  // live producer authority instead of hashing the instance into a second
-  // state path. Ambiguous or absent matches keep the fail-closed fallback.
-  if (input.adapter === "cursor") {
+  // Some adapters carry native session identity only on their start signal.
+  // Later hooks may still have an exact coordination instance, so reuse its
+  // single live producer authority instead of hashing the instance into a
+  // second state path. Ambiguous or absent matches keep the fail-closed fallback.
+  if (adapterBehavior(input.adapter).sessionIdentityOnStartOnly) {
     const matches = listHookProducerStateRecordsV3(input.coordRoot).filter(
       ({ state }) => state.adapter === input.adapter && state.instance_id === input.instance_id,
     );
@@ -666,6 +659,7 @@ function processHookSignalLocked(
   sessionHash: `hid_${string}`,
   path: string,
 ): RecordHookSignalV3Result {
+  const behavior = adapterBehavior(input.adapter);
   const rootId = control.genesis.event.scope.root_id as `root_${string}`;
   const epochId = control.genesis.profile.privacy_key_epoch;
   const boundaryEventId =
@@ -701,14 +695,15 @@ function processHookSignalLocked(
       throw new Error("V3 producer state authority does not match the active boundary");
     }
     if (
-      state?.adapter === "cursor" &&
+      state &&
+      behavior.tracksExecutionMode &&
       input.payload.cursor_mode &&
       input.payload.cursor_mode !== "unknown"
     ) {
       if (!state.cursor_mode || state.cursor_mode === "unknown") {
         state.cursor_mode = input.payload.cursor_mode;
       } else if (state.cursor_mode !== input.payload.cursor_mode) {
-        throw new Error("Cursor execution mode changed within one V3 generation");
+        throw new Error("Execution mode changed within one V3 generation");
       }
     }
     let recovered: RecordHookSignalV3Result | undefined;
@@ -756,7 +751,7 @@ function processHookSignalLocked(
         input.payload.session_id ?? input.payload.conversation_id ?? input.payload.agent_id;
       const onboardable =
         !state &&
-        RECOVERY_ENABLED_ADAPTERS.has(input.adapter) &&
+        behavior.turnRecovery &&
         input.signal !== "session-end" &&
         nativeSessionIdentity !== undefined;
       if (!onboardable) {
@@ -794,7 +789,7 @@ function processHookSignalLocked(
           instance_id: input.instance_id,
           signal: input.signal,
           session_hash: sessionHash,
-          ...(input.adapter === "codex" ? codexMidFlightDiagnosticContext(input.payload) : {}),
+          ...(behavior.midFlightDiagnosticContext?.(input.payload) ?? {}),
         });
       }
     }
@@ -805,7 +800,7 @@ function processHookSignalLocked(
       state.generation_id,
       state.privacy_epoch_id,
     );
-    const recoveryEnabled = RECOVERY_ENABLED_ADAPTERS.has(input.adapter);
+    const recoveryEnabled = behavior.turnRecovery;
     const nativeTid = input.payload.turn_id
       ? (normalizeNativeIdV3(
           fingerprintContext,
@@ -814,7 +809,7 @@ function processHookSignalLocked(
         ).replace(/^hid_/, "tid_") as `tid_${string}`)
       : undefined;
     const cursorPromptWithinOpenTurn =
-      input.adapter === "cursor" &&
+      behavior.promptContinuesOpenTurn &&
       input.signal === "user-prompt-submit" &&
       state.current_turn_id !== undefined &&
       state.current_turn_span !== undefined;
@@ -923,8 +918,32 @@ function processHookSignalLocked(
     // their self-contained timing cannot drift by a millisecond.
     const eventClock = signalClock(input);
     if (input.signal === "after-agent-response") {
+      // Cursor Stop followups auto-submit without beforeSubmitPrompt, so they
+      // never open a turn. The first stop already closed the human turn.
+      // Later completed replies still fire afterAgentResponse; bind them to a
+      // derived remediation turn so Stop can consume the new ritual instead of
+      // looping on the frozen first terminal.
+      const ritualFromResponseEvent = behavior.completedResponseEvent === input.signal;
+      if (
+        ritualFromResponseEvent &&
+        input.turn_ritual &&
+        (!state.current_turn_id || !state.current_turn_span)
+      ) {
+        commitRecoveredToolTurnStart(input, state, path, rootId, fingerprintContext, {
+          stop_remediation: true,
+        });
+        writeProducerDiagnosticV3(input.coordRoot, "cursor_response_ritual_recovered_turn", {
+          adapter: input.adapter,
+          instance_id: input.instance_id,
+          generation_id: state.generation_id,
+          signal: input.signal,
+          reason: "no_open_turn",
+          turn_id: state.current_turn_id,
+          status_box_present_strict: input.turn_ritual.status_box_present_strict,
+        });
+      }
       if (
-        input.adapter !== "cursor" ||
+        !ritualFromResponseEvent ||
         !state.current_turn_id ||
         !state.current_turn_span ||
         !input.turn_ritual
@@ -1023,6 +1042,10 @@ function processHookSignalLocked(
         };
         state.spans.push(span);
       }
+      span.line_changes = prepareToolLineChanges(
+        input.payload,
+        input.payload.cwd ?? input.coordRoot,
+      );
     } else if (input.signal === "post-tool-use" || input.signal === "post-tool-use-failure") {
       span = sourceId
         ? state.spans.find((candidate) => candidate.source_id === sourceId)
@@ -1174,13 +1197,12 @@ function processHookSignalLocked(
       input.signal === "stop" || input.signal === "stop-failure"
         ? turnTelemetryForTerminal(input, state, eventClock.observed_at)
         : undefined;
-    const cursorToolChannelSupport =
-      input.adapter === "cursor"
-        ? cursorToolChannelSupportV3(state.cursor_mode ?? "unknown")
-        : undefined;
+    const cursorToolChannelSupport = behavior.tracksExecutionMode
+      ? cursorToolChannelSupportV3(state.cursor_mode ?? "unknown")
+      : undefined;
     const cursorToolChannelUnattested =
       (input.signal === "stop" || input.signal === "stop-failure") &&
-      input.adapter === "cursor" &&
+      behavior.tracksExecutionMode &&
       cursorToolChannelSupport !== "unsupported" &&
       state.tool_call_count === 0;
     if (input.signal === "sub-agent-start" && delegation && !delegation.open_event_id) {
@@ -1192,15 +1214,16 @@ function processHookSignalLocked(
     // 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 ritualArrivesSeparately = behavior.completedResponseEvent !== undefined;
     const cursorResponseRitual =
-      input.adapter === "cursor" &&
+      ritualArrivesSeparately &&
       (input.signal === "stop" || input.signal === "stop-failure") &&
       state.current_turn_id &&
       state.cursor_response_ritual?.turn_id === state.current_turn_id
         ? state.cursor_response_ritual
         : undefined;
     const terminalTurnRitual =
-      input.adapter === "cursor" && (input.signal === "stop" || input.signal === "stop-failure")
+      ritualArrivesSeparately && (input.signal === "stop" || input.signal === "stop-failure")
         ? cursorResponseRitual
           ? {
               status_box_present: cursorResponseRitual.status_box_present,
@@ -1253,6 +1276,7 @@ function processHookSignalLocked(
       span_id: openingSpan?.span_id ?? closingSpan?.span_id,
       parent_span_id: openingSpan?.parent_span_id ?? closingSpan?.parent_span_id,
       terminal_span: terminalSpan,
+      tool_line_changes: span?.line_changes,
       harness_timing: state.turn_harness,
       turn_telemetry: turnTelemetry,
       caused_by: [
@@ -1777,13 +1801,14 @@ function commitRecoveredTurnCompleted(
   commitEventLocked(input, state, path, event);
 }
 
-/** Open a derived turn for tools that arrive after their native turn closed. */
+/** Open a derived turn for signals that arrive after their native turn closed. */
 function commitRecoveredToolTurnStart(
   input: RecordHookSignalV3Input,
   state: HookProducerStateV3,
   path: string,
   rootId: `root_${string}`,
   fingerprintContext: ReturnType<typeof fingerprintContextV3>,
+  options?: { stop_remediation?: boolean },
 ): void {
   const clock = signalClock(input);
   const span = openSpanStateV3({
@@ -1819,6 +1844,7 @@ function commitRecoveredToolTurnStart(
     observed_at: clock.observed_at,
     monotonic_ns: orderedEventMonotonic(state, input.monotonic_ns),
     clock_id: state.clock_id,
+    ...(options?.stop_remediation ? { stop_remediation: true } : {}),
   });
   if (event?.event_type !== "turn.started") {
     throw new Error("recovered tool turn start could not be normalized");
@@ -2105,7 +2131,8 @@ function maybeCommitActiveRuntimeContextObservation(
   }
   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 behavior = adapterBehavior(input.adapter);
+  if (!nativeSessionId || (!nativeTurnId && !behavior.nativeTurnIdOptional)) return;
 
   const now = Date.now();
   const configuredInterval = input.runtimeTelemetryOptions?.activeContextProbeIntervalMs;
@@ -2148,23 +2175,22 @@ function maybeCommitActiveRuntimeContextObservation(
     );
     return;
   }
-  if (input.adapter === "cursor" && state.cursor_mode === "cloud") {
-    publishProducerState(input.coordRoot, path, state);
-    return;
-  }
-  if (input.adapter === "openclaw") {
+  // Runtime readers exist only for workflow adapters; an event-only adapter
+  // has no transcript to read.
+  const runtimeAdapter = normalizeAdapter(input.adapter);
+  if (!runtimeAdapter || !behavior.runtimeContextAvailable(state.cursor_mode)) {
     publishProducerState(input.coordRoot, path, state);
     return;
   }
 
   const transcriptPath = runtimeTranscriptPath(input, state);
-  if (!transcriptPath && input.adapter !== "cursor") {
+  if (!transcriptPath && !behavior.runtimeContextTranscriptOptional) {
     publishProducerState(input.coordRoot, path, state);
     return;
   }
   const runtime = readRuntimeContextTelemetry(
     {
-      adapter: input.adapter,
+      adapter: runtimeAdapter,
       session_id: nativeSessionId,
       ...(nativeTurnId ? { turn_id: nativeTurnId } : {}),
       ...(state.current_turn_span?.opened_at
@@ -2354,7 +2380,7 @@ function queuePendingRuntimeContext(
   nativeTurnId: string | undefined,
 ): void {
   if (
-    input.adapter !== "codex" ||
+    !adapterBehavior(input.adapter).runtimeContextRetry ||
     !target ||
     measurement.state !== "expected_but_missing" ||
     !retryableRuntimeContextReason(measurement.reason)
@@ -2389,7 +2415,12 @@ function reconcilePendingRuntimeContexts(
   fingerprintContext: ReturnType<typeof fingerprintContextV3>,
   options: { deferRetryLimit?: boolean; finalAttempt?: boolean } = {},
 ): void {
-  if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length) return;
+  if (
+    !adapterBehavior(state.adapter).runtimeContextRetry ||
+    !state.pending_runtime_contexts?.length
+  ) {
+    return;
+  }
   for (const pending of [...state.pending_runtime_contexts]) {
     const runtime = readRuntimeContextTelemetry(
       {
@@ -2455,7 +2486,20 @@ function reconcilePendingRuntimeContextsBeforeApprovedEnd(
   rootId: `root_${string}`,
   fingerprintContext: ReturnType<typeof fingerprintContextV3>,
 ): void {
-  if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length) return;
+  if (
+    !adapterBehavior(state.adapter).runtimeContextRetry ||
+    !state.pending_runtime_contexts?.length
+  ) {
+    return;
+  }
+  // Context reconciliation continues the hook boot's sequence, even when the
+  // finalizer drives it. Recover that producer identity from its validated
+  // session start instead of attaching the sequence to the finalizer's name.
+  const ledger = readLedgerV3(input.coordRoot, { authority: input.mode });
+  const start = ledger.events.find(({ event }) => event.event_id === state.started_event_id)?.event;
+  if (!ledger.complete || !start || start.producer.boot_id !== state.boot_id) {
+    throw new Error("event_v3_finalizer_context_producer_unavailable");
+  }
   for (const [index, delayMs] of APPROVED_END_RUNTIME_CONTEXT_RETRY_DELAYS_MS.entries()) {
     if (delayMs > 0) sleepSync(delayMs);
     reconcilePendingRuntimeContexts(
@@ -2466,7 +2510,7 @@ function reconcilePendingRuntimeContextsBeforeApprovedEnd(
         payload: { raw: {} },
         adapter: state.adapter,
         instance_id: state.instance_id,
-        producer_id: "prd_agent-finalizer",
+        producer_id: start.producer.producer_id as `prd_${string}`,
         build_id: input.build_id,
         platform: input.platform,
         observed_at: new Date().toISOString(),
@@ -2499,9 +2543,11 @@ function turnTelemetryForTerminal(
   observedAt: string,
 ): TurnTelemetryV3 {
   const native = extractTurnTelemetryV3(input.adapter, input.payload.raw, observedAt);
+  const behavior = adapterBehavior(input.adapter);
   if (native.context.state === "observed") return native;
-  if (input.adapter === "openclaw") return native;
-  if (input.adapter === "cursor" && state.cursor_mode === "cloud") {
+  const runtimeAdapter = normalizeAdapter(input.adapter);
+  if (!runtimeAdapter || behavior.nativeTelemetryOnly) return native;
+  if (!behavior.runtimeContextAvailable(state.cursor_mode)) {
     return {
       ...native,
       context: { state: "unsupported", capability: "context_usage" },
@@ -2509,7 +2555,7 @@ function turnTelemetryForTerminal(
   }
 
   const request = {
-    adapter: input.adapter,
+    adapter: runtimeAdapter,
     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),
@@ -2519,7 +2565,7 @@ function turnTelemetryForTerminal(
   let runtime = readRuntimeContextTelemetry(request, input.runtimeTelemetryOptions);
   if (runtime.bytes_read > 0) recordRuntimeTelemetryTiming(state, runtime.io_duration_ms);
   if (
-    input.adapter === "codex" &&
+    behavior.runtimeContextRetry &&
     runtime.state === "partial" &&
     retryableRuntimeContextReason(runtime.reason)
   ) {
@@ -2554,24 +2600,21 @@ function runtimeTranscriptPath(
   input: RecordHookSignalV3Input,
   state: HookProducerStateV3,
 ): string | undefined {
-  if (input.adapter !== "codex") return input.payload.transcript_path;
+  const discover = adapterBehavior(input.adapter).discoverTranscript;
+  if (!discover) 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,
-    );
+    const verified = discover(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(
+    const verified = discover(
       nativeSessionId,
       state.runtime_transcript_path,
       input.runtimeTelemetryOptions,
@@ -2580,11 +2623,7 @@ function runtimeTranscriptPath(
     state.runtime_transcript_path = undefined;
   }
 
-  const discovered = discoverCodexSessionTranscript(
-    nativeSessionId,
-    undefined,
-    input.runtimeTelemetryOptions,
-  );
+  const discovered = discover(nativeSessionId, undefined, input.runtimeTelemetryOptions);
   if (discovered) state.runtime_transcript_path = discovered;
   return discovered;
 }
@@ -2676,11 +2715,12 @@ function maybeAttestTuningChange(
   let candidate: { effort?: string; speed?: string; model?: string } | undefined;
   let attestationSource: "native" | "derived" = "native";
   let sourceEvent = `${input.adapter}.effort-payload`;
-  if (input.adapter === "claude-code" || input.adapter === "cursor") {
+  const behavior = adapterBehavior(input.adapter);
+  if (behavior.effortAttestation === "payload") {
     if (!input.payload.effort) return;
     candidate = { effort: input.payload.effort };
   } else if (
-    input.adapter === "codex" &&
+    behavior.effortAttestation === "rollout-probe" &&
     (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.
@@ -2723,9 +2763,9 @@ function maybeAttestTuningChange(
     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") {
+  // Payload change detection rides the payload; the paired transcript row
+  // also carries speed and the (possibly swapped) model, so refresh from it.
+  if (behavior.transcriptTuningRefresh) {
     const runtime = readRuntimeTuning({
       adapter: "claude-code",
       transcript_path: input.payload.transcript_path,
@@ -2878,9 +2918,7 @@ function commitRuntimeAttestationChange(
 }
 
 function modelProviderFor(adapter: EventAdapterIdV3): string {
-  if (adapter === "claude-code") return "anthropic";
-  if (adapter === "codex") return "openai";
-  return adapter;
+  return adapterBehavior(adapter).modelProvider;
 }
 
 function recordRuntimeTelemetryTiming(state: HookProducerStateV3, durationMs: number): void {
@@ -3125,47 +3163,13 @@ function buildMidFlightSessionStart(
  */
 function isCursorPromptBootstrap(input: RecordHookSignalV3Input): boolean {
   return (
-    input.adapter === "cursor" &&
+    adapterBehavior(input.adapter).promptMayPrecedeSessionStart &&
     input.signal === "user-prompt-submit" &&
     (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: ParsedPayload,
-  env: NodeJS.ProcessEnv = process.env,
-): Record<string, string | boolean> {
-  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: RecordHookSignalV3Input,
   sessionHash: `hid_${string}`,
@@ -3554,7 +3558,7 @@ export function reanchorArchivedHookProducersV3(
         payload: {
           raw: {},
           ...(previous.current_native_turn_id ? { turn_id: previous.current_native_turn_id } : {}),
-          ...(previous.adapter === "cursor" && previous.cursor_mode
+          ...(adapterBehavior(previous.adapter).tracksExecutionMode && previous.cursor_mode
             ? { cursor_mode: previous.cursor_mode }
             : {}),
         },
@@ -3745,7 +3749,10 @@ export function reconcilePendingRuntimeContextV3(
       // holds everything this producer durably recorded.
       return { state: "missing" };
     }
-    if (state.adapter !== "codex" || !state.pending_runtime_contexts?.length) {
+    if (
+      !adapterBehavior(state.adapter).runtimeContextRetry ||
+      !state.pending_runtime_contexts?.length
+    ) {
       return { state: "not_pending" };
     }
     const context = fingerprintContextV3(
@@ -3863,7 +3870,9 @@ function newProducerState(
     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,
+    cursor_mode: adapterBehavior(input.adapter).tracksExecutionMode
+      ? (input.payload.cursor_mode ?? "unknown")
+      : undefined,
     privacy_epoch_id: epochId,
     epoch_genesis_id: genesisId,
     boot_id: bootId,
@@ -4048,7 +4057,7 @@ function cursorShellSemanticKey(
   input: RecordHookSignalV3Input,
   context: ReturnType<typeof fingerprintContextV3>,
 ): `hid_${string}` | undefined {
-  if (input.adapter !== "cursor") return undefined;
+  if (!adapterBehavior(input.adapter).shellOperationDedup) return undefined;
   const command = extractBashCommand(input.payload.tool_name, input.payload.tool_input);
   return command
     ? normalizeNativeIdV3(context, "cursor.shell-operation", command.normalize("NFC"))
@@ -4215,9 +4224,9 @@ function producerStatePath(
 function acquireStateLease(coordRoot: string, statePath: string) {
   const directory = join(statePath, "..");
   const producerRoot = join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers");
-  mkdirSync(directory, { recursive: true, mode: 0o700 });
-  chmodSync(producerRoot, 0o700);
-  chmodSync(directory, 0o700);
+  mkdirSync(directory, { recursive: true, mode: stateDirMode() });
+  chmodSync(producerRoot, stateDirMode());
+  chmodSync(directory, stateDirMode());
   const acquiredControl = readEventV3ControlState(coordRoot);
   const acquiredGenesis =
     acquiredControl.state === "candidate" || acquiredControl.state === "active"
@@ -4263,13 +4272,13 @@ function publishProducerState(coordRoot: string, path: string, state: HookProduc
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, `${JSON.stringify(state)}\n`, "utf8");
     fsyncSync(fd);
     closeSync(fd);
     fd = undefined;
     renameSync(temporary, path);
-    chmodSync(path, 0o600);
+    chmodSync(path, stateFileMode());
     fsyncParentDirectory(path);
   } finally {
     if (fd !== undefined) closeSync(fd);
@@ -4282,7 +4291,7 @@ function readProducerState(path: string): HookProducerStateV3 {
   if (!metadata.isFile() || metadata.isSymbolicLink()) {
     throw new Error("V3 producer state path is unsafe");
   }
-  if ((metadata.mode & 0o077) !== 0) throw new Error("V3 producer state is not owner-only");
+  if (stateModeTooOpen(metadata.mode)) throw new Error("V3 producer state is open to other users");
   let parsed: unknown;
   try {
     parsed = JSON.parse(readFileSync(path, "utf8"));
@@ -4312,7 +4321,7 @@ function readProducerState(path: string): HookProducerStateV3 {
   ) {
     state.pending_runtime_contexts = undefined;
   }
-  if (state.adapter === "cursor") state.cursor_mode ??= "unknown";
+  if (adapterBehavior(state.adapter).tracksExecutionMode) state.cursor_mode ??= "unknown";
   const allowedKeys = new Set([
     "active_runtime_context_probe",
     "adapter",

package/src/core/events/v3/recovery.ts

@@ -11,6 +11,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { basename, join, resolve } from "node:path";
+import { stateDirMode, stateFileMode } from "../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { initializeEventLedgerV3 } from "./bootstrap.ts";
 import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
@@ -133,8 +134,8 @@ function recoveryIdFor(failure: EventV3RecoveryFailure): `rcv_${string}` {
 function publishRecoveryIntent(root: string, value: EventV3RecoveryIntent): EventV3RecoveryIntent {
   const intent = validateEventV3RecoveryIntent(value);
   const records = eventV3RecoveryRecordsRoot(root);
-  mkdirSync(records, { recursive: true, mode: 0o700 });
-  chmodSync(records, 0o700);
+  mkdirSync(records, { recursive: true, mode: stateDirMode() });
+  chmodSync(records, stateDirMode());
   const path = recoveryIntentPath(records, intent.recovery_id);
   const serialized = `${canonicalJsonV3(intent)}\n`;
   if (existsSync(path)) {
@@ -256,7 +257,7 @@ function publishExclusive(path: string, serialized: string): void {
   const temporary = `${path}.tmp.${process.pid}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, serialized, "utf8");
     fsyncSync(fd);
     closeSync(fd);