@skaile/workspaces 4.34.0 → 4.36.0

package/dist/{chunk-OS6256B2.js → chunk-KVDXSEQH.js}

@@ -1,30 +1,30 @@
-import { WorkspacePlugin } from './chunk-2EUW6NZD.js';
-import { buildWorkspaceToolDefs } from './chunk-N2UGG6WV.js';
-import { findAiAssetsRoot } from './chunk-7IH3RKKK.js';
+import { WorkspacePlugin } from './chunk-TILISP6X.js';
+import { buildWorkspaceToolDefs } from './chunk-LIS5KT2X.js';
+import { findAiAssetsRoot } from './chunk-OEBAXTQ4.js';
 import { WebSocketServerTransport } from './chunk-5LKOAX7I.js';
 import { assembleSystemPrompt, buildCapabilitiesPromptSection } from './chunk-W3UDISS2.js';
 import { prepareNativePolicy, codexInstanceEnvironment, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult } from './chunk-HCYS7GFP.js';
-import { resolveFlowPath } from './chunk-JRSCSYRF.js';
-import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-Q6NDQ6BH.js';
-import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-OWN2W2IW.js';
-import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-DHLE66FV.js';
-import { EventNormalizer } from './chunk-NVQLE4MK.js';
-import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-LX3FKVLL.js';
+import { resolveFlowPath } from './chunk-3CLUU45N.js';
+import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-5JAO4MXA.js';
+import { ConnectFailureCarryOver, registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-FWZTKSYI.js';
+import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-S63H4HDH.js';
+import { EventNormalizer } from './chunk-3VUHHDZW.js';
+import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-NTASYPDN.js';
 import { scopeReconfigureModel } from './chunk-EINLFFP6.js';
 import { CodexNativeStateUnavailable } from './chunk-LOO5CB5M.js';
 import { dispatchCapability } from './chunk-TTITGVXV.js';
 import { classifyClaudeSdkError } from './chunk-XBSQ4KMC.js';
 import { agentExecRequested } from './chunk-YROR332M.js';
-import { toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, AgentDriver } from './chunk-MTWZ7KHZ.js';
-import { loadFlow } from './chunk-7HJ6SFFF.js';
+import { toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, AgentDriver } from './chunk-MQU632EK.js';
+import { loadFlow } from './chunk-FLGLODDF.js';
 import { parseFlowDefinition } from './chunk-DIQDYNXZ.js';
 import { renderStimulusPrompt } from './chunk-K3IBZ2UZ.js';
 import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-JS7DCCDA.js';
-import { resolveSettings, loadProviderRegistry } from './chunk-3ELIPWCH.js';
-import { resolveRuntimeAssets } from './chunk-JRIU5GA7.js';
+import { resolveSettings, loadProviderRegistry } from './chunk-FJYOQMXT.js';
+import { resolveRuntimeAssets } from './chunk-VRFKCF3R.js';
 import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
-import { resolveSkWorkspaceConfig, resolveAgentDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill, STAGED_SKILL_MARKER } from './chunk-LRCSWOZO.js';
-import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-2FBPAR2V.js';
+import { resolveSkWorkspaceConfig, resolveAgentDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill, STAGED_SKILL_MARKER } from './chunk-QKXDRBLL.js';
+import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-SQ7IN7KR.js';
 import { parseAssetRef } from './chunk-GEEW6SY2.js';
 import { resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, resolveLogsRetention, enforceLogsRetention } from './chunk-JMKB7IB4.js';
 import { pickRegistryEntries, registryEntries, resolveEntryBaseUrl, parseModelRef, isEntryEnabled, parseCredentialRef } from './chunk-MJHSLODD.js';
@@ -51,6 +51,8 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Agent, request } from 'https';
+import { Readable } from 'stream';
 import mime from 'mime';
 import { Worker } from 'worker_threads';
 
@@ -1517,6 +1519,58 @@ var FileChangedCoalescer = class {
     state.dirCapHit = false;
   }
 };
+var isBun = typeof globalThis.Bun !== "undefined";
+var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+function createPinnedCaFetch(ca) {
+  if (isBun) {
+    return (url, init) => {
+      assertHttps(url);
+      return fetch(url, { ...init, keepalive: false, tls: { ca } });
+    };
+  }
+  const agent = new Agent({ ca });
+  return (url, init) => {
+    assertHttps(url);
+    return nodeHttpsFetch(new URL(String(url)), init, agent);
+  };
+}
+function assertHttps(url) {
+  if (new URL(String(url)).protocol !== "https:") {
+    throw new Error("an MCP server with a pinned CA must use an https URL");
+  }
+}
+async function nodeHttpsFetch(url, init, agent) {
+  const headers = {};
+  new Headers(init?.headers).forEach((value, key) => {
+    headers[key] = value;
+  });
+  const body = init?.body == null ? void 0 : Buffer.from(await new Response(init.body).arrayBuffer());
+  return new Promise((resolve4, reject) => {
+    const req = request(
+      url,
+      { method: init?.method ?? "GET", headers, agent, signal: init?.signal ?? void 0 },
+      (res) => {
+        const responseHeaders = new Headers();
+        for (const [key, value] of Object.entries(res.headers)) {
+          if (value === void 0) continue;
+          for (const v of Array.isArray(value) ? value : [value]) responseHeaders.append(key, v);
+        }
+        const status = res.statusCode ?? 0;
+        const responseBody = NULL_BODY_STATUSES.has(status) ? null : Readable.toWeb(res);
+        if (responseBody === null) res.resume();
+        resolve4(
+          new Response(responseBody, {
+            status,
+            statusText: res.statusMessage,
+            headers: responseHeaders
+          })
+        );
+      }
+    );
+    req.on("error", reject);
+    req.end(body);
+  });
+}
 var execFileAsync2 = promisify(execFile);
 var DEFAULT_NIX_TIMEOUT_MS = 3e4;
 var NIX_TIMEOUT_ENV_VAR = "SKAILE_NIX_TIMEOUT_MS";
@@ -1753,6 +1807,20 @@ function resolveMcpUrl(decl, secrets) {
     throw new Error(`resolved url for MCP server '${decl.id}' is not a valid URL`);
   }
 }
+function resolveMcpCa(decl, secrets) {
+  const raw = decl.ca;
+  if (raw === void 0 || raw === "") return void 0;
+  const value = isKnownSecretRef(raw) ? secrets?.resolve(raw) : raw;
+  if (value === void 0) {
+    throw new Error(
+      `CA for MCP server '${decl.id}' unavailable \u2014 unresolved secret ref '${raw}' in ca`
+    );
+  }
+  if (!value.includes("-----BEGIN CERTIFICATE-----")) {
+    throw new Error(`ca for MCP server '${decl.id}' is not a PEM certificate`);
+  }
+  return value;
+}
 var RESERVED_MCP_SERVER_IDS = /* @__PURE__ */ new Set([
   "skaile-connectors",
   "skaile-workspace",
@@ -1887,7 +1955,11 @@ function buildTransport(decl, secrets) {
       serverId: decl.id,
       kind: "header"
     });
-    return new SSEClientTransport(resolveMcpUrl(decl, secrets), { requestInit: { headers } });
+    const pinned = pinnedFetch(decl, secrets);
+    return new SSEClientTransport(resolveMcpUrl(decl, secrets), {
+      requestInit: { headers },
+      ...pinned ? { fetch: pinned } : {}
+    });
   }
   if (transport === "http") {
     if (!decl.url) throw new Error(`http MCP server '${decl.id}' is missing 'url'`);
@@ -1895,12 +1967,18 @@ function buildTransport(decl, secrets) {
       serverId: decl.id,
       kind: "header"
     });
+    const pinned = pinnedFetch(decl, secrets);
     return new StreamableHTTPClientTransport(resolveMcpUrl(decl, secrets), {
-      requestInit: { headers }
+      requestInit: { headers },
+      ...pinned ? { fetch: pinned } : {}
     });
   }
   throw new Error(`Unknown MCP transport '${transport}' for server '${decl.id}'`);
 }
+function pinnedFetch(decl, secrets) {
+  const ca = resolveMcpCa(decl, secrets);
+  return ca === void 0 ? void 0 : createPinnedCaFetch(ca);
+}
 function defaultMcpClientConnector(secrets) {
   return async (decl) => {
     const transport = buildTransport(decl, secrets);
@@ -2447,6 +2525,7 @@ function logConnectorReport(results, resLog) {
     }
   }
 }
+var connectFailureCarryOver = new ConnectFailureCarryOver();
 async function connectAllConnectors(connectorDeclarations, projectDir, runtimeAssets, secretProvider, tokenMediator, preMintedSecrets, deferFilesystemMounts, watch, resLog, capabilityRegistry, s3Presigner) {
   const presigner = s3Presigner ?? (capabilityRegistry ? buildS3Presigner({
     invokeRemote: (name, input) => capabilityRegistry.invokeRemote(name, input),
@@ -2458,7 +2537,8 @@ async function connectAllConnectors(connectorDeclarations, projectDir, runtimeAs
     tokenMediator,
     ...presigner ? { s3Presigner: presigner } : {},
     preMintedSecrets,
-    onStatusChange: watch?.onConnectorStatus
+    onStatusChange: watch?.onConnectorStatus,
+    failureCarryOver: connectFailureCarryOver
   });
   try {
     const report = await resourceManager.connectAll(connectorDeclarations, {
@@ -2562,6 +2642,15 @@ function wireExternalMcpServersForSdk(mcpServers, resolvedDecls, secretProvider,
     instance: sessionMeta?.sessionId ?? "no-session"
   });
   for (const decl of resolvedDecls) {
+    if (decl.ca && decl.transport && decl.transport !== "stdio") {
+      mcpLog.warn(
+        "MCP server skipped: it pins a CA, which the SDK mcpServers config cannot carry",
+        {
+          id: decl.id
+        }
+      );
+      continue;
+    }
     const serverConfig = toSdkMcpServerConfig(
       decl,
       secretProvider
@@ -3522,13 +3611,19 @@ var CapabilityRegistry = class {
   }
 };
 function computeCapabilitySignature(caps) {
-  const canonical2 = caps.slice().sort((a, b) => a.name.localeCompare(b.name)).map((c) => ({
+  const canonical2 = caps.filter((c) => !isConnectionScopedAppCapability(c)).sort((a, b) => a.name.localeCompare(b.name)).map((c) => ({
     name: c.name,
     origin: c.origin.kind,
     schemaSha256: sha256(JSON.stringify(c.inputSchema ?? {}))
   }));
   return sha256(JSON.stringify(canonical2));
 }
+function capabilitySignatureInputs(caps) {
+  return caps.filter((c) => !isConnectionScopedAppCapability(c)).map((c) => `${c.name}:${c.origin.kind}`).sort();
+}
+function isConnectionScopedAppCapability(cap) {
+  return cap.origin.kind === "app" || cap.name.startsWith(APP_CAPABILITY_PREFIX);
+}
 function sha256(input) {
   return createHash("sha256").update(input).digest("hex");
 }
@@ -4803,6 +4898,41 @@ function compactionGateTimeoutMs() {
   const raw = Number(process.env.SKAILE_COMPACTION_GATE_TIMEOUT_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_GATE_TIMEOUT_MS;
 }
+var DEFAULT_COMPACTION_TURN_WAIT_MS = 10 * 6e4;
+function compactionTurnWaitMs() {
+  const raw = Number(process.env.SKAILE_COMPACTION_TURN_WAIT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_TURN_WAIT_MS;
+}
+var PLATFORM_COMPACTION_TURN_WAIT_MS = 3e4;
+function compactionTurnWaitFor(trigger) {
+  return trigger === "threshold" ? compactionTurnWaitMs() : PLATFORM_COMPACTION_TURN_WAIT_MS;
+}
+async function claimDriverForCompaction(deps) {
+  const hold = deps.gate.begin();
+  let released = false;
+  const release2 = () => {
+    if (released) return;
+    released = true;
+    deps.gate.settle(hold);
+  };
+  const timeoutMs = deps.timeoutMs ?? compactionTurnWaitMs();
+  if (await raceDeadline(deps.awaitClaimedTurns(), timeoutMs) === "opened") return release2;
+  release2();
+  deps.log(
+    `[serve] compaction skipped: a turn still held the driver after ${Math.round(timeoutMs / 1e3)}s`
+  );
+  return null;
+}
+var TURN_COMPACTION_YIELD_ATTEMPTS = 3;
+async function beginTurnClearOfCompaction(deps, maxAttempts = TURN_COMPACTION_YIELD_ATTEMPTS) {
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    if (!await deps.awaitIdle()) return null;
+    const endTurn = await deps.claimTurn();
+    if (deps.gate.isIdle()) return endTurn;
+    endTurn();
+  }
+  throw new Error(`turn overtaken by a compaction ${maxAttempts} times running`);
+}
 var COMPACTION_GATE_TIMEOUT_MESSAGE = "The session is still compacting its history and could not take this message. Send it again in a moment.";
 async function guardTurnAgainstCompaction(deps) {
   const outcome = await deps.gate.awaitIdle(deps.timeoutMs ?? compactionGateTimeoutMs());
@@ -4814,6 +4944,7 @@ async function guardTurnAgainstCompaction(deps) {
 }
 
 // runner/src/driver-swap-gate.ts
+var TURN_BIND_ATTEMPTS = 3;
 var DriverSwapGate = class {
   /** Resolves when the in-flight driver recreate settles (resolve or reject). */
   activeDriverSwap = null;
@@ -4859,6 +4990,25 @@ var DriverSwapGate = class {
     }
     return endTurn;
   }
+  /**
+   * Claim a turn slot on a driver no swap is about to replace. `prepare` is the
+   * turn's async pre-flight (the driver start); a swap that registers during it
+   * has already passed its turn wait, so the prompt waits that swap out and
+   * prepares again on the fresh driver instead of dispatching onto the one being
+   * killed. The slot is claimed in the same tick as the final check, so any later
+   * swap waits for the turn. A failed swap releases the waiter; a throwing
+   * `prepare` rejects with no slot claimed. Returns `endTurn`, as `beginTurn` does.
+   * Bounded like the driver start: swaps overtaking every attempt is pathological,
+   * and failing loudly beats spinning.
+   */
+  async beginTurnOnLiveDriver(prepare, maxAttempts = TURN_BIND_ATTEMPTS) {
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      await this.awaitSwap();
+      await prepare();
+      if (!this.isSwapping()) return this.beginTurn();
+    }
+    throw new Error(`turn's driver replaced by a swap ${maxAttempts} times running`);
+  }
   /** Whether a driver swap is registered and has not settled yet. */
   isSwapping() {
     return this.activeDriverSwap !== null;
@@ -5041,6 +5191,38 @@ var PendingTurns = class {
   }
 };
 
+// runner/src/prompt-turn-queue.ts
+var PromptTurnQueue = class {
+  tail = Promise.resolve();
+  held = 0;
+  /** Take the next place. Call before the first `await` of the prompt's handler. */
+  join() {
+    const queued = this.held > 0;
+    this.held += 1;
+    const ready = this.tail;
+    let open4;
+    const done = new Promise((resolve4) => {
+      open4 = resolve4;
+    });
+    this.tail = ready.then(() => done);
+    let left = false;
+    return {
+      queued,
+      ready,
+      leave: () => {
+        if (left) return;
+        left = true;
+        this.held -= 1;
+        open4();
+      }
+    };
+  }
+  /** Prompts that joined and have not left yet; for diagnostics and tests. */
+  get size() {
+    return this.held;
+  }
+};
+
 // runner/src/serial-lock.ts
 function createSerialLock() {
   let tail = Promise.resolve();
@@ -5739,7 +5921,12 @@ var CompactionOrchestrator = class {
     this._isCompacting = true;
     this._startFired = false;
     this._endFired = false;
+    let releaseDriver = null;
     try {
+      if (this.opts.claimDriver) {
+        releaseDriver = await this.opts.claimDriver(trigger);
+        if (!releaseDriver) return null;
+      }
       return await this._doCompact(trigger, focus);
     } finally {
       this._isCompacting = false;
@@ -5750,7 +5937,11 @@ var CompactionOrchestrator = class {
           `[compaction] onCompactionEnd threw while unwinding: ${err instanceof Error ? err.message : String(err)}`
         );
       } finally {
-        this.opts.onCompactionSettled?.();
+        try {
+          this.opts.onCompactionSettled?.();
+        } finally {
+          releaseDriver?.();
+        }
       }
     }
   }
@@ -7623,6 +7814,10 @@ function createSessionStimulusBus(opts) {
     }
   }
   return {
+    hasTurn(connectorId) {
+      const q = queues.get(connectorId);
+      return q !== void 0 && (q.inFlight || q.pending.length > 0);
+    },
     signal(connectorId, sig) {
       const coalesceMs = sig.coalesceMs ?? defaultCoalesceMs;
       log?.debug("stimulus signaled", {
@@ -8053,7 +8248,7 @@ async function recreateKeepingLiveFlows(flows, deps) {
     try {
       const run = await deps.reconnect(snapshot);
       reconnected.push(snapshot.runId);
-      if (restoredRunHasWorkToResume(run)) deps.resume(run);
+      if (restoredRunHasWorkToResume(run) || deps.needsAgentTurn?.(run)) deps.resume(run);
     } catch (err) {
       deps.warn("flow run could not be reconnected after the driver recreate", {
         runId: snapshot.runId,
@@ -8063,6 +8258,19 @@ async function recreateKeepingLiveFlows(flows, deps) {
   }
   return reconnected;
 }
+function reconnectedRunNeedsAgentTurn(state) {
+  return state.cutDriverWork && state.wantsAgentTurn && !state.busHasTurn && !state.promptQueuedForRun;
+}
+var DRIVER_ACTIVITY_EVENTS = /* @__PURE__ */ new Set([
+  "message_start",
+  "message_update",
+  "tool_call"
+]);
+function driverActiveAfterTurnEnd(active, event) {
+  const type = event?.type;
+  if (type === "agent_end" || type === "result") return false;
+  return typeof type === "string" && DRIVER_ACTIVITY_EVENTS.has(type) ? true : active;
+}
 async function buildStoreSnapshotReplay(manager, activeFlows) {
   const events = [];
   for (const { runId, adapter, handle } of activeFlows) {
@@ -9437,7 +9645,9 @@ async function startAgentServer(opts) {
   const pendingTurns = new PendingTurns(() => {
     if (!compacting) sendEvent({ type: "status", phase: "idle" });
   });
+  const promptTurns = new PromptTurnQueue();
   let driverRestartChain = Promise.resolve();
+  let liveDriverActiveAfterTurn = false;
   let driver = secretsMode === "env" ? agentSession.driver : void 0;
   let secretsProvisioned = secretsMode === "env";
   function swapDriver() {
@@ -9456,6 +9666,7 @@ async function startAgentServer(opts) {
     driver = incoming;
     normalizer.reset();
     driverStarted = false;
+    liveDriverActiveAfterTurn = false;
     driverStartInFlight = null;
   }
   let eventSeq = 0;
@@ -9506,6 +9717,15 @@ async function startAgentServer(opts) {
         compactionGate.settle(gateHold);
         gateHold = null;
       },
+      // A user turn that already holds a slot keeps the driver; the compaction
+      // waits for it rather than prompting the driver under it. A platform call
+      // waits briefly: a turn paused on a question can hold its slot for hours.
+      claimDriver: (trigger) => claimDriverForCompaction({
+        gate: compactionGate,
+        awaitClaimedTurns: () => driverSwapGate.awaitActiveTurn(),
+        log,
+        timeoutMs: compactionTurnWaitFor(trigger)
+      }),
       onLog: (line) => log(`[serve] ${line}`),
       // Phase 3: stamp every CompactionAttemptEvent with the registry's
       // current signature so wake-time tier-1 selection has the input it
@@ -9548,6 +9768,7 @@ async function startAgentServer(opts) {
           await starting.start();
           if (driver !== starting) return;
           starting.on("agent-event", (event) => {
+            liveDriverActiveAfterTurn = driverActiveAfterTurnEnd(liveDriverActiveAfterTurn, event);
             const normalized = normalizer.normalize(event);
             const turnEnded = event.type === "agent_end";
             for (const e of normalized) {
@@ -9621,6 +9842,12 @@ async function startAgentServer(opts) {
       )
     );
   }
+  function activeFlowWantsAgentTurn(runId) {
+    const entry = activeFlows.get(runId);
+    if (!entry) return false;
+    if (!flowRunDrivesTurns(entry.adapter.getExecution(entry.handle))) return false;
+    return entry.adapter.shouldDriveAgentTurn(entry.handle, { kind: "resumed_after_hibernation" });
+  }
   async function countPendingTurn(run) {
     const end = pendingTurns.begin();
     try {
@@ -10067,6 +10294,8 @@ async function startAgentServer(opts) {
     });
   }
   async function recreateAgentSessionInner(overrides) {
+    const cutDriverWork = driverStarted && liveDriverActiveAfterTurn;
+    const redriven = [];
     const reconnected = await recreateKeepingLiveFlows(activeFlows.values(), {
       recreate: () => rebuildAgentSession(overrides),
       hasConnector: (id) => resourceManager?.has(id) ?? false,
@@ -10078,11 +10307,25 @@ async function startAgentServer(opts) {
         )
       ),
       resume: (run) => kickFlowTurn(run, { kind: "resumed_after_hibernation" }),
+      needsAgentTurn: (run) => {
+        const needed = reconnectedRunNeedsAgentTurn({
+          cutDriverWork,
+          wantsAgentTurn: activeFlowWantsAgentTurn(run.runId),
+          busHasTurn: stimulusBus?.hasTurn(run.connectorId) ?? false,
+          // Approximate: a waiting reply counts too. A prompt reaches one run only.
+          promptQueuedForRun: pendingTurns.size > 0 && pickChatFlowTarget(activeFlows.values())?.runId === run.runId
+        });
+        if (needed) redriven.push(run.runId);
+        return needed;
+      },
       warn: (message, fields) => serverLog.warn(message, fields)
     });
     if (reconnected.length > 0) {
       serverLog.info("flow runs reconnected after the driver recreate", { runIds: reconnected });
     }
+    if (redriven.length > 0) {
+      serverLog.warn("flow turn re-driven after the driver recreate", { runIds: redriven });
+    }
     emitAvailability();
   }
   async function rebuildAgentSession(overrides) {
@@ -10596,6 +10839,9 @@ async function startAgentServer(opts) {
           log(
             `[serve] tier-1 resume rejected: signature mismatch (expected=${cfgExpectedSig.slice(0, 12)} current=${currentSig.slice(0, 12)})`
           );
+          log(
+            `[serve] tier-1 resume signed set: ${capabilitySignatureInputs(capabilityRegistry.list()).join(",")}`
+          );
           sendEvent({
             type: "resume_failed",
             resumeSessionId: cfgResumeSessionId,
@@ -10701,6 +10947,20 @@ async function startAgentServer(opts) {
   const awaitCompactionIdle = (what) => guardTurnAgainstCompaction({ gate: compactionGate, what, log, sendEvent });
   async function handlePrompt(cmd) {
     if (cmd.messageId) sendEvent({ type: "prompt_ack", messageId: cmd.messageId });
+    const place = promptTurns.join();
+    try {
+      if (place.queued) {
+        driver?.supersedePendingQuestion?.();
+        const queuedAt = Date.now();
+        await place.ready;
+        logPhase("prompt_queue_wait", queuedAt);
+      }
+      await runPromptTurn(cmd, place.leave);
+    } finally {
+      place.leave();
+    }
+  }
+  async function runPromptTurn(cmd, leaveQueue) {
     const promptReceivedAt = Date.now();
     const sessionIsReady = await awaitSessionReadyOrFail();
     logPhase("prompt_gate_wait", promptReceivedAt, { ready: sessionIsReady });
@@ -10721,6 +10981,7 @@ async function startAgentServer(opts) {
     await restageMaterializedSkills(true);
     const activeFlow = pickChatFlowTarget(activeFlows.values());
     if (activeFlow) {
+      leaveQueue();
       sendEvent({ type: "status", phase: "thinking" });
       try {
         const bus = getOrCreateStimulusBus();
@@ -10749,19 +11010,31 @@ async function startAgentServer(opts) {
     }
     const driverStartStartedAt = Date.now();
     let driverStartOk = false;
+    let driverStartAttempts = 0;
+    let endTurn;
     try {
-      await ensureDriverStarted();
-      driverStartOk = true;
+      endTurn = await beginTurnClearOfCompaction({
+        gate: compactionGate,
+        awaitIdle: () => awaitCompactionIdle("prompt"),
+        claimTurn: () => driverSwapGate.beginTurnOnLiveDriver(() => {
+          driverStartAttempts += 1;
+          return ensureDriverStarted();
+        })
+      });
+      driverStartOk = endTurn !== null;
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       log(`[serve] driver start failed: ${errMsg}`);
       sendEvent({ type: "error", message: `Driver start failed: ${errMsg}`, fatal: true });
       return;
     } finally {
-      logPhase("driver_start", driverStartStartedAt, { ok: driverStartOk });
+      logPhase("driver_start", driverStartStartedAt, {
+        ok: driverStartOk,
+        attempts: driverStartAttempts
+      });
     }
+    if (!endTurn) return;
     sendEvent({ type: "status", phase: "thinking" });
-    const endTurn = driverSwapGate.beginTurn();
     try {
       await driver.promptInput({ text: cmd.prompt, attachments: cmd.attachments });
     } catch (err) {
@@ -10792,8 +11065,22 @@ async function startAgentServer(opts) {
     });
     if (routed === "answered") return;
     if (!driver.acceptsReplyAsPrompt) return;
-    if (!await awaitCompactionIdle("reply")) return;
-    const endTurn = driverSwapGate.beginTurn();
+    let endTurn;
+    try {
+      endTurn = await beginTurnClearOfCompaction({
+        gate: compactionGate,
+        awaitIdle: () => awaitCompactionIdle("reply"),
+        claimTurn: () => driverSwapGate.beginTurnOnLiveDriver(ensureDriverStarted)
+      });
+    } catch (err) {
+      sendEvent({
+        type: "error",
+        message: `Reply failed: ${err instanceof Error ? err.message : String(err)}`,
+        fatal: false
+      });
+      return;
+    }
+    if (!endTurn) return;
     try {
       await driver.prompt(cmd.answer);
     } catch (err) {
@@ -11382,6 +11669,6 @@ function touchSession(state) {
   return { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
 }
 
-export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowRunDrivesTurns, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-OS6256B2.js.map
-//# sourceMappingURL=chunk-OS6256B2.js.map
+export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, capabilitySignatureInputs, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, driverActiveAfterTurnEnd, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowRunDrivesTurns, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, reconnectedRunNeedsAgentTurn, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
+//# sourceMappingURL=chunk-KVDXSEQH.js.map
+//# sourceMappingURL=chunk-KVDXSEQH.js.map