@schoolai/shipyard 3.23.0 → 3.24.0-rc.20260813.1

package/dist/{serve-J3MG3WHK.js → serve-RWFBSQIE.js}

@@ -12,7 +12,7 @@ import {
   guardedSubscribe,
   makeInitialAttemptState,
   shutdownFileWatcherGuard
-} from "./chunk-7E6VXTEO.js";
+} from "./chunk-JZTUQVHQ.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -39,13 +39,13 @@ import {
   startPlanBackfillForDaemon,
   sync,
   validatePeerId
-} from "./chunk-LRBG3X5U.js";
+} from "./chunk-UK3IMOSP.js";
 import {
   loadAuthToken
 } from "./chunk-2UE3TNY7.js";
 import {
   getDaemonVersion
-} from "./chunk-W3EMVBWP.js";
+} from "./chunk-DDC5OQOC.js";
 import {
   collectPriorCrashDetail,
   getRecentWasmPanicMessages
@@ -56,6 +56,7 @@ import {
   CHARS_PER_TOKEN,
   CODEX_BUNDLED_VERSION,
   CURSOR_MODEL_CATALOG,
+  DAEMON_PR_COLD_DISCOVERY_INTERVAL_MS,
   DAEMON_PR_POLL_INTERVAL_MS,
   PROFILE_AUTH_ADAPTERS,
   REDACTED_THINKING_PLACEHOLDER,
@@ -87,6 +88,7 @@ import {
   cursorImportConversation,
   cursorPermissionModeMap,
   decideCursorAuthRefresh,
+  decidePrColdDiscoveryPlan,
   decidePrPollPlan,
   deduplicatePRs,
   detectAgentProviders,
@@ -135,6 +137,7 @@ import {
   notificationsSince,
   pickLastKnownCapabilities,
   profileRegistry,
+  reconcileCursorSupportsFastMode,
   recordGithubReadFailure,
   refreshCodexAuthSlice,
   refreshCommands,
@@ -154,6 +157,7 @@ import {
   searchPrs,
   setBootstrapPhaseBreadcrumbSink,
   setBootstrapPhaseMetricsSink,
+  setCursorFastModeSupportLookup,
   skipForMainChannel,
   snapshotProfileAuth,
   supportsAdaptiveThinking,
@@ -174,7 +178,7 @@ import {
   unresolveReviewThread,
   withLabelAsync,
   writeCursorApiKeyToVault
-} from "./chunk-OCYT65KO.js";
+} from "./chunk-BN54GQR3.js";
 import {
   buildNodeSpawnEnv,
   nodeSpawnEnvOverlay,
@@ -229,14 +233,15 @@ import {
   createOneShotPool
 } from "./chunk-ZFKJAYAN.js";
 import {
-  parseRunnerToDaemon
-} from "./chunk-CKQL7TWQ.js";
+  parseRunnerToDaemon,
+  shouldUseCursorFastModePricing
+} from "./chunk-NG355H2L.js";
 import {
   XML_TAGS,
   createAssetResolver,
   toSdkContent,
   toSdkPermissionMode
-} from "./chunk-HQTCVJRK.js";
+} from "./chunk-TU3MSY2I.js";
 import {
   AGENT_IDS,
   AGENT_SYSTEM_CLAUDE_CODE,
@@ -441,7 +446,7 @@ import {
   unsafeAssertSourceId,
   vizFileExtension,
   withPreferredRuntimeAuthMethod
-} from "./chunk-QI5ERXFK.js";
+} from "./chunk-BGJ6QJNS.js";
 import {
   AuthGitHubCallbackRequestSchema,
   AuthGitHubCallbackResponseSchema,
@@ -489,7 +494,7 @@ import {
   VaultKeyPutResponseSchema,
   classifyClaudeCodeCompatibility,
   classifyCodexCompatibility
-} from "./chunk-UESTOND6.js";
+} from "./chunk-RL25HGER.js";
 import {
   external_exports as external_exports2
 } from "./chunk-EHQITHQX.js";
@@ -6016,7 +6021,7 @@ function nanoid(size = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.23.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.24.0" : "unknown";
 function createDaemonSignaling(config) {
   const agentId = config.agentId ?? nanoid();
   function send(msg) {
@@ -7350,6 +7355,9 @@ function computeTransportEnabled(server, live) {
   return server.enabled;
 }
 function resolveSnapshotAwareLive(s2, sessionEntry, workspaceLive, inSnapshot) {
+  if (workspaceLive?.status === "needs-auth") {
+    return { live: workspaceLive, transportEnabled: true };
+  }
   if (sessionEntry) {
     return { live: sessionEntry, transportEnabled: sessionEntry.status !== "disabled" };
   }
@@ -7362,6 +7370,22 @@ function resolveSnapshotAwareLive(s2, sessionEntry, workspaceLive, inSnapshot) {
     transportEnabled: computeTransportEnabled(s2, workspaceLive)
   };
 }
+function collectMcpSessionCoordinatorDivergences(sessionServers, liveStatuses) {
+  const out = [];
+  for (const [name, session] of Object.entries(sessionServers)) {
+    if (!session) continue;
+    const coordinator = liveStatuses[name];
+    if (!coordinator) continue;
+    if (session.status === "connected" && coordinator.status === "needs-auth") {
+      out.push({
+        name,
+        sessionStatus: session.status,
+        coordinatorStatus: coordinator.status
+      });
+    }
+  }
+  return out;
+}
 function buildWorkspaceRow(s2, live, transportEnabled, userEnabled) {
   const accountIssue = s2.source === "claudeai" && s2.authStatus === "unauthenticated" && s2.url === void 0 ? {
     errorType: "agent_signin_required",
@@ -12063,32 +12087,69 @@ function createPublishTools(ctx) {
             true
           );
         }
-        try {
-          await deletePublish({
-            sessionServerUrl: ctx.sessionServerUrl,
-            authToken: token,
-            publishId
-          });
-          const store = ctx.publishedArtifactStore;
-          if (store) {
-            const taskId = resolveHarnessTaskId(ctx.taskId, ctx.getTaskIdForThread);
-            const allBindings = store.listByTask(taskId);
-            const match = allBindings.find((b2) => b2.publishId === publishId);
-            if (match) {
-              await store.deleteBinding(taskId, match.bindKind, match.bindKey);
-            }
-          }
+        const taskId = resolveHarnessTaskId(ctx.taskId, ctx.getTaskIdForThread);
+        const outcome = await runUnpublish({
+          publishId,
+          taskId,
+          sessionServerUrl: ctx.sessionServerUrl,
+          authToken: token,
+          publishedArtifactStore: ctx.publishedArtifactStore
+        });
+        if (outcome.ok) {
           return textResult(JSON.stringify({ ok: true }));
-        } catch (err3) {
-          return textResult(
-            `Failed to unpublish: ${err3 instanceof Error ? err3.message : String(err3)}`,
-            true
-          );
         }
+        return textResult(outcome.error, true);
       }
     }
   ];
 }
+async function runUnpublish(params) {
+  try {
+    await deletePublish({
+      sessionServerUrl: params.sessionServerUrl,
+      authToken: params.authToken,
+      publishId: params.publishId
+    });
+  } catch (err3) {
+    return {
+      ok: false,
+      error: `Failed to unpublish: ${err3 instanceof Error ? err3.message : String(err3)}`
+    };
+  }
+  const store = params.publishedArtifactStore;
+  if (store) {
+    const match = store.listByTask(params.taskId).find((b2) => b2.publishId === params.publishId);
+    if (match) {
+      await store.deleteBinding(params.taskId, match.bindKind, match.bindKey);
+    }
+  }
+  return { ok: true };
+}
+async function handleUnpublishRequest(params) {
+  const { correlationId, sendControl } = params;
+  const token = params.getAuthToken();
+  if (!token) {
+    sendControl({
+      type: "unpublish_result",
+      correlationId,
+      ok: false,
+      error: "Not authenticated. Please log in before unpublishing."
+    });
+    return;
+  }
+  const outcome = await runUnpublish({
+    publishId: params.publishId,
+    taskId: params.taskId,
+    sessionServerUrl: params.sessionServerUrl,
+    authToken: token,
+    publishedArtifactStore: params.publishedArtifactStore
+  });
+  if (outcome.ok) {
+    sendControl({ type: "unpublish_result", correlationId, ok: true });
+  } else {
+    sendControl({ type: "unpublish_result", correlationId, ok: false, error: outcome.error });
+  }
+}
 async function handlePublishRequest(params) {
   const { correlationId, target, ttl, title, sendControl } = params;
   function emitProgress(phase, detail) {
@@ -14692,6 +14753,7 @@ function filterOutboundForCollab(msg, collabTaskId, getTaskSync) {
      */
     case "publish_progress":
     case "publish_result":
+    case "unpublish_result":
       return null;
     /**
      * task_index_version is a heartbeat staleness probe response carrying the
@@ -15461,6 +15523,61 @@ async function routeRequestSkills(args) {
   args.sendControl(args.buildSnapshot());
 }
 
+// src/services/channels/control-channel/unpublish-request-wiring.ts
+function wireOnRequestUnpublish(deps, logAdapter) {
+  return ({ correlationId, taskId, publishId, sendControl }) => {
+    logAdapter({
+      event: "unpublish_request_received",
+      correlationId,
+      taskId,
+      publishId
+    });
+    const wrappedSendControl = (msg) => {
+      if (msg.type === "unpublish_result") {
+        logAdapter({
+          event: "unpublish_result",
+          correlationId,
+          ok: msg.ok,
+          error: msg.ok ? void 0 : msg.error
+        });
+      }
+      sendControl(msg);
+    };
+    const sessionServerUrl = deps.sessionServerUrl;
+    const getAuthToken = deps.getAuthToken;
+    if (!sessionServerUrl || !getAuthToken) {
+      wrappedSendControl({
+        type: "unpublish_result",
+        correlationId,
+        ok: false,
+        error: "Unpublish not available: session server not configured."
+      });
+      return;
+    }
+    handleUnpublishRequest({
+      correlationId,
+      taskId,
+      publishId,
+      sessionServerUrl,
+      getAuthToken,
+      publishedArtifactStore: deps.publishedArtifactStore ?? null,
+      sendControl: wrappedSendControl
+    }).catch((err3) => {
+      logAdapter({
+        event: "unpublish_request_unhandled_error",
+        correlationId,
+        error: err3 instanceof Error ? err3.message : String(err3)
+      });
+      wrappedSendControl({
+        type: "unpublish_result",
+        correlationId,
+        ok: false,
+        error: `Unexpected error: ${err3 instanceof Error ? err3.message : String(err3)}`
+      });
+    });
+  };
+}
+
 // src/services/channels/control-channel-handler.ts
 function handleControlChannel(send, callbacks, log) {
   function sendControl(msg) {
@@ -15957,6 +16074,14 @@ function routeMessage(msg, callbacks, sendControl, log) {
         sendControl
       });
       break;
+    case "request_unpublish":
+      callbacks.onRequestUnpublish({
+        correlationId: msg.correlationId,
+        taskId: msg.taskId,
+        publishId: msg.publishId,
+        sendControl
+      });
+      break;
     case "start_from_linear":
       callbacks.onStartFromLinear(msg);
       break;
@@ -21436,7 +21561,11 @@ function matchCollabQueueCorrelationIds(messages, queueEntries) {
 }
 
 // src/services/session/claude-tool-guard.ts
-var SHIPYARD_DENIED_CLAUDE_TOOLS = ["Artifact"];
+var SHIPYARD_DENIED_CLAUDE_TOOLS = [
+  "Artifact",
+  "EnterWorktree",
+  "ExitWorktree"
+];
 function detectDeniedToolsPresent(initTools, denied = SHIPYARD_DENIED_CLAUDE_TOOLS) {
   const present = new Set(initTools);
   return denied.filter((name) => present.has(name));
@@ -27032,6 +27161,14 @@ function wireControlChannel(rawChannel, daemon, logAdapter, deps) {
           });
         });
       },
+      onRequestUnpublish: wireOnRequestUnpublish(
+        {
+          sessionServerUrl: deps?.sessionServerUrl,
+          getAuthToken: deps?.getAuthToken,
+          publishedArtifactStore: deps?.publishedArtifactStore
+        },
+        logAdapter
+      ),
       onStartFromLinear: (payload) => linearStartHandler.handleStartFromLinear(payload),
       /**
        * Browser-initiated flush for a specific resource URI (PROTOCOL_VERSION 48).
@@ -33580,6 +33717,7 @@ function buildCollabRoomManager(deps) {
 import { randomUUID as randomUUID25 } from "crypto";
 import { mkdir as mkdir36 } from "fs/promises";
 import { join as join79 } from "path";
+import { getHeapStatistics } from "v8";
 
 // src/shared/capabilities/cursor-boot-auth.ts
 async function mergeCursorAuthFromVault(caps, detect, log) {
@@ -34291,6 +34429,24 @@ function mergeWithDefaultComposerSettings(caller, defaults) {
   return normalizeComposerSettings(merged);
 }
 
+// src/services/task/session-activity.ts
+function isActiveUserWork(state) {
+  switch (state) {
+    case "spawning":
+    case "running":
+    case "stopping":
+      return true;
+    case "warm_idle":
+    case "resumable_idle":
+    case "cold_idle":
+      return false;
+    default: {
+      const _exhaustive = state;
+      throw new Error(`Unhandled session state: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+
 // src/services/bootstrap/rehydrate.ts
 var ACTIVE_STATUSES = {
   open: true,
@@ -34313,9 +34469,11 @@ var ACTIVE_STATUSES = {
    */
   canceled: false
 };
-function planStaleSweep(tasks, isRunning) {
+function planStaleSweep(tasks, getSessionState) {
   return Object.values(tasks).map((task) => {
-    if (ACTIVE_STATUSES[task.status] && !isRunning(task.taskId)) {
+    const state = getSessionState(task.taskId);
+    const isLive = state !== null && isActiveUserWork(state);
+    if (ACTIVE_STATUSES[task.status] && !isLive) {
       return { kind: "mark_input_required", taskId: task.taskId, previousStatus: task.status };
     }
     return { kind: "keep", taskId: task.taskId };
@@ -34342,6 +34500,15 @@ function classifyPersistedSessions(sessions, knownTaskIds) {
 }
 var EAGER_RESTORE_STATUSES = {
   open: true,
+  /**
+   * Since the `planStaleSweep` fix for issue #5224, an eagerly-restored
+   * `in_progress` task lands in `resumable_idle` and is immediately demoted
+   * to `input_required` by the sweep three lines later in the boot sequence
+   * — the eventual status is identical to `input_required` either way.
+   * Eager restore is still worth it here purely as a warm-cache optimization:
+   * the resumable SDK session is materialized immediately rather than on the
+   * user's next message, so replying doesn't pay the lazy-restore cost.
+   */
   in_progress: true,
   /**
    * Excluded for boot-cost reasons, not correctness: `planStaleSweep`
@@ -34696,7 +34863,7 @@ async function migrateLegacyPreviewData(canvasRepo, previewStateStore, taskState
 }
 async function sweepStaleTasks(taskStateStore, taskManager, log) {
   const tasks = await taskStateStore.listTasks();
-  const actions = planStaleSweep(tasks, (id) => taskManager.isRunning(id));
+  const actions = planStaleSweep(tasks, (id) => taskManager.getTaskState(id)?.sessionState ?? null);
   const noBroadcast = { broadcast: false };
   for (const action of actions) {
     if (action.kind === "mark_input_required") {
@@ -37464,7 +37631,7 @@ function createDaemonPrPollingService(deps) {
     syncing = true;
     return true;
   }
-  async function loadPlanTasks() {
+  async function loadPlanTasks2() {
     const records = await deps.taskStateStore.listTasks();
     return Object.values(records).map(
       (record) => toPrPollPlanTask(record, deps.getPrState(record.taskId))
@@ -37488,7 +37655,7 @@ function createDaemonPrPollingService(deps) {
     }
   }
   async function runSyncCore() {
-    const tasks = await loadPlanTasks();
+    const tasks = await loadPlanTasks2();
     if (disposed) return;
     const tasksById = new Map(tasks.map((task) => [task.taskId, task]));
     stopIneligibleSubscriptions(tasksById);
@@ -37549,70 +37716,8 @@ function createDaemonPrPollingService(deps) {
   return { start, requestSync, dispose };
 }
 
-// src/services/pr-first-discovery.ts
-function applyPrFirstDiscovery(payload, attributedTaskIds, effects) {
-  const { taskId } = payload;
-  const pr = payload.currentBranchPR;
-  if (!pr || attributedTaskIds.has(taskId)) return;
-  attributedTaskIds.add(taskId);
-  effects.forceRefresh(taskId);
-  effects.attribute(taskId, pr);
-}
-
-// src/services/pr-poll-subscriptions.ts
-function createPRPollSubscriptionCoordinator(poller) {
-  const subscriptions = /* @__PURE__ */ new Map();
-  function startPolling(taskId, cwd, source = "browser") {
-    const existing = subscriptions.get(taskId);
-    if (existing) {
-      const wasEmpty = existing.sources.size === 0;
-      const cwdChanged = existing.cwd !== cwd;
-      existing.cwd = cwd;
-      existing.sources.add(source);
-      if (wasEmpty) {
-        poller.startPolling(taskId, cwd);
-      } else if (cwdChanged) {
-        void poller.updateCwd(taskId, cwd);
-      } else if (source === "browser") {
-        poller.refreshNow(taskId);
-      }
-      return;
-    }
-    subscriptions.set(taskId, { cwd, sources: /* @__PURE__ */ new Set([source]) });
-    poller.startPolling(taskId, cwd);
-  }
-  function stopPolling(taskId, source = "browser") {
-    const entry = subscriptions.get(taskId);
-    if (!entry) return;
-    entry.sources.delete(source);
-    if (entry.sources.size > 0) return;
-    subscriptions.delete(taskId);
-    poller.stopPolling(taskId);
-  }
-  function getCwd(taskId) {
-    return subscriptions.get(taskId)?.cwd ?? poller.getCwd(taskId);
-  }
-  async function updateCwd(taskId, newCwd) {
-    const entry = subscriptions.get(taskId);
-    if (!entry) return;
-    if (entry.cwd === newCwd) return;
-    entry.cwd = newCwd;
-    await poller.updateCwd(taskId, newCwd);
-  }
-  function dispose() {
-    subscriptions.clear();
-    poller.dispose();
-  }
-  return {
-    startPolling,
-    stopPolling,
-    forceRefresh: poller.forceRefresh,
-    refreshNow: poller.refreshNow,
-    getCwd,
-    updateCwd,
-    dispose
-  };
-}
+// src/services/pr-cold-discovery.ts
+import { existsSync as existsSync7 } from "fs";
 
 // src/services/pr-stack/build-stack-graph.ts
 var DEFAULT_MAX_DEPTH = 20;
@@ -37938,47 +38043,47 @@ async function fetchCIDataWithRemote(pr, cwd, remote) {
   );
   return { requiredChecks };
 }
+async function fetchFastPRState(cwd, log) {
+  const backoff = getGithubReadBackoffState();
+  if (backoff.backoffUntil !== null) {
+    log.warn(
+      { backoffUntil: backoff.backoffUntil, reason: backoff.reason },
+      "PR polling skipped during GitHub read backoff"
+    );
+    return null;
+  }
+  const available = await isGhAvailable();
+  if (!available) {
+    return {
+      prAvailable: false,
+      currentBranchPR: null,
+      assignedReviews: [],
+      userPRs: [],
+      allPRs: [],
+      remote: ""
+    };
+  }
+  const [prResults, remote] = await Promise.all([
+    Promise.allSettled([getPRForCurrentBranch(cwd), getAssignedReviews(cwd), getUserPRs(cwd)]),
+    gitExecSafe(cwd, ["remote", "get-url", "origin"]).then((v2) => v2 ?? "")
+  ]);
+  const [currentPR, assigned, user] = prResults;
+  const { allPRs, currentBranchPR: rawPR } = deduplicatePRs(currentPR, assigned, user);
+  const currentBranchPR = rawPR ? await enrichClosedPR(rawPR, cwd) : null;
+  return {
+    prAvailable: true,
+    currentBranchPR,
+    assignedReviews: assigned.status === "fulfilled" ? assigned.value : [],
+    userPRs: user.status === "fulfilled" ? user.value : [],
+    allPRs,
+    remote
+  };
+}
 function createPRPoller(callbacks, log, resolveTopLevel = getGitTopLevel) {
   const repos = /* @__PURE__ */ new Map();
   const taskToRepo = /* @__PURE__ */ new Map();
   let disposed = false;
   let activePollCount = 0;
-  async function fetchFastPRState(cwd) {
-    const backoff = getGithubReadBackoffState();
-    if (backoff.backoffUntil !== null) {
-      log.warn(
-        { backoffUntil: backoff.backoffUntil, reason: backoff.reason },
-        "PR polling skipped during GitHub read backoff"
-      );
-      return null;
-    }
-    const available = await isGhAvailable();
-    if (!available) {
-      return {
-        prAvailable: false,
-        currentBranchPR: null,
-        assignedReviews: [],
-        userPRs: [],
-        allPRs: [],
-        remote: ""
-      };
-    }
-    const [prResults, remote] = await Promise.all([
-      Promise.allSettled([getPRForCurrentBranch(cwd), getAssignedReviews(cwd), getUserPRs(cwd)]),
-      gitExecSafe(cwd, ["remote", "get-url", "origin"]).then((v2) => v2 ?? "")
-    ]);
-    const [currentPR, assigned, user] = prResults;
-    const { allPRs, currentBranchPR: rawPR } = deduplicatePRs(currentPR, assigned, user);
-    const currentBranchPR = rawPR ? await enrichClosedPR(rawPR, cwd) : null;
-    return {
-      prAvailable: true,
-      currentBranchPR,
-      assignedReviews: assigned.status === "fulfilled" ? assigned.value : [],
-      userPRs: user.status === "fulfilled" ? user.value : [],
-      allPRs,
-      remote
-    };
-  }
   async function fetchEnrichment(fast, cwd) {
     const ciData = await fetchCIDataWithRemote(fast.currentBranchPR, cwd, fast.remote).catch(
       () => ({
@@ -38115,7 +38220,7 @@ function createPRPoller(callbacks, log, resolveTopLevel = getGitTopLevel) {
     const currentBranch = await gitExecSafe(entry.cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) ?? "";
     if (disposed) return;
     handleBranchChange(topLevel, entry, currentBranch);
-    const fast = await fetchFastPRState(entry.cwd);
+    const fast = await fetchFastPRState(entry.cwd, log);
     if (!fast || disposed) return;
     entry.lastPolledAt = Date.now();
     pushPhase1IfChanged(topLevel, entry, fast);
@@ -38311,6 +38416,190 @@ function createPRPoller(callbacks, log, resolveTopLevel = getGitTopLevel) {
   return { startPolling, stopPolling, forceRefresh, refreshNow, getCwd, updateCwd, dispose };
 }
 
+// src/services/pr-cold-discovery.ts
+async function loadPlanTasks(taskStateStore, getPrState) {
+  const records = await taskStateStore.listTasks();
+  return Object.values(records).map(
+    (record) => toPrPollPlanTask(record, getPrState(record.taskId))
+  );
+}
+function createPrColdDiscoveryService(deps) {
+  const intervalMs = deps.intervalMs ?? DAEMON_PR_COLD_DISCOVERY_INTERVAL_MS;
+  const now = deps.now ?? Date.now;
+  const checkPR = deps.checkPR ?? fetchFastPRState;
+  const lastCheckedAt = /* @__PURE__ */ new Map();
+  let timer = null;
+  let disposed = false;
+  let syncing = false;
+  let syncQueued = false;
+  let unsubscribeTaskStore = null;
+  async function checkTask(task) {
+    if (!task.cwd) return;
+    if (!existsSync7(task.cwd)) {
+      deps.log.debug({ taskId: task.taskId, cwd: task.cwd }, "Cold discovery skipped, cwd missing");
+      return;
+    }
+    try {
+      const fast = await checkPR(task.cwd, deps.log);
+      if (fast?.currentBranchPR) {
+        deps.log.debug(
+          { taskId: task.taskId, prUrl: fast.currentBranchPR.url },
+          "Cold discovery found a PR, handing off to daemon polling"
+        );
+        deps.subscriptions.startPolling(task.taskId, task.cwd, "daemon");
+      }
+    } catch (err3) {
+      recordGithubReadFailure(err3);
+      deps.log.warn({ err: err3, taskId: task.taskId }, "Cold discovery check failed");
+    }
+  }
+  function tryEnterSync() {
+    if (disposed) return false;
+    if (syncing) {
+      syncQueued = true;
+      return false;
+    }
+    syncing = true;
+    return true;
+  }
+  async function runSyncCore() {
+    const tasks = await loadPlanTasks(deps.taskStateStore, deps.getPrState);
+    if (disposed) return;
+    const tasksById = new Map(tasks.map((task) => [task.taskId, task]));
+    const currentTime = now();
+    const toCheck = decidePrColdDiscoveryPlan(
+      tasks,
+      currentTime,
+      lastCheckedAt,
+      deps.getRateLimitState(),
+      {
+        intervalMs
+      }
+    );
+    for (const taskId of toCheck) {
+      lastCheckedAt.set(taskId, currentTime);
+    }
+    if (toCheck.length > 0) {
+      deps.log.debug({ taskIds: toCheck }, "Cold PR discovery candidates selected");
+    }
+    await Promise.all(
+      toCheck.map((taskId) => {
+        const task = tasksById.get(taskId);
+        return task ? checkTask(task) : Promise.resolve();
+      })
+    );
+  }
+  function finishSync() {
+    syncing = false;
+    if (!syncQueued || disposed) return;
+    syncQueued = false;
+    void sync2();
+  }
+  async function sync2() {
+    if (!tryEnterSync()) return;
+    try {
+      await runSyncCore();
+    } catch (err3) {
+      deps.log.warn(
+        { error: err3 instanceof Error ? err3.message : String(err3) },
+        "Cold PR discovery sync failed"
+      );
+    } finally {
+      finishSync();
+    }
+  }
+  function requestSync() {
+    void sync2();
+  }
+  function start() {
+    if (timer !== null || disposed) return;
+    unsubscribeTaskStore = deps.taskStateStore.subscribe((event) => {
+      if (event.kind === "delete") {
+        lastCheckedAt.delete(event.id);
+        return;
+      }
+      requestSync();
+    });
+    requestSync();
+    timer = setInterval(requestSync, intervalMs);
+    timer.unref();
+  }
+  function dispose() {
+    disposed = true;
+    if (timer) clearInterval(timer);
+    timer = null;
+    unsubscribeTaskStore?.();
+    unsubscribeTaskStore = null;
+    lastCheckedAt.clear();
+  }
+  return { start, dispose };
+}
+
+// src/services/pr-first-discovery.ts
+function applyPrFirstDiscovery(payload, attributedTaskIds, effects) {
+  const { taskId } = payload;
+  const pr = payload.currentBranchPR;
+  if (!pr || attributedTaskIds.has(taskId)) return;
+  attributedTaskIds.add(taskId);
+  effects.forceRefresh(taskId);
+  effects.attribute(taskId, pr);
+}
+
+// src/services/pr-poll-subscriptions.ts
+function createPRPollSubscriptionCoordinator(poller) {
+  const subscriptions = /* @__PURE__ */ new Map();
+  function startPolling(taskId, cwd, source = "browser") {
+    const existing = subscriptions.get(taskId);
+    if (existing) {
+      const wasEmpty = existing.sources.size === 0;
+      const cwdChanged = existing.cwd !== cwd;
+      existing.cwd = cwd;
+      existing.sources.add(source);
+      if (wasEmpty) {
+        poller.startPolling(taskId, cwd);
+      } else if (cwdChanged) {
+        void poller.updateCwd(taskId, cwd);
+      } else if (source === "browser") {
+        poller.refreshNow(taskId);
+      }
+      return;
+    }
+    subscriptions.set(taskId, { cwd, sources: /* @__PURE__ */ new Set([source]) });
+    poller.startPolling(taskId, cwd);
+  }
+  function stopPolling(taskId, source = "browser") {
+    const entry = subscriptions.get(taskId);
+    if (!entry) return;
+    entry.sources.delete(source);
+    if (entry.sources.size > 0) return;
+    subscriptions.delete(taskId);
+    poller.stopPolling(taskId);
+  }
+  function getCwd(taskId) {
+    return subscriptions.get(taskId)?.cwd ?? poller.getCwd(taskId);
+  }
+  async function updateCwd(taskId, newCwd) {
+    const entry = subscriptions.get(taskId);
+    if (!entry) return;
+    if (entry.cwd === newCwd) return;
+    entry.cwd = newCwd;
+    await poller.updateCwd(taskId, newCwd);
+  }
+  function dispose() {
+    subscriptions.clear();
+    poller.dispose();
+  }
+  return {
+    startPolling,
+    stopPolling,
+    forceRefresh: poller.forceRefresh,
+    refreshNow: poller.refreshNow,
+    getCwd,
+    updateCwd,
+    dispose
+  };
+}
+
 // src/services/channels/control-channel/pr-ingest-dedup.ts
 var INGEST_DEDUPE_WINDOW_MS = 15e3;
 function createPrIngestDedup() {
@@ -38499,6 +38788,14 @@ function buildPRAttributionSubsystem(daemon, options) {
     log: prPollerLog
   });
   daemonPrPolling.start();
+  const prColdDiscovery = createPrColdDiscoveryService({
+    taskStateStore: daemon.taskStateStore,
+    subscriptions: prPoller,
+    getPrState,
+    getRateLimitState: getGithubReadBackoffState,
+    log: prPollerLog
+  });
+  prColdDiscovery.start();
   const unsubscribeCwdChanged = daemon.taskManager.addOnCwdChanged((taskId, newCwd) => {
     void prPoller.updateCwd(taskId, newCwd);
   });
@@ -38575,6 +38872,7 @@ function buildPRAttributionSubsystem(daemon, options) {
     seedReadyPromise,
     dispose: () => {
       daemonPrPolling?.dispose();
+      prColdDiscovery.dispose();
       unsubscribeCwdChanged();
       prPoller.dispose();
     }
@@ -39897,6 +40195,11 @@ var EXTENSION_KIND = {
   ".jpeg": "screenshot",
   ".gif": "screenshot",
   ".webp": "screenshot",
+  /**
+   * #5231 — asset download already maps .svg → image/svg+xml; registration must
+   * match so the viewer takes the visual path instead of monospace `other`.
+   */
+  ".svg": "screenshot",
   ".mp4": "video",
   ".webm": "video",
   ".mov": "video",
@@ -51381,7 +51684,7 @@ import { extname as extname3 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 
 // src/services/lsp/language-server-registry.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import { dirname as dirname22, isAbsolute as isAbsolute4, join as join53 } from "path";
 function decideTypescriptServer(d) {
@@ -51507,7 +51810,7 @@ function createRegistryDeps(requireFrom) {
     resolveBin: (pkg, binName) => resolveBinViaPackageJson(pkg, binName, req),
     resolveTsgoBinary: () => resolveTsgoBinaryPath(req),
     nodeExecPath: resolveNodeExecPath(),
-    fileExists: (path5) => existsSync7(path5),
+    fileExists: (path5) => existsSync8(path5),
     readJsonFile: (path5) => {
       try {
         return parse2(readFileSync8(path5, "utf-8"));
@@ -51531,7 +51834,7 @@ function resolveTsgoBinaryPath(req) {
   }
   const exeDir = join53(dirname22(pkgJsonPath), "lib");
   const exe = process.platform === "win32" ? join53(exeDir, "tsgo.exe") : join53(exeDir, "tsgo");
-  if (!existsSync7(exe)) {
+  if (!existsSync8(exe)) {
     throw new Error(`tsgo native binary not found: ${exe}`);
   }
   return exe;
@@ -70010,7 +70313,7 @@ function applyCursorUsage(result, usage, ctx) {
   };
   const catalog = CURSOR_MODEL_CATALOG.find((m2) => m2.id === ctx.modelId);
   if (catalog !== void 0) {
-    const fastPricing = ctx.fastMode && ctx.fastModeParam !== null ? catalog.fastModePricing : void 0;
+    const fastPricing = shouldUseCursorFastModePricing(ctx.fastMode, ctx.fastModeParam) ? catalog.fastModePricing : void 0;
     const costIn = fastPricing?.costInputUsd ?? catalog.costInputUsd;
     const costOut = fastPricing?.costOutputUsd ?? catalog.costOutputUsd;
     if (costIn !== void 0 && costOut !== void 0) {
@@ -70314,18 +70617,16 @@ var CursorAgentSubprocess = class {
   #injectedAgentId = null;
   /**
    * Live Fast Mode flag. Mirrored in the runner via `init` (initial value)
-   * and `set_fast_mode` IPC (subsequent toggles). `pushMessage` does not
-   * read this directly — it's the runner that wraps `agent.send()` with
-   * `SendOptions.model.params` when both `#fastMode === true` AND
-   * `#fastModeParam !== null`.
+   * and `set_fast_mode` IPC (subsequent toggles). The runner attaches
+   * `SendOptions.model.params` with value `"true"`/`"false"` whenever
+   * `#fastModeParam` is non-null; `#fastMode` selects which value.
    */
   #fastMode = false;
   /**
-   * Resolved Fast Mode binding for this task's `modelId`. Frozen at spawn
-   * time — the daemon never re-discovers per-task because Cursor model
-   * Fast-Mode bindings are stable for the lifetime of a session. A future
-   * `setModel` call could in principle invalidate this; today the runner
-   * just keeps using the binding it was given.
+   * Resolved Fast Mode ON-binding for this task's `modelId`. Frozen at
+   * spawn time — the daemon never re-discovers per-task because Cursor
+   * Fast Mode bindings are stable for the lifetime of a session. Null
+   * means the model exposes no Fast Mode knob (omit `model.params`).
    */
   #fastModeParam = null;
   /**
@@ -71440,12 +71741,7 @@ var CursorAgentSubprocess = class {
       status: normalizeCursorMcpStatus(s2.status)
     }));
     if (this.#mcpStatus.length === 0) {
-      const fallback = [HARNESS_SERVER_NAME, ...this.#mcpServerSet].map(
-        (name) => ({
-          name,
-          status: "connected"
-        })
-      );
+      const fallback = [{ name: HARNESS_SERVER_NAME, status: "connected" }];
       this.#mcpStatus = fallback;
       logger.info({
         event: "cursor_subprocess_mcp_status_seeded_from_spawn",
@@ -71759,49 +72055,41 @@ function createCursorMeCache(deps) {
 import { createHash as createHash8 } from "crypto";
 
 // src/services/session/profiles/cursor-fast-mode-resolver.ts
-var FAST_MODE_ID_PREFIXES = ["fast", "speed", "tier", "pricing"];
-var FAST_MODE_VALUE_PREFERENCE = ["fast", "priority", "high"];
-function idHasFastModePrefix(rawId) {
-  const lower = rawId.toLowerCase();
-  for (const prefix of FAST_MODE_ID_PREFIXES) {
-    if (lower.startsWith(prefix)) return true;
-  }
-  return false;
-}
-function pickFastModeValue(values) {
-  const lowerToOriginal = /* @__PURE__ */ new Map();
+function findTrueFalseValues(values) {
+  let trueValue;
+  let falseValue;
   for (const entry of values) {
-    lowerToOriginal.set(entry.value.toLowerCase(), entry.value);
-  }
-  for (const preferred of FAST_MODE_VALUE_PREFERENCE) {
-    const match = lowerToOriginal.get(preferred);
-    if (match !== void 0) return match;
+    const lower = entry.value.toLowerCase();
+    if (lower === "true") trueValue = entry.value;
+    if (lower === "false") falseValue = entry.value;
   }
-  return null;
+  if (trueValue === void 0 || falseValue === void 0) return null;
+  return { trueValue, falseValue };
 }
 function resolveCursorFastModeParam(model) {
   const warnings = [];
   const parameters = model.parameters ?? [];
-  const matching = parameters.filter(
-    (param) => idHasFastModePrefix(param.id) && pickFastModeValue(param.values) !== null
-  );
-  if (matching.length === 0) {
+  const fastParams = parameters.filter((param) => param.id.toLowerCase() === "fast");
+  if (fastParams.length === 0) {
     return { param: null, warnings };
   }
-  if (matching.length > 1) {
+  if (fastParams.length > 1) {
     warnings.push(
-      `cursor model ${model.id} exposes ${matching.length} fast-mode-shaped parameters; picking first (${matching[0]?.id ?? "unknown"})`
+      `cursor model ${model.id} exposes ${fastParams.length} parameters named "fast"; picking first`
     );
   }
-  const chosen = matching[0];
+  const chosen = fastParams[0];
   if (chosen === void 0) {
     return { param: null, warnings };
   }
-  const value = pickFastModeValue(chosen.values);
-  if (value === null) {
+  const pair = findTrueFalseValues(chosen.values);
+  if (pair === null) {
+    warnings.push(
+      `cursor model ${model.id} has parameter id="fast" but values are not {true,false}; refusing to bind (values=[${chosen.values.map((v2) => v2.value).join(",")}])`
+    );
     return { param: null, warnings };
   }
-  return { param: { id: chosen.id, value }, warnings };
+  return { param: { id: chosen.id, value: pair.trueValue }, warnings };
 }
 
 // src/services/session/profiles/cursor-models-cache.ts
@@ -71860,6 +72148,7 @@ function createCursorModelsCache(deps) {
   function recordModel(model) {
     const { param, warnings } = resolveCursorFastModeParam(model);
     cache2.set(model.id, { fastModeParam: param });
+    const catalogClaimsFast = CURSOR_MODEL_CATALOG.find((entry) => entry.id === model.id)?.supportsFastMode === true;
     if (param !== null) {
       deps.log("info", {
         event: "cursor_fast_mode_resolved",
@@ -71869,7 +72158,16 @@ function createCursorModelsCache(deps) {
       });
     } else {
       const reason = (model.parameters?.length ?? 0) === 0 ? "no_parameters" : "no_matching_param";
-      deps.log("info", { event: "cursor_fast_mode_unresolved", modelId: model.id, reason });
+      if (catalogClaimsFast) {
+        deps.log("warn", {
+          event: "cursor_fast_mode_catalog_drift",
+          modelId: model.id,
+          reason,
+          catalogSupportsFastMode: true
+        });
+      } else {
+        deps.log("info", { event: "cursor_fast_mode_unresolved", modelId: model.id, reason });
+      }
     }
     for (const warning of warnings) {
       deps.log("warn", {
@@ -71925,10 +72223,40 @@ function createCursorModelsCache(deps) {
     lastKeyHash = keyHash;
     lastRefreshAt = now();
     ready = true;
+    deps.onRefreshComplete?.();
   }
   return { getFastModeParam, isReady, refresh };
 }
 
+// src/services/session/profiles/cursor-models-cache-wiring.ts
+function createWiredCursorModelsCache(deps) {
+  let modelsApplier = null;
+  const cache2 = createCursorModelsCache({
+    listModels: deps.listModels,
+    log: deps.log,
+    onRefreshComplete: () => {
+      const current = deps.getCurrentModels();
+      if (current === void 0 || modelsApplier === null) return;
+      if (!cache2.isReady()) return;
+      const next = reconcileCursorSupportsFastMode(current, {
+        isReady: () => true,
+        supportsFastMode: (modelId) => cache2.getFastModeParam(modelId) !== null
+      });
+      void modelsApplier(next);
+    }
+  });
+  setCursorFastModeSupportLookup({
+    isReady: () => cache2.isReady(),
+    supportsFastMode: (modelId) => cache2.getFastModeParam(modelId) !== null
+  });
+  return {
+    cache: cache2,
+    setModelsApplier: (apply) => {
+      modelsApplier = apply;
+    }
+  };
+}
+
 // src/services/session/profiles/cursor-vault-key-cache.ts
 function createCursorVaultKeyCache() {
   let current = null;
@@ -74335,6 +74663,12 @@ function logPerf(entry) {
   }
 }
 var DEFAULT_READ_CACHE_BUDGET_BYTES = 384 * 1024 * 1024;
+var READ_CACHE_HEAP_FRACTION = 0.05;
+var READ_CACHE_BUDGET_CAP_BYTES = 2048 * 1024 * 1024;
+function computeReadCacheBudgetBytes(heapSizeLimitBytes) {
+  const scaled = Math.round(heapSizeLimitBytes * READ_CACHE_HEAP_FRACTION);
+  return Math.min(READ_CACHE_BUDGET_CAP_BYTES, Math.max(DEFAULT_READ_CACHE_BUDGET_BYTES, scaled));
+}
 function buildJsonlConversationStore(dataDir, opts = {}) {
   const channelsDir = join67(dataDir, "channels");
   const seqCounters = /* @__PURE__ */ new Map();
@@ -75982,7 +76316,7 @@ var LoroDocSweeper = class {
 };
 
 // src/services/task/manager/task-manager.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { homedir as homedir13 } from "os";
 import { dirname as dirname37 } from "path";
 
@@ -78488,6 +78822,13 @@ function handleSpawning(snapshot, event) {
   }
   return noop(snapshot);
 }
+function buildStallGiveUpMessage(recoveryAttempts) {
+  if (recoveryAttempts <= 0) {
+    return "The agent stopped responding mid-run. Send a message to try again.";
+  }
+  const plural = recoveryAttempts === 1 ? "time" : "times";
+  return `The agent stopped responding mid-run. Automatic recovery already retried ${recoveryAttempts} ${plural} without success \u2014 send a message to resume.`;
+}
 function runningStallTimeout(sessionId, event) {
   const b2 = createEffectBuilder();
   b2.log("running", "resumable_idle", event.type);
@@ -78495,11 +78836,7 @@ function runningStallTimeout(sessionId, event) {
   b2.effects.push({ type: "clear_queue" });
   if (!event.recoveryArmed) {
     b2.taskStatus("input_required");
-    b2.emitError(
-      "The agent stopped responding mid-run. Send a message to try again.",
-      "sdk_error",
-      "run_stall_timeout"
-    );
+    b2.emitError(buildStallGiveUpMessage(event.recoveryAttempts), "sdk_error", "run_stall_timeout");
   }
   b2.effects.push({ type: "kill_runner" });
   return {
@@ -79320,10 +79657,13 @@ var AgentSessionManager = class {
         return;
       }
       let recoveryArmed = false;
+      let recoveryAttempts = 0;
       try {
-        recoveryArmed = this.#config.onStallTimeout?.() ?? false;
+        const outcome = this.#config.onStallTimeout?.() ?? { armed: false, recoveryAttempts: 0 };
+        recoveryArmed = outcome.armed;
+        recoveryAttempts = outcome.recoveryAttempts;
       } finally {
-        this.#dispatch({ type: "run_stall_timeout", recoveryArmed });
+        this.#dispatch({ type: "run_stall_timeout", recoveryArmed, recoveryAttempts });
       }
     }, timeoutMs);
   }
@@ -79351,48 +79691,98 @@ var AgentSessionManager = class {
 
 // src/services/conversation/cursor-recovery-controller.ts
 var MAX_SIGNAL_DEATH_RETRIES = 1;
-var MAX_STALL_RESUME_RETRIES = 1;
+var MAX_STALL_RESUME_RETRIES = 3;
+var STALL_RESUME_BASE_DELAY_MS = 3e3;
+var STALL_RESUME_BACKOFF_MULTIPLIER = 3;
+function stallResumeDelayMs(attempt) {
+  return STALL_RESUME_BASE_DELAY_MS * STALL_RESUME_BACKOFF_MULTIPLIER ** (attempt - 1);
+}
 var MAX_CRASH_DEATH_RETRIES = 1;
 var CursorRecoveryController = class {
   #signalDeathRetries = 0;
   #stallResumeRetries = 0;
   #stallResumeArmed = false;
   #crashDeathRetries = 0;
+  /**
+   * Pending timer for the settle-delay before an armed stall resume fires.
+   * Cleared at every call site that supersedes the in-flight resume (new
+   * user turn, stop, rewind, dispose) plus its own callback on fire — the
+   * same shape as `RateLimitFlapController#timer`. A single handle suffices;
+   * `consumeStallResumeOnDeath` cannot run twice without an intervening
+   * `onStallTimeout` re-arming it.
+   */
+  #stallResumeTimer = null;
   #deps;
   constructor(deps) {
     this.#deps = deps;
   }
+  /**
+   * Cancel a pending delayed stall resume. Idempotent. Call from any path
+   * that supersedes the armed resume (new user turn, stop, rewind, dispose)
+   * — without this, a fresh intent would race the deferred
+   * `respawnForResume()` fired by the settle-delay timer.
+   */
+  cancelPendingResume() {
+    if (this.#stallResumeTimer !== null) {
+      clearTimeout(this.#stallResumeTimer);
+      this.#stallResumeTimer = null;
+    }
+  }
   /** Reset every budget. Call on each new user turn and on turn_complete. */
   reset() {
+    this.cancelPendingResume();
     this.#signalDeathRetries = 0;
     this.#stallResumeRetries = 0;
     this.#stallResumeArmed = false;
     this.#crashDeathRetries = 0;
   }
+  /**
+   * Call on `turn_complete` instead of `reset()`. A successful auto-recovery
+   * otherwise leaves no trace that the daemon self-healed rather than the
+   * run simply never stalling — log the recovery before clearing the budget.
+   */
+  noteTurnCompleteRecovery() {
+    if (this.#stallResumeRetries > 0) {
+      this.#deps.log({
+        event: "thread_cursor_stall_auto_resume_recovered",
+        threadId: this.#deps.threadId,
+        attempts: this.#stallResumeRetries
+      });
+    }
+    this.reset();
+  }
   /**
    * Fired by the manager when the stall watchdog expires, BEFORE the
    * `run_stall_timeout` event transitions the FSM. A mid-run Cursor stall
    * otherwise lands in `resumable_idle` with a "send a message to try again"
-   * banner and strands the orphaned turn until the user returns. Arm a one-shot
-   * resume so the imminent `kill_runner` death is resumed instead of surfaced.
-   * On repeat (cap exceeded) stay armed-off and let the existing banner run.
+   * banner and strands the orphaned turn until the user returns. Arm a
+   * resume so the imminent `kill_runner` death is resumed instead of
+   * surfaced. On repeat, up to `MAX_STALL_RESUME_RETRIES` times, stay
+   * armed-off and let the existing banner run.
    *
-   * Returns true when a recovery was armed — the manager passes this as
-   * `recoveryArmed` on the `run_stall_timeout` FSM event so the FSM suppresses
-   * the user-facing error banner during the 5-second self-heal (Fix B2).
+   * Returns `armed: true` when a recovery was armed — the manager passes
+   * this as `recoveryArmed` on the `run_stall_timeout` FSM event so the FSM
+   * suppresses the user-facing error banner during the self-heal.
+   * `recoveryAttempts` is only ever positive on the cap-exceeded give-up
+   * (see `StallTimeoutOutcome`), letting the FSM distinguish "never
+   * attempted" from "tried N times".
    */
   onStallTimeout() {
-    if (this.#deps.getState() !== "running") return false;
-    if (this.#deps.getAgentSystem() !== AGENT_SYSTEM_CURSOR) return false;
+    if (this.#deps.getState() !== "running") return { armed: false, recoveryAttempts: 0 };
+    if (this.#deps.getAgentSystem() !== AGENT_SYSTEM_CURSOR) {
+      return { armed: false, recoveryAttempts: 0 };
+    }
     this.#stallResumeRetries++;
     if (this.#stallResumeRetries > MAX_STALL_RESUME_RETRIES) {
+      const recoveryAttempts = this.#stallResumeRetries - 1;
       this.#deps.log({
         event: "thread_cursor_stall_resume_cap_exceeded",
         threadId: this.#deps.threadId,
-        retries: this.#stallResumeRetries
+        retries: this.#stallResumeRetries,
+        maxRetries: MAX_STALL_RESUME_RETRIES
       });
       this.#stallResumeRetries = 0;
-      return false;
+      return { armed: false, recoveryAttempts };
     }
     this.#deps.log({
       event: "thread_cursor_stall_resume_armed",
@@ -79400,19 +79790,41 @@ var CursorRecoveryController = class {
       retries: this.#stallResumeRetries
     });
     this.#stallResumeArmed = true;
-    return true;
+    return { armed: true, recoveryAttempts: 0 };
   }
   /**
-   * Consume an armed stall resume on the `kill_runner` death. By now the FSM is
-   * in `resumable_idle` and the subprocess was already cleared by Thread's
-   * force-kill, so this only re-spawns. Race-free: we resume ON the death, so
-   * the hung runner is confirmed gone. Returns true when it handled the death.
+   * Consume an armed stall resume on the `kill_runner` death. By now the FSM
+   * is in `resumable_idle` and the subprocess was already cleared by
+   * Thread's force-kill. Schedule the actual resume after
+   * `stallResumeDelayMs(attempt)` rather than firing immediately — the
+   * settle window that prevents the busy collision (see
+   * `MAX_STALL_RESUME_RETRIES`'s doc comment). Returns true as soon as it
+   * commits to handling the death (the timer is in-flight); the caller must
+   * not also surface it.
    */
   consumeStallResumeOnDeath() {
     if (!this.#stallResumeArmed) return false;
     this.#stallResumeArmed = false;
-    this.#deps.log({ event: "thread_cursor_stall_auto_resume", threadId: this.#deps.threadId });
-    this.#deps.respawnForResume();
+    this.cancelPendingResume();
+    const attempt = this.#stallResumeRetries;
+    const delayMs = stallResumeDelayMs(attempt);
+    this.#deps.log({
+      event: "thread_cursor_stall_auto_resume_scheduled",
+      threadId: this.#deps.threadId,
+      attempt,
+      delayMs
+    });
+    this.#stallResumeTimer = setTimeout(() => {
+      this.#stallResumeTimer = null;
+      if (this.#deps.isDisposed()) return;
+      this.#deps.log({
+        event: "thread_cursor_stall_auto_resume",
+        threadId: this.#deps.threadId,
+        attempt,
+        delayMs
+      });
+      this.#deps.respawnForResume();
+    }, delayMs);
     return true;
   }
   /**
@@ -80523,6 +80935,7 @@ var Thread = class {
       threadId: config.threadId,
       getState: () => this.#manager.state,
       getAgentSystem: () => this.#agentSystem,
+      isDisposed: () => this.#disposed,
       log: config.log,
       clearSubprocess: () => {
         this.#subprocess?.setOnCwdChanged(null);
@@ -80683,8 +81096,16 @@ var Thread = class {
    * Unlike `handleUserMessage`, this does NOT call `#recovery.noteNewUserTurn()`
    * (which resets the request-aborted retry budget) because a synthetic wake is
    * not a real user message.
+   *
+   * DOES cancel a pending flap/stall-resume timer, same reasoning as `stop()`
+   * and `rewind()`: `sendMessage` from `resumable_idle` walks the FSM to
+   * `spawning` on its own, so a still-armed timer firing later would call
+   * `respawnForResume()` against whatever run this wake started — a resume
+   * with nothing to do with the death it was originally scheduled for.
    */
   pushSyntheticMessageAndWake(content) {
+    this.#rateLimitFlap.cancelPendingRetry();
+    this.#cursorRecovery.cancelPendingResume();
     this.#manager.sendMessage(content);
   }
   /**
@@ -80725,6 +81146,7 @@ var Thread = class {
   }
   stop() {
     this.#rateLimitFlap.cancelPendingRetry();
+    this.#cursorRecovery.cancelPendingResume();
     this.#manager.stop();
   }
   /**
@@ -80734,6 +81156,7 @@ var Thread = class {
    */
   rewind(resumeAtMessageId) {
     this.#rateLimitFlap.cancelPendingRetry();
+    this.#cursorRecovery.cancelPendingResume();
     this.#manager.rewind(resumeAtMessageId);
   }
   notifySetupReady() {
@@ -80887,6 +81310,7 @@ var Thread = class {
     await this.#asyncQueue;
     this.#disposed = true;
     this.#rateLimitFlap.cancelPendingRetry();
+    this.#cursorRecovery.cancelPendingResume();
     this.#permissionHandler.denyAllPending("Thread disposed");
     this.#permissionQueue.length = 0;
     this.#streamDelta.dispose();
@@ -81527,7 +81951,7 @@ var Thread = class {
         });
         this.#streamDelta.resetForTurn();
         this.#recovery.resetRetriesOnTurnComplete();
-        this.#cursorRecovery.reset();
+        this.#cursorRecovery.noteTurnCompleteRecovery();
         this.#rateLimitFlap.noteRecoveredOnTurnComplete((event.result.outputTokens ?? 0) > 0);
         this.#emitThreadTurnStats(event.result);
         this.#manager.notifyTurnComplete();
@@ -81691,7 +82115,7 @@ var Thread = class {
 
 // src/services/plan/plan-handler.ts
 import { randomUUID as randomUUID21 } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
 import { mkdir as mkdir33, readFile as readFile45, writeFile as writeFile26 } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname34, join as join73 } from "path";
@@ -81803,7 +82227,7 @@ function decideWatchResolved(trigger, snapshot) {
 
 // src/services/plan/plan-file-bridge.ts
 import { createHash as createHash12, randomUUID as randomUUID20 } from "crypto";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { readFile as readFile44, rename as rename18, writeFile as writeFile25 } from "fs/promises";
 import { basename as basename13, dirname as dirname33 } from "path";
 var FILE_READ_MAX_RETRIES = 3;
@@ -81998,7 +82422,7 @@ var PlanFileBridge = class _PlanFileBridge {
    */
   async #startDirectoryWatcher(filePath) {
     const dir = dirname33(filePath);
-    if (!existsSync8(dir)) return;
+    if (!existsSync9(dir)) return;
     const targetFilename = basename13(filePath);
     let sub;
     try {
@@ -82231,7 +82655,7 @@ var PlanFileBridge = class _PlanFileBridge {
   }
   async #doWriteBackToFile() {
     if (this.#disposed || !this.#filePath) return;
-    if (!existsSync8(this.#filePath)) return;
+    if (!existsSync9(this.#filePath)) return;
     const content = this.#config.planRepo.getContent(this.#config.taskId);
     const hash = contentHash(content);
     if (hash === this.#lastWrittenHash) return;
@@ -82462,7 +82886,7 @@ function greedyLCS(a, b2) {
 }
 
 // src/services/plan/plan-file-watcher.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join72 } from "path";
 var DEFAULT_PLANS_DIR = join72(homedir9(), ".claude", "plans");
@@ -82525,7 +82949,7 @@ function createPlanFileWatcher(deps) {
     deps.onTimeout();
   }, PLAN_WATCH_TIMEOUT_MS);
   const plansDir = deps.plansDir ?? DEFAULT_PLANS_DIR;
-  if (!existsSync9(plansDir)) {
+  if (!existsSync10(plansDir)) {
     deps.log({
       event: "plan_watch_skip_missing_dir",
       taskId: deps.taskId,
@@ -82988,7 +83412,7 @@ var PlanHandler = class {
   }
   async #rehydratePlanFileBridge(filePath, toolUseId) {
     if (this.#deps.isDisposed()) return;
-    if (!existsSync10(filePath)) {
+    if (!existsSync11(filePath)) {
       this.#deps.log({
         event: "plan_bridge_rehydrate_file_missing",
         taskId: this.#deps.taskId,
@@ -83687,7 +84111,7 @@ var PlanHandler = class {
       return newest?.path ?? null;
     }
     const plansDir = join73(homedir10(), ".claude", "plans");
-    if (!existsSync10(plansDir)) return null;
+    if (!existsSync11(plansDir)) return null;
     try {
       const files = readdirSync5(plansDir).filter((f2) => f2.endsWith(".md")).map((f2) => ({
         path: join73(plansDir, f2),
@@ -89478,7 +89902,7 @@ async function resolveTaskListPrepend(ctx) {
 }
 
 // src/services/task/cc-task-file-store.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { readdir as readdir21, readFile as readFile47 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 import { basename as basename14, dirname as dirname36, join as join75 } from "path";
@@ -89607,7 +90031,7 @@ function createCCTaskFileWatcher(listId, log) {
     }
   }
   async function startDirWatcher(reason = "initial") {
-    if (!existsSync11(dir)) return false;
+    if (!existsSync12(dir)) return false;
     try {
       const sub = await guardedSubscribe(dir, onDirEvent, { ignore: ["**/*/"] }, "lazy", reason);
       if (watchState.stopped) {
@@ -94249,12 +94673,22 @@ function pushTaskMcpStateSnapshot(ctx, taskId) {
   for (const s2 of ctx.sessionMcpsByTask.get(taskId) ?? []) {
     sessionServers[s2.name] = { status: normalizeMcpStatus(s2.status) };
   }
+  const liveStatuses = liveStatusesFromStatusEntries(ctx.getMcpCoordinator()?.getStatuses() ?? []);
+  for (const divergence of collectMcpSessionCoordinatorDivergences(sessionServers, liveStatuses)) {
+    logger.info({
+      event: "mcp_session_coordinator_status_divergence",
+      taskId,
+      serverName: divergence.name,
+      sessionStatus: divergence.sessionStatus,
+      coordinatorStatus: divergence.coordinatorStatus
+    });
+  }
   const message = {
     type: "mcp_state_snapshot",
     taskId,
     servers: resolveMcpStateSnapshot({
       workspaceServers: workspaceServersFromCapabilities(ctx.getCapabilities()),
-      liveStatuses: liveStatusesFromStatusEntries(ctx.getMcpCoordinator()?.getStatuses() ?? []),
+      liveStatuses,
       sessionServers,
       perTaskDisabled: settings.disabledMcpServers ?? null,
       perTaskSnapshot: settings.mcpServerSnapshot ?? null
@@ -96547,16 +96981,6 @@ var TaskManager = class {
   getOrchestrator(taskId) {
     return this.#tasks.get(taskId)?.orchestrator ?? null;
   }
-  /**
-   * True if the task has an orchestrator with a live or resumable session.
-   * cold_idle orchestrators are NOT considered running — the SDK session is
-   * expired and the task needs user input to restart.
-   */
-  isRunning(taskId) {
-    const task = this.#tasks.get(taskId);
-    if (!task) return false;
-    return task.orchestrator.state !== "cold_idle";
-  }
   get size() {
     return this.#tasks.size;
   }
@@ -96951,7 +97375,7 @@ var TaskManager = class {
 function pathExistsForLog2(path5) {
   if (!path5) return false;
   try {
-    return existsSync12(path5);
+    return existsSync13(path5);
   } catch {
     return false;
   }
@@ -97594,7 +98018,9 @@ async function createDaemon(deps) {
   const compactor = startLoroCompactor(storageAdapter);
   const taskStateStore = buildTaskStateStore(deps.dataDir);
   const planRepo = new PlanRepository(repo, PLAN_EPOCH, createPlanContentBridge(), storageAdapter);
-  const jsonlStore = buildJsonlConversationStore(deps.dataDir);
+  const jsonlStore = buildJsonlConversationStore(deps.dataDir, {
+    readCacheBudgetBytes: computeReadCacheBudgetBytes(getHeapStatistics().heap_size_limit)
+  });
   const store = buildObservableConversationStore(jsonlStore);
   const sessionPersistence = buildSessionPersistence(deps.dataDir);
   const collabQueuePersistence = buildCollabQueuePersistence(deps.dataDir);
@@ -97654,14 +98080,15 @@ async function createDaemon(deps) {
   const CURSOR_VAULT_WRITE_TIMEOUT_MS = 5e3;
   const cursorStoredByRef = { current: "" };
   const cursorVaultKeyCache = createCursorVaultKeyCache();
-  const cursorModelsCache = createCursorModelsCache({
+  const { cache: cursorModelsCache, setModelsApplier: setCursorFastModeModelsApplierFn } = createWiredCursorModelsCache({
     listModels: async (options) => {
       const { Cursor } = await import("@cursor/sdk");
       return Cursor.models.list(options);
     },
     log: (level, entry) => {
       logger[level](entry);
-    }
+    },
+    getCurrentModels: () => capabilitiesRef.current?.models
   });
   cursorVaultKeyCache.subscribe((key) => {
     void cursorModelsCache.refresh(key);
@@ -99792,6 +100219,7 @@ async function createDaemon(deps) {
     clearCursorVaultCache: () => {
       cursorVaultKeyCache.set(null);
     },
+    setCursorFastModeModelsApplier: setCursorFastModeModelsApplierFn,
     notifyCodexAccountId: (accountId) => {
       codexEngineRef.current?.notifyAccountId(accountId);
     },
@@ -99921,7 +100349,7 @@ async function createDaemon(deps) {
 }
 
 // src/services/serve-helpers.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 
 // src/services/bootstrap/self-update.ts
 import { execFile as execFile11, spawn as spawn13 } from "child_process";
@@ -100589,7 +101017,7 @@ function resolveClaudeCodePath(log) {
     log({ event: "claude_code_path_resolved", source: "sdk_default" });
     return void 0;
   }
-  if (!existsSync13(envPath)) {
+  if (!existsSync14(envPath)) {
     log({ event: "claude_code_path_skipped", source: "env", path: envPath, reason: "missing" });
     log({ event: "claude_code_path_resolved", source: "sdk_default" });
     return void 0;
@@ -101978,24 +102406,6 @@ function buildPluginConfigStore(pluginsDir) {
   };
 }
 
-// src/services/task/session-activity.ts
-function isActiveUserWork(state) {
-  switch (state) {
-    case "spawning":
-    case "running":
-    case "stopping":
-      return true;
-    case "warm_idle":
-    case "resumable_idle":
-    case "cold_idle":
-      return false;
-    default: {
-      const _exhaustive = state;
-      throw new Error(`Unhandled session state: ${JSON.stringify(_exhaustive)}`);
-    }
-  }
-}
-
 // src/services/task/electron-idle-rpc.ts
 function registerElectronIdleRpc(taskManager, parentPort2) {
   parentPort2.on("message", (event) => {
@@ -102613,6 +103023,9 @@ async function runServeBody(options, captureRefs) {
     log: logAdapter
   });
   codexSkillsApplyScopedPatchRef = applyScopedPatch;
+  daemon.setCursorFastModeModelsApplier(async (models) => {
+    await applyScopedPatch({ models });
+  });
   void (async () => {
     try {
       const seed = await loadCodexSkillsCache(codexSkillsCachePath);
@@ -103067,4 +103480,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-J3MG3WHK.js.map
+//# sourceMappingURL=serve-RWFBSQIE.js.map