chainlesschain 0.166.103 → 0.166.105

package/src/runtime/headless-runner.js

@@ -23,7 +23,9 @@
  */
 
 import { randomUUID } from "node:crypto";
+import { transportErrorDetails } from "../lib/transport-error-details.js";
 import { captureAgentExecutionPolicy } from "../lib/agent-execution-policy.js";
+import { HERMETIC_CODING_SYSTEM_PROMPT } from "../lib/coding-task-guidance.js";
 import { bootstrap } from "./bootstrap.js";
 import {
   buildSystemPrompt,
@@ -57,6 +59,7 @@ import {
   appendAuthorityEvent as jsonlAppendAuthorityEvent,
   readEvents as jsonlReadEvents,
   readVerifiedEvents as jsonlReadVerifiedEvents,
+  readVerifiedProjection as jsonlReadVerifiedProjection,
   findLatestEvent as jsonlFindLatestEvent,
   rebuildMessages as jsonlRebuildMessages,
   sessionExists as jsonlSessionExists,
@@ -137,7 +140,9 @@ import executionBroker from "../lib/process-execution-broker/index.js";
 import { extractPluginUsageAttribution } from "../lib/plugin-usage-attribution.js";
 import { formatManagedCheckpointEvent } from "../lib/managed-checkpoint-render.js";
 import {
+  normalizeSessionBudgetRootConfig,
   openProductionSessionBudgetRoot,
+  readProductionSessionBudget,
   sessionBudgetAdmissionError,
 } from "../lib/session-budget-production-root.js";
 import {
@@ -288,6 +293,74 @@ export function resolveHeadlessSkillDecisionOptions(options = {}) {
   });
 }
 
+function createDecisionUsageRecoveryProjection() {
+  const started = new Map();
+  const seenCallIds = new Set();
+  let blocked = false;
+  return {
+    accept(event) {
+      if (blocked) return;
+      const data = event?.data;
+      const callId = data?.callId;
+      const isDecision =
+        typeof data?.operationId === "string" &&
+        data.operationId.startsWith("decision:");
+      if (event?.type === "model_usage_started" && isDecision) {
+        if (typeof callId !== "string" || !callId || seenCallIds.has(callId)) {
+          blocked = true;
+          return;
+        }
+        let boundary;
+        try {
+          boundary = projectRuntimeUsageBoundary(data, "started");
+        } catch {
+          blocked = true;
+          return;
+        }
+        seenCallIds.add(callId);
+        started.set(callId, boundary);
+      } else if (
+        event?.type === "model_usage_unknown" &&
+        (isDecision || started.has(callId))
+      ) {
+        blocked = true;
+      } else if (event?.type === "token_usage" && started.has(callId)) {
+        let settlement;
+        try {
+          settlement = projectRuntimeTokenUsage(data);
+        } catch {
+          blocked = true;
+          return;
+        }
+        const boundary = started.get(callId);
+        if (
+          settlement.callId !== boundary.callId ||
+          settlement.operationId !== boundary.operationId ||
+          settlement.provider !== boundary.provider ||
+          settlement.model !== boundary.model ||
+          settlement.source !== boundary.source
+        ) {
+          blocked = true;
+          return;
+        }
+        started.delete(callId);
+      }
+    },
+    finish() {
+      return blocked || started.size > 0;
+    },
+  };
+}
+
+function hasUnreconciledDecisionUsage(events) {
+  if (!Array.isArray(events)) return true;
+  const projection = createDecisionUsageRecoveryProjection();
+  for (const event of events) {
+    projection.accept(event);
+  }
+  return projection.finish();
+}
+
 /**
  * Resolve a --permission-mode string into the session-policy tier + a
  * non-interactive confirmer + whether to clamp tools to the read-only set.
@@ -500,6 +573,7 @@ export function applyForkSession(opts = {}, store = {}) {
  */
 const HEADLESS_SESSION_RESOLUTION = Symbol("headlessSessionResolution");
 const HEADLESS_SESSION_HOST_LEASE = Symbol("headlessSessionHostLease");
+const HEADLESS_CANONICAL_ADMISSION = Symbol("headlessCanonicalAdmission");
 const HEADLESS_HOOK_EVENT_CLEANUP = Symbol("headlessHookEventCleanup");
 const HOST_EVENT_BACKLOG_CODE = "CC_HOST_EVENT_BACKLOG_EXHAUSTED";
 const HOST_EVENT_BACKLOG_ERROR =
@@ -528,6 +602,7 @@ async function withHeadlessSessionHostLease(options, deps, task) {
   let lease = null;
   let budgetRoot = null;
   let scopedOptions = options;
+  let preflightAdmission;
   try {
     // Session authority/lease/budget setup can lazily initialize AppConfig and
     // DatabaseManager. Those legacy diagnostics use console.info (stdout), and
@@ -589,13 +664,101 @@ async function withHeadlessSessionHostLease(options, deps, task) {
               : lease.signal,
           }
         : options;
+      const canReadCanonical =
+        !hasInjectedSessionStore ||
+        typeof deps.readVerifiedEvents === "function";
+      if (
+        authoritySessionId &&
+        !canReadCanonical &&
+        (deps.sessionBudgetStore || options.sessionBudgetRoot?.enabled) &&
+        (resolution.resumeId ||
+          deps.sessionExists?.(authoritySessionId) !== false)
+      ) {
+        throw Object.assign(
+          new Error("budgeted resume requires verified session events"),
+          { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+        );
+      }
+      if (authoritySessionId && canReadCanonical) {
+        preflightAdmission = readSessionHostResumeState(authoritySessionId, {
+          sessionHasPersistedEvidence:
+            deps.sessionHasPersistedEvidence ||
+            (!hasInjectedSessionStore
+              ? jsonlSessionHasPersistedEvidence
+              : undefined),
+          sessionExists: deps.sessionExists || jsonlSessionExists,
+          readVerifiedEvents:
+            deps.readVerifiedEvents || jsonlReadVerifiedEvents,
+        });
+      }
+      if (preflightAdmission && !preflightAdmission.snapshot.verified) {
+        // The inner runner reports the canonical failure without opening or
+        // mutating a budget sidecar for an unverified transcript.
+        return;
+      }
+      const sidecar =
+        authoritySessionId &&
+        (process.platform === "linux" || deps.sessionBudgetStore)
+          ? readProductionSessionBudget(authoritySessionId, {
+              store: deps.sessionBudgetStore,
+            })
+          : null;
+      if (!preflightAdmission && !hasInjectedSessionStore && sidecar) {
+        throw Object.assign(
+          new Error("budget sidecar has no canonical JSONL session"),
+          { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+        );
+      }
+      let effectiveBudgetConfig = options.sessionBudgetRoot;
+      if (preflightAdmission) {
+        const canonicalConfig = preflightAdmission.sessionBudgetRoot;
+        const requestedConfig = options.sessionBudgetRoot?.enabled
+          ? normalizeSessionBudgetRootConfig(options.sessionBudgetRoot)
+          : null;
+        if (canonicalConfig?.enabled) {
+          if (!sidecar) {
+            throw Object.assign(
+              new Error(
+                "budgeted session is missing its durable budget sidecar",
+              ),
+              { code: "CC_SESSION_BUDGET_SIDECAR_REQUIRED" },
+            );
+          }
+          if (requestedConfig) {
+            if (
+              JSON.stringify(requestedConfig) !==
+              JSON.stringify(canonicalConfig)
+            ) {
+              throw Object.assign(
+                new Error(
+                  "session budget does not match its JSONL declaration",
+                ),
+                { code: "CC_SESSION_BUDGET_CONFIG_MISMATCH" },
+              );
+            }
+          } else {
+            effectiveBudgetConfig = canonicalConfig;
+          }
+        } else if (requestedConfig || sidecar) {
+          throw Object.assign(
+            new Error(
+              "existing session has no canonical JSONL budget declaration",
+            ),
+            { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+          );
+        }
+      }
+      scopedOptions = {
+        ...scopedOptions,
+        sessionBudgetRoot: effectiveBudgetConfig,
+      };
       budgetRoot = openProductionSessionBudgetRoot(
         authoritySessionId,
-        options.sessionBudgetRoot,
+        effectiveBudgetConfig,
         {
           persist: resolution.persist,
           signal: scopedOptions.signal || null,
-          table: options.sessionBudgetRoot?.table,
+          table: effectiveBudgetConfig?.table || options.priceTable,
           open: deps.openSessionBudget,
           store: deps.sessionBudgetStore,
           registry: deps.sessionBudgetRegistry,
@@ -609,6 +772,7 @@ async function withHeadlessSessionHostLease(options, deps, task) {
       ...deps,
       [HEADLESS_SESSION_RESOLUTION]: resolution,
       [HEADLESS_SESSION_HOST_LEASE]: lease,
+      [HEADLESS_CANONICAL_ADMISSION]: preflightAdmission,
     });
   } finally {
     // Cleanup can touch the same lazy stores. Keep late diagnostics out of a
@@ -939,18 +1103,20 @@ async function runAgentHeadlessInWorkspace(
     !hasInjectedSessionStore || typeof deps.readVerifiedEvents === "function";
   const canonicalAdmissionId = resumeId || (persist ? sessionId : null);
   const canonicalAdmission =
-    canonicalAdmissionId && canReadCanonicalResume
-      ? readSessionHostResumeState(canonicalAdmissionId, {
-          sessionHasPersistedEvidence:
-            deps.sessionHasPersistedEvidence ||
-            (!hasInjectedSessionStore
-              ? jsonlSessionHasPersistedEvidence
-              : undefined),
-          sessionExists: deps.sessionExists || jsonlSessionExists,
-          readVerifiedEvents:
-            deps.readVerifiedEvents || jsonlReadVerifiedEvents,
-        })
-      : null;
+    deps[HEADLESS_CANONICAL_ADMISSION] !== undefined
+      ? deps[HEADLESS_CANONICAL_ADMISSION]
+      : canonicalAdmissionId && canReadCanonicalResume
+        ? readSessionHostResumeState(canonicalAdmissionId, {
+            sessionHasPersistedEvidence:
+              deps.sessionHasPersistedEvidence ||
+              (!hasInjectedSessionStore
+                ? jsonlSessionHasPersistedEvidence
+                : undefined),
+            sessionExists: deps.sessionExists || jsonlSessionExists,
+            readVerifiedEvents:
+              deps.readVerifiedEvents || jsonlReadVerifiedEvents,
+          })
+        : null;
   if (canonicalAdmission && !canonicalAdmission.snapshot.verified) {
     const message =
       "CC_SESSION_HOST_SNAPSHOT_UNVERIFIED: canonical JSONL session is not " +
@@ -1059,8 +1225,9 @@ async function runAgentHeadlessInWorkspace(
       const loaded = loadHooks({ cwd, settingsFile: options.settingsFile });
       // Fold in installed plugins' hooks/hooks.json (Phase 3.3c) — plugins ADD
       // to the user's settings hooks, never replace them.
-      const { mergePluginHooks } =
-        await import("../lib/plugin-runtime/hooks.js");
+      const { mergePluginHooks } = await import(
+        "../lib/plugin-runtime/hooks.js"
+      );
       const effectiveHooks = mergePluginHooks(
         attachAuthorityErrors(loaded.hooks, loaded.authorityErrors),
         { cwd },
@@ -1101,8 +1268,9 @@ async function runAgentHeadlessInWorkspace(
   // the run, so no explicit restore is needed.
   if (!hermeticExecution) {
     try {
-      const { applyPluginBinPath } =
-        await import("../lib/plugin-runtime/bin.js");
+      const { applyPluginBinPath } = await import(
+        "../lib/plugin-runtime/bin.js"
+      );
       applyPluginBinPath({ cwd });
     } catch {
       /* best-effort — plugin bin PATH never blocks a headless run */
@@ -1113,8 +1281,9 @@ async function runAgentHeadlessInWorkspace(
   // keys not already set; the process exits at the end so no restore is needed.
   if (!hermeticExecution) {
     try {
-      const { applyPluginSettingsEnv } =
-        await import("../lib/plugin-runtime/settings.js");
+      const { applyPluginSettingsEnv } = await import(
+        "../lib/plugin-runtime/settings.js"
+      );
       applyPluginSettingsEnv({ cwd });
     } catch {
       /* best-effort — plugin settings never block a headless run */
@@ -1248,8 +1417,9 @@ async function runAgentHeadlessInWorkspace(
   if (isHeadlessConfigCommand(prompt)) {
     const cm = await import("../lib/config-manager.js");
     const { getConfigPath } = await import("../lib/paths.js");
-    const { runConfigDirective } =
-      await import("../lib/headless-config-command.js");
+    const { runConfigDirective } = await import(
+      "../lib/headless-config-command.js"
+    );
     const { text, isError } = runConfigDirective(prompt, {
       configManager: cm,
       getConfigPath,
@@ -1325,8 +1495,9 @@ async function runAgentHeadlessInWorkspace(
           model = macro.model;
           writeErr(`  command: model → ${model}\n`);
           try {
-            const { maybeWarnDeprecatedModel } =
-              await import("../lib/model-deprecation.js");
+            const { maybeWarnDeprecatedModel } = await import(
+              "../lib/model-deprecation.js"
+            );
             maybeWarnDeprecatedModel({ model });
           } catch {
             // deprecation notice is best-effort
@@ -1363,8 +1534,9 @@ async function runAgentHeadlessInWorkspace(
 
   // ── Permission + tool resolution ──────────────────────────────────────
   if (managedSettings) {
-    const { assertManagedPermissionMode } =
-      await import("../lib/settings-loader.cjs");
+    const { assertManagedPermissionMode } = await import(
+      "../lib/settings-loader.cjs"
+    );
     assertManagedPermissionMode(options.permissionMode, managedSettings);
   }
   const perm = resolvePermissionMode(options.permissionMode);
@@ -1824,8 +1996,9 @@ async function runAgentHeadlessInWorkspace(
       : null;
   if (!hermeticExecution && !instructionExcludes) {
     try {
-      const { readStringArraySetting } =
-        await import("../lib/settings-loader.cjs");
+      const { readStringArraySetting } = await import(
+        "../lib/settings-loader.cjs"
+      );
       const fromSettings = readStringArraySetting("instructionExcludes", {
         cwd,
         settingsFile: options.settingsFile,
@@ -1850,10 +2023,9 @@ async function runAgentHeadlessInWorkspace(
     : options.skillLoader ||
       new CLISkillLoader(captureSkillRuntimeDependencies(options));
   const systemContent = hermeticExecution
-    ? composeSystemPrompt(
-        "You are a hermetic code fixer. The exposed file tools are the complete tool surface. Inspect and mutate only the exact paths authorized in the user request, then return a concise completion message.",
-        { projectMemory: false },
-      )
+    ? composeSystemPrompt(HERMETIC_CODING_SYSTEM_PROMPT, {
+        projectMemory: false,
+      })
     : composeSystemPrompt(
         buildSystemPrompt(cwd, {
           additionalDirectories,
@@ -1880,8 +2052,9 @@ async function runAgentHeadlessInWorkspace(
   // settings.json UserPromptSubmit hooks. block → abort the run; context → inject.
   if (settingsHooks) {
     try {
-      const { runUserPromptSubmitHooks } =
-        await import("../lib/settings-hook-events.js");
+      const { runUserPromptSubmitHooks } = await import(
+        "../lib/settings-hook-events.js"
+      );
       const ups = await runUserPromptSubmitHooks(settingsHooks, {
         prompt: userContent,
         cwd,
@@ -1911,8 +2084,9 @@ async function runAgentHeadlessInWorkspace(
   let instructionsLoadedContext = null;
   if (settingsHooks && _loadedInstructions) {
     try {
-      const { runInstructionsLoadedHooks } =
-        await import("../lib/settings-hook-events.js");
+      const { runInstructionsLoadedHooks } = await import(
+        "../lib/settings-hook-events.js"
+      );
       instructionsLoadedContext = (
         await runInstructionsLoadedHooks(settingsHooks, {
           files: _loadedInstructions.files,
@@ -1929,8 +2103,9 @@ async function runAgentHeadlessInWorkspace(
   let sessionStartContext = null;
   if (settingsHooks) {
     try {
-      const { runSessionStartHooks } =
-        await import("../lib/settings-hook-events.js");
+      const { runSessionStartHooks } = await import(
+        "../lib/settings-hook-events.js"
+      );
       sessionStartContext = (
         await runSessionStartHooks(settingsHooks, {
           source: resumeId ? "resume" : "startup",
@@ -1950,8 +2125,9 @@ async function runAgentHeadlessInWorkspace(
   // back up" — e.g. re-run a workspace sanity check. Observe-only, best-effort.
   if (settingsHooks && resumeId && history.length > 0) {
     try {
-      const { runObserveHooks } =
-        await import("../lib/settings-hook-events.js");
+      const { runObserveHooks } = await import(
+        "../lib/settings-hook-events.js"
+      );
       await runObserveHooks(
         settingsHooks,
         "SessionResume",
@@ -2012,6 +2188,9 @@ async function runAgentHeadlessInWorkspace(
           provider,
           model,
           observabilityScope: options.observabilityScope,
+          ...(options.sessionBudgetRoot?.enabled === true
+            ? { sessionBudgetRoot: options.sessionBudgetRoot }
+            : {}),
           executionLocation: captureAmbientExecutionLocation({
             provider,
             model,
@@ -2200,8 +2379,9 @@ async function runAgentHeadlessInWorkspace(
   // --add-dir → workspaceRootDirs = [cwd] and this is a no-op. Best-effort.
   if (hostMcp?.mcpClient && additionalDirectories.length > 0) {
     try {
-      const { notifyMcpRootsChanged, workspaceRootDirs } =
-        await import("../repl/add-dir.js");
+      const { notifyMcpRootsChanged, workspaceRootDirs } = await import(
+        "../repl/add-dir.js"
+      );
       notifyMcpRootsChanged(
         [hostMcp.mcpClient],
         workspaceRootDirs(options.cwd || process.cwd(), additionalDirectories),
@@ -2309,8 +2489,9 @@ async function runAgentHeadlessInWorkspace(
         error.code = "CC_REMOTE_APPROVAL_GATE_UNAVAILABLE";
         throw error;
       }
-      const { startHeadlessRemoteApproval } =
-        await import("../lib/remote-approval-bridge.js");
+      const { startHeadlessRemoteApproval } = await import(
+        "../lib/remote-approval-bridge.js"
+      );
       _remoteApproval = await (
         deps.startHeadlessRemoteApproval || startHeadlessRemoteApproval
       )({
@@ -2341,8 +2522,9 @@ async function runAgentHeadlessInWorkspace(
   let _collectorEnabled = false;
   if (!hermeticExecution) {
     try {
-      const { isOtlpCollectorEnabled } =
-        await import("../lib/observability/index.js");
+      const { isOtlpCollectorEnabled } = await import(
+        "../lib/observability/index.js"
+      );
       _collectorEnabled = isOtlpCollectorEnabled();
     } catch {
       _collectorEnabled = false;
@@ -2350,8 +2532,9 @@ async function runAgentHeadlessInWorkspace(
   }
   if (!hermeticExecution && (options.otlp || _collectorEnabled)) {
     try {
-      const { TelemetryRecorder } =
-        await import("../lib/telemetry/span-recorder.js");
+      const { TelemetryRecorder } = await import(
+        "../lib/telemetry/span-recorder.js"
+      );
       _otlpRecorder = new TelemetryRecorder({ serviceName: "cc-agent" });
     } catch {
       _otlpRecorder = null; // telemetry is best-effort, never blocks the run
@@ -2365,8 +2548,9 @@ async function runAgentHeadlessInWorkspace(
   let _hookSupervisor = null;
   if (settingsHooks) {
     try {
-      const { AsyncHookSupervisor } =
-        await import("../lib/async-hook-supervisor.js");
+      const { AsyncHookSupervisor } = await import(
+        "../lib/async-hook-supervisor.js"
+      );
       _hookSupervisor = new AsyncHookSupervisor({
         persistStats: true,
         // Durably park failed-rewake signals keyed by session so a crash before
@@ -2458,13 +2642,35 @@ async function runAgentHeadlessInWorkspace(
   const skillDecisionOptions = resolveHeadlessSkillDecisionOptions(options);
   let skillDecisionRuntime = null;
   if (skillDecisionOptions.mode !== "off") {
-    const previousUnknownDecisionUsage = store.findLatestEvent(
-      sessionId,
-      "model_usage_unknown",
-      (event) =>
-        typeof event?.data?.operationId === "string" &&
-        event.data.operationId.startsWith("decision:"),
-    );
+    let previousUnreconciledDecisionUsage;
+    if (
+      !hasInjectedSessionStore ||
+      typeof deps.readVerifiedEvents === "function"
+    ) {
+      try {
+        previousUnreconciledDecisionUsage = hasInjectedSessionStore
+          ? hasUnreconciledDecisionUsage(store.readVerifiedEvents(sessionId))
+          : jsonlReadVerifiedProjection(
+              sessionId,
+              createDecisionUsageRecoveryProjection,
+            );
+      } catch {
+        // Without a verified settlement, a resumed provider call could be paid twice.
+        previousUnreconciledDecisionUsage = true;
+      }
+    } else {
+      // Legacy injected stores cannot prove a prior call was settled. Their
+      // explicit no-session answer still permits a fresh test/embedding run.
+      previousUnreconciledDecisionUsage =
+        store.sessionExists(sessionId) ||
+        store.findLatestEvent(
+          sessionId,
+          "model_usage_unknown",
+          (event) =>
+            typeof event?.data?.operationId === "string" &&
+            event.data.operationId.startsWith("decision:"),
+        ) != null;
+    }
     const decisionProvider =
       deps.decisionProvider ||
       createDecisionProvider({
@@ -2487,11 +2693,12 @@ async function runAgentHeadlessInWorkspace(
         options.decisionTenantId || evolutionIngress?.tenantId || "cli-local",
       sessionId,
       provider: decisionProvider,
+      evolutionIngress,
       persist: persistDecisionEvent,
       observe: (observation) =>
         persistDecisionEvent("skill_decision_observation", observation),
       sessionBudget: options.sessionBudget || null,
-      initialUsageUnknown: previousUnknownDecisionUsage != null,
+      initialUsageUnknown: previousUnreconciledDecisionUsage,
       timeoutMs: skillDecisionOptions.timeoutMs,
     });
   }
@@ -2837,8 +3044,9 @@ async function runAgentHeadlessInWorkspace(
   if (options.goal !== undefined && options.goal !== false) {
     try {
       const explicitId = typeof options.goal === "string" ? options.goal : null;
-      const { resolveActiveGoal, linkSession } =
-        await import("../lib/goal-store.js");
+      const { resolveActiveGoal, linkSession } = await import(
+        "../lib/goal-store.js"
+      );
       const goal = (deps.resolveActiveGoal || resolveActiveGoal)({
         explicitId,
         sessionId,
@@ -3642,6 +3850,7 @@ async function runAgentHeadlessInWorkspace(
         autoRewake &&
         _hookSupervisor &&
         !stopForCost &&
+        endReason !== "deferred-mutation-unresolved" &&
         endReason !== "max_turns" &&
         endReason !== "cost-budget-exhausted"
       ) {
@@ -3696,7 +3905,8 @@ async function runAgentHeadlessInWorkspace(
         !goalEngine.done &&
         !stopForCost &&
         endReason !== "cost-budget-exhausted" &&
-        endReason !== "max_turns"
+        endReason !== "max_turns" &&
+        endReason !== "deferred-mutation-unresolved"
       ) {
         // Feed this turn's usage DELTA so the engine's totals equal the run's
         // cumulative usage (recordTurnUsage accumulates).
@@ -3814,17 +4024,23 @@ async function runAgentHeadlessInWorkspace(
       : sessionBudgetFailed
         ? "error_session_budget"
         : "error";
+    const transportDetails =
+      errorSubtype === "error" ? transportErrorDetails(err) : undefined;
+    const diagnosticFields = transportDetails
+      ? { error_details: transportDetails }
+      : {};
     if (isStream) {
       emitStream({
         type: "result",
         subtype: errorSubtype,
         is_error: true,
         error: message,
+        ...diagnosticFields,
       });
     } else if (isJson) {
       writeOut(
-        JSON.stringify(
-          buildResultEnvelope({
+        JSON.stringify({
+          ...buildResultEnvelope({
             subtype: errorSubtype,
             isError: true,
             result: message,
@@ -3836,7 +4052,8 @@ async function runAgentHeadlessInWorkspace(
             denials,
             compactionDegradations,
           }),
-        ) + "\n",
+          ...diagnosticFields,
+        }) + "\n",
       );
     } else {
       writeErr(`Error: ${message}\n`);
@@ -3887,8 +4104,9 @@ async function runAgentHeadlessInWorkspace(
     await cleanupDeadline.run("settings-hooks", async () => {
       if (settingsHooks) {
         try {
-          const { runObserveHooks } =
-            await import("../lib/settings-hook-events.js");
+          const { runObserveHooks } = await import(
+            "../lib/settings-hook-events.js"
+          );
           const stopPayload = {
             reason: pipeState.closed ? "pipe_closed" : endReason,
             cwd,
@@ -4018,7 +4236,11 @@ async function runAgentHeadlessInWorkspace(
   const exhausted =
     endReason === "budget-exhausted" || endReason === "max_turns";
   const costStopped = endReason === "cost-budget-exhausted";
-  let isError = exhausted || costStopped || endReason === "no-response";
+  let isError =
+    exhausted ||
+    costStopped ||
+    endReason === "no-response" ||
+    endReason === "deferred-mutation-unresolved";
   let subtype = exhausted
     ? "error_max_turns"
     : costStopped
@@ -4165,8 +4387,9 @@ async function runAgentHeadlessInWorkspace(
       emitStream({ type: "denials_summary", count: denials.length, denials });
     }
     try {
-      const { appendRecentDenials } =
-        await import("../lib/permission-denial-store.js");
+      const { appendRecentDenials } = await import(
+        "../lib/permission-denial-store.js"
+      );
       appendRecentDenials(denials, {
         sessionId,
         permissionMode: options.permissionMode || "default",
@@ -4239,8 +4462,9 @@ async function runAgentHeadlessInWorkspace(
     }
     if (_collectorEnabled) {
       try {
-        const { exportTelemetryRecorder } =
-          await import("../lib/observability/index.js");
+        const { exportTelemetryRecorder } = await import(
+          "../lib/observability/index.js"
+        );
         exportTelemetryRecorder(_otlpRecorder);
       } catch {
         // Telemetry is observational only and never changes the agent result.