@schoolai/shipyard 3.25.0 → 3.26.0-rc.20260819.0

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

@@ -12,7 +12,7 @@ import {
   guardedSubscribe,
   makeInitialAttemptState,
   shutdownFileWatcherGuard
-} from "./chunk-IRS6HYMU.js";
+} from "./chunk-ALNGADQY.js";
 import {
   TRAILER_SCHEMA_VERSION,
   appendTrailerToMessage,
@@ -45,7 +45,7 @@ import {
 } from "./chunk-2UE3TNY7.js";
 import {
   getDaemonVersion
-} from "./chunk-XNH6FVIX.js";
+} from "./chunk-FU6IF6C2.js";
 import {
   collectPriorCrashDetail,
   getRecentWasmPanicMessages
@@ -6022,7 +6022,7 @@ function nanoid(size = 21) {
 }
 
 // src/services/bootstrap/signaling.ts
-var DAEMON_NPM_VERSION = true ? "3.25.0" : "unknown";
+var DAEMON_NPM_VERSION = true ? "3.26.0" : "unknown";
 function createDaemonSignaling(config) {
   const agentId = config.agentId ?? nanoid();
   function send(msg) {
@@ -21281,11 +21281,11 @@ function freshOccupancyOrNull(raw) {
 }
 function resolveCompactionThreshold(params) {
   const { taskPrefs, runtimePrefs, runtimeDefaultFraction, maxTokens } = params;
-  const fromPrefs = prefsToFraction(taskPrefs, maxTokens);
-  if (fromPrefs !== void 0) return fromPrefs;
+  const fromTask = prefsToFraction(taskPrefs, maxTokens);
+  if (fromTask !== void 0) return { tier: "task", fraction: fromTask };
   const fromRuntime = prefsToFraction(runtimePrefs, maxTokens);
-  if (fromRuntime !== void 0) return fromRuntime;
-  return runtimeDefaultFraction;
+  if (fromRuntime !== void 0) return { tier: "runtime", fraction: fromRuntime };
+  return runtimeDefaultFraction !== null ? { tier: "default", fraction: runtimeDefaultFraction } : { tier: "none", fraction: null };
 }
 function resolveActiveCompactionPrefs(params) {
   return params.taskPrefs ?? params.runtimePrefs ?? null;
@@ -34388,6 +34388,10 @@ function applyPersistedComposerSettings(orchestrator, settings) {
     patch.disabledMcpServers = normalizedSettings.disabledMcpServers;
   if (normalizedSettings.mcpServerSnapshot != null)
     patch.mcpServerSnapshot = normalizedSettings.mcpServerSnapshot;
+  if (normalizedSettings.compactionPrefs != null)
+    patch.compactionPrefs = normalizedSettings.compactionPrefs;
+  if (normalizedSettings.mutedResources != null)
+    patch.mutedResources = normalizedSettings.mutedResources;
   if (Object.keys(patch).length > 0) orchestrator.applySettings(patch);
 }
 function persistMessageBorneComposerSettings(deps, settings) {
@@ -55183,11 +55187,11 @@ 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";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
+  CallToolRequestSchema as CallToolRequestSchema2,
+  ListToolsRequestSchema as ListToolsRequestSchema2
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/shared/mcp/connect-failure-log.ts
@@ -55195,6 +55199,126 @@ function classifyConnectFailureLevel(errorKind) {
   return errorKind === "auth" ? "info" : "error";
 }
 
+// src/shared/mcp/proxy-loopback-binding.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var LOCAL_HTTP_SESSION_IDLE_MS = 5 * 60 * 1e3;
+function buildLocalHttpProxyMcpServer(opts) {
+  const mcpServer = new McpServer(
+    { name: `shipyard-proxy-http:${opts.serverName}`, version: "1.0.0" },
+    { capabilities: { tools: { listChanged: true } } }
+  );
+  const lowLevelServer = mcpServer.server;
+  lowLevelServer.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [...opts.lookupTools()]
+  }));
+  lowLevelServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    opts.log({
+      event: "proxy_http_call_tool_handler_fired",
+      serverName: opts.serverName,
+      toolName: name
+    });
+    const knownTool = opts.lookupTools().find((tool) => tool.name === name);
+    if (!knownTool) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Unknown tool "${name}" on server "${opts.serverName}"`
+          }
+        ],
+        isError: true
+      };
+    }
+    const client = opts.lookupClient();
+    if (!client) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `MCP server "${opts.serverName}" is not connected`
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      return await client.callTool({ name, arguments: args });
+    } catch (err3) {
+      return opts.onToolCallError(err3, name);
+    }
+  });
+  return mcpServer;
+}
+function toLocalHttpExposure(binding) {
+  return {
+    serverName: binding.serverName,
+    url: binding.url,
+    host: binding.host,
+    port: binding.port,
+    bearerToken: binding.bearerToken,
+    bearerTokenEnvVar: binding.bearerTokenEnvVar
+  };
+}
+function makeBearerTokenEnvVar(serverName) {
+  const sanitized = serverName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  return `SHIPYARD_MCP_PROXY_TOKEN_${sanitized}`;
+}
+async function disposeLocalHttpBinding(binding, log) {
+  const sessions = [...binding.sessions.values(), ...binding.pendingSessions];
+  binding.sessions.clear();
+  binding.pendingSessions.clear();
+  await Promise.all(
+    sessions.map((session) => disposeLocalHttpSession(session, binding.serverName, log))
+  );
+  await new Promise((resolve12) => {
+    binding.httpServer.closeAllConnections?.();
+    binding.httpServer.close(() => resolve12());
+  });
+  log({
+    event: "mcp_proxy_local_http_unbound",
+    serverName: binding.serverName,
+    port: binding.port
+  });
+}
+async function disposeLocalHttpSession(session, serverName, log) {
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  try {
+    await session.mcpServer.close();
+  } catch (err3) {
+    log({
+      event: "mcp_proxy_local_http_mcp_server_close_failed",
+      serverName,
+      error: err3 instanceof Error ? err3.message : String(err3)
+    });
+  }
+}
+function armLocalHttpSessionExpiry(session, sessionId, sessions, serverName, log) {
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  session.idleTimer = null;
+  if (sessions.get(sessionId) !== session) return;
+  if (session.activeRequestCount > 0 || session.notificationStreamReady) return;
+  session.idleTimer = setTimeout(() => {
+    if (sessions.get(sessionId) !== session || session.notificationStreamReady) return;
+    sessions.delete(sessionId);
+    void disposeLocalHttpSession(session, serverName, log);
+  }, LOCAL_HTTP_SESSION_IDLE_MS);
+  session.idleTimer.unref();
+}
+function startLocalHttpSessionRequest(session) {
+  session.activeRequestCount += 1;
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  session.idleTimer = null;
+}
+function finishLocalHttpSessionRequest(session, sessionId, sessions, serverName, log) {
+  session.activeRequestCount = Math.max(0, session.activeRequestCount - 1);
+  armLocalHttpSessionExpiry(session, sessionId, sessions, serverName, log);
+}
+
 // src/shared/mcp/proxy-loopback-listener.ts
 import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { createServer as createServer3 } from "http";
@@ -55333,7 +55457,8 @@ async function startLoopbackHttpServer(opts) {
       req,
       res,
       bearerToken: opts.bearerToken,
-      transport: opts.transport,
+      createTransport: opts.createTransport,
+      lookupTransport: opts.lookupTransport,
       log: opts.log,
       serverName: opts.serverName
     }).catch((err3) => {
@@ -55422,11 +55547,64 @@ async function handleProxyHttpRequest(opts) {
     );
     return;
   }
-  await opts.transport.handleRequest(opts.req, opts.res);
+  await forwardAuthenticatedRequest(opts);
+}
+async function forwardAuthenticatedRequest(opts) {
+  const sessionHeader = opts.req.headers["mcp-session-id"];
+  const sessionId = Array.isArray(sessionHeader) ? sessionHeader[0] : sessionHeader;
+  const created = sessionId === void 0;
+  const session = created ? await opts.createTransport() : opts.lookupTransport(sessionId);
+  if (!session) {
+    await respondProxyError(
+      opts.req,
+      opts.res,
+      404,
+      MCP_PROXY_JSON_RPC_SESSION_NOT_FOUND,
+      "session_not_found"
+    );
+    return;
+  }
+  const isNotificationStream = opts.req.method === "GET";
+  if (isNotificationStream) observeNotificationStream(opts.req, opts.res, session);
+  session.onRequestStart();
+  try {
+    await session.transport.handleRequest(opts.req, opts.res);
+  } finally {
+    session.onRequestEnd();
+    if (created && session.transport.sessionId === void 0) await session.dispose();
+  }
+}
+function observeNotificationStream(req, res, session) {
+  let readinessTimer = null;
+  let becameReady = false;
+  res.once("close", () => {
+    if (readinessTimer) clearTimeout(readinessTimer);
+    if (becameReady) session.onStreamClosed();
+  });
+  let retryMs = 1;
+  const markReadyAfterHeaders = () => {
+    if (res.closed) return;
+    if (res.headersSent) {
+      if (isSuccessfulNotificationStream(req, res)) {
+        becameReady = true;
+        session.onStreamReady();
+      }
+      return;
+    }
+    readinessTimer = setTimeout(markReadyAfterHeaders, retryMs);
+    readinessTimer.unref();
+    retryMs = Math.min(retryMs * 2, 250);
+  };
+  markReadyAfterHeaders();
+}
+function isSuccessfulNotificationStream(req, res) {
+  const accept = req.headers.accept ?? "";
+  return res.statusCode === 200 && accept.toLowerCase().includes("text/event-stream");
 }
 var MCP_PROXY_JSON_RPC_INTERNAL = -32603;
 var MCP_PROXY_JSON_RPC_UNAUTHORIZED = -32001;
 var MCP_PROXY_JSON_RPC_NOT_FOUND = -32004;
+var MCP_PROXY_JSON_RPC_SESSION_NOT_FOUND = -32005;
 async function respondProxyError(req, res, status, code, message) {
   sendJsonRpcHttpError(res, status, code, message, await readRequestId(req));
 }
@@ -55809,7 +55987,9 @@ var McpProxyServer = class {
       });
       return;
     }
+    const previousTools = this.#servers.get(name)?.tools ?? [];
     this.#servers.set(name, { client, transport, config, tools, provider });
+    this.#notifyLocalHttpToolListChanged(name, previousTools, tools);
     this.#connectErrors.delete(name);
     this.#connectErrorMessages.delete(name);
     this.#deps.log({
@@ -55820,6 +56000,30 @@ var McpProxyServer = class {
       toolNames: tools.map((t) => t.name)
     });
   }
+  #notifyLocalHttpToolListChanged(name, before, after) {
+    if (JSON.stringify(before) === JSON.stringify(after)) return;
+    const binding = this.#localHttpBindings.get(name);
+    if (!binding) return;
+    for (const session of binding.sessions.values()) {
+      if (!session.notificationStreamReady) {
+        session.pendingToolListChanged = true;
+        continue;
+      }
+      this.#sendLocalHttpToolListChanged(name, session);
+    }
+  }
+  #sendLocalHttpToolListChanged(name, session) {
+    session.pendingToolListChanged = false;
+    session.sentToolListChangedOnCurrentStream = true;
+    void session.mcpServer.server.sendToolListChanged().catch((err3) => {
+      session.pendingToolListChanged = true;
+      this.#deps.log({
+        event: "mcp_proxy_local_http_tool_list_changed_failed",
+        serverName: name,
+        error: err3 instanceof Error ? err3.message : String(err3)
+      });
+    });
+  }
   async #shouldPreflightRefresh(name) {
     const token = await this.#deps.tokenStore.getToken(name);
     return token ? this.#deps.tokenStore.needsRefresh(token) : false;
@@ -56061,7 +56265,7 @@ var McpProxyServer = class {
   async exposeAsLocalHttp(serverName) {
     const cached = this.#localHttpBindings.get(serverName);
     if (cached) {
-      return toExposure(cached);
+      return toLocalHttpExposure(cached);
     }
     const inFlight = this.#localHttpPending.get(serverName);
     if (inFlight) return inFlight;
@@ -56109,28 +56313,114 @@ var McpProxyServer = class {
    * @internal
    */
   getLocalHttpBindingsForTest() {
-    return new Map([...this.#localHttpBindings].map(([k2, v2]) => [k2, toExposure(v2)]));
+    return new Map([...this.#localHttpBindings].map(([k2, v2]) => [k2, toLocalHttpExposure(v2)]));
   }
   async #buildLocalHttpBinding(serverName) {
     const bearerToken = randomUUID13();
     const bearerTokenEnvVar = makeBearerTokenEnvVar(serverName);
-    const mcpServer = buildLocalHttpProxyMcpServer({
-      serverName,
-      lookupClient: () => this.#servers.get(serverName)?.client ?? null,
-      lookupTools: () => this.#servers.get(serverName)?.tools ?? [],
-      log: this.#deps.log,
-      onAuthError: (sn) => {
-        this.#connectErrors.set(sn, "auth");
-        this.#fireOnAuthRequired(sn);
-      }
-    });
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID13()
-    });
-    await mcpServer.connect(transport);
+    const sessions = /* @__PURE__ */ new Map();
+    const pendingSessions = /* @__PURE__ */ new Set();
+    const createSession = async () => {
+      const mcpServer = buildLocalHttpProxyMcpServer({
+        serverName,
+        lookupClient: () => this.#servers.get(serverName)?.client ?? null,
+        lookupTools: () => this.#servers.get(serverName)?.tools ?? [],
+        log: this.#deps.log,
+        onToolCallError: (err3, toolName) => handleToolCallError(err3, toolName, serverName, this.#deps.log, (sn) => {
+          this.#connectErrors.set(sn, "auth");
+          this.#fireOnAuthRequired(sn);
+        })
+      });
+      let session;
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID13(),
+        onsessioninitialized: (sessionId) => {
+          pendingSessions.delete(session);
+          sessions.set(sessionId, session);
+          armLocalHttpSessionExpiry(session, sessionId, sessions, serverName, this.#deps.log);
+        },
+        onsessionclosed: (sessionId) => {
+          const closed = sessions.get(sessionId);
+          sessions.delete(sessionId);
+          if (closed?.idleTimer) clearTimeout(closed.idleTimer);
+        }
+      });
+      session = {
+        transport,
+        mcpServer,
+        activeRequestCount: 0,
+        notificationStreamReady: false,
+        pendingToolListChanged: false,
+        sentToolListChangedOnCurrentStream: false,
+        idleTimer: null
+      };
+      pendingSessions.add(session);
+      await mcpServer.connect(transport);
+      return session;
+    };
     const { httpServer, host, port } = await startLoopbackHttpServer({
       bearerToken,
-      transport,
+      createTransport: async () => {
+        const session = await createSession();
+        return {
+          transport: session.transport,
+          dispose: async () => {
+            pendingSessions.delete(session);
+            await disposeLocalHttpSession(session, serverName, this.#deps.log);
+          },
+          onRequestStart: () => startLocalHttpSessionRequest(session),
+          onRequestEnd: () => {
+            const sessionId = session.transport.sessionId;
+            if (sessionId) {
+              finishLocalHttpSessionRequest(
+                session,
+                sessionId,
+                sessions,
+                serverName,
+                this.#deps.log
+              );
+            }
+          },
+          onStreamReady: () => {
+          },
+          onStreamClosed: () => {
+          }
+        };
+      },
+      lookupTransport: (sessionId) => {
+        const session = sessions.get(sessionId);
+        return session ? {
+          transport: session.transport,
+          dispose: () => disposeLocalHttpSession(session, serverName, this.#deps.log),
+          onRequestStart: () => startLocalHttpSessionRequest(session),
+          onRequestEnd: () => finishLocalHttpSessionRequest(
+            session,
+            sessionId,
+            sessions,
+            serverName,
+            this.#deps.log
+          ),
+          onStreamReady: () => {
+            session.notificationStreamReady = true;
+            session.sentToolListChangedOnCurrentStream = false;
+            if (session.idleTimer) {
+              clearTimeout(session.idleTimer);
+              session.idleTimer = null;
+            }
+            if (session.pendingToolListChanged) {
+              this.#sendLocalHttpToolListChanged(serverName, session);
+            }
+          },
+          onStreamClosed: () => {
+            session.notificationStreamReady = false;
+            if (session.sentToolListChangedOnCurrentStream) {
+              session.pendingToolListChanged = true;
+            }
+            session.sentToolListChangedOnCurrentStream = false;
+            armLocalHttpSessionExpiry(session, sessionId, sessions, serverName, this.#deps.log);
+          }
+        } : void 0;
+      },
       log: this.#deps.log,
       serverName
     });
@@ -56142,8 +56432,8 @@ var McpProxyServer = class {
       bearerToken,
       bearerTokenEnvVar,
       httpServer,
-      transport,
-      mcpServer
+      sessions,
+      pendingSessions
     };
     this.#localHttpBindings.set(serverName, binding);
     this.#deps.log({
@@ -56153,7 +56443,7 @@ var McpProxyServer = class {
       host,
       bearerTokenEnvVar
     });
-    return toExposure(binding);
+    return toLocalHttpExposure(binding);
   }
   /**
    * Return connection statuses for all proxy-managed servers.
@@ -56222,6 +56512,7 @@ var McpProxyServer = class {
     } catch {
     }
     this.#servers.delete(name);
+    this.#notifyLocalHttpToolListChanged(name, server.tools, []);
   }
   /** Disconnect all servers and clean up resources. */
   async dispose() {
@@ -56257,15 +56548,15 @@ function handleToolCallError(err3, toolName, serverName, log, onAuthError) {
 }
 function buildPerServerProxy(serverName, client, tools, log, onAuthError) {
   const proxyName = `shipyard-proxy:${serverName}`;
-  const mcpServer = new McpServer(
+  const mcpServer = new McpServer2(
     { name: proxyName, version: "1.0.0" },
     { capabilities: { tools: {} } }
   );
   const lowLevelServer = mcpServer.server;
-  lowLevelServer.setRequestHandler(ListToolsRequestSchema, async () => ({
+  lowLevelServer.setRequestHandler(ListToolsRequestSchema2, async () => ({
     tools: [...tools]
   }));
-  lowLevelServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+  lowLevelServer.setRequestHandler(CallToolRequestSchema2, async (request) => {
     const { name, arguments: args } = request.params;
     log({ event: "proxy_call_tool_handler_fired", serverName, toolName: name });
     const knownTool = tools.find((t) => t.name === name);
@@ -56289,98 +56580,6 @@ function buildPerServerProxy(serverName, client, tools, log, onAuthError) {
     instance: mcpServer
   };
 }
-function toExposure(binding) {
-  return {
-    serverName: binding.serverName,
-    url: binding.url,
-    host: binding.host,
-    port: binding.port,
-    bearerToken: binding.bearerToken,
-    bearerTokenEnvVar: binding.bearerTokenEnvVar
-  };
-}
-function makeBearerTokenEnvVar(serverName) {
-  const sanitized = serverName.toUpperCase().replace(/[^A-Z0-9]/g, "_");
-  return `SHIPYARD_MCP_PROXY_TOKEN_${sanitized}`;
-}
-function buildLocalHttpProxyMcpServer(opts) {
-  const mcpServer = new McpServer(
-    { name: `shipyard-proxy-http:${opts.serverName}`, version: "1.0.0" },
-    { capabilities: { tools: {} } }
-  );
-  const lowLevelServer = mcpServer.server;
-  lowLevelServer.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [...opts.lookupTools()]
-  }));
-  lowLevelServer.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    opts.log({
-      event: "proxy_http_call_tool_handler_fired",
-      serverName: opts.serverName,
-      toolName: name
-    });
-    const tools = opts.lookupTools();
-    const knownTool = tools.find((t) => t.name === name);
-    if (!knownTool) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Unknown tool "${name}" on server "${opts.serverName}"`
-          }
-        ],
-        isError: true
-      };
-    }
-    const client = opts.lookupClient();
-    if (!client) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `MCP server "${opts.serverName}" is not connected`
-          }
-        ],
-        isError: true
-      };
-    }
-    try {
-      return await client.callTool({ name, arguments: args });
-    } catch (err3) {
-      return handleToolCallError(err3, name, opts.serverName, opts.log, opts.onAuthError);
-    }
-  });
-  return mcpServer;
-}
-async function disposeLocalHttpBinding(binding, log) {
-  try {
-    await binding.transport.close();
-  } catch (err3) {
-    log({
-      event: "mcp_proxy_local_http_transport_close_failed",
-      serverName: binding.serverName,
-      error: err3 instanceof Error ? err3.message : String(err3)
-    });
-  }
-  try {
-    await binding.mcpServer.close();
-  } catch (err3) {
-    log({
-      event: "mcp_proxy_local_http_mcp_server_close_failed",
-      serverName: binding.serverName,
-      error: err3 instanceof Error ? err3.message : String(err3)
-    });
-  }
-  await new Promise((resolve12) => {
-    binding.httpServer.closeAllConnections?.();
-    binding.httpServer.close(() => resolve12());
-  });
-  log({
-    event: "mcp_proxy_local_http_unbound",
-    serverName: binding.serverName,
-    port: binding.port
-  });
-}
 
 // src/services/mcp/oauth/reauth-orchestrator.ts
 var ReauthOrchestrator = class {
@@ -61369,12 +61568,21 @@ var McpServerStartupStatusUpdatedNotificationSchema = external_exports2.object({
   name: external_exports2.string(),
   status: external_exports2.string()
 }).passthrough();
+var McpAuthStatusSchema = external_exports2.enum(["unsupported", "notLoggedIn", "bearerToken", "oAuth"]);
 var McpServerStatusEntrySchema = external_exports2.object({
   name: external_exports2.string(),
-  status: McpServerStartupStatusSchema.catch("ready")
+  tools: external_exports2.record(external_exports2.string(), external_exports2.unknown()),
+  resources: external_exports2.array(external_exports2.unknown()),
+  resourceTemplates: external_exports2.array(external_exports2.unknown()),
+  authStatus: McpAuthStatusSchema
+}).passthrough();
+var ListMcpServerStatusParamsSchema = external_exports2.object({
+  cursor: external_exports2.string().nullish(),
+  limit: external_exports2.number().int().nullish(),
+  detail: external_exports2.enum(["full", "toolsAndAuthOnly"]).nullish(),
+  threadId: external_exports2.string().nullish()
 }).passthrough();
-var ListMcpServerStatusParamsSchema = external_exports2.object({ cursor: external_exports2.string().nullish(), limit: external_exports2.number().int().optional() }).passthrough();
-var ListMcpServerStatusResponseSchema = external_exports2.object({ data: external_exports2.array(McpServerStatusEntrySchema) }).passthrough();
+var ListMcpServerStatusResponseSchema = external_exports2.object({ data: external_exports2.array(McpServerStatusEntrySchema), nextCursor: external_exports2.string().nullable() }).passthrough();
 var SkillsListParamsSchema = external_exports2.object({ cwds: external_exports2.array(external_exports2.string()).optional(), force_reload: external_exports2.boolean().optional() }).passthrough();
 var SkillMetadataSchema = external_exports2.object({
   name: external_exports2.string(),
@@ -65781,7 +65989,7 @@ var CodexAgentSubprocess = class _CodexAgentSubprocess {
   async #emitInitFromThreadStart(response) {
     const harnessMcp = this.#harnessHttp !== null ? [{ name: HARNESS_SERVER_NAME, status: "connected" }] : [];
     const [mcpResult, skillsResult] = await Promise.allSettled([
-      this.#client.listMcpServerStatus({ limit: 100 }),
+      this.#listThreadMcpInventory(response.thread.id),
       this.#client.listSkills({ cwds: [this.#cwd], force_reload: false })
     ]);
     if (mcpResult.status === "rejected") {
@@ -65790,7 +65998,10 @@ var CodexAgentSubprocess = class _CodexAgentSubprocess {
     if (skillsResult.status === "rejected") {
       this.#log({ event: "codex_discover_skills_failed", error: String(skillsResult.reason) });
     }
-    const discoveredMcps = mcpResult.status === "fulfilled" ? mcpResult.value.data.filter((s2) => s2.name !== HARNESS_SERVER_NAME).map((s2) => ({ name: s2.name, status: s2.status })) : [];
+    const discoveredMcps = mcpResult.status === "fulfilled" ? mcpResult.value.filter((s2) => s2.name !== HARNESS_SERVER_NAME).map(toCodexMcpConnectionStatus) : [];
+    const discoveredMcpTools = mcpResult.status === "fulfilled" ? mcpResult.value.flatMap(
+      (server) => server.authStatus === "notLoggedIn" ? [] : Object.keys(server.tools).map((tool) => `mcp__${server.name}__${tool}`)
+    ) : [];
     const discoveredSkillInfos = skillsResult.status === "fulfilled" ? coerceCodexSkillsListToSkillInfo(skillsResult.value.data) : [];
     const discoveredSkills = discoveredSkillInfos.map((s2) => s2.name);
     this.#log({
@@ -65798,16 +66009,8 @@ var CodexAgentSubprocess = class _CodexAgentSubprocess {
       mcpCount: discoveredMcps.length,
       skillsCount: discoveredSkills.length
     });
-    const startingServers = new Set(
-      discoveredMcps.filter((s2) => s2.status === "starting").map((s2) => s2.name)
-    );
-    await waitForMcpServersToSettle({
-      startingServers,
-      getMcpStatus: () => this.#client.listMcpServerStatus({ limit: 100 }).then((r) => r.data.map((s2) => ({ name: s2.name, status: s2.status }))),
-      log: this.#log
-    });
     const metadata = {
-      tools: [],
+      tools: discoveredMcpTools,
       skills: discoveredSkills,
       agents: [],
       mcpServers: [...harnessMcp, ...discoveredMcps],
@@ -65831,6 +66034,27 @@ var CodexAgentSubprocess = class _CodexAgentSubprocess {
       }
     }
   }
+  async #listThreadMcpInventory(threadId) {
+    const inventory = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor = null;
+    do {
+      const page = await this.#client.listMcpServerStatus({
+        threadId,
+        detail: "toolsAndAuthOnly",
+        limit: 100,
+        ...cursor === null ? {} : { cursor }
+      });
+      inventory.push(...page.data);
+      cursor = page.nextCursor;
+      if (cursor !== null && seenCursors.has(cursor)) {
+        this.#log({ event: "codex_mcp_inventory_cursor_repeated", threadId });
+        break;
+      }
+      if (cursor !== null) seenCursors.add(cursor);
+    } while (cursor !== null);
+    return inventory;
+  }
   pushMessage(content) {
     if (this.#closed) return;
     this.#lastUserContent = content;
@@ -66208,7 +66432,9 @@ var CodexAgentSubprocess = class _CodexAgentSubprocess {
     return { added: [], removed: [], errors: {} };
   }
   async mcpServerStatus() {
-    return [];
+    if (this.#threadId === null) return [];
+    const inventory = await this.#listThreadMcpInventory(this.#threadId);
+    return inventory.map(toCodexMcpConnectionStatus);
   }
   async mcpAuthenticate(_serverName) {
     return null;
@@ -66547,6 +66773,13 @@ var CodexAgentSubprocess = class _CodexAgentSubprocess {
     this.#onEvent({ type: "sdk_error", error: `Codex engine unavailable: ${reason}` });
   }
 };
+function toCodexMcpConnectionStatus(server) {
+  const toolCount = Object.keys(server.tools).length;
+  if (server.authStatus === "notLoggedIn") {
+    return { name: server.name, status: "needs-auth", toolCount: 0 };
+  }
+  return { name: server.name, status: "connected", toolCount };
+}
 function toCodexWireEffort(effort) {
   return effort;
 }
@@ -67073,7 +67306,7 @@ function createCodexFacadeApiBuilder(d) {
 // src/services/harness/harness-http-server.ts
 import { randomUUID as randomUUID15 } from "crypto";
 import { createServer as createServer4 } from "http";
-import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer as McpServer3 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport as StreamableHTTPServerTransport2 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 var SHIPYARD_GENERATION_HEADER = "x-shipyard-generation";
 async function createHarnessHttpServer(opts = {}) {
@@ -67256,7 +67489,7 @@ async function createHarnessHttpServer(opts = {}) {
   }
   async function buildRequestServer(ctx, scope) {
     const { tools } = buildHarnessTools(ctx);
-    const mcpServer = new McpServer2(
+    const mcpServer = new McpServer3(
       { name: HARNESS_SERVER_NAME, version: "1.0.0" },
       ctx.instructions !== void 0 ? { instructions: ctx.instructions } : void 0
     );
@@ -78817,7 +79050,13 @@ function handleSpawning(snapshot, event) {
   }
   return noop(snapshot);
 }
-function buildStallGiveUpMessage(recoveryAttempts) {
+function buildStallGiveUpMessage(recoveryAttempts, stallPhase) {
+  if (stallPhase === "first_step") {
+    if (recoveryAttempts <= 0) {
+      return "The agent never started running. Send a message to try again.";
+    }
+    return "The agent never started running \u2014 no progress at all, across every automatic retry. Resuming this session will keep failing the same way; start a fresh task instead.";
+  }
   if (recoveryAttempts <= 0) {
     return "The agent stopped responding mid-run. Send a message to try again.";
   }
@@ -78831,7 +79070,11 @@ function runningStallTimeout(sessionId, event) {
   b2.effects.push({ type: "clear_queue" });
   if (!event.recoveryArmed) {
     b2.taskStatus("input_required");
-    b2.emitError(buildStallGiveUpMessage(event.recoveryAttempts), "sdk_error", "run_stall_timeout");
+    b2.emitError(
+      buildStallGiveUpMessage(event.recoveryAttempts, event.stallPhase),
+      "sdk_error",
+      "run_stall_timeout"
+    );
   }
   b2.effects.push({ type: "kill_runner" });
   return {
@@ -79654,11 +79897,19 @@ var AgentSessionManager = class {
       let recoveryArmed = false;
       let recoveryAttempts = 0;
       try {
-        const outcome = this.#config.onStallTimeout?.() ?? { armed: false, recoveryAttempts: 0 };
+        const outcome = this.#config.onStallTimeout?.(decision.phase) ?? {
+          armed: false,
+          recoveryAttempts: 0
+        };
         recoveryArmed = outcome.armed;
         recoveryAttempts = outcome.recoveryAttempts;
       } finally {
-        this.#dispatch({ type: "run_stall_timeout", recoveryArmed, recoveryAttempts });
+        this.#dispatch({
+          type: "run_stall_timeout",
+          recoveryArmed,
+          recoveryAttempts,
+          stallPhase: decision.phase
+        });
       }
     }, timeoutMs);
   }
@@ -79687,17 +79938,34 @@ var AgentSessionManager = class {
 // src/services/conversation/cursor-recovery-controller.ts
 var MAX_SIGNAL_DEATH_RETRIES = 1;
 var MAX_STALL_RESUME_RETRIES = 3;
+var MAX_COLD_START_RESUME_RETRIES = 1;
 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;
+function decideStallResume(input) {
+  if (input.state !== "running") return { kind: "decline" };
+  if (input.agentSystem !== AGENT_SYSTEM_CURSOR) return { kind: "decline" };
+  const isColdStart = input.phase === "first_step";
+  const next = (isColdStart ? input.coldStartRetries : input.midRunRetries) + 1;
+  const max = isColdStart ? MAX_COLD_START_RESUME_RETRIES : MAX_STALL_RESUME_RETRIES;
+  return next > max ? { kind: "give_up", recoveryAttempts: next - 1 } : { kind: "arm", retries: next };
+}
 var CursorRecoveryController = class {
   #signalDeathRetries = 0;
   #stallResumeRetries = 0;
   #stallResumeArmed = false;
   #crashDeathRetries = 0;
+  /**
+   * Consecutive silent resumes attempted for stalls in which the run never
+   * produced a first step. Deliberately NOT cleared by `reset()` — see
+   * `decideStallResume`. `noteFirstStep()` is its only reset.
+   */
+  #coldStartResumeRetries = 0;
+  /** Which budget armed the pending resume, so the backoff reads the right counter. */
+  #armedPhase = null;
   /**
    * Pending timer for the settle-delay before an armed stall resume fires.
    * Cleared at every call site that supersedes the in-flight resume (new
@@ -79723,14 +79991,37 @@ var CursorRecoveryController = class {
       this.#stallResumeTimer = null;
     }
   }
-  /** Reset every budget. Call on each new user turn and on turn_complete. */
+  /**
+   * Reset every turn-scoped budget. Call on each new user turn and on
+   * turn_complete.
+   *
+   * `#coldStartResumeRetries` is deliberately excluded: it is scoped to "has
+   * this session ever started a run", not to the current turn, and only
+   * `noteFirstStep()` clears it. Adding it here would restore the #5298
+   * livelock, where each human nudge bought another full futile round.
+   */
   reset() {
     this.cancelPendingResume();
     this.#signalDeathRetries = 0;
     this.#stallResumeRetries = 0;
     this.#stallResumeArmed = false;
+    this.#armedPhase = null;
     this.#crashDeathRetries = 0;
   }
+  /**
+   * Call on every `step_progress`. A completed step is the only evidence that
+   * this session can actually run, so it is the only thing that may forgive
+   * the cold-start budget. Cheap and idempotent — fires on every step.
+   */
+  noteFirstStep() {
+    if (this.#coldStartResumeRetries === 0) return;
+    this.#deps.log({
+      event: "thread_cursor_cold_start_budget_cleared",
+      threadId: this.#deps.threadId,
+      clearedRetries: this.#coldStartResumeRetries
+    });
+    this.#coldStartResumeRetries = 0;
+  }
   /**
    * Call on `turn_complete` instead of `reset()`. A successful auto-recovery
    * otherwise leaves no trace that the daemon self-healed rather than the
@@ -79762,30 +80053,43 @@ var CursorRecoveryController = class {
    * (see `StallTimeoutOutcome`), letting the FSM distinguish "never
    * attempted" from "tried N times".
    */
-  onStallTimeout() {
-    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,
-        maxRetries: MAX_STALL_RESUME_RETRIES
-      });
-      this.#stallResumeRetries = 0;
-      return { armed: false, recoveryAttempts };
-    }
-    this.#deps.log({
-      event: "thread_cursor_stall_resume_armed",
-      threadId: this.#deps.threadId,
-      retries: this.#stallResumeRetries
+  onStallTimeout(phase) {
+    const decision = decideStallResume({
+      state: this.#deps.getState(),
+      agentSystem: this.#deps.getAgentSystem(),
+      phase,
+      midRunRetries: this.#stallResumeRetries,
+      coldStartRetries: this.#coldStartResumeRetries
     });
-    this.#stallResumeArmed = true;
-    return { armed: true, recoveryAttempts: 0 };
+    const isColdStart = phase === "first_step";
+    switch (decision.kind) {
+      case "decline":
+        return { armed: false, recoveryAttempts: 0, phase };
+      case "give_up":
+        this.#deps.log({
+          event: "thread_cursor_stall_resume_cap_exceeded",
+          threadId: this.#deps.threadId,
+          phase,
+          retries: decision.recoveryAttempts + 1,
+          maxRetries: isColdStart ? MAX_COLD_START_RESUME_RETRIES : MAX_STALL_RESUME_RETRIES
+        });
+        this.#stallResumeRetries = 0;
+        return { armed: false, recoveryAttempts: decision.recoveryAttempts, phase };
+      case "arm":
+        if (isColdStart) this.#coldStartResumeRetries = decision.retries;
+        else this.#stallResumeRetries = decision.retries;
+        this.#deps.log({
+          event: "thread_cursor_stall_resume_armed",
+          threadId: this.#deps.threadId,
+          phase,
+          retries: decision.retries
+        });
+        this.#stallResumeArmed = true;
+        this.#armedPhase = phase;
+        return { armed: true, recoveryAttempts: 0, phase };
+      default:
+        return assertNever(decision);
+    }
   }
   /**
    * Consume an armed stall resume on the `kill_runner` death. By now the FSM
@@ -79801,7 +80105,8 @@ var CursorRecoveryController = class {
     if (!this.#stallResumeArmed) return false;
     this.#stallResumeArmed = false;
     this.cancelPendingResume();
-    const attempt = this.#stallResumeRetries;
+    const attempt = this.#armedPhase === "first_step" ? this.#coldStartResumeRetries : this.#stallResumeRetries;
+    this.#armedPhase = null;
     const delayMs = stallResumeDelayMs(attempt);
     this.#deps.log({
       event: "thread_cursor_stall_auto_resume_scheduled",
@@ -80917,7 +81222,7 @@ var Thread = class {
         onClose: () => this.#handleClose(),
         onForceKill: () => this.#handleForceKill(),
         onKillRunner: () => this.#handleForceKill(),
-        onStallTimeout: () => this.#cursorRecovery.onStallTimeout(),
+        onStallTimeout: (phase) => this.#cursorRecovery.onStallTimeout(phase),
         log: config.log,
         onSessionStateChange: (newState, prevState) => this.#notifyStateChange(newState, prevState),
         stallTimeoutMs: config.stallTimeoutMs ?? null,
@@ -82068,6 +82373,7 @@ var Thread = class {
         break;
       case "step_progress":
         this.#manager.notifyStepProgress();
+        this.#cursorRecovery.noteFirstStep();
         break;
       /** Handled in #enqueueSubprocessEvent (off-queue heartbeat); unreachable here. */
       case "stream_activity":
@@ -87723,7 +88029,7 @@ function computeTelemetryTokenContext(params) {
   const usedTokens = params.lastWindowOccupancyEvent ? resolveLiveContextTokens(params.lastWindowOccupancyEvent).liveContextTokens : void 0;
   const window = resolveContextWindow(params.currentModel, 0);
   const windowTokens = window > 0 ? window : void 0;
-  const fraction = resolveCompactionThreshold({
+  const { fraction } = resolveCompactionThreshold({
     taskPrefs: params.taskPrefs,
     runtimePrefs: params.runtimePrefs,
     runtimeDefaultFraction: params.compactionThreshold,
@@ -87861,7 +88167,7 @@ function decideByRatio(params) {
   }
   if (params.isCompacting || params.hasPendingTimer) return { kind: "noop" };
   if (params.threshold !== null && usageRatio >= params.threshold) {
-    return { kind: "schedule", delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS };
+    return { kind: "schedule", delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS, decisionPath: "ratio" };
   }
   return { kind: "noop" };
 }
@@ -87871,7 +88177,11 @@ function decideByMessageCount(params) {
   if (params.liveMessageCount === void 0) return { kind: "noop" };
   const baseline = params.backstopBaselineSeq ?? 0;
   if (params.liveMessageCount - baseline >= AUTO_COMPACTION_MESSAGE_CEILING) {
-    return { kind: "schedule", delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS };
+    return {
+      kind: "schedule",
+      delayMs: AUTO_COMPACTION_CANCEL_DELAY_MS,
+      decisionPath: "message_count"
+    };
   }
   return { kind: "noop" };
 }
@@ -88435,8 +88745,14 @@ function priorOccupancyFromTurnStats(prior) {
 }
 function handleAutoCompactionSnapshot(ctx, event, contextWindow, occupancyStale = false) {
   const { liveContextTokens } = resolveLiveContextTokens(event);
+  const resolution = resolveCompactionThreshold({
+    taskPrefs: ctx.getTaskPrefs(),
+    runtimePrefs: ctx.getCompactionByRuntimePrefs(),
+    runtimeDefaultFraction: ctx.getCompactionThreshold(),
+    maxTokens: contextWindow
+  });
   const decision = decideAutoCompaction({
-    threshold: resolveEffectiveThresholdFraction(ctx, contextWindow),
+    threshold: resolution.fraction,
     liveContextTokens,
     contextWindow,
     isCompacting: ctx.isCompactionActive(),
@@ -88461,7 +88777,13 @@ function handleAutoCompactionSnapshot(ctx, event, contextWindow, occupancyStale
     case "schedule":
       ctx.setBackstopBaselineSeq(ctx.getLiveMessageCount());
       ctx.dispatchCompactionEvent({ kind: "threshold_reached", now: Date.now() });
-      ctx.scheduleAutoCompaction(decision.delayMs, liveContextTokens, contextWindow);
+      ctx.scheduleAutoCompaction(decision.delayMs, liveContextTokens, contextWindow, {
+        effectiveThreshold: resolution.fraction,
+        thresholdTier: resolution.tier,
+        runtimeDefaultFraction: ctx.getCompactionThreshold(),
+        decisionPath: decision.decisionPath,
+        occupancyStale
+      });
       return;
     default:
       assertNever(decision);
@@ -88491,14 +88813,6 @@ function logCumulativeFallback(ctx, liveContextTokens) {
     });
   }
 }
-function resolveEffectiveThresholdFraction(ctx, contextWindow) {
-  return resolveCompactionThreshold({
-    taskPrefs: ctx.getTaskPrefs(),
-    runtimePrefs: ctx.getCompactionByRuntimePrefs(),
-    runtimeDefaultFraction: ctx.getCompactionThreshold(),
-    maxTokens: contextWindow
-  });
-}
 
 // src/services/task/orchestrator/compaction-controller.ts
 var CompactionController = class {
@@ -88963,7 +89277,7 @@ var CompactionController = class {
    * Schedule the auto-compaction timer (called by the auto-compaction
    * decision from task-event-dispatch via the eventCtx).
    */
-  scheduleAutoCompaction(delayMs, liveContextTokens, contextWindow) {
+  scheduleAutoCompaction(delayMs, liveContextTokens, contextWindow, decisionContext) {
     if (this.#pendingAutoCompactionTimer !== null) return;
     const cancelDeadline = Date.now() + delayMs;
     this.#pendingAutoCompactionTimer = setTimeout(() => {
@@ -88980,7 +89294,11 @@ var CompactionController = class {
     this.#deps.log({
       event: "auto_compaction_pending",
       taskId: this.#deps.taskId,
-      threshold: this.#compactionThreshold,
+      effectiveThreshold: decisionContext.effectiveThreshold,
+      thresholdTier: decisionContext.thresholdTier,
+      runtimeDefaultFraction: decisionContext.runtimeDefaultFraction,
+      decisionPath: decisionContext.decisionPath,
+      occupancyStale: decisionContext.occupancyStale,
       liveContextTokens,
       contextWindow,
       cancelDeadline
@@ -94523,7 +94841,12 @@ var Task = class {
       setAutoCompactionSuppressedUntilBelow: (value) => {
         this.#compaction.setAutoCompactionSuppressedUntilBelow(value);
       },
-      scheduleAutoCompaction: (delayMs, liveContextTokens, contextWindow) => this.#compaction.scheduleAutoCompaction(delayMs, liveContextTokens, contextWindow),
+      scheduleAutoCompaction: (delayMs, liveContextTokens, contextWindow, decisionContext) => this.#compaction.scheduleAutoCompaction(
+        delayMs,
+        liveContextTokens,
+        contextWindow,
+        decisionContext
+      ),
       getCompactionThreshold: () => this.#compaction.getCompactionThreshold(),
       getCompactionByRuntimePrefs: () => this.#compaction.getCompactionByRuntimePrefs(),
       getTaskPrefs: () => this.#deps.taskStateStore.getTaskSync(this.#taskIdRef.current)?.composerSettings?.compactionPrefs ?? null,
@@ -103626,4 +103949,4 @@ export {
   decideWorkspaceScope,
   serve
 };
-//# sourceMappingURL=serve-HTQMCHRP.js.map
+//# sourceMappingURL=serve-JSMTUTQZ.js.map