@skaile/workspaces 5.1.3 → 5.2.0

package/dist/{chunk-KWP4RVTJ.js → chunk-ZSFTCMZL.js}

@@ -1,32 +1,32 @@
-import { WorkspacePlugin } from './chunk-KNC55536.js';
-import { buildWorkspaceToolDefs } from './chunk-WPWJRDR3.js';
-import { findAiAssetsRoot } from './chunk-TYUJB336.js';
+import { WorkspacePlugin } from './chunk-XIYXBHLN.js';
+import { buildWorkspaceToolDefs } from './chunk-2MEMXBLC.js';
+import { findAiAssetsRoot } from './chunk-7Y43UXKA.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-ZVKJNNME.js';
-import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-VDJKWKH2.js';
-import { ConnectFailureCarryOver, registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-M4ISBWXR.js';
-import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-WKIOWDLQ.js';
-import { EventNormalizer } from './chunk-QU4J5YSJ.js';
-import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-TVOODIZE.js';
+import { resolveFlowPath } from './chunk-IOUIC2ZD.js';
+import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-XOTJVCJB.js';
+import { ConnectFailureCarryOver, registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-MGHUSFYQ.js';
+import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-UDBN3LZU.js';
+import { EventNormalizer } from './chunk-OFNXRI4L.js';
+import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-2QZG5VJQ.js';
 import { scopeReconfigureModel } from './chunk-EINLFFP6.js';
 import { CodexNativeStateUnavailable } from './chunk-LOO5CB5M.js';
-import { dispatchCapability } from './chunk-RDYI4MML.js';
+import { dispatchCapability } from './chunk-BNUZEYC3.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-ZD7CX25M.js';
-import { loadFlow } from './chunk-UMSWQKCY.js';
+import { driverCapabilities, toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, supportsLiveToolUpdates, AgentDriver } from './chunk-3E2TIPBZ.js';
+import { loadFlow } from './chunk-RXPC4KBW.js';
 import { parseFlowDefinition } from './chunk-QZLWJETK.js';
 import { renderStimulusPrompt } from './chunk-XUUYAS3Z.js';
-import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-IDEA6CYI.js';
-import { resolveLibraryDir, resolveSettings, loadProviderRegistry } from './chunk-IWCCZL7C.js';
-import { resolveRuntimeAssets } from './chunk-YDJZRLGN.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-MXXKTQXJ.js';
+import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION, deliveryClassOf } from './chunk-K2K7OF4P.js';
+import { resolveLibraryDir, resolveSettings, loadProviderRegistry } from './chunk-BIMEKYOE.js';
+import { resolveRuntimeAssets } from './chunk-PU5VY7KF.js';
+import { DEFAULT_DRIVER_ID, resolveDriverPaths } from './chunk-5BEFNLOR.js';
+import { resolveSkWorkspaceConfig, resolveAgentDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill, STAGED_SKILL_MARKER } from './chunk-P2EM6FNQ.js';
 import { globalSkaileDir } from './chunk-TLKM4M47.js';
-import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-DXUQCMVT.js';
-import { parseAssetRef } from './chunk-43ZBF3WH.js';
+import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-YANDJSMN.js';
+import { parseAssetRef } from './chunk-OABIGSUY.js';
 import { resolveLogStoreConfig, createLogStoreFromConfig, OnLogBridgeSink, WsLogSink, resolveLogsRetention, enforceLogsRetention } from './chunk-JMKB7IB4.js';
 import { pickRegistryEntries, registryEntries, resolveEntryBaseUrl, parseModelRef, isEntryEnabled, parseCredentialRef } from './chunk-MJHSLODD.js';
 import { getLogStore, registerLogStore, createLogger, resetLogStore, isUnwritableStreamError, markStreamBroken, isBrokenPipeError, redactCredentials } from './chunk-BOFL7GIF.js';
@@ -2332,6 +2332,7 @@ function parsePresignResult(raw, op) {
 // runner/src/resources.ts
 async function buildAgentResources(projectDir, driverType, _onLog, watch, secretProvider, sessionMeta, tokenMediator, preMintedSecrets, deferFilesystemMounts, capabilityRegistry, fallbackConnectorDeclarations, extraMcpDeclarations, s3Presigner) {
   const managedProjectMcp = sessionMeta?.managedCodex ? await resolveExternalMcpDeclarations(projectDir, sessionMeta.sessionId, true) : void 0;
+  const inProcessMcp = driverCapabilities(driverType).inProcessMcpServers;
   const resLog = createLogger({
     kind: "runner",
     subkind: "resources",
@@ -2415,7 +2416,7 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
       }
       return externalMcpManager;
     };
-    if (driverType === "claude-sdk") {
+    if (inProcessMcp) {
       const inProcess = await buildInProcessMcpServers(
         resourceManager,
         projectDir,
@@ -2442,7 +2443,7 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
         mcpSecretChain,
         sessionMeta
       );
-    } else if (driverType === "claude-sdk") {
+    } else if (inProcessMcp) {
       externalMcpDeclarations = await resolveExternalMcpDeclarations(
         projectDir,
         sessionMeta?.sessionId
@@ -2454,7 +2455,7 @@ async function buildAgentResources(projectDir, driverType, _onLog, watch, secret
         sessionMeta
       );
     }
-    if (!resourceManager && driverType !== "claude-sdk" && !externalMcpManager?.hasServers() && !capabilityRegistry)
+    if (!resourceManager && !inProcessMcp && !externalMcpManager?.hasServers() && !capabilityRegistry)
       return noopResult;
     let coalescer = null;
     const startWatching = () => {
@@ -2724,7 +2725,7 @@ function toSdkMcpServerConfig(decl, secrets) {
 // runner/src/session-builder.ts
 async function createAgentSession(config) {
   const managed = config.managedCodex;
-  if (managed && (config.driver !== "codex" || !config.model || !config.aiProviderConfigId || !config.capabilityRegistry || !config.capabilities))
+  if (managed && (!driverCapabilities(config.driver).managedSession || !config.model || !config.aiProviderConfigId || !config.capabilityRegistry || !config.capabilities))
     throw new Error("AI_PROFILE_INVALID");
   const {
     projectDir,
@@ -2763,7 +2764,7 @@ async function createAgentSession(config) {
     driver: driverOverride,
     model: modelOverride
   });
-  const driverType = managed ? "codex" : settings.driver ?? "omp";
+  const driverType = (managed ? config.driver : settings.driver) ?? DEFAULT_DRIVER_ID;
   const model = managed ? config.model : settings.model;
   const registry = loadSessionRegistry(projectDir, config.registry, config.providers, sessionLog);
   const modelRef = config.modelRef?.trim() || model?.trim() || void 0;
@@ -2867,7 +2868,7 @@ async function createAgentSession(config) {
   const maxTurns = maxTurnsOverride ?? manifest?.runtime?.max_turns;
   let driver;
   try {
-    const extraMcpServers = driverType === "claude-sdk" ? await config.extraInProcessMcpServers?.() : void 0;
+    const extraMcpServers = driverCapabilities(driverType).inProcessMcpServers ? await config.extraInProcessMcpServers?.() : void 0;
     const driverMcpServers = extraMcpServers ? { ...mcpServers, ...extraMcpServers } : mcpServers;
     driver = await createSessionDriver({
       config,
@@ -4502,7 +4503,7 @@ function validateCodexInit(cmd, supported, previous) {
   if (requirements !== void 0 && (!Array.isArray(requirements) || requirements.some((item) => typeof item !== "string" || !supported.includes(item))))
     throw new Error("Unsupported runtime: required features are unavailable");
   const profile = cmd.resolvedConfig.agentConfig;
-  const managed = profile?.driver === "codex" && (profile.authMode !== void 0 || requirements?.includes("codex-app-server-v1"));
+  const managed = profile !== void 0 && driverCapabilities(profile.driver).managedSession && (profile.authMode !== void 0 || requirements?.includes("codex-app-server-v1"));
   if ((managed || cmd.credentials.ai !== void 0) && !supported.includes("codex-app-server-v1"))
     throw new Error("Unsupported runtime: codex-app-server-v1 is unavailable");
   if (!managed && cmd.credentials.ai === void 0) return;
@@ -4605,7 +4606,7 @@ function loadManagedCodexHostConfig(file, projectDir) {
 function bindManagedCodexInit(host, cmd, refreshCredential) {
   const profile = cmd.resolvedConfig.agentConfig;
   const credential = parseCodexCredential(cmd.credentials.ai);
-  if (!profile?.authMode || !["subscription", "api-key"].includes(profile.authMode) || cmd.identity.sessionId !== host.sessionId || profile?.driver !== "codex" || !profile.model || !host.subpromptModels.available.includes(profile.model) || credential.configId !== cmd.resolvedConfig.aiProviderConfigId || profile.authMode === "subscription" !== (credential.kind === "codex-subscription"))
+  if (!profile?.authMode || !["subscription", "api-key"].includes(profile.authMode) || cmd.identity.sessionId !== host.sessionId || !driverCapabilities(profile.driver).managedSession || !profile.model || !host.subpromptModels.available.includes(profile.model) || credential.configId !== cmd.resolvedConfig.aiProviderConfigId || profile.authMode === "subscription" !== (credential.kind === "codex-subscription"))
     throw refused();
   const reasoningEffort = profile.effort ?? host.reasoningEffort;
   if (!["minimal", "low", "medium", "high", "xhigh"].includes(reasoningEffort)) throw refused();
@@ -5012,6 +5013,309 @@ function planRuntimeSessionEmit(input) {
   return { type: "runtime_session", driverSessionId, model, capabilitySignature };
 }
 
+// runner/src/init-build-hold.ts
+var DEFAULT_CONNECTOR_MUTATE_INIT_HOLD_MS = 1e4;
+function resolveConnectorMutateInitHoldMs(env = process.env) {
+  const parsed = Number.parseInt(env.SKAILE_CONNECTOR_MUTATE_INIT_HOLD_MS ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_CONNECTOR_MUTATE_INIT_HOLD_MS;
+}
+function createInitBuildHold(now = Date.now) {
+  let current = null;
+  let tail = Promise.resolve();
+  let held = 0;
+  const building = () => current !== null && !current.done;
+  async function awaitNewestBuild() {
+    for (; ; ) {
+      const build = current;
+      if (!build) return null;
+      if (!build.done) await build.settled;
+      if (current === build) return build.error;
+    }
+  }
+  return {
+    beginBuild() {
+      let resolve4;
+      const build = {
+        done: false,
+        error: null,
+        settled: new Promise((r) => {
+          resolve4 = r;
+        })
+      };
+      current = build;
+      const settle = (error) => {
+        if (build.done) return;
+        build.done = true;
+        build.error = error;
+        resolve4();
+      };
+      return { succeed: () => settle(null), fail: (error) => settle(error) };
+    },
+    run(task, deadlineMs) {
+      if (held === 0 && !building()) {
+        if (current?.error) return task({ kind: "failed", error: current.error });
+        return task({ kind: "ready", remainingMs: void 0 });
+      }
+      held++;
+      const arrivedAt = now();
+      const previous = tail;
+      const turn = previous.then(awaitNewestBuild);
+      let timer;
+      const deadline = deadlineMs === void 0 ? null : new Promise((resolve4) => {
+        timer = setTimeout(() => resolve4("timeout"), deadlineMs);
+        timer.unref?.();
+      });
+      let markStarted;
+      const started = new Promise((resolve4) => {
+        markStarted = resolve4;
+      });
+      const result = (async () => {
+        const first = deadline ? await Promise.race([turn, deadline]) : await turn;
+        clearTimeout(timer);
+        if (first === "timeout") {
+          void turn.then(markStarted);
+          return task({ kind: "timeout", waitedMs: now() - arrivedAt });
+        }
+        markStarted();
+        if (first) return task({ kind: "failed", error: first });
+        return task({
+          kind: "ready",
+          remainingMs: deadlineMs === void 0 ? void 0 : Math.max(0, deadlineMs - (now() - arrivedAt))
+        });
+      })();
+      tail = started;
+      void Promise.allSettled([turn, result]).then(() => {
+        held--;
+      });
+      return result;
+    },
+    held: () => held
+  };
+}
+
+// runner/src/serial-lock.ts
+function createSerialLock() {
+  let tail = Promise.resolve();
+  return (fn) => {
+    const run = tail.then(fn, fn);
+    tail = run.catch(() => void 0);
+    return run;
+  };
+}
+function createCoalescedTask(lock, fn) {
+  let waiting = null;
+  return (...args) => {
+    if (waiting) return waiting;
+    const run = lock(() => {
+      waiting = null;
+      return fn(...args);
+    });
+    waiting = run;
+    return run;
+  };
+}
+async function recordStagedSkills(staged, projectDir, skillsDir, names, timeoutMs) {
+  for (const name of names) {
+    const path6 = join(projectDir, skillsDir, name);
+    const st = await tryWithFsDeadline(`lstat ${path6}`, () => lstat(path6), null, timeoutMs);
+    staged.set(
+      name,
+      st?.isDirectory() && st.birthtimeMs > 0 ? { path: path6, dev: st.dev, ino: st.ino, birthtimeMs: st.birthtimeMs } : null
+    );
+  }
+}
+async function isStillOurs(record2, path6, timeoutMs) {
+  if (!record2 || record2.path !== path6) return false;
+  const st = await tryWithFsDeadline(`lstat ${path6}`, () => lstat(path6), null, timeoutMs);
+  return st?.isDirectory() === true && st.dev === record2.dev && st.ino === record2.ino && st.birthtimeMs === record2.birthtimeMs;
+}
+async function recordLoadedSkillDigests(loaded, projectDir, skillsDir, names, opts) {
+  for (const name of names) {
+    if (opts.driverUp && opts.previouslyStaged.has(name)) continue;
+    const path6 = join(projectDir, skillsDir, name);
+    loaded.set(name, { path: path6, digest: await stagedSkillDigest(path6) });
+  }
+}
+var DIGEST_DEADLINE_FACTOR = 4;
+var DIGEST_MAX_BYTES = 64 * 1024 * 1024;
+var DIGEST_CHUNK_BYTES = 64 * 1024;
+var DIGEST_OPEN_FLAGS = constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+async function stagedSkillDigest(dir, timeoutMs) {
+  return tryWithFsDeadline(
+    `digest ${dir}`,
+    async () => {
+      const hash = createHash("sha256");
+      let budget = DIGEST_MAX_BYTES;
+      const hashFile = async (path6) => {
+        const fh = await open(path6, DIGEST_OPEN_FLAGS);
+        try {
+          const st = await fh.stat();
+          if (!st.isFile()) throw new Error(`not a regular file: ${path6}`);
+          if (st.size > budget) throw new Error("skill too large to digest");
+          const buf = Buffer.alloc(DIGEST_CHUNK_BYTES);
+          let total = 0;
+          for (; ; ) {
+            const { bytesRead } = await fh.read(buf, 0, buf.length, null);
+            if (bytesRead === 0) break;
+            total += bytesRead;
+            if (total > budget) throw new Error("skill too large to digest");
+            hash.update(buf.subarray(0, bytesRead));
+          }
+          budget -= total;
+          hash.update(`\0${total}\0`);
+        } finally {
+          await fh.close();
+        }
+      };
+      const walk = async (rel) => {
+        const here = rel ? join(dir, rel) : dir;
+        if (rel && !(await lstat(here)).isDirectory()) throw new Error(`not a dir: ${here}`);
+        const entries = await readdir(here, { withFileTypes: true });
+        entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        for (const entry of entries) {
+          if (!rel && entry.name === STAGED_SKILL_MARKER) continue;
+          const path6 = rel ? `${rel}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) {
+            hash.update(`d\0${path6}\0`);
+            await walk(path6);
+          } else if (entry.isSymbolicLink()) {
+            hash.update(`l\0${path6}\0${await readlink(join(dir, path6))}\0`);
+          } else if (entry.isFile()) {
+            hash.update(`f\0${path6}\0`);
+            await hashFile(join(dir, path6));
+          } else {
+            hash.update(`o\0${path6}\0`);
+          }
+        }
+      };
+      await walk("");
+      return hash.digest("hex");
+    },
+    null,
+    fsDeadlineMs() * DIGEST_DEADLINE_FACTOR
+  );
+}
+async function attachStagedSkill(deps, name) {
+  try {
+    const skillsDir = deps.skillsDir();
+    const dirName = name.includes("/") ? name.split("/").pop() : name;
+    const { staged, unchanged } = await deps.withSkillFsLock(async () => {
+      const dest = join(deps.projectDir, skillsDir, dirName);
+      const loaded = deps.stagedSkillDirs.has(dirName) ? deps.loadedSkillDigests.get(dirName) : void 0;
+      const names = await stageMaterializedSkills(deps.projectDir, skillsDir, { declared: [name] });
+      let same = false;
+      if (names.includes(dirName)) {
+        const digest = await stagedSkillDigest(dest);
+        same = digest !== null && loaded?.path === dest && loaded.digest === digest;
+        if (!same) deps.loadedSkillDigests.set(dirName, { path: dest, digest });
+      }
+      await recordStagedSkills(deps.stagedSkillDirs, deps.projectDir, skillsDir, names);
+      return { staged: names, unchanged: same ? dirName : null };
+    });
+    if (staged.length === 0) {
+      return {
+        ok: false,
+        code: "skill_not_materialized",
+        message: `no materialized skill matching "${name}" under .skaile/assets/skill`
+      };
+    }
+    const live = deps.driverStarted();
+    const toRestart = staged.filter((s) => s !== unchanged);
+    if (toRestart.length === 0) {
+      deps.log(
+        `[serve] runner.attach_instance: skill ${staged.join(", ")} already staged and unchanged \u2014 no driver restart`
+      );
+      return { ok: true, id: name, live, toolCount: 0 };
+    }
+    deps.log(`[serve] runner.attach_instance staged skill(s): ${toRestart.join(", ")}`);
+    deps.scheduleSkillRestart(toRestart.map((s) => ({ name: s, action: "add" })));
+    return { ok: true, id: name, live, toolCount: 0 };
+  } catch (err) {
+    return {
+      ok: false,
+      code: "skill_attach_failed",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function detachStagedSkill(deps, name) {
+  try {
+    const skillsDir = deps.skillsDir();
+    const dirName = name.split("/").pop() ?? name;
+    const result = await deps.withSkillFsLock(async () => {
+      const knownStaged = await isStillOurs(
+        deps.stagedSkillDirs.get(dirName),
+        join(deps.projectDir, skillsDir, dirName)
+      );
+      return unstageSkill(deps.projectDir, skillsDir, name, { knownStaged });
+    });
+    const live = deps.driverStarted();
+    if ("reason" in result) {
+      deps.log(
+        `[serve] runner.detach_instance: "${result.name}" exists but was not staged by the runner \u2014 left in place`
+      );
+      return { ok: true, id: result.name, removed: false, live, reason: result.reason };
+    }
+    const wasTracked = deps.stagedSkillDirs.delete(result.name);
+    if (!result.removedStaged && !wasTracked) {
+      deps.log(`[serve] runner.detach_instance: skill "${result.name}" was not staged`);
+      return { ok: true, id: result.name, removed: result.removedAsset, live };
+    }
+    deps.log(`[serve] runner.detach_instance unstaged skill: ${result.name}`);
+    deps.scheduleSkillRestart([{ name: result.name, action: "remove" }]);
+    return { ok: true, id: result.name, removed: true, live };
+  } catch (err) {
+    return {
+      ok: false,
+      code: "skill_detach_failed",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function pathState(path6) {
+  try {
+    await withFsDeadline(`lstat ${path6}`, () => lstat(path6));
+    return "present";
+  } catch (err) {
+    return err?.code === "ENOENT" ? "absent" : "unknown";
+  }
+}
+async function removeUnlistedStagedSkills(deps, skillsDir) {
+  const allowed = await readSkillAllowList(deps.projectDir);
+  if (!allowed) return [];
+  const root = join(deps.projectDir, skillsDir);
+  const entries = await tryWithFsDeadline(
+    `readdir ${root}`,
+    () => readdir(root, { withFileTypes: true }),
+    []
+  );
+  const removed = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || allowed.has(entry.name)) continue;
+    try {
+      const dir = join(root, entry.name);
+      if (await pathState(join(deps.projectDir, ".skaile/assets/skill", entry.name)) !== "absent") {
+        continue;
+      }
+      const knownStaged = await isStillOurs(deps.stagedSkillDirs.get(entry.name), dir);
+      if (!knownStaged && !await isStagedSkillMarkerFor(dir, entry.name).catch(() => false))
+        continue;
+      const result = await unstageSkill(deps.projectDir, skillsDir, entry.name, {
+        knownStaged,
+        keepAsset: true
+      });
+      if ("reason" in result || !result.removedStaged) continue;
+      deps.stagedSkillDirs.delete(result.name);
+      removed.push(result.name);
+    } catch (err) {
+      deps.log(
+        `[serve] could not remove unlisted skill "${entry.name}" (left in place): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return removed;
+}
+
 // runner/src/compaction-gate.ts
 var CompactionGate = class {
   /**
@@ -5125,7 +5429,7 @@ async function claimDriverForCompaction(deps) {
     released = true;
     deps.gate.settle(hold);
   };
-  const timeoutMs = deps.timeoutMs ?? compactionTurnWaitMs();
+  const { timeoutMs } = deps;
   if (await raceDeadline(deps.awaitClaimedTurns(), timeoutMs) !== "opened") {
     release2();
     deps.log(
@@ -5133,30 +5437,30 @@ async function claimDriverForCompaction(deps) {
     );
     return null;
   }
-  if (deps.isSwapping?.()) {
+  if (deps.isDriverReplaced()) {
     release2();
-    deps.log("[serve] compaction skipped: a driver swap is pending");
+    deps.log("[serve] compaction skipped: its driver is being or has been replaced");
     return null;
   }
-  const endTurn = deps.claimTurnSlot?.();
+  const endTurn = deps.claimTurnSlot();
   return () => {
-    endTurn?.();
+    endTurn();
     release2();
   };
 }
 var TURN_COMPACTION_YIELD_ATTEMPTS = 3;
-async function beginTurnClearOfCompaction(deps, maxAttempts = TURN_COMPACTION_YIELD_ATTEMPTS) {
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+async function beginTurnClearOfCompaction(deps) {
+  for (let attempt = 0; attempt < TURN_COMPACTION_YIELD_ATTEMPTS; 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`);
+  throw new Error(`turn overtaken by a compaction ${TURN_COMPACTION_YIELD_ATTEMPTS} 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());
+  const outcome = await deps.gate.awaitIdle(compactionGateTimeoutMs());
   if (outcome === "waited") deps.log(`[serve] ${deps.what} released after compaction settled`);
   if (outcome !== "timeout") return true;
   deps.log(`[serve] ${deps.what} abandoned: a compaction has held the driver past its bound`);
@@ -5277,103 +5581,23 @@ var DriverSwapGate = class {
   beginSwap(recreate) {
     this.activeDriverSwap = recreate;
     const clear = () => {
-      if (this.activeDriverSwap === recreate) this.activeDriverSwap = null;
-    };
-    recreate.then(clear, clear);
-  }
-  /**
-   * Await the in-flight swap before reading the live driver. Re-checks in a loop
-   * so a second swap starting during the wait is also awaited.
-   */
-  async awaitSwap() {
-    while (this.activeDriverSwap) {
-      try {
-        await this.activeDriverSwap;
-      } catch {
-      }
-    }
-  }
-};
-
-// runner/src/init-build-hold.ts
-var DEFAULT_CONNECTOR_MUTATE_INIT_HOLD_MS = 1e4;
-function resolveConnectorMutateInitHoldMs(env = process.env) {
-  const parsed = Number.parseInt(env.SKAILE_CONNECTOR_MUTATE_INIT_HOLD_MS ?? "", 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_CONNECTOR_MUTATE_INIT_HOLD_MS;
-}
-function createInitBuildHold(now = Date.now) {
-  let current = null;
-  let tail = Promise.resolve();
-  let held = 0;
-  const building = () => current !== null && !current.done;
-  async function awaitNewestBuild() {
-    for (; ; ) {
-      const build = current;
-      if (!build) return null;
-      if (!build.done) await build.settled;
-      if (current === build) return build.error;
-    }
+      if (this.activeDriverSwap === recreate) this.activeDriverSwap = null;
+    };
+    recreate.then(clear, clear);
   }
-  return {
-    beginBuild() {
-      let resolve4;
-      const build = {
-        done: false,
-        error: null,
-        settled: new Promise((r) => {
-          resolve4 = r;
-        })
-      };
-      current = build;
-      const settle = (error) => {
-        if (build.done) return;
-        build.done = true;
-        build.error = error;
-        resolve4();
-      };
-      return { succeed: () => settle(null), fail: (error) => settle(error) };
-    },
-    run(task, deadlineMs) {
-      if (held === 0 && !building()) {
-        if (current?.error) return task({ kind: "failed", error: current.error });
-        return task({ kind: "ready", remainingMs: void 0 });
+  /**
+   * Await the in-flight swap before reading the live driver. Re-checks in a loop
+   * so a second swap starting during the wait is also awaited.
+   */
+  async awaitSwap() {
+    while (this.activeDriverSwap) {
+      try {
+        await this.activeDriverSwap;
+      } catch {
       }
-      held++;
-      const arrivedAt = now();
-      const previous = tail;
-      const turn = previous.then(awaitNewestBuild);
-      let timer;
-      const deadline = deadlineMs === void 0 ? null : new Promise((resolve4) => {
-        timer = setTimeout(() => resolve4("timeout"), deadlineMs);
-        timer.unref?.();
-      });
-      let markStarted;
-      const started = new Promise((resolve4) => {
-        markStarted = resolve4;
-      });
-      const result = (async () => {
-        const first = deadline ? await Promise.race([turn, deadline]) : await turn;
-        clearTimeout(timer);
-        if (first === "timeout") {
-          void turn.then(markStarted);
-          return task({ kind: "timeout", waitedMs: now() - arrivedAt });
-        }
-        markStarted();
-        if (first) return task({ kind: "failed", error: first });
-        return task({
-          kind: "ready",
-          remainingMs: deadlineMs === void 0 ? void 0 : Math.max(0, deadlineMs - (now() - arrivedAt))
-        });
-      })();
-      tail = started;
-      void Promise.allSettled([turn, result]).then(() => {
-        held--;
-      });
-      return result;
-    },
-    held: () => held
-  };
-}
+    }
+  }
+};
 
 // runner/src/pending-turns.ts
 var PendingTurns = class {
@@ -5397,9 +5621,15 @@ var PendingTurns = class {
       }
     };
   }
-  /** Call at a turn's end, while that turn is still counted: whether to report idle now. */
-  shouldReportIdle() {
-    if (this.count > 1) {
+  /**
+   * Whether to report idle now, at the end of something that ran on the driver.
+   * A `"turn"` end belongs to a counted turn, which is still counted when it
+   * fires. A `"compaction"` end (the compaction turn, or the snapshot turn after
+   * it) is no counted turn, so every counted turn is waiting behind it.
+   */
+  shouldReportIdle(endedBy) {
+    const own = endedBy === "turn" ? 1 : 0;
+    if (this.count > own) {
       this.idleOwed = true;
       return false;
     }
@@ -5467,248 +5697,298 @@ var PromptTurnQueue = class {
   }
 };
 
-// runner/src/serial-lock.ts
-function createSerialLock() {
-  let tail = Promise.resolve();
-  return (fn) => {
-    const run = tail.then(fn, fn);
-    tail = run.catch(() => void 0);
-    return run;
-  };
-}
-function createCoalescedTask(lock, fn) {
-  let waiting = null;
-  return (...args) => {
-    if (waiting) return waiting;
-    const run = lock(() => {
-      waiting = null;
-      return fn(...args);
+// runner/src/turn-scheduler.ts
+var FLOW_TURN_COMPACTION_TIMEOUT = "Flow turn abandoned: a compaction held the driver";
+var TurnScheduler = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  swaps = new DriverSwapGate();
+  compactions = new CompactionGate();
+  pending = new PendingTurns(() => this.sendIdle());
+  queue = new PromptTurnQueue();
+  /** The compaction that armed the event suppression; null while none runs. */
+  suppressedBy = null;
+  /** Compactions past their end callback and not yet settled: a snapshot turn may still run. */
+  snapshotTurns = /* @__PURE__ */ new Set();
+  /** Counts {@link compactionHooks} calls; only the latest hooks may start a compaction. */
+  hooksGeneration = 0;
+  /** Run a chat prompt: queue it, wait out swaps and compactions, claim the driver, dispatch. */
+  prompt(turn) {
+    return this.counted(async () => {
+      const place = this.queue.join(turn.owner);
+      try {
+        if (place.queued) {
+          turn.onQueued?.();
+          const queuedAt = Date.now();
+          await place.ready;
+          this.deps.logPhase("prompt_queue_wait", queuedAt, { dropped: place.dropped });
+          if (place.dropped) return;
+        }
+        await this.runPrompt(turn, place.leave);
+      } finally {
+        place.leave();
+      }
     });
-    waiting = run;
-    return run;
-  };
-}
-async function recordStagedSkills(staged, projectDir, skillsDir, names, timeoutMs) {
-  for (const name of names) {
-    const path6 = join(projectDir, skillsDir, name);
-    const st = await tryWithFsDeadline(`lstat ${path6}`, () => lstat(path6), null, timeoutMs);
-    staged.set(
-      name,
-      st?.isDirectory() && st.birthtimeMs > 0 ? { path: path6, dev: st.dev, ino: st.ino, birthtimeMs: st.birthtimeMs } : null
-    );
   }
-}
-async function isStillOurs(record2, path6, timeoutMs) {
-  if (!record2 || record2.path !== path6) return false;
-  const st = await tryWithFsDeadline(`lstat ${path6}`, () => lstat(path6), null, timeoutMs);
-  return st?.isDirectory() === true && st.dev === record2.dev && st.ino === record2.ino && st.birthtimeMs === record2.birthtimeMs;
-}
-async function recordLoadedSkillDigests(loaded, projectDir, skillsDir, names, opts) {
-  for (const name of names) {
-    if (opts.driverUp && opts.previouslyStaged.has(name)) continue;
-    const path6 = join(projectDir, skillsDir, name);
-    loaded.set(name, { path: path6, digest: await stagedSkillDigest(path6) });
+  /**
+   * Run a question reply. A paused question takes the answer at once, ahead of
+   * every wait. A recreate waits for the paused turn, and that turn waits for
+   * this answer, so gating the answer on the swap wedges the session for good.
+   * Anything else is a fresh turn and queues like a prompt.
+   */
+  reply(turn) {
+    return this.counted(async () => {
+      if (!await turn.admit()) return;
+      const paused = this.deps.getDriver();
+      if (paused.hasPendingQuestion()) {
+        if (paused.answerQuestion(turn.answer, turn.question, turn.requestId)) {
+          turn.onAnswered?.();
+          return;
+        }
+      } else {
+        await this.swaps.awaitSwap();
+      }
+      if (!this.deps.getDriver().acceptsReplyAsPrompt) {
+        if (!this.deps.getDriver().hasPendingQuestion()) {
+          this.deps.log("[serve] reply: driver takes no reply as a prompt; answer not delivered");
+          this.deps.sendEvent({
+            type: "error",
+            message: "This question is no longer open, so the agent did not get your answer. Send it as a new message.",
+            fatal: false
+          });
+        }
+        return;
+      }
+      let endTurn;
+      try {
+        endTurn = await this.claim("reply", () => this.deps.ensureDriverStarted());
+      } catch (err) {
+        this.deps.sendEvent(replyFailed(err));
+        return;
+      }
+      if (!endTurn) return;
+      try {
+        await this.deps.getDriver().prompt(freshTurnReplyPrompt(turn.answer, turn.question));
+      } catch (err) {
+        this.deps.sendEvent(replyFailed(err));
+      } finally {
+        endTurn();
+      }
+    });
   }
-}
-var DIGEST_DEADLINE_FACTOR = 4;
-var DIGEST_MAX_BYTES = 64 * 1024 * 1024;
-var DIGEST_CHUNK_BYTES = 64 * 1024;
-var DIGEST_OPEN_FLAGS = constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
-async function stagedSkillDigest(dir, timeoutMs) {
-  return tryWithFsDeadline(
-    `digest ${dir}`,
-    async () => {
-      const hash = createHash("sha256");
-      let budget = DIGEST_MAX_BYTES;
-      const hashFile = async (path6) => {
-        const fh = await open(path6, DIGEST_OPEN_FLAGS);
+  /**
+   * Run one flow turn and resolve on its `agent_end`.
+   *
+   * Waits out a pending swap, any compaction, and every turn already in flight.
+   * The in-flight wait is what makes the `agent_end` listener safe: a flow
+   * started from inside a chat turn would otherwise resolve on that turn's end.
+   * The slot is held for the whole turn, never across a wait, which would stall
+   * a swap behind a compaction.
+   */
+  flowTurn(prompt, timeoutMs) {
+    return this.counted(async () => {
+      for (; ; ) {
+        await this.swaps.awaitSwap();
+        if (!await this.awaitCompactionIdle("flow turn"))
+          throw new Error(FLOW_TURN_COMPACTION_TIMEOUT);
+        const endTurn = await this.swaps.beginQueuedTurn();
+        if (this.swaps.isSwapping() || !this.compactions.isIdle()) {
+          endTurn();
+          continue;
+        }
         try {
-          const st = await fh.stat();
-          if (!st.isFile()) throw new Error(`not a regular file: ${path6}`);
-          if (st.size > budget) throw new Error("skill too large to digest");
-          const buf = Buffer.alloc(DIGEST_CHUNK_BYTES);
-          let total = 0;
-          for (; ; ) {
-            const { bytesRead } = await fh.read(buf, 0, buf.length, null);
-            if (bytesRead === 0) break;
-            total += bytesRead;
-            if (total > budget) throw new Error("skill too large to digest");
-            hash.update(buf.subarray(0, bytesRead));
-          }
-          budget -= total;
-          hash.update(`\0${total}\0`);
+          await this.deps.ensureDriverStarted();
+          await awaitAgentEnd(this.deps.getDriver(), prompt, timeoutMs);
+          return;
         } finally {
-          await fh.close();
-        }
-      };
-      const walk = async (rel) => {
-        const here = rel ? join(dir, rel) : dir;
-        if (rel && !(await lstat(here)).isDirectory()) throw new Error(`not a dir: ${here}`);
-        const entries = await readdir(here, { withFileTypes: true });
-        entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-        for (const entry of entries) {
-          if (!rel && entry.name === STAGED_SKILL_MARKER) continue;
-          const path6 = rel ? `${rel}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            hash.update(`d\0${path6}\0`);
-            await walk(path6);
-          } else if (entry.isSymbolicLink()) {
-            hash.update(`l\0${path6}\0${await readlink(join(dir, path6))}\0`);
-          } else if (entry.isFile()) {
-            hash.update(`f\0${path6}\0`);
-            await hashFile(join(dir, path6));
-          } else {
-            hash.update(`o\0${path6}\0`);
-          }
+          endTurn();
         }
-      };
-      await walk("");
-      return hash.digest("hex");
-    },
-    null,
-    fsDeadlineMs() * DIGEST_DEADLINE_FACTOR
-  );
-}
-async function attachStagedSkill(deps, name) {
-  try {
-    const skillsDir = deps.skillsDir();
-    const dirName = name.includes("/") ? name.split("/").pop() : name;
-    const { staged, unchanged } = await deps.withSkillFsLock(async () => {
-      const dest = join(deps.projectDir, skillsDir, dirName);
-      const loaded = deps.stagedSkillDirs.has(dirName) ? deps.loadedSkillDigests.get(dirName) : void 0;
-      const names = await stageMaterializedSkills(deps.projectDir, skillsDir, { declared: [name] });
-      let same = false;
-      if (names.includes(dirName)) {
-        const digest = await stagedSkillDigest(dest);
-        same = digest !== null && loaded?.path === dest && loaded.digest === digest;
-        if (!same) deps.loadedSkillDigests.set(dirName, { path: dest, digest });
       }
-      await recordStagedSkills(deps.stagedSkillDirs, deps.projectDir, skillsDir, names);
-      return { staged: names, unchanged: same ? dirName : null };
     });
-    if (staged.length === 0) {
-      return {
-        ok: false,
-        code: "skill_not_materialized",
-        message: `no materialized skill matching "${name}" under .skaile/assets/skill`
-      };
-    }
-    const live = deps.driverStarted();
-    const toRestart = staged.filter((s) => s !== unchanged);
-    if (toRestart.length === 0) {
-      deps.log(
-        `[serve] runner.attach_instance: skill ${staged.join(", ")} already staged and unchanged \u2014 no driver restart`
-      );
-      return { ok: true, id: name, live, toolCount: 0 };
-    }
-    deps.log(`[serve] runner.attach_instance staged skill(s): ${toRestart.join(", ")}`);
-    deps.scheduleSkillRestart(toRestart.map((s) => ({ name: s, action: "add" })));
-    return { ok: true, id: name, live, toolCount: 0 };
-  } catch (err) {
-    return {
-      ok: false,
-      code: "skill_attach_failed",
-      message: err instanceof Error ? err.message : String(err)
-    };
   }
-}
-async function detachStagedSkill(deps, name) {
-  try {
-    const skillsDir = deps.skillsDir();
-    const dirName = name.split("/").pop() ?? name;
-    const result = await deps.withSkillFsLock(async () => {
-      const knownStaged = await isStillOurs(
-        deps.stagedSkillDirs.get(dirName),
-        join(deps.projectDir, skillsDir, dirName)
-      );
-      return unstageSkill(deps.projectDir, skillsDir, name, { knownStaged });
-    });
-    const live = deps.driverStarted();
-    if ("reason" in result) {
-      deps.log(
-        `[serve] runner.detach_instance: "${result.name}" exists but was not staged by the runner \u2014 left in place`
-      );
-      return { ok: true, id: result.name, removed: false, live, reason: result.reason };
-    }
-    const wasTracked = deps.stagedSkillDirs.delete(result.name);
-    if (!result.removedStaged && !wasTracked) {
-      deps.log(`[serve] runner.detach_instance: skill "${result.name}" was not staged`);
-      return { ok: true, id: result.name, removed: result.removedAsset, live };
-    }
-    deps.log(`[serve] runner.detach_instance unstaged skill: ${result.name}`);
-    deps.scheduleSkillRestart([{ name: result.name, action: "remove" }]);
-    return { ok: true, id: result.name, removed: true, live };
-  } catch (err) {
+  /**
+   * Run a driver swap (recreate): queued behind every earlier swap, then behind
+   * every turn holding a slot. Prompts defer to it from the moment it is
+   * registered. Never call from inside a swap: it would wait on itself.
+   */
+  runSwap(swap) {
+    return this.swaps.runSwap(swap);
+  }
+  /**
+   * The driver ended a turn. Reports idle unless a compaction suppresses it, or
+   * more turns are queued behind this one, in which case it is owed and goes
+   * out when the last of them settles.
+   */
+  reportTurnEnd() {
+    this.reportIdleIfDrained(this.snapshotTurns.size > 0 ? "compaction" : "turn");
+  }
+  /**
+   * Drop every prompt `senderId` has waiting, in queue order. The prompt whose
+   * turn is running is not waiting, and a prompt with no sender is nobody's to drop.
+   */
+  dropQueuedPromptsFrom(senderId) {
+    return this.queue.dropQueuedFrom(senderId);
+  }
+  /** Turns taken on and not yet settled, waiting ones included. */
+  get pendingTurns() {
+    return this.pending.size;
+  }
+  /**
+   * Whether a compaction is running, from its start until its end callback: the
+   * host must not see the compaction turn's events, `status: idle` included.
+   */
+  get isCompacting() {
+    return this.suppressedBy !== null;
+  }
+  /**
+   * The hooks one compaction orchestrator wires to take part in scheduling: it
+   * claims the driver before it starts, holds user turns off from its start
+   * until it has settled, and suppresses turn events from its start until its
+   * end. Call once per orchestrator; a newer call retires the hooks before it,
+   * so a stale orchestrator (its driver replaced by a swap) can no longer
+   * start a compaction.
+   */
+  compactionHooks() {
+    const generation = ++this.hooksGeneration;
+    const superseded = () => generation !== this.hooksGeneration;
+    let hold = null;
     return {
-      ok: false,
-      code: "skill_detach_failed",
-      message: err instanceof Error ? err.message : String(err)
+      // 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: async (trigger) => {
+        if (superseded()) {
+          this.deps.log("[serve] compaction skipped: its driver has been replaced");
+          return null;
+        }
+        return claimDriverForCompaction({
+          gate: this.compactions,
+          awaitClaimedTurns: () => this.swaps.awaitActiveTurn(),
+          isDriverReplaced: () => this.swaps.isSwapping() || superseded(),
+          claimTurnSlot: () => this.swaps.beginTurn(),
+          log: this.deps.log,
+          timeoutMs: compactionTurnWaitFor(trigger)
+        });
+      },
+      onCompactionStart: (trigger) => {
+        hold = this.compactions.begin();
+        this.suppressedBy = hold;
+        this.deps.sendEvent({ type: "status", phase: "compacting" });
+        this.deps.log(`[serve] compaction started (trigger=${trigger})`);
+      },
+      onCompactionEnd: () => {
+        if (hold === null || this.suppressedBy !== hold) return;
+        this.suppressedBy = null;
+        this.snapshotTurns.add(hold);
+        this.reportIdleIfDrained("compaction");
+      },
+      onCompactionSettled: () => {
+        if (hold !== null && this.suppressedBy === hold) this.suppressedBy = null;
+        if (hold !== null) this.snapshotTurns.delete(hold);
+        this.compactions.settle(hold);
+        hold = null;
+      }
     };
   }
-}
-async function pathState(path6) {
-  try {
-    await withFsDeadline(`lstat ${path6}`, () => lstat(path6));
-    return "present";
-  } catch (err) {
-    return err?.code === "ENOENT" ? "absent" : "unknown";
-  }
-}
-async function removeUnlistedStagedSkills(deps, skillsDir) {
-  const allowed = await readSkillAllowList(deps.projectDir);
-  if (!allowed) return [];
-  const root = join(deps.projectDir, skillsDir);
-  const entries = await tryWithFsDeadline(
-    `readdir ${root}`,
-    () => readdir(root, { withFileTypes: true }),
-    []
-  );
-  const removed = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || allowed.has(entry.name)) continue;
-    try {
-      const dir = join(root, entry.name);
-      if (await pathState(join(deps.projectDir, ".skaile/assets/skill", entry.name)) !== "absent") {
-        continue;
+  async runPrompt(turn, leaveQueue) {
+    if (!await turn.admit()) return;
+    await this.swaps.awaitSwap();
+    if (!await this.awaitCompactionIdle("prompt")) return;
+    const handOff = await turn.route();
+    if (handOff === false) return;
+    if (handOff) {
+      leaveQueue();
+      try {
+        await handOff();
+      } finally {
+        this.reportIdleIfDrained("turn");
       }
-      const knownStaged = await isStillOurs(deps.stagedSkillDirs.get(entry.name), dir);
-      if (!knownStaged && !await isStagedSkillMarkerFor(dir, entry.name).catch(() => false))
-        continue;
-      const result = await unstageSkill(deps.projectDir, skillsDir, entry.name, {
-        knownStaged,
-        keepAsset: true
+      return;
+    }
+    const startedAt = Date.now();
+    let ok = false;
+    let attempts = 0;
+    let endTurn;
+    try {
+      endTurn = await this.claim("prompt", () => {
+        attempts += 1;
+        return this.deps.ensureDriverStarted();
       });
-      if ("reason" in result || !result.removedStaged) continue;
-      deps.stagedSkillDirs.delete(result.name);
-      removed.push(result.name);
+      ok = endTurn !== null;
     } catch (err) {
-      deps.log(
-        `[serve] could not remove unlisted skill "${entry.name}" (left in place): ${err instanceof Error ? err.message : String(err)}`
-      );
+      const message = errorMessage2(err);
+      this.deps.log(`[serve] driver start failed: ${message}`);
+      this.deps.sendEvent({
+        type: "error",
+        message: `Driver start failed: ${message}`,
+        fatal: true
+      });
+      return;
+    } finally {
+      this.deps.logPhase("driver_start", startedAt, { ok, attempts });
     }
-  }
-  return removed;
-}
-
-// runner/src/flow-turn-dispatch.ts
-var FLOW_TURN_COMPACTION_TIMEOUT = "Flow turn abandoned: a compaction held the driver";
-async function dispatchFlowTurn(deps, prompt, timeoutMs) {
-  for (; ; ) {
-    await deps.gate.awaitSwap();
-    if (!await deps.awaitCompactionIdle()) throw new Error(FLOW_TURN_COMPACTION_TIMEOUT);
-    const endTurn = await deps.gate.beginQueuedTurn();
-    if (deps.gate.isSwapping() || deps.isCompacting()) {
+    if (!endTurn) return;
+    try {
+      await turn.dispatch();
+    } catch (err) {
+      const message = errorMessage2(err);
+      this.deps.log(`[serve] prompt failed: ${message}`);
+      this.deps.sendEvent({ type: "error", message: `Prompt failed: ${message}`, fatal: true });
+    } finally {
       endTurn();
-      continue;
     }
+  }
+  /** Claim a turn slot on a live driver no swap or compaction occupies. `null`: turn abandoned. */
+  claim(what, prepare) {
+    return beginTurnClearOfCompaction({
+      gate: this.compactions,
+      awaitIdle: () => this.awaitCompactionIdle(what),
+      claimTurn: () => this.swaps.beginTurnOnLiveDriver(prepare)
+    });
+  }
+  /** `false` when a compaction held the driver past its bound; the abandon is already reported. */
+  awaitCompactionIdle(what) {
+    return guardTurnAgainstCompaction({
+      gate: this.compactions,
+      what,
+      log: this.deps.log,
+      sendEvent: this.deps.sendEvent
+    });
+  }
+  /** Count a turn from receipt until its handler settles, so waiting turns count as queued. */
+  async counted(run) {
+    const end = this.pending.begin();
     try {
-      await deps.ensureDriverStarted();
-      await awaitAgentEnd(deps.getDriver(), prompt, timeoutMs);
-      return;
+      return await run();
     } finally {
-      endTurn();
+      end();
     }
   }
+  /** Idle unless a compaction suppresses events or more turns are queued, in which case it is owed. */
+  reportIdleIfDrained(endedBy) {
+    if (this.suppressedBy) return;
+    if (this.pending.shouldReportIdle(endedBy)) this.sendIdle();
+  }
+  /** The only `status: idle` emit site. Silent while a compaction suppresses turn events. */
+  sendIdle() {
+    if (this.suppressedBy) return;
+    this.deps.sendEvent({ type: "status", phase: "idle" });
+  }
+};
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function replyFailed(err) {
+  return { type: "error", message: `Reply failed: ${errorMessage2(err)}`, fatal: false };
+}
+function freshTurnReplyPrompt(answer, question) {
+  const asked = question?.replace(/\s+/g, " ").trim();
+  if (!asked) return answer;
+  return `${answer}
+
+(The answer above is to your question "${asked}")`;
 }
 function awaitAgentEnd(driver, prompt, timeoutMs) {
   return new Promise((resolve4, reject) => {
@@ -5737,25 +6017,6 @@ function awaitAgentEnd(driver, prompt, timeoutMs) {
   });
 }
 
-// runner/src/reply-routing.ts
-async function routeReply(deps) {
-  const current = deps.getDriver();
-  if (current.hasPendingQuestion()) {
-    if (!current.answerQuestion(deps.answer, deps.question, deps.requestId)) return "fresh-turn";
-    deps.onAnswered?.();
-    return "answered";
-  }
-  await deps.awaitSwap();
-  return "fresh-turn";
-}
-function freshTurnReplyPrompt(answer, question) {
-  const asked = question?.replace(/\s+/g, " ").trim();
-  if (!asked) return answer;
-  return `${answer}
-
-(The answer above is to your question "${asked}")`;
-}
-
 // runner/src/event-gap-buffer.ts
 var EVENT_GAP_BUFFER_MAX_EVENTS = 1e4;
 var EVENT_GAP_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
@@ -6738,7 +6999,8 @@ function selectClaudeCodeCredentialsSecret(secrets, selection) {
   const legacy = secrets[CLAUDE_CODE_CREDENTIALS_KEY];
   if (legacy) return { key: CLAUDE_CODE_CREDENTIALS_KEY, value: legacy };
   if (!selection?.registry) return void 0;
-  if (selection.driver && selection.driver !== "claude-sdk") return void 0;
+  if (selection.driver && !driverCapabilities(selection.driver).claudeCodeCredentials)
+    return void 0;
   const entries = registryEntries(selection.registry).map(
     ([id, entry2]) => [id, { ...entry2, kind: entryKind(entry2) }]
   );
@@ -8480,9 +8742,6 @@ function pickRepointedManager(next, current, disposed) {
   if (current !== null && current === disposed) return null;
   return current;
 }
-function supportsLiveToolUpdates(driverType, managedCodex = false) {
-  return driverType !== "claude-sdk" && !(driverType === "codex" && managedCodex);
-}
 function buildResourcesAvailablePayload(manager, mcpManager, driverLive, bakedServerIds) {
   const { mounts, connectors } = splitConnectorsForWire(manager);
   const mcp_servers = (mcpManager?.listServers() ?? []).map((s) => ({
@@ -8491,19 +8750,16 @@ function buildResourcesAvailablePayload(manager, mcpManager, driverLive, bakedSe
   }));
   return { type: "resources_available", mounts, connectors, mcp_servers, sessionRoot: true };
 }
-function isTerminalFlowStatus(status) {
-  return status === "complete" || status === "cancelled";
-}
 function hasNonTerminalFlow(flows) {
   for (const f of flows) {
-    if (!isTerminalFlowStatus(f.adapter.getExecution(f.handle).status)) return true;
+    if (!f.adapter.turnRule(f.handle).terminal) return true;
   }
   return false;
 }
 function registerActiveFlow(flows, runId, entry) {
   const removed = [];
   for (const [key, existing] of flows) {
-    if (isTerminalFlowStatus(existing.adapter.getExecution(existing.handle).status)) {
+    if (existing.adapter.turnRule(existing.handle).terminal) {
       flows.delete(key);
       removed.push(key);
     }
@@ -8515,21 +8771,18 @@ function pickFlowToolTarget(flows, manager) {
   let latest;
   for (const entry of flows) latest = entry;
   if (!latest || !manager) return null;
-  if (isTerminalFlowStatus(latest.adapter.getExecution(latest.handle).status)) return null;
+  if (latest.adapter.turnRule(latest.handle).terminal) return null;
   return { manager, connectorId: latest.connectorId };
 }
-function flowRunDrivesTurns(execution) {
-  return !(execution.done || execution.status === "failed" || isTerminalFlowStatus(execution.status));
-}
 function pickChatFlowTarget(flows) {
   let latest;
   for (const entry of flows) latest = entry;
   if (!latest) return null;
-  if (!flowRunDrivesTurns(latest.adapter.getExecution(latest.handle))) return null;
+  if (!latest.adapter.turnRule(latest.handle).acceptsTurn) return null;
   return latest;
 }
 function flowStartNeedsDriverRestart(state) {
-  return state.driverStarted && state.driverType === "claude-sdk" && !state.flowToolsBaked;
+  return state.driverStarted && driverCapabilities(state.driverType).inProcessMcpServers && !state.flowToolsBaked;
 }
 async function setUpFlowConnector(deps) {
   const recreated = await deps.recreateForFlowTools();
@@ -8540,8 +8793,8 @@ async function setUpFlowConnector(deps) {
 async function recreateKeepingLiveFlows(flows, deps) {
   const live = [];
   for (const { runId, connectorId, flowDef, adapter, handle } of flows) {
+    if (adapter.turnRule(handle).terminal) continue;
     const execution = adapter.getExecution(handle);
-    if (isTerminalFlowStatus(execution.status)) continue;
     live.push({ runId, connectorId, flowDef, execution: structuredClone(execution) });
   }
   await deps.recreate();
@@ -8562,7 +8815,7 @@ async function recreateKeepingLiveFlows(flows, deps) {
   return reconnected;
 }
 function reconnectedRunNeedsAgentTurn(state) {
-  return state.cutDriverWork && state.wantsAgentTurn && !state.busHasTurn && !state.promptQueuedForRun;
+  return state.cutDriverWork && state.restoreKick === "agent_work" && !state.busHasTurn && !state.promptQueuedForRun;
 }
 var DRIVER_ACTIVITY_EVENTS = /* @__PURE__ */ new Set([
   "message_start",
@@ -8965,11 +9218,11 @@ function toActiveFlowTarget(entry) {
     runId: entry.runId,
     connectorId: entry.connectorId,
     hydratedStateChanged: entry.hydratedStateChanged,
-    hasRuntimeWork: entry.adapter.hasRuntimeWork(entry.handle)
+    restoreKick: entry.adapter.turnRule(entry.handle).restoreKick
   };
 }
 function restoredRunHasWorkToResume(target) {
-  return target.hydratedStateChanged === true || target.hasRuntimeWork === true;
+  return target.hydratedStateChanged === true || target.restoreKick === "runtime_work";
 }
 async function executeConnectorMutate(cmd, deps) {
   let acked = false;
@@ -9158,7 +9411,7 @@ async function applyConnectorMutate(cmd, deps, respond, connectorWaitMs) {
         } else if (cmd.op === "hydrate") {
           const active = deps.flowState().activeFlow;
           const changed = typeof result === "string" && JSON.stringify(payload.state) !== result;
-          if (active && (changed || active.hasRuntimeWork === true)) {
+          if (active && (changed || active.restoreKick === "runtime_work")) {
             deps.signalStimulus(active, { kind: "resumed_after_hibernation" });
           }
         }
@@ -9577,7 +9830,7 @@ async function startAgentServer(opts) {
     return {
       projectDir: opts.projectDir,
       agentDir,
-      driver: managedCodex ? "codex" : opts.driver ?? wireAgentConfig?.driver,
+      driver: managedCodex ? wireAgentConfig?.driver : opts.driver ?? wireAgentConfig?.driver,
       model: managedCodex ? wireAgentConfig?.model : opts.model ?? wireAgentConfig?.model,
       // The control-plane registry layer, normalized to the bare `id → entry`
       // map the session builder layers `providers.yml` under.
@@ -9893,18 +10146,17 @@ async function startAgentServer(opts) {
   }
   const normalizer = new EventNormalizer();
   function forwardNormalizedEvent(event) {
-    if (compacting) return;
+    if (turnScheduler.isCompacting) return;
     contextUsage.observeEvent(event);
-    const isTransient = event.type === "status" || event.type === "sync_status" || event.type === "resources_available" || event.type === "resource_response" || event.type === "commands_available";
-    if (!isTransient) {
+    if (deliveryClassOf(event.type) === "persisted") {
       eventSeq++;
       compactionOrchestrator?.trackMessage(eventSeq);
     }
     if (event.type === "finished") {
       scheduleContextUsageEmit("turn-end");
-      if (!compacting && compactionOrchestrator?.shouldCompact()) {
+      if (!turnScheduler.isCompacting && compactionOrchestrator?.shouldCompact()) {
         const compactionTimer = setTimeout(() => {
-          if (compacting || !compactionOrchestrator?.shouldCompact()) return;
+          if (turnScheduler.isCompacting || !compactionOrchestrator?.shouldCompact()) return;
           compactionOrchestrator.compact("threshold").catch((err) => {
             log(
               `[serve] auto-compaction failed: ${err instanceof Error ? err.message : String(err)}`
@@ -9927,12 +10179,13 @@ async function startAgentServer(opts) {
   }
   let driverStarted = false;
   let driverStartInFlight = null;
-  const driverSwapGate = new DriverSwapGate();
-  const compactionGate = new CompactionGate();
-  const pendingTurns = new PendingTurns(() => {
-    if (!compacting) sendEvent({ type: "status", phase: "idle" });
+  const turnScheduler = new TurnScheduler({
+    ensureDriverStarted,
+    getDriver: () => driver,
+    sendEvent,
+    log,
+    logPhase
   });
-  const promptTurns = new PromptTurnQueue();
   let driverRestartChain = Promise.resolve();
   let liveDriverActiveAfterTurn = false;
   let driver = secretsMode === "env" ? agentSession.driver : void 0;
@@ -9975,8 +10228,6 @@ async function startAgentServer(opts) {
     };
     sendEvent(runtimeSessionEvent);
   }
-  let compacting = false;
-  let suppressedBy = null;
   let compactionOrchestrator = null;
   const compactionConfig = wsConfig.compaction;
   function scheduleContextUsageEmit(trigger) {
@@ -9991,18 +10242,13 @@ async function startAgentServer(opts) {
   }
   function rebuildCompactionOrchestrator() {
     if (!driver) return;
-    let gateHold = null;
     compactionOrchestrator = new CompactionOrchestrator({
       driver,
       config: compactionConfig,
       contextWindows,
-      onCompactionStart: (trigger) => {
-        compacting = true;
-        gateHold = compactionGate.begin();
-        suppressedBy = gateHold;
-        sendEvent({ type: "status", phase: "compacting" });
-        log(`[serve] compaction started (trigger=${trigger})`);
-      },
+      // Start, end, settled and the driver claim: the scheduler owns the holds,
+      // the event suppression and the `status` phases around a compaction.
+      ...turnScheduler.compactionHooks(),
       onSnapshot: (snapshot) => {
         sendEvent(snapshot);
         contextUsage.onCompaction(snapshot.summary);
@@ -10011,27 +10257,6 @@ async function startAgentServer(opts) {
       onCompactionAttempt: (event) => {
         sendEvent(event);
       },
-      onCompactionEnd: () => {
-        if (suppressedBy !== gateHold) return;
-        compacting = false;
-        suppressedBy = null;
-        sendEvent({ type: "status", phase: "idle" });
-      },
-      onCompactionSettled: () => {
-        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(),
-        isSwapping: () => driverSwapGate.isSwapping(),
-        claimTurnSlot: () => driverSwapGate.beginTurn(),
-        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
@@ -10078,7 +10303,8 @@ async function startAgentServer(opts) {
             const normalized = normalizer.normalize(event);
             const turnEnded = event.type === "agent_end";
             for (const e of normalized) {
-              if (turnEnded && !compacting && e.type === "status" && e.phase === "idle" && !pendingTurns.shouldReportIdle()) {
+              if (turnEnded && e.type === "status" && e.phase === "idle") {
+                turnScheduler.reportTurnEnd();
                 continue;
               }
               forwardNormalizedEvent(e);
@@ -10118,7 +10344,6 @@ async function startAgentServer(opts) {
         const stimulus = stimulusFromMetas(metas);
         await entry.adapter.drainRuntimeNodes(entry.handle);
         const execution = entry.adapter.getExecution(entry.handle);
-        if (!flowRunDrivesTurns(execution)) return;
         if (!entry.adapter.shouldDriveAgentTurn(entry.handle, stimulus)) return;
         await ensureFlowDriverStarted();
         await driveOrchestratorTurn({
@@ -10126,42 +10351,13 @@ async function startAgentServer(opts) {
           execution,
           stimulus,
           emit: sendEvent,
-          deliver: (prompt) => awaitFlowAgentEnd(prompt, FLOW_TURN_TIMEOUT_MS)
+          deliver: (prompt) => turnScheduler.flowTurn(prompt, FLOW_TURN_TIMEOUT_MS)
         });
       },
       log: serverLog
     });
     return stimulusBus;
   }
-  function awaitFlowAgentEnd(prompt, timeoutMs) {
-    return countPendingTurn(
-      () => dispatchFlowTurn(
-        {
-          gate: driverSwapGate,
-          awaitCompactionIdle: () => awaitCompactionIdle("flow turn"),
-          isCompacting: () => !compactionGate.isIdle(),
-          ensureDriverStarted,
-          getDriver: () => driver
-        },
-        prompt,
-        timeoutMs
-      )
-    );
-  }
-  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 {
-      return await run();
-    } finally {
-      end();
-    }
-  }
   function ensureResourceManagerForFlow() {
     if (!resourceManager) {
       registerBuiltinConnectors();
@@ -10259,7 +10455,7 @@ async function startAgentServer(opts) {
           execution,
           stimulus,
           emit: sendEvent,
-          deliver: (prompt) => awaitFlowAgentEnd(prompt, FLOW_TURN_TIMEOUT_MS)
+          deliver: (prompt) => turnScheduler.flowTurn(prompt, FLOW_TURN_TIMEOUT_MS)
         });
       }
     });
@@ -10305,7 +10501,7 @@ async function startAgentServer(opts) {
       execute: (op, args) => adapter.executeOp(handle, op, args),
       mandatoryGates: () => adapter.getMandatoryAgentApprovalNodeIds(handle)
     };
-    if (agentSession?.driverType === "claude-sdk") {
+    if (driverCapabilities(agentSession?.driverType).inProcessMcpServers) {
       try {
         const server = await buildSdkConnectorTools(manager, { z: z });
         const flowServer = flowToolsBaked ? null : await buildSdkFlowTools(manager, connectorId, { z: z });
@@ -10327,7 +10523,7 @@ async function startAgentServer(opts) {
         log(`[serve] failed to rebuild MCP tools for flow: ${errMsg}`);
       }
     }
-    if (agentSession?.driverType === "codex" && !driver.acceptsReplyAsPrompt) {
+    if (driverCapabilities(agentSession?.driverType).managedSession && !driver.acceptsReplyAsPrompt) {
       removeCodexFlowTools?.();
       removeCodexFlowTools = registerCodexFlowTools(capabilityRegistry, manager, connectorId);
     }
@@ -10592,7 +10788,7 @@ async function startAgentServer(opts) {
     return { needsWireFallbackRecreate, needsWireAgentConfigRecreate };
   }
   async function recreateAgentSession(overrides) {
-    return driverSwapGate.runSwap(async () => {
+    return turnScheduler.runSwap(async () => {
       const resolved = typeof overrides === "function" ? overrides() : overrides;
       if (!resolved) return false;
       await recreateAgentSessionInner(resolved);
@@ -10616,10 +10812,10 @@ async function startAgentServer(opts) {
       needsAgentTurn: (run) => {
         const needed = reconnectedRunNeedsAgentTurn({
           cutDriverWork,
-          wantsAgentTurn: activeFlowWantsAgentTurn(run.runId),
+          restoreKick: run.restoreKick ?? null,
           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
+          promptQueuedForRun: turnScheduler.pendingTurns > 0 && pickChatFlowTarget(activeFlows.values())?.runId === run.runId
         });
         if (needed) redriven.push(run.runId);
         return needed;
@@ -10822,7 +11018,7 @@ async function startAgentServer(opts) {
     }
   }
   async function rebuildMcpToolsForNewStores(storesRegistered) {
-    if (!(storesRegistered > 0 && !driverStarted && agentSession?.driverType === "claude-sdk")) {
+    if (!(storesRegistered > 0 && !driverStarted && driverCapabilities(agentSession?.driverType).inProcessMcpServers)) {
       return;
     }
     try {
@@ -10974,13 +11170,15 @@ async function startAgentServer(opts) {
     }
     try {
       validateCodexInit(cmd, supportedRuntimeFeatures, runtimeIdentity ?? void 0);
-      const wantsManaged = cmd.resolvedConfig.agentConfig?.driver === "codex";
+      const wantsManaged = driverCapabilities(
+        cmd.resolvedConfig.agentConfig?.driver
+      ).managedSession;
       if (managedHost && !wantsManaged) throw new Error("AI_PROFILE_INVALID");
       if (managedHost && wantsManaged) {
         if (managedBootstrapClosed || agentSession && !managedInitFingerprint || cmd.secrets && CLAUDE_CODE_CREDENTIALS_KEY in cmd.secrets)
           throw new Error("AI_PROFILE_INVALID");
         const profile2 = cmd.resolvedConfig.agentConfig;
-        if (opts.driver && opts.driver !== "codex" || opts.provider && opts.provider !== "openai" || opts.model && opts.model !== profile2.model)
+        if (opts.driver && opts.driver !== profile2.driver || opts.provider && opts.provider !== "openai" || opts.model && opts.model !== profile2.model)
           throw new Error("AI_PROFILE_INVALID");
         const initialCredential = parseCodexCredential(cmd.credentials.ai);
         const binding = bindManagedCodexInit(managedHost, cmd, async (input, signal) => {
@@ -11089,7 +11287,7 @@ async function startAgentServer(opts) {
         settings = { driver: driver2 ?? profile?.driver, model: model ?? profile?.model };
       }
       credentialsSelection = {
-        driver: settings.driver ?? "omp",
+        driver: settings.driver ?? DEFAULT_DRIVER_ID,
         registry: wireAgentConfig?.registry,
         modelRef: wireAgentConfig?.modelRef?.trim() || settings.model?.trim() || void 0
       };
@@ -11138,7 +11336,7 @@ async function startAgentServer(opts) {
       let pendingResumeSessionId;
       const cfgResumeSessionId = cfg.resumeSessionId;
       const cfgExpectedSig = cfg.expectedCapabilitySignature;
-      const resumeTargetDriver = managedCodex ? "codex" : opts.driver ?? wireAgentConfig?.driver ?? agentSession?.driverType;
+      const resumeTargetDriver = (managedCodex ? void 0 : opts.driver) ?? wireAgentConfig?.driver ?? agentSession?.driverType;
       if (cfgResumeSessionId) {
         const currentSig = computeCapabilitySignature(capabilityRegistry.list());
         if (cfgExpectedSig && cfgExpectedSig !== currentSig) {
@@ -11153,7 +11351,7 @@ async function startAgentServer(opts) {
             resumeSessionId: cfgResumeSessionId,
             reason: "signature_mismatch"
           });
-        } else if (resumeProbe === "jsonl_lost" && resumeTargetDriver === "claude-sdk") {
+        } else if (resumeProbe === "jsonl_lost" && driverCapabilities(resumeTargetDriver).resumeNeedsTranscript) {
           log(`[serve] tier-1 resume skipped: no transcript for ${cfgResumeSessionId}`);
           sendEvent({
             type: "resume_failed",
@@ -11250,129 +11448,88 @@ 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({ senderId: cmd.senderId, messageId: cmd.messageId });
-    try {
-      if (place.queued) {
-        driver?.supersedePendingQuestion?.();
-        const queuedAt = Date.now();
-        await place.ready;
-        logPhase("prompt_queue_wait", queuedAt, { dropped: place.dropped });
-        if (place.dropped) return;
-      }
-      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 });
-    if (!sessionIsReady) return;
-    if (!secretsProvisioned) {
-      log("[serve] prompt received before secrets provisioned \u2014 rejecting");
-      sendEvent({
-        type: "error",
-        message: "Secrets not yet provisioned \u2014 send provision_secrets first",
-        fatal: false
-      });
-      return;
-    }
-    log(`[serve] prompt: ${cmd.prompt.slice(0, 80)}...`);
-    contextUsage.observeUserPrompt(cmd.prompt);
-    await driverSwapGate.awaitSwap();
-    if (!await awaitCompactionIdle("prompt")) return;
-    await restageMaterializedSkills(true);
-    try {
-      await rebuildForLateMcpDeclarations({
-        driverStarted: () => driverStarted,
-        unloadedMcpDeclarationIds: () => agentSession.unloadedMcpDeclarationIds(),
-        resumeSessionId: () => agentSession.resumeSessionId,
-        recreate: (overrides) => recreateAgentSession(overrides),
-        log,
-        warn: (line) => serverLog.warn(line)
-      });
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      serverLog.warn(`[serve] session rebuild for late MCP servers failed: ${errMsg}`);
-      sendEvent({ type: "error", message: `Session rebuild failed: ${errMsg}`, fatal: true });
-      return;
-    }
-    const activeFlow = pickChatFlowTarget(activeFlows.values());
-    if (activeFlow) {
-      leaveQueue();
-      sendEvent({ type: "status", phase: "thinking" });
-      try {
-        const bus = getOrCreateStimulusBus();
-        const userStimulus = {
-          kind: "user_message",
-          text: cmd.prompt,
-          senderId: "user"
-        };
-        await bus.signal(activeFlow.connectorId, {
-          promptFragment: renderStimulusPrompt(userStimulus),
-          meta: {
-            kind: "user_message",
-            runId: activeFlow.runId,
-            text: cmd.prompt,
-            senderId: "user"
+    await turnScheduler.prompt({
+      owner: { senderId: cmd.senderId, messageId: cmd.messageId },
+      // The turn ahead may be paused on a question it can only leave through
+      // this driver's rule for a new prompt; apply it now, not after that turn.
+      onQueued: () => driver?.supersedePendingQuestion?.(),
+      admit: async () => {
+        const promptReceivedAt = Date.now();
+        const sessionIsReady = await awaitSessionReadyOrFail();
+        logPhase("prompt_gate_wait", promptReceivedAt, { ready: sessionIsReady });
+        if (!sessionIsReady) return false;
+        if (!secretsProvisioned) {
+          log("[serve] prompt received before secrets provisioned \u2014 rejecting");
+          sendEvent({
+            type: "error",
+            message: "Secrets not yet provisioned \u2014 send provision_secrets first",
+            fatal: false
+          });
+          return false;
+        }
+        log(`[serve] prompt: ${cmd.prompt.slice(0, 80)}...`);
+        contextUsage.observeUserPrompt(cmd.prompt);
+        return true;
+      },
+      route: async () => {
+        await restageMaterializedSkills(true);
+        try {
+          await rebuildForLateMcpDeclarations({
+            driverStarted: () => driverStarted,
+            unloadedMcpDeclarationIds: () => agentSession.unloadedMcpDeclarationIds(),
+            resumeSessionId: () => agentSession.resumeSessionId,
+            recreate: (overrides) => recreateAgentSession(overrides),
+            log,
+            warn: (line) => serverLog.warn(line)
+          });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          serverLog.warn(`[serve] session rebuild for late MCP servers failed: ${errMsg}`);
+          sendEvent({ type: "error", message: `Session rebuild failed: ${errMsg}`, fatal: true });
+          return false;
+        }
+        const activeFlow = pickChatFlowTarget(activeFlows.values());
+        if (!activeFlow) return null;
+        return async () => {
+          sendEvent({ type: "status", phase: "thinking" });
+          try {
+            const bus = getOrCreateStimulusBus();
+            const userStimulus = {
+              kind: "user_message",
+              text: cmd.prompt,
+              senderId: "user"
+            };
+            await bus.signal(activeFlow.connectorId, {
+              promptFragment: renderStimulusPrompt(userStimulus),
+              meta: {
+                kind: "user_message",
+                runId: activeFlow.runId,
+                text: cmd.prompt,
+                senderId: "user"
+              }
+            });
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log(`[serve] flow user-message turn failed: ${errMsg}`);
+            sendEvent({ type: "error", message: `Flow turn failed: ${errMsg}`, fatal: false });
           }
-        });
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        log(`[serve] flow user-message turn failed: ${errMsg}`);
-        sendEvent({ type: "error", message: `Flow turn failed: ${errMsg}`, fatal: false });
-      } finally {
-        if (pendingTurns.shouldReportIdle()) sendEvent({ type: "status", phase: "idle" });
+        };
+      },
+      dispatch: async () => {
+        sendEvent({ type: "status", phase: "thinking" });
+        await driver.promptInput({ text: cmd.prompt, attachments: cmd.attachments });
       }
-      return;
-    }
-    const driverStartStartedAt = Date.now();
-    let driverStartOk = false;
-    let driverStartAttempts = 0;
-    let endTurn;
-    try {
-      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,
-        attempts: driverStartAttempts
-      });
-    }
-    if (!endTurn) return;
-    sendEvent({ type: "status", phase: "thinking" });
-    try {
-      await driver.promptInput({ text: cmd.prompt, attachments: cmd.attachments });
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      log(`[serve] prompt failed: ${errMsg}`);
-      sendEvent({ type: "error", message: `Prompt failed: ${errMsg}`, fatal: true });
-    } finally {
-      endTurn();
-    }
+    });
   }
   async function handleReply(cmd) {
-    if (!await awaitSessionReadyOrFail()) return;
-    log(`[serve] reply: ${cmd.answer.slice(0, 80)}...`);
-    const routed = await routeReply({
-      getDriver: () => driver,
-      awaitSwap: () => driverSwapGate.awaitSwap(),
+    await turnScheduler.reply({
+      admit: async () => {
+        if (!await awaitSessionReadyOrFail()) return false;
+        log(`[serve] reply: ${cmd.answer.slice(0, 80)}...`);
+        return true;
+      },
       answer: cmd.answer,
       question: cmd.question,
       requestId: cmd.requestId,
@@ -11385,49 +11542,10 @@ async function startAgentServer(opts) {
         ...cmd.requestId !== void 0 ? { requestId: cmd.requestId } : {}
       })
     });
-    if (routed === "answered") return;
-    if (!driver.acceptsReplyAsPrompt) {
-      if (!driver.hasPendingQuestion()) {
-        log("[serve] reply: driver takes no reply as a prompt; answer not delivered");
-        sendEvent({
-          type: "error",
-          message: "This question is no longer open, so the agent did not get your answer. Send it as a new message.",
-          fatal: false
-        });
-      }
-      return;
-    }
-    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(freshTurnReplyPrompt(cmd.answer, cmd.question));
-    } catch (err) {
-      sendEvent({
-        type: "error",
-        message: `Reply failed: ${err instanceof Error ? err.message : String(err)}`,
-        fatal: false
-      });
-    } finally {
-      endTurn();
-    }
   }
   async function handleCancel(cmd) {
     if (cmd.senderId) {
-      const dropped = promptTurns.dropQueuedFrom(cmd.senderId);
+      const dropped = turnScheduler.dropQueuedPromptsFrom(cmd.senderId);
       if (dropped.length > 0) {
         log(`[serve] cancel dropped ${dropped.length} queued prompt(s) of the presser`);
         sendEvent({
@@ -11703,10 +11821,10 @@ async function startAgentServer(opts) {
         await handleSessionInit(cmd);
         break;
       case "prompt":
-        await countPendingTurn(() => handlePrompt(cmd));
+        await handlePrompt(cmd);
         break;
       case "reply":
-        await countPendingTurn(() => handleReply(cmd));
+        await handleReply(cmd);
         break;
       case "cancel":
         await handleCancel(cmd);
@@ -11815,7 +11933,7 @@ async function startAgentServer(opts) {
   }
   function emitAvailability() {
     if (resourceManager || agentSession?.getExternalMcpManager()) {
-      const driverLive = agentSession?.driverType !== "claude-sdk";
+      const driverLive = driverCapabilities(agentSession?.driverType).liveToolUpdates;
       const payload = buildResourcesAvailablePayload(
         resourceManager,
         agentSession?.getExternalMcpManager() ?? null,
@@ -12015,6 +12133,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, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WRITE_RANGE_PARTIAL_TTL_MS, 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, writeRangeChunk, writeRangePartialPath };
-//# sourceMappingURL=chunk-KWP4RVTJ.js.map
-//# sourceMappingURL=chunk-KWP4RVTJ.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, MOUNT_WRITE_MAX_CHUNK_BYTES, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WRITE_RANGE_PARTIAL_TTL_MS, 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, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, 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, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile, writeRangeChunk, writeRangePartialPath };
+//# sourceMappingURL=chunk-ZSFTCMZL.js.map
+//# sourceMappingURL=chunk-ZSFTCMZL.js.map