@skaile/workspaces 4.38.0 → 5.0.0

package/dist/{chunk-R5ARWJGE.js → chunk-YOWFUJO7.js}

@@ -1,38 +1,38 @@
-import { WorkspacePlugin } from './chunk-BQ3HXZNT.js';
-import { buildWorkspaceToolDefs } from './chunk-YCJ3PJNB.js';
-import { findAiAssetsRoot } from './chunk-EOKAFBJ7.js';
+import { WorkspacePlugin } from './chunk-TVYLXZTT.js';
+import { buildWorkspaceToolDefs } from './chunk-RSHMAEK3.js';
+import { findAiAssetsRoot } from './chunk-TYUJB336.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-27DN4DZD.js';
-import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-DOVURNRK.js';
-import { ConnectFailureCarryOver, registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-J5UF3OOS.js';
-import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-YQEF36D5.js';
-import { EventNormalizer } from './chunk-7UL2SQQH.js';
-import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-5NYBY6ZE.js';
+import { resolveFlowPath } from './chunk-GFPG27HK.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-53WMBXSL.js';
+import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-H5G3OYY6.js';
+import { EventNormalizer } from './chunk-KREXWKVX.js';
+import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-TVOODIZE.js';
 import { scopeReconfigureModel } from './chunk-EINLFFP6.js';
 import { CodexNativeStateUnavailable } from './chunk-LOO5CB5M.js';
-import { dispatchCapability } from './chunk-PRCUGFXV.js';
+import { dispatchCapability } from './chunk-RDYI4MML.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-6KPQDP7P.js';
-import { loadFlow } from './chunk-7RC37XFW.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-YNUBJY3L.js';
-import { resolveLibraryDir, resolveSettings, loadProviderRegistry } from './chunk-YV3YI3TA.js';
-import { resolveRuntimeAssets } from './chunk-36ML6SFP.js';
+import { toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, AgentDriver } from './chunk-RP4B4HVX.js';
+import { loadFlow } from './chunk-22DN3DB2.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-MBVNMPG7.js';
+import { resolveRuntimeAssets } from './chunk-CGJ7B6MZ.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-JEPSP6XK.js';
+import { resolveSkWorkspaceConfig, resolveAgentDir, loadMcpServerDeclarations, COMPACTION_DEFAULTS, resolveCompactionThresholdPercent, validateAssetRecipeAttr, deriveSingleMaterializedMcpDeclaration, stageMaterializedSkills, readSkillAllowList, isStagedSkillMarkerFor, unstageSkill, STAGED_SKILL_MARKER } from './chunk-HWE3FXF4.js';
 import { globalSkaileDir } from './chunk-TLKM4M47.js';
-import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-5K2VT6E2.js';
-import { parseAssetRef } from './chunk-A5EDMBFG.js';
+import { withFsDeadline, FsDeadlineError, fsDeadlineMs, parseFrontmatter, tryWithFsDeadline } from './chunk-DXUQCMVT.js';
+import { parseAssetRef } from './chunk-43ZBF3WH.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';
 import { __require } from './chunk-NSBPE2FW.js';
 import pc from 'picocolors';
-import path5, { join, resolve, relative, sep, isAbsolute, basename, dirname } from 'path';
+import path5, { join, resolve, basename, dirname, relative, sep, isAbsolute } from 'path';
 import { Marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import fs4, { readFile, readdir, lstat, stat, rm, unlink, mkdir, writeFile, realpath, rename, open, readlink, mkdtemp } from 'fs/promises';
@@ -3864,6 +3864,176 @@ async function readMountRange(targetPath, range, authoritativeSize) {
     });
   }
 }
+var MOUNT_WRITE_MAX_CHUNK_BYTES = 8 * 1024 * 1024;
+var WRITE_RANGE_PARTIAL_TTL_MS = 60 * 60 * 1e3;
+var PARTIAL_SUFFIX = ".skaile-partial";
+var UPLOAD_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+var PARTIAL_NAME_MAX_BYTES = 120;
+function writeRangePartialPath(targetPath, uploadId) {
+  const name = basename(targetPath);
+  const stem = Buffer.byteLength(name) > PARTIAL_NAME_MAX_BYTES ? createHash("sha256").update(name).digest("hex").slice(0, 32) : name;
+  return join(dirname(targetPath), `.${stem}.${uploadId}${PARTIAL_SUFFIX}`);
+}
+var partialLocks = /* @__PURE__ */ new Map();
+var transferOutcomes = /* @__PURE__ */ new Map();
+function recordOutcome(partialPath, outcome, size) {
+  const now = Date.now();
+  for (const [key, entry] of transferOutcomes) {
+    if (now - entry.at > WRITE_RANGE_PARTIAL_TTL_MS) transferOutcomes.delete(key);
+  }
+  transferOutcomes.set(partialPath, { outcome, size, at: now });
+}
+async function withPartialLock(key, fn) {
+  const previous = partialLocks.get(key) ?? Promise.resolve();
+  const run = previous.catch(() => {
+  }).then(fn);
+  partialLocks.set(key, run);
+  try {
+    return await run;
+  } finally {
+    if (partialLocks.get(key) === run) partialLocks.delete(key);
+  }
+}
+function invalidRange(message) {
+  return new ResourceOperationError(`Invalid write range: ${message}`, "invalid_range");
+}
+function parseWriteRange(options, content) {
+  const { uploadId, offset, size, abort } = options ?? {};
+  if (typeof uploadId !== "string" || !UPLOAD_ID_PATTERN.test(uploadId)) {
+    throw invalidRange("uploadId must be 1-64 letters, digits, '-' or '_'");
+  }
+  if (abort === true) return { uploadId, offset: 0, size: 0, abort: true, chunk: Buffer.alloc(0) };
+  for (const [name, value] of [
+    ["offset", offset],
+    ["size", size]
+  ]) {
+    if (!(Number.isSafeInteger(value) && value >= 0)) {
+      throw invalidRange(`${name} must be a non-negative integer`);
+    }
+  }
+  const body = typeof content === "object" && content !== null ? content : void 0;
+  if (body?.encoding !== "binary" || typeof body.data !== "string") {
+    throw invalidRange('the chunk must be base64 content with encoding "binary"');
+  }
+  if (body.data.length > Math.ceil(MOUNT_WRITE_MAX_CHUNK_BYTES / 3) * 4) {
+    throw invalidRange(`a chunk holds at most ${MOUNT_WRITE_MAX_CHUNK_BYTES} bytes`);
+  }
+  const chunk = Buffer.from(body.data, "base64");
+  if (chunk.length > MOUNT_WRITE_MAX_CHUNK_BYTES) {
+    throw invalidRange(`a chunk holds at most ${MOUNT_WRITE_MAX_CHUNK_BYTES} bytes`);
+  }
+  if (offset + chunk.length > size) {
+    throw invalidRange(
+      `a chunk of ${chunk.length} bytes at offset ${offset} runs past the stated size of ${size}`
+    );
+  }
+  if (chunk.length === 0 && offset < size) {
+    throw invalidRange(
+      `an empty chunk at offset ${offset} cannot complete a file of ${size} bytes`
+    );
+  }
+  return { uploadId, offset, size, abort: false, chunk };
+}
+async function sweepStalePartials(targetPath, keep) {
+  const dir = dirname(targetPath);
+  try {
+    const names = await withFsDeadline(`readdir ${dir}`, () => readdir(dir));
+    const now = Date.now();
+    for (const name of names) {
+      if (!name.startsWith(".") || !name.endsWith(PARTIAL_SUFFIX)) continue;
+      const abs = join(dir, name);
+      if (abs === keep) continue;
+      const st = await withFsDeadline(`lstat ${abs}`, () => lstat(abs));
+      if (st.isFile() && now - st.mtimeMs > WRITE_RANGE_PARTIAL_TTL_MS) {
+        await withFsDeadline(`unlink ${abs}`, () => unlink(abs));
+      }
+    }
+  } catch {
+  }
+}
+async function openPartial(partialPath, start) {
+  if (start) await withFsDeadline(`rm ${partialPath}`, () => rm(partialPath, { force: true }));
+  const flags = start ? constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW : constants.O_RDWR | constants.O_NOFOLLOW;
+  const opening = open(partialPath, flags);
+  try {
+    return await withFsDeadline(`open ${partialPath}`, () => opening);
+  } catch (err) {
+    void opening.then((h) => h.close()).catch(() => {
+    });
+    throw err;
+  }
+}
+async function writeRangeChunk(targetPath, options, content) {
+  const req = parseWriteRange(options, content);
+  const partialPath = writeRangePartialPath(targetPath, req.uploadId);
+  return withPartialLock(partialPath, async () => {
+    const known = transferOutcomes.get(partialPath);
+    if (req.abort) {
+      await withFsDeadline(`rm ${partialPath}`, () => rm(partialPath, { force: true }));
+      transferOutcomes.delete(partialPath);
+      return { received: 0, size: 0, complete: false };
+    }
+    const received = req.offset + req.chunk.length;
+    if (req.offset > 0 && known?.outcome === "done") {
+      if (received === req.size && known.size === req.size) {
+        return { received, size: req.size, complete: true };
+      }
+      throw invalidRange(`transfer "${req.uploadId}" is already complete`);
+    }
+    if (req.offset > 0 && known?.outcome === "stalled") {
+      throw invalidRange(
+        `transfer "${req.uploadId}" stalled on a slow mount; start again at offset 0`
+      );
+    }
+    const parentDir = dirname(targetPath);
+    await withFsDeadline(`mkdir ${parentDir}`, () => mkdir(parentDir, { recursive: true }));
+    if (req.offset === 0) await sweepStalePartials(targetPath, partialPath);
+    let fh;
+    try {
+      fh = await openPartial(partialPath, req.offset === 0);
+      if (req.offset === 0) transferOutcomes.delete(partialPath);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ELOOP") throw invalidRange("the partial file is not a regular file");
+      if (code !== "ENOENT" || req.offset === 0) throw err;
+      throw invalidRange(`no transfer "${req.uploadId}" is in progress; start again at offset 0`);
+    }
+    try {
+      const st = await withFsDeadline(`fstat ${partialPath}`, () => fh.stat());
+      if (!st.isFile()) throw invalidRange("the partial file is not a regular file");
+      if (st.size !== req.offset) {
+        throw invalidRange(`expected offset ${st.size}, got ${req.offset}`);
+      }
+      await withFsDeadline(`write ${partialPath} @${req.offset}+${req.chunk.length}`, async () => {
+        let done = 0;
+        while (done < req.chunk.length) {
+          const { bytesWritten } = await fh.write(
+            req.chunk,
+            done,
+            req.chunk.length - done,
+            req.offset + done
+          );
+          done += bytesWritten;
+        }
+      });
+    } catch (err) {
+      if (err instanceof FsDeadlineError) {
+        void fh.close().catch(() => {
+        });
+        recordOutcome(partialPath, "stalled", req.size);
+      } else {
+        await fh.close().catch(() => {
+        });
+      }
+      throw err;
+    }
+    await withFsDeadline(`close ${partialPath}`, () => fh.close());
+    if (received < req.size) return { received, size: req.size, complete: false };
+    await withFsDeadline(`rename ${partialPath}`, () => rename(partialPath, targetPath));
+    recordOutcome(partialPath, "done", req.size);
+    return { received, size: req.size, complete: true };
+  });
+}
 var MOUNT_STAT_MAX_ENTRIES = 5e4;
 var MOUNT_STAT_BUDGET_MS = 1e4;
 var MOUNT_STAT_CONCURRENCY = 16;
@@ -4094,6 +4264,11 @@ async function handleMountResourceRequest(command, manager, emit) {
         data = true;
         break;
       }
+      case "write_range": {
+        if (rel === "") throw new Error("A file path is required");
+        data = await writeRangeChunk(targetPath, options, content);
+        break;
+      }
       case "mkdir": {
         if (rel === "") throw new Error("A folder path is required");
         const parentDir = dirname(targetPath);
@@ -4216,27 +4391,34 @@ async function readDanglingLink(absPath) {
 async function handleSessionRootResourceRequest(command, rootDir, emit) {
   const { requestId, connectorId, operation, path: reqPath, content } = command;
   try {
-    if (operation !== "write" && operation !== "delete") {
+    if (operation !== "write" && operation !== "write_range" && operation !== "delete") {
       throw unsupportedOperation(operation, "the session root");
     }
+    const access = operation === "delete" ? "delete" : "write";
     if (!reqPath) throw new Error("A path is required for the session root");
     if (isAbsolute(reqPath)) throw new Error("Absolute paths are not allowed for the session root");
     const root = resolve(rootDir);
     const targetPath = resolve(root, reqPath);
     if (!isWithin2(root, targetPath)) throw new Error("Path traversal outside the session root");
     const rel = relative(root, targetPath).split(sep).join("/");
-    if (!isSessionRootPathAllowed(rel, operation)) {
+    if (!isSessionRootPathAllowed(rel, access)) {
       throw new Error(
         `Path "${rel}" is not writable in the session root \u2014 allowed: ${[...SESSION_ROOT_WRITABLE_FILES, ...SESSION_ROOT_WRITABLE_DIRS.map((d) => `${d}/**`)].join(", ")}`
       );
     }
     const realRoot = await withFsDeadline(`realpath ${root}`, () => realpath(root));
-    const onDisk = operation === "write" ? await resolveOnDisk(targetPath) : join(await resolveOnDisk(dirname(targetPath)), basename(targetPath));
-    if (!isWithin2(realRoot, operation === "write" ? onDisk : dirname(onDisk))) {
+    const onDisk = access === "write" ? await resolveOnDisk(targetPath) : join(await resolveOnDisk(dirname(targetPath)), basename(targetPath));
+    if (!isWithin2(realRoot, access === "write" ? onDisk : dirname(onDisk))) {
       throw new Error("Path escapes the session root through a symlink");
     }
     let data = true;
-    if (operation === "write") {
+    if (operation === "write_range") {
+      data = await writeRangeChunk(
+        onDisk,
+        command.options,
+        content
+      );
+    } else if (operation === "write") {
       const parentDir = dirname(onDisk);
       await withFsDeadline(`mkdir ${parentDir}`, () => mkdir(parentDir, { recursive: true }));
       const writeContent = typeof content === "string" ? content : content?.data ?? "";
@@ -4918,12 +5100,23 @@ async function claimDriverForCompaction(deps) {
     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;
+  if (await raceDeadline(deps.awaitClaimedTurns(), timeoutMs) !== "opened") {
+    release2();
+    deps.log(
+      `[serve] compaction skipped: a turn still held the driver after ${Math.round(timeoutMs / 1e3)}s`
+    );
+    return null;
+  }
+  if (deps.isSwapping?.()) {
+    release2();
+    deps.log("[serve] compaction skipped: a driver swap is pending");
+    return null;
+  }
+  const endTurn = deps.claimTurnSlot?.();
+  return () => {
+    endTurn?.();
+    release2();
+  };
 }
 var TURN_COMPACTION_YIELD_ATTEMPTS = 3;
 async function beginTurnClearOfCompaction(deps, maxAttempts = TURN_COMPACTION_YIELD_ATTEMPTS) {
@@ -5821,6 +6014,11 @@ function compactionTimeoutMs() {
   const raw = Number(process.env.SKAILE_COMPACTION_TIMEOUT_MS);
   return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_TIMEOUT_MS;
 }
+var DEFAULT_COMPACTION_INACTIVITY_MS = 3 * 6e4;
+function compactionInactivityMs() {
+  const raw = Number(process.env.SKAILE_COMPACTION_INACTIVITY_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_COMPACTION_INACTIVITY_MS;
+}
 var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set(["timeout", "unknown"]);
 var RETRY_FOCUS_DIRECTIVE = `The previous attempt to write this summary did not finish in time, most likely
 because it ran long. Be economical: compress aggressively, and drop low-value
@@ -6096,7 +6294,8 @@ var CompactionOrchestrator = class {
    * thing that separates a genuinely empty model response from a turn that was
    * settled by something other than the model, which resolves in milliseconds.
    *
-   * The call is bounded by {@link compactionTimeoutMs}; on expiry the turn is
+   * The call is bounded by {@link compactionInactivityMs} of driver silence and
+   * by the {@link compactionTimeoutMs} ceiling; on either expiry the turn is
    * aborted and `timedOut` is returned so the caller can record a classified
    * `timeout` rather than wait out the driver's much longer stall watchdog.
    */
@@ -6104,7 +6303,10 @@ var CompactionOrchestrator = class {
     let summaryText = "";
     let sawDeltas = false;
     const capturedMessages = /* @__PURE__ */ new WeakSet();
+    let rearmInactivity = () => {
+    };
     const captureHandler = (raw) => {
+      rearmInactivity();
       const event = raw;
       if (event.type === "text") {
         summaryText += event.content ?? "";
@@ -6144,23 +6346,36 @@ var CompactionOrchestrator = class {
     let promptError = null;
     let timedOut = false;
     let timer;
+    let idleTimer;
     const startedAt = Date.now();
     const timeoutMs = compactionTimeoutMs();
+    const inactivityMs = compactionInactivityMs();
     try {
-      this.driver.on("agent-event", captureHandler);
-      const running = this.driver.prompt(prompt);
       const expiry = new Promise((resolve4) => {
         timer = setTimeout(() => resolve4("expired"), timeoutMs);
+        let lastEventAt = Date.now();
+        const check = () => {
+          const lastSeen = Math.max(lastEventAt, this.driver.lastActivityAt?.() ?? 0);
+          const idleMs = Date.now() - lastSeen;
+          if (idleMs >= inactivityMs) resolve4("stalled");
+          else idleTimer = setTimeout(check, inactivityMs - idleMs);
+        };
+        rearmInactivity = () => {
+          lastEventAt = Date.now();
+        };
+        idleTimer = setTimeout(check, inactivityMs);
       });
+      this.driver.on("agent-event", captureHandler);
+      const running = this.driver.prompt(prompt);
       const outcome = await Promise.race([running.then(() => "settled"), expiry]);
-      if (outcome === "expired") {
+      if (outcome !== "settled") {
         timedOut = true;
         const settled = running.then(
           () => void 0,
           () => void 0
         );
         promptError = new Error(
-          `Compaction prompt did not complete within ${timeoutMs}ms; the turn was aborted.`
+          outcome === "stalled" ? `Compaction prompt produced no output for ${inactivityMs}ms; the turn was aborted.` : `Compaction prompt did not complete within ${timeoutMs}ms; the turn was aborted.`
         );
         const aborted = this.driver.abort().catch((abortErr) => {
           this.opts.onLog?.(`[compaction] abort after timeout failed: ${String(abortErr)}`);
@@ -6177,6 +6392,9 @@ var CompactionOrchestrator = class {
       promptError = err;
     } finally {
       clearTimeout(timer);
+      clearTimeout(idleTimer);
+      rearmInactivity = () => {
+      };
       this.driver.removeListener("agent-event", captureHandler);
     }
     return { summaryText, promptError, elapsedMs: Date.now() - startedAt, timedOut };
@@ -9749,6 +9967,8 @@ async function startAgentServer(opts) {
       claimDriver: (trigger) => claimDriverForCompaction({
         gate: compactionGate,
         awaitClaimedTurns: () => driverSwapGate.awaitActiveTurn(),
+        isSwapping: () => driverSwapGate.isSwapping(),
+        claimTurnSlot: () => driverSwapGate.beginTurn(),
         log,
         timeoutMs: compactionTurnWaitFor(trigger)
       }),
@@ -11710,6 +11930,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, 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-R5ARWJGE.js.map
-//# sourceMappingURL=chunk-R5ARWJGE.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, 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-YOWFUJO7.js.map
+//# sourceMappingURL=chunk-YOWFUJO7.js.map