@schoolai/shipyard 3.24.0 → 3.25.0

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

@@ -12,7 +12,7 @@ import {
   guardedSubscribe,
   makeInitialAttemptState,
   shutdownFileWatcherGuard
-} from "./chunk-JZTUQVHQ.js";
+} from "./chunk-IRS6HYMU.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -39,13 +39,13 @@ import {
   startPlanBackfillForDaemon,
   sync,
   validatePeerId
-} from "./chunk-UK3IMOSP.js";
+} from "./chunk-VQCBF7X5.js";
 import {
   loadAuthToken
 } from "./chunk-2UE3TNY7.js";
 import {
   getDaemonVersion
-} from "./chunk-DDC5OQOC.js";
+} from "./chunk-XNH6FVIX.js";
 import {
   collectPriorCrashDetail,
   getRecentWasmPanicMessages
@@ -178,7 +178,7 @@ import {
   unresolveReviewThread,
   withLabelAsync,
   writeCursorApiKeyToVault
-} from "./chunk-BN54GQR3.js";
+} from "./chunk-YTYPMVS4.js";
 import {
   buildNodeSpawnEnv,
   nodeSpawnEnvOverlay,
@@ -233,15 +233,16 @@ import {
   createOneShotPool
 } from "./chunk-ZFKJAYAN.js";
 import {
+  buildCursorMcpConfigFromSet,
   parseRunnerToDaemon,
   shouldUseCursorFastModePricing
-} from "./chunk-NG355H2L.js";
+} from "./chunk-BBKZIEKF.js";
 import {
   XML_TAGS,
   createAssetResolver,
   toSdkContent,
   toSdkPermissionMode
-} from "./chunk-TU3MSY2I.js";
+} from "./chunk-X4IWMBWY.js";
 import {
   AGENT_IDS,
   AGENT_SYSTEM_CLAUDE_CODE,
@@ -446,7 +447,7 @@ import {
   unsafeAssertSourceId,
   vizFileExtension,
   withPreferredRuntimeAuthMethod
-} from "./chunk-BGJ6QJNS.js";
+} from "./chunk-FC3HWVYQ.js";
 import {
   AuthGitHubCallbackRequestSchema,
   AuthGitHubCallbackResponseSchema,
@@ -6021,7 +6022,7 @@ function nanoid(size = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.24.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.25.0" : "unknown";
 function createDaemonSignaling(config) {
   const agentId = config.agentId ?? nanoid();
   function send(msg) {
@@ -33770,8 +33771,8 @@ function getCursorHookShimPath() {
 function verifyCursorHookShimPresent(path5) {
   const resolved = path5 ?? getCursorHookShimPath();
   try {
-    const stat19 = statSync4(resolved);
-    if (!stat19.isFile()) return null;
+    const stat20 = statSync4(resolved);
+    if (!stat20.isFile()) return null;
     return { path: resolved };
   } catch {
     return null;
@@ -34362,7 +34363,8 @@ function parseQueueKey(queueKey) {
 // src/services/task/manager/task-manager-composer-settings.ts
 var DEPRECATED_COMPOSER_MODEL_FALLBACKS = {
   "gpt-5.3-codex": "gpt-5.6-sol",
-  "gpt-5.5": "gpt-5.6-sol"
+  "gpt-5.5": "gpt-5.6-sol",
+  "grok-4.5": "grok-4.6"
 };
 function normalizeComposerModel(model) {
   return DEPRECATED_COMPOSER_MODEL_FALLBACKS[model] ?? model;
@@ -52554,61 +52556,6 @@ function decideBridgeMaterialization(input) {
   }
 }
 
-// src/services/mcp/cursor-mcp-config.ts
-function isRecord8(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function copyNonEmptyRecord(target, key, value) {
-  if (isRecord8(value) && Object.keys(value).length > 0) target[key] = value;
-}
-function buildCursorStdioEntry(value) {
-  if (typeof value.command !== "string" || value.command.length === 0) return null;
-  const entry = { type: "stdio", command: value.command };
-  if (Array.isArray(value.args) && value.args.length > 0) entry.args = value.args;
-  copyNonEmptyRecord(entry, "env", value.env);
-  if (typeof value.cwd === "string" && value.cwd.length > 0) entry.cwd = value.cwd;
-  return entry;
-}
-function buildCursorHttpEntry(value) {
-  if (typeof value.url !== "string" || value.url.length === 0) return null;
-  const transport = value.type === "sse" ? "sse" : value.type === "http" ? "http" : "http";
-  const entry = { type: transport, url: value.url };
-  const headers = value.headers ?? value.http_headers;
-  copyNonEmptyRecord(entry, "headers", headers);
-  return entry;
-}
-function getUnsupportedCursorMcpReason(value) {
-  if (value.type === "sdk" || "instance" in value) return "unsupported_sdk_instance";
-  return null;
-}
-function buildCursorMcpEntry(value) {
-  if (!isRecord8(value)) return { kind: "skip", reason: "not_object" };
-  const unsupportedReason = getUnsupportedCursorMcpReason(value);
-  if (unsupportedReason) return { kind: "skip", reason: unsupportedReason };
-  if (typeof value.command === "string") {
-    const stdio = buildCursorStdioEntry(value);
-    return stdio ? { kind: "ok", config: stdio } : { kind: "skip", reason: "missing_command" };
-  }
-  if (typeof value.url === "string") {
-    const http2 = buildCursorHttpEntry(value);
-    return http2 ? { kind: "ok", config: http2 } : { kind: "skip", reason: "missing_url" };
-  }
-  return { kind: "skip", reason: "missing_command_or_url" };
-}
-function buildCursorMcpConfigFromSet(servers) {
-  const result = {};
-  const skipped = [];
-  for (const [name, config] of Object.entries(servers)) {
-    const entry = buildCursorMcpEntry(config);
-    if (entry.kind === "ok") {
-      result[name] = entry.config;
-    } else {
-      skipped.push({ name, reason: entry.reason });
-    }
-  }
-  return { servers: result, skipped };
-}
-
 // src/services/mcp/oauth/auth-status.ts
 var UNSUPPORTED_DCR_PATTERNS = [
   /incompatible auth server/i,
@@ -55232,8 +55179,7 @@ function findAvailablePort() {
 }
 
 // src/shared/mcp/proxy-server.ts
-import { randomUUID as randomUUID13, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { createServer as createServer3 } from "http";
+import { randomUUID as randomUUID13 } from "crypto";
 import { auth as auth2, UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -55249,6 +55195,10 @@ function classifyConnectFailureLevel(errorKind) {
   return errorKind === "auth" ? "info" : "error";
 }
 
+// src/shared/mcp/proxy-loopback-listener.ts
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createServer as createServer3 } from "http";
+
 // src/shared/mcp/json-rpc-http-error.ts
 var JSON_CONTENT_TYPE = "application/json";
 var DEFAULT_MAX_ID_BODY_BYTES = 1024 * 1024;
@@ -55376,6 +55326,117 @@ function caseInsensitiveDelete(obj, key) {
   }
 }
 
+// src/shared/mcp/proxy-loopback-listener.ts
+async function startLoopbackHttpServer(opts) {
+  const httpServer = createServer3((req, res) => {
+    void handleProxyHttpRequest({
+      req,
+      res,
+      bearerToken: opts.bearerToken,
+      transport: opts.transport,
+      log: opts.log,
+      serverName: opts.serverName
+    }).catch((err3) => {
+      const message = err3 instanceof Error ? err3.message : String(err3);
+      opts.log({
+        event: "mcp_proxy_local_http_request_error",
+        serverName: opts.serverName,
+        error: message
+      });
+      if (!res.headersSent) {
+        sendJsonRpcHttpError(
+          res,
+          500,
+          MCP_PROXY_JSON_RPC_INTERNAL,
+          "internal_error",
+          FALLBACK_REQUEST_ID
+        );
+      }
+    });
+  });
+  await new Promise((resolve12, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => {
+      httpServer.off("error", reject);
+      resolve12();
+    });
+  });
+  const addr = httpServer.address();
+  if (addr === null || typeof addr === "string") {
+    httpServer.close();
+    throw new Error("Failed to bind MCP proxy HTTP server: missing AddressInfo");
+  }
+  return { httpServer, host: addr.address, port: addr.port };
+}
+async function handleProxyHttpRequest(opts) {
+  installResponseIdSanitizer(opts.res, FALLBACK_REQUEST_ID);
+  const url = opts.req.url ?? "/";
+  if (url !== "/mcp") {
+    opts.log({
+      event: "mcp_proxy_local_http_rejected",
+      serverName: opts.serverName,
+      reason: "not_found",
+      status: 404,
+      method: opts.req.method ?? "unknown",
+      path: url
+    });
+    await respondProxyError(opts.req, opts.res, 404, MCP_PROXY_JSON_RPC_NOT_FOUND, "not_found");
+    return;
+  }
+  const authHeader = opts.req.headers.authorization;
+  if (!authHeader?.toLowerCase().startsWith("bearer ")) {
+    opts.log({
+      event: "mcp_proxy_local_http_rejected",
+      serverName: opts.serverName,
+      reason: authHeader === void 0 ? "bearer_absent" : "bearer_malformed",
+      status: 401,
+      method: opts.req.method ?? "unknown"
+    });
+    await respondProxyError(
+      opts.req,
+      opts.res,
+      401,
+      MCP_PROXY_JSON_RPC_UNAUTHORIZED,
+      "unauthorized"
+    );
+    return;
+  }
+  const provided = authHeader.slice("bearer ".length).trim();
+  if (!timingSafeStringEquals(provided, opts.bearerToken)) {
+    opts.log({
+      event: "mcp_proxy_local_http_rejected",
+      serverName: opts.serverName,
+      reason: "bearer_mismatch",
+      status: 401,
+      method: opts.req.method ?? "unknown",
+      providedLength: provided.length,
+      expectedLength: opts.bearerToken.length,
+      sameShape: provided.length === opts.bearerToken.length
+    });
+    await respondProxyError(
+      opts.req,
+      opts.res,
+      401,
+      MCP_PROXY_JSON_RPC_UNAUTHORIZED,
+      "unauthorized"
+    );
+    return;
+  }
+  await opts.transport.handleRequest(opts.req, opts.res);
+}
+var MCP_PROXY_JSON_RPC_INTERNAL = -32603;
+var MCP_PROXY_JSON_RPC_UNAUTHORIZED = -32001;
+var MCP_PROXY_JSON_RPC_NOT_FOUND = -32004;
+async function respondProxyError(req, res, status, code, message) {
+  sendJsonRpcHttpError(res, status, code, message, await readRequestId(req));
+}
+function timingSafeStringEquals(provided, expected) {
+  const expectedBuf = Buffer.from(expected, "utf8");
+  const providedBuf = Buffer.from(provided, "utf8");
+  if (providedBuf.length !== expectedBuf.length) return false;
+  return timingSafeEqual2(providedBuf, expectedBuf);
+}
+
 // src/shared/mcp/proxy-server.ts
 var GATEWAY_BASE_URL = "https://mcp-proxy.anthropic.com/v1/mcp";
 var GATEWAY_BETA_HEADER = "mcp-servers-2025-12-04";
@@ -56291,88 +56352,6 @@ function buildLocalHttpProxyMcpServer(opts) {
   });
   return mcpServer;
 }
-async function startLoopbackHttpServer(opts) {
-  const httpServer = createServer3((req, res) => {
-    void handleProxyHttpRequest({
-      req,
-      res,
-      bearerToken: opts.bearerToken,
-      transport: opts.transport
-    }).catch((err3) => {
-      const message = err3 instanceof Error ? err3.message : String(err3);
-      opts.log({
-        event: "mcp_proxy_local_http_request_error",
-        serverName: opts.serverName,
-        error: message
-      });
-      if (!res.headersSent) {
-        sendJsonRpcHttpError(
-          res,
-          500,
-          MCP_PROXY_JSON_RPC_INTERNAL,
-          "internal_error",
-          FALLBACK_REQUEST_ID
-        );
-      }
-    });
-  });
-  await new Promise((resolve12, reject) => {
-    httpServer.once("error", reject);
-    httpServer.listen(0, "127.0.0.1", () => {
-      httpServer.off("error", reject);
-      resolve12();
-    });
-  });
-  const addr = httpServer.address();
-  if (addr === null || typeof addr === "string") {
-    httpServer.close();
-    throw new Error("Failed to bind MCP proxy HTTP server: missing AddressInfo");
-  }
-  return { httpServer, host: addr.address, port: addr.port };
-}
-async function handleProxyHttpRequest(opts) {
-  installResponseIdSanitizer(opts.res, FALLBACK_REQUEST_ID);
-  const url = opts.req.url ?? "/";
-  if (url !== "/mcp") {
-    await respondProxyError(opts.req, opts.res, 404, MCP_PROXY_JSON_RPC_NOT_FOUND, "not_found");
-    return;
-  }
-  const authHeader = opts.req.headers.authorization;
-  if (!authHeader?.toLowerCase().startsWith("bearer ")) {
-    await respondProxyError(
-      opts.req,
-      opts.res,
-      401,
-      MCP_PROXY_JSON_RPC_UNAUTHORIZED,
-      "unauthorized"
-    );
-    return;
-  }
-  const provided = authHeader.slice("bearer ".length).trim();
-  if (!timingSafeStringEquals(provided, opts.bearerToken)) {
-    await respondProxyError(
-      opts.req,
-      opts.res,
-      401,
-      MCP_PROXY_JSON_RPC_UNAUTHORIZED,
-      "unauthorized"
-    );
-    return;
-  }
-  await opts.transport.handleRequest(opts.req, opts.res);
-}
-var MCP_PROXY_JSON_RPC_INTERNAL = -32603;
-var MCP_PROXY_JSON_RPC_UNAUTHORIZED = -32001;
-var MCP_PROXY_JSON_RPC_NOT_FOUND = -32004;
-async function respondProxyError(req, res, status, code, message) {
-  sendJsonRpcHttpError(res, status, code, message, await readRequestId(req));
-}
-function timingSafeStringEquals(provided, expected) {
-  const expectedBuf = Buffer.from(expected, "utf8");
-  const providedBuf = Buffer.from(provided, "utf8");
-  if (providedBuf.length !== expectedBuf.length) return false;
-  return timingSafeEqual2(providedBuf, expectedBuf);
-}
 async function disposeLocalHttpBinding(binding, log) {
   try {
     await binding.transport.close();
@@ -64932,7 +64911,7 @@ function buildCodexMcpConfigFromSet(servers) {
   return { servers: result, skipped };
 }
 function buildCodexMcpEntry(value) {
-  if (!isRecord9(value)) return { kind: "skip", reason: "not_object" };
+  if (!isRecord8(value)) return { kind: "skip", reason: "not_object" };
   const unsupportedReason = getUnsupportedCodexMcpReason(value);
   if (unsupportedReason) return { kind: "skip", reason: unsupportedReason };
   if (typeof value.command === "string") {
@@ -64951,7 +64930,7 @@ function getUnsupportedCodexMcpReason(value) {
 function buildCodexStdioMcpEntry(value) {
   const entry = { command: value.command };
   if (Array.isArray(value.args) && value.args.length > 0) entry.args = value.args;
-  copyNonEmptyRecord2(entry, "env", value.env);
+  copyNonEmptyRecord(entry, "env", value.env);
   return entry;
 }
 function buildCodexHttpMcpEntry(value) {
@@ -64959,14 +64938,14 @@ function buildCodexHttpMcpEntry(value) {
   if (typeof value.bearer_token_env_var === "string") {
     entry.bearer_token_env_var = value.bearer_token_env_var;
   }
-  copyNonEmptyRecord2(entry, "http_headers", value.http_headers ?? value.headers);
-  copyNonEmptyRecord2(entry, "env_http_headers", value.env_http_headers);
+  copyNonEmptyRecord(entry, "http_headers", value.http_headers ?? value.headers);
+  copyNonEmptyRecord(entry, "env_http_headers", value.env_http_headers);
   return entry;
 }
-function copyNonEmptyRecord2(target, key, value) {
-  if (isRecord9(value) && Object.keys(value).length > 0) target[key] = value;
+function copyNonEmptyRecord(target, key, value) {
+  if (isRecord8(value) && Object.keys(value).length > 0) target[key] = value;
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveCodexSpawnPolicy(opts) {
@@ -67437,7 +67416,7 @@ function buildCodexSpawnArgs(args) {
     stripEnv: args.stripEnv
   };
 }
-function isRecord10(value) {
+function isRecord9(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function partitionAnnotationsByCacheBucket(records) {
@@ -69002,7 +68981,7 @@ function createVizPreviewRegistry(deps) {
   }
   const previewLifecycleSubs = /* @__PURE__ */ new Map();
   function isLocalPreviewElement(dataField, selfUserId) {
-    if (!isRecord10(dataField)) return false;
+    if (!isRecord9(dataField)) return false;
     return dataField.ownerUserId === selfUserId;
   }
   function collectLocalPreviewElementIds(taskId) {
@@ -71126,10 +71105,19 @@ var CursorAgentSubprocess = class {
     if (added.length === 0 && removed.length === 0) {
       return { added: [], removed: [], errors: {} };
     }
+    const converted = buildCursorMcpConfigFromSet(servers);
+    if (converted.skipped.length > 0) {
+      logger.warn({
+        event: "cursor_set_mcp_servers_skipped_entries",
+        taskId: this.#harnessTaskId,
+        skipped: converted.skipped,
+        keptCount: Object.keys(converted.servers).length
+      });
+    }
     this.#sendToChild({
       kind: "set_mcp_servers",
       generation: this.#generation,
-      servers: buildCursorMcpConfigFromSet(servers).servers
+      servers: converted.servers
     });
     this.#mcpServerSet = incoming;
     return { added, removed, errors: {} };
@@ -76356,6 +76344,13 @@ function isKnownAgentProvider(runtimeId) {
   const id = AGENT_IDS.find((a) => a === runtimeId);
   return id !== void 0 && profileRegistry.has(id);
 }
+function deriveSubprocessKind(runtimeId) {
+  if (!isKnownAgentProvider(runtimeId)) return "claude";
+  const profileId = profileRegistry.get(runtimeId).id;
+  if (profileId === "codex") return "codex";
+  if (profileId === "cursor") return "cursor";
+  return "claude";
+}
 
 // src/services/task/cross-runtime/bridge-orchestration.ts
 function maybeApplyCrossRuntimeSwitch(ctx, taskId, orchestrator, settings) {
@@ -82122,21 +82117,75 @@ import { dirname as dirname34, join as join73 } from "path";
 
 // src/services/plan-backfill/plan-lazy-rebuild.ts
 var SETTLE_BUDGET_MS = 2e3;
+function classifyPlanDocState(input) {
+  if (input.hasContent) return { kind: "has-content" };
+  const probe = input.probe;
+  if (probe === null) return { kind: "rebuild", reason: "no-boundary", chunkCount: 0 };
+  switch (probe.kind) {
+    case "absent":
+      return { kind: "rebuild", reason: "no-chunks", chunkCount: 0 };
+    case "unreadable":
+      return {
+        kind: "storage-error",
+        reason: "chunks-unreadable",
+        chunkCount: 0,
+        chunksPath: probe.path,
+        code: probe.code
+      };
+    case "chunks": {
+      if (input.docHasImportedOps)
+        return { kind: "rebuild", reason: "durably-empty", chunkCount: probe.chunkCount };
+      return input.retriesExhausted ? { kind: "rebuild", reason: "exhausted-retries", chunkCount: probe.chunkCount } : {
+        kind: "storage-error",
+        reason: "chunks-not-loaded",
+        chunkCount: probe.chunkCount,
+        chunksPath: probe.path,
+        code: null
+      };
+    }
+    default: {
+      const _exhaustive = probe;
+      void _exhaustive;
+      return {
+        kind: "storage-error",
+        reason: "chunks-not-loaded",
+        chunkCount: 0,
+        chunksPath: "",
+        code: null
+      };
+    }
+  }
+}
 async function ensurePlanDocRebuilt(deps) {
   try {
     const verdict = await settleAndCheckContent(deps);
-    if (verdict === "has-content") return { kind: "has-content" };
-    if (verdict === "storage-error") {
-      deps.log({ event: "plan_lazy_rebuild_storage_error", taskId: deps.taskId });
+    if (verdict.kind === "has-content") return { kind: "has-content" };
+    if (verdict.kind === "storage-error") {
+      deps.log({
+        event: "plan_lazy_rebuild_storage_error",
+        taskId: deps.taskId,
+        reason: verdict.reason,
+        chunkCount: verdict.chunkCount,
+        chunksPath: verdict.chunksPath,
+        code: verdict.code
+      });
       return { kind: "storage-error" };
     }
+    if (verdict.reason === "durably-empty" || verdict.reason === "exhausted-retries") {
+      deps.log({
+        event: "plan_lazy_rebuild_durably_empty",
+        taskId: deps.taskId,
+        reason: verdict.reason,
+        chunkCount: verdict.chunkCount
+      });
+    }
     const sources = await gatherBackfillSources(
       deps.taskRecord,
       deps.taskId,
       deps.dataDir,
       deps.shipyardHome
     );
-    const fileFallback = await resolveFileFallback(deps.taskId, sources);
+    const fileFallback = await resolveFileFallback(deps.taskId, sources, deps.planRepo);
     if (sources.planVersions.length === 0 && !fileFallback) return { kind: "no-source" };
     const action = planBackfill({
       taskId: deps.taskId,
@@ -82171,9 +82220,18 @@ async function settleAndCheckContent(deps) {
     await sync(doc).waitForSync({ kind: "storage", timeout: SETTLE_BUDGET_MS });
   } catch {
   }
-  if (deps.planRepo.getContent(deps.taskId).trim() !== "") return "has-content";
-  const onDisk = await (deps.hasOnDiskDoc?.() ?? deps.planRepo.hasOnDiskDoc(deps.taskId));
-  return onDisk === true ? "storage-error" : "absent";
+  const retriesExhausted = deps.retriesExhausted ?? false;
+  const hasContent = deps.planRepo.getContent(deps.taskId).trim() !== "";
+  if (hasContent)
+    return classifyPlanDocState({
+      hasContent,
+      docHasImportedOps: true,
+      probe: null,
+      retriesExhausted
+    });
+  const probe = await (deps.probeDocChunks?.() ?? deps.planRepo.probeDocChunks(deps.taskId));
+  const docHasImportedOps = deps.docHasImportedOps?.() ?? deps.planRepo.docHasImportedOps(deps.taskId);
+  return classifyPlanDocState({ hasContent, docHasImportedOps, probe, retriesExhausted });
 }
 
 // src/services/plan/plan-detection-policy.ts
@@ -82228,7 +82286,7 @@ function decideWatchResolved(trigger, snapshot) {
 // src/services/plan/plan-file-bridge.ts
 import { createHash as createHash12, randomUUID as randomUUID20 } from "crypto";
 import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile44, rename as rename18, writeFile as writeFile25 } from "fs/promises";
+import { readFile as readFile44, rename as rename18, stat as stat18, writeFile as writeFile25 } from "fs/promises";
 import { basename as basename13, dirname as dirname33 } from "path";
 var FILE_READ_MAX_RETRIES = 3;
 var FILE_READ_RETRY_BASE_MS = 200;
@@ -82616,6 +82674,15 @@ var PlanFileBridge = class _PlanFileBridge {
     }
     await this.#writeBackToFile();
   }
+  /** Byte size of the plan file on disk, or 0 when it is missing or unreadable. */
+  async #existingFileSize() {
+    if (!this.#filePath) return 0;
+    try {
+      return (await stat18(this.#filePath)).size;
+    } catch {
+      return 0;
+    }
+  }
   async #readFileWithRetry(filePath) {
     let lastError;
     for (let attempt = 0; attempt < FILE_READ_MAX_RETRIES; attempt++) {
@@ -82659,6 +82726,18 @@ var PlanFileBridge = class _PlanFileBridge {
     const content = this.#config.planRepo.getContent(this.#config.taskId);
     const hash = contentHash(content);
     if (hash === this.#lastWrittenHash) return;
+    if (content.trim() === "") {
+      const existingBytes = await this.#existingFileSize();
+      if (existingBytes > 0) {
+        this.#config.log({
+          event: "plan_write_back_refused_empty",
+          taskId: this.#config.taskId,
+          filePath: this.#filePath,
+          existingBytes
+        });
+        return;
+      }
+    }
     const tmpPath = `${this.#filePath}.${randomUUID20()}.tmp`;
     await writeFile25(tmpPath, content, "utf-8");
     await rename18(tmpPath, this.#filePath);
@@ -83290,15 +83369,19 @@ var PlanStorageRecoveryController = class {
         this.#scheduleAttempt(detection, attempt + 1);
         return;
       case "exhausted":
-      case "give_up":
         this.#inFlight = false;
         this.#deps.log({
           event: "plan_storage_recovery_gave_up",
           taskId: this.#deps.taskId,
           attempt,
-          reason: action.kind
+          reason: action.kind,
+          outcome: outcome.kind
         });
         return;
+      case "give_up":
+        this.#inFlight = false;
+        await this.#rebuildAsDurable(detection, attempt);
+        return;
       default: {
         const _exhaustive = action;
         void _exhaustive;
@@ -83307,6 +83390,51 @@ var PlanStorageRecoveryController = class {
       }
     }
   }
+  /**
+   * Last pass, after the whole attempt budget is spent on a persistent
+   * `storage-error`. `storage-error` means the doc's
+   * chunks are on disk but nothing imported — which is a TRANSIENT load failure
+   * only for as long as retrying can still change the answer. Once N evict-and-
+   * reload attempts have each re-read disk and seen the same nothing, the reading
+   * is durable, and the two states behind it are both better served by a rebuild:
+   * a doc that was flushed while holding zero ops (real, and reachable — a
+   * repo-WIDE `repo.flush()` persists a handle that was merely opened), and a
+   * storage fault that is not going to clear on this cycle.
+   *
+   * Giving up here instead is what left #5266's symptom in place: a permanent
+   * "Failed to load plan" over a durable source that was never consulted. Time is
+   * the discriminator no single observation could supply, and the retries are how
+   * we spend it — so the rebuild is gated behind them, never in place of them.
+   */
+  async #rebuildAsDurable(detection, attempt) {
+    const outcome = await ensurePlanDocRebuilt({
+      taskId: this.#deps.taskId,
+      planRepo: this.#deps.planRepo,
+      taskRecord: { lastPlanDetection: { filePath: detection.filePath } },
+      dataDir: this.#deps.dataDir,
+      shipyardHome: getShipyardHome(),
+      retriesExhausted: true,
+      log: this.#deps.log
+    });
+    if (this.#deps.isDisposed()) return;
+    if (outcome.kind === "rebuilt") {
+      this.#deps.log({
+        event: "plan_storage_recovery_succeeded",
+        taskId: this.#deps.taskId,
+        attempt,
+        via: "durable-rebuild"
+      });
+      this.#deps.reEmitPlanDetected(detection);
+      return;
+    }
+    this.#deps.log({
+      event: "plan_storage_recovery_gave_up",
+      taskId: this.#deps.taskId,
+      attempt,
+      reason: "give_up",
+      outcome: outcome.kind
+    });
+  }
 };
 
 // src/services/plan/plan-handler.ts
@@ -89265,6 +89393,14 @@ function clampReasoningEffortForModelSwitch(args) {
 
 // src/services/task/orchestrator/task-mcp-coordinator.ts
 function connectDynamicMcpServersForTask(params) {
+  if (params.subprocessKind !== "claude") {
+    params.log({
+      event: "dynamic_mcp_push_skipped_non_claude",
+      taskId: params.taskId,
+      subprocessKind: params.subprocessKind
+    });
+    return;
+  }
   const resolved = params.resolveMcpServers();
   if (!resolved || Object.keys(resolved).length === 0) return;
   const filtered = filterDisabledMcpServers(resolved, params.disabledMcpServers, {
@@ -89912,11 +90048,11 @@ var IDLE_SWEEP_INTERVAL_MS = 6e4;
 function sanitize(id) {
   return id.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
-function isRecord11(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isCCTaskFile(value) {
-  if (!isRecord11(value)) return false;
+  if (!isRecord10(value)) return false;
   return typeof value.id === "string" && typeof value.subject === "string" && typeof value.description === "string" && typeof value.status === "string" && VALID_STATUSES.has(value.status) && Array.isArray(value.blocks) && Array.isArray(value.blockedBy);
 }
 function createCCTaskFileWatcher(listId, log) {
@@ -90989,9 +91125,9 @@ var SubagentTranscriptWatcher = class {
     let fh = null;
     try {
       fh = await open2(this.#config.transcriptPath, "r");
-      const stat19 = await fh.stat();
-      if (stat19.size <= this.#bytesRead) return;
-      const bytesToRead = stat19.size - this.#bytesRead;
+      const stat20 = await fh.stat();
+      if (stat20.size <= this.#bytesRead) return;
+      const bytesToRead = stat20.size - this.#bytesRead;
       const buffer = Buffer.alloc(bytesToRead);
       const { bytesRead } = await fh.read(buffer, 0, bytesToRead, this.#bytesRead);
       this.#bytesRead += bytesRead;
@@ -94309,6 +94445,12 @@ var Task = class {
    */
   #connectDynamicMcpServers() {
     connectDynamicMcpServersForTask({
+      /**
+       * Derived from the SHARED owner so this gate and the task-manager's
+       * coordinator-adoption push cannot disagree about who owns the MCP push
+       * (#5265). The push itself is Claude-only — see the callee.
+       */
+      subprocessKind: deriveSubprocessKind(this.#runtimeId),
       mainThread: this.#getPrimary(),
       log: this.#deps.log,
       resolveMcpServers: this.#deps.resolveMcpServers,
@@ -97266,14 +97408,7 @@ var TaskManager = class {
       onSubprocessReady: (tid) => {
         const task = this.#tasks.get(tid);
         if (!task) return;
-        const _rId = task.orchestrator.runtimeId;
-        const _adoptProfile = isKnownAgentProvider(_rId) ? profileRegistry.get(_rId) : null;
-        const subprocessKind = (() => {
-          const profileId = _adoptProfile?.id;
-          if (profileId === "codex") return "codex";
-          if (profileId === "cursor") return "cursor";
-          return "claude";
-        })();
+        const subprocessKind = deriveSubprocessKind(task.orchestrator.runtimeId);
         void this.pushTaskSkillsSnapshot(tid);
         this.#registerMcpAdoption(
           tid,
@@ -99070,7 +99205,7 @@ async function createDaemon(deps) {
     }
   });
   function projectCanvasElementForResolver(taskId, el) {
-    const innerData = isRecord10(el.data.data) ? el.data.data : {};
+    const innerData = isRecord9(el.data.data) ? el.data.data : {};
     const elementId = String(el.id);
     if (el.data.type !== "preview" || !deps.previewStateStore) {
       return { id: elementId, type: el.data.type, data: innerData };
@@ -99124,7 +99259,7 @@ async function createDaemon(deps) {
       const elements = canvasRepo.getElements(taskId);
       const target = elements.find((el) => String(el.id) === elementId);
       if (!target) return;
-      const currentData = isRecord10(target.data.data) ? target.data.data : {};
+      const currentData = isRecord9(target.data.data) ? target.data.data : {};
       canvasRepo.updateElement(taskId, target.id, {
         data: { ...currentData, port: newPort }
       });
@@ -101061,6 +101196,17 @@ var WARN_EVENTS = /* @__PURE__ */ new Set([
   "subprocess_force_killed",
   "file_watcher_events_dropped",
   "mcp_server_toggle_failed",
+  /**
+   * Both #5266. `plan_storage_recovery_gave_up` means a core-loop surface stays
+   * dark until something else re-triggers a load — it logged at INFO while the
+   * user was staring at "Failed to load plan", which is how a 93k-line session
+   * hid it. `plan_write_back_refused_empty` means the durable plan markdown was
+   * about to be truncated to 0 bytes and we declined; if that guard ever starts
+   * firing routinely, an empty replica is reaching the bridge and someone needs
+   * to see it.
+   */
+  "plan_storage_recovery_gave_up",
+  "plan_write_back_refused_empty",
   /**
    * Mermaid validation fails open when the mermaid module itself cannot load
    * (e.g. a packaging defect stripped a transitive dep): diagrams are created
@@ -101958,7 +102104,7 @@ async function saveCodexSkillsCache(path5, cache2) {
 }
 
 // src/services/skills-mirror/manager.ts
-import { lstat, mkdir as mkdir40, readlink, stat as stat18, symlink, unlink as unlink18 } from "fs/promises";
+import { lstat, mkdir as mkdir40, readlink, stat as stat19, symlink, unlink as unlink18 } from "fs/promises";
 import { homedir as homedir14 } from "os";
 import { dirname as dirname40, join as join83 } from "path";
 
@@ -102170,7 +102316,7 @@ function planMirrorActions(skills, paths) {
 }
 async function classifyManifestEntry(entry) {
   try {
-    await stat18(entry.target);
+    await stat19(entry.target);
     return "retain";
   } catch (err3) {
     if (isEnoent(err3)) return "sweep-dangling";
@@ -103480,4 +103626,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-RWFBSQIE.js.map
+//# sourceMappingURL=serve-HTQMCHRP.js.map