@skaile/workspaces 4.32.1 → 4.33.0

package/dist/{chunk-EOX3QH74.js → chunk-3C6Q6TCZ.js}

@@ -1,25 +1,25 @@
-import { WorkspacePlugin } from './chunk-JYWEWJ46.js';
-import { buildWorkspaceToolDefs } from './chunk-BU53MUL5.js';
+import { WorkspacePlugin } from './chunk-SK36WO2Z.js';
+import { buildWorkspaceToolDefs } from './chunk-QDRQKQOU.js';
 import { findAiAssetsRoot } from './chunk-7IH3RKKK.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-OS4SXZTQ.js';
+import { resolveFlowPath } from './chunk-I6NZG7WX.js';
 import { findAiAssetsRoot as findAiAssetsRoot$1, deployCatalogEntry, undeployCatalogEntry } from './chunk-Q6NDQ6BH.js';
-import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-223FKFTC.js';
-import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, isKnownSecretRef, deriveSingleMaterializedConnectorDeclaration } from './chunk-2JANXYTJ.js';
-import { EventNormalizer } from './chunk-MNA22VPT.js';
+import { registerBuiltinConnectors, buildConnectorPromptSection, findMissingPackages, installNpmPackages, ConnectorManager, buildSdkConnectorTools, buildLazySdkFlowTools, describeFlowOperations, buildConnectorToolDefs, buildFlowToolDefs, SessionNodeExecutor, SessionSubpromptRunner, ClassifierSubpromptRunner, SessionInlineSubFlowRunner, driveOrchestratorTurn, buildSdkFlowTools } from './chunk-ACDHNOT7.js';
+import { loadYamlConnectorDeclarations, withMaterializedConnectorDeclarations, SecretProviderChain, ConnectorStartupError, isKnownSecretRef, EnvSecretProvider, PreMintedSecretProvider, InMemorySecretProvider, resolvedConfigToDeclarations, deriveSingleMaterializedConnectorDeclaration } from './chunk-2JANXYTJ.js';
+import { EventNormalizer } from './chunk-4T25XCWX.js';
 import { probeResumeTranscript, transcriptStoreForRuntime } from './chunk-LX3FKVLL.js';
 import { scopeReconfigureModel } from './chunk-EINLFFP6.js';
 import { CodexNativeStateUnavailable } from './chunk-LOO5CB5M.js';
-import { dispatchCapability } from './chunk-XVGB3K4B.js';
+import { dispatchCapability } from './chunk-UWJAJP6T.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-MVSF6AB4.js';
+import { toAgentEffort, createDriver, catalogLayer, providerCredentialEnvName, toMergedRegistry, registryCredentialEnv, AI_PROVIDER_PRESETS, AgentDriver } from './chunk-TAZMDZFP.js';
 import { loadFlow } from './chunk-JULFGNQN.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-34ZVTPDV.js';
+import { withActivityLabelJsonSchema, TOOL_ACTIVITY_PROMPT_SECTION, SESSION_ROOT_CONNECTOR_ID, PROTOCOL_VERSION } from './chunk-JS7DCCDA.js';
 import { resolveSettings, loadProviderRegistry } from './chunk-WPISSDEI.js';
 import { resolveRuntimeAssets } from './chunk-5RHPNNWP.js';
 import { resolveDriverPaths } from './chunk-K5GBV4SA.js';
@@ -52,6 +52,7 @@ import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import mime from 'mime';
+import { Worker } from 'worker_threads';
 
 var PreInitRingSink = class {
   ring = [];
@@ -111,13 +112,19 @@ var currentSessionId = null;
 function bootstrapRunnerLogStore(opts) {
   const existing = getLogStore();
   if (existing && currentSessionId === opts.sessionId) {
-    return { store: existing, dispose: () => disposeStore(existing) };
+    const reusedPath = opts.projectDir ? path5.join(opts.projectDir, ".skaile", "logs.db") : void 0;
+    return {
+      store: existing,
+      dispose: () => disposeStore(existing),
+      ...reusedPath ? { logsDbPath: reusedPath } : {}
+    };
   }
   const cfg = resolveLogStoreConfig({
     sessionId: opts.sessionId,
     workspacePath: opts.projectDir,
     yamlBlock: opts.yamlBlock
   });
+  const logsDbPath = cfg.mode === "persistent" && cfg.workspacePath ? path5.join(cfg.workspacePath, ".skaile", "logs.db") : void 0;
   const store = createLogStoreFromConfig(cfg);
   if (opts.onLog) {
     store.addSink(new OnLogBridgeSink(opts.onLog));
@@ -137,7 +144,8 @@ function bootstrapRunnerLogStore(opts) {
       disposeStore(store);
       currentSessionId = null;
     },
-    ...retention ? { retention } : {}
+    ...retention ? { retention } : {},
+    ...logsDbPath ? { logsDbPath } : {}
   };
 }
 function scheduleRetention(cfg) {
@@ -1730,6 +1738,21 @@ function resolveRecordSecretsStrict(record2, secrets, ctx) {
   }
   return resolved;
 }
+function resolveMcpUrl(decl, secrets) {
+  const raw = decl.url ?? "";
+  if (!isKnownSecretRef(raw)) return new URL(raw);
+  const resolved = secrets?.resolve(raw);
+  if (resolved === void 0) {
+    throw new Error(
+      `credential for MCP server '${decl.id}' unavailable \u2014 unresolved secret ref '${raw}' in url`
+    );
+  }
+  try {
+    return new URL(resolved);
+  } catch {
+    throw new Error(`resolved url for MCP server '${decl.id}' is not a valid URL`);
+  }
+}
 var RESERVED_MCP_SERVER_IDS = /* @__PURE__ */ new Set([
   "skaile-connectors",
   "skaile-workspace",
@@ -1864,7 +1887,7 @@ function buildTransport(decl, secrets) {
       serverId: decl.id,
       kind: "header"
     });
-    return new SSEClientTransport(new URL(decl.url), { requestInit: { headers } });
+    return new SSEClientTransport(resolveMcpUrl(decl, secrets), { requestInit: { headers } });
   }
   if (transport === "http") {
     if (!decl.url) throw new Error(`http MCP server '${decl.id}' is missing 'url'`);
@@ -1872,7 +1895,9 @@ function buildTransport(decl, secrets) {
       serverId: decl.id,
       kind: "header"
     });
-    return new StreamableHTTPClientTransport(new URL(decl.url), { requestInit: { headers } });
+    return new StreamableHTTPClientTransport(resolveMcpUrl(decl, secrets), {
+      requestInit: { headers }
+    });
   }
   throw new Error(`Unknown MCP transport '${transport}' for server '${decl.id}'`);
 }
@@ -2569,7 +2594,15 @@ function toSdkMcpServerConfig(decl, secrets) {
   }
   if (transport === "sse" || transport === "http") {
     if (!decl.url) return null;
-    const cfg = { type: transport, url: decl.url };
+    let url = decl.url;
+    if (isKnownSecretRef(url)) {
+      try {
+        url = resolveMcpUrl(decl, secrets).href;
+      } catch {
+        return null;
+      }
+    }
+    const cfg = { type: transport, url };
     if (decl.headers && Object.keys(decl.headers).length > 0) {
       cfg.headers = resolveRecordSecrets(decl.headers, secrets);
     }
@@ -6905,11 +6938,12 @@ function replyResults(results) {
 }
 function buildLifecycleHandler(deps) {
   const { getCompactionOrchestrator, getResourceManager, log } = deps;
-  return async ({ phase }) => {
+  return async ({ phase, trigger }) => {
     switch (phase) {
       case "compact": {
         const orchestrator = getCompactionOrchestrator();
-        if (orchestrator) await orchestrator.compact("manual");
+        if (orchestrator)
+          await orchestrator.compact(trigger === "hibernate" ? "hibernate" : "manual");
         else log("[lifecycle] compact: no compaction orchestrator \u2014 skipped");
         return { ok: true };
       }
@@ -7235,7 +7269,8 @@ var setStateInput = z7.strictObject({
   value: requiredUnknown
 });
 var lifecycleInput = z7.strictObject({
-  phase: z7.enum(["hibernate", "close", "compact"])
+  phase: z7.enum(["hibernate", "close", "compact"]),
+  trigger: z7.enum(["manual", "hibernate"]).optional()
 });
 var reconfigureInputSchema = z7.strictObject({
   model: z7.string().trim().min(1).optional(),
@@ -7406,7 +7441,7 @@ function buildRunnerCapabilities(handlers) {
     defineCapability({
       name: "runner.lifecycle",
       displayName: "Session lifecycle",
-      description: "Transition the session lifecycle: hibernate (connectors persist state), close (connectors finalize), or compact conversation history.",
+      description: "Transition the session lifecycle: hibernate (connectors persist state), close (connectors finalize), or compact conversation history (trigger hibernate: no follow-up agent turn).",
       side: "agent",
       origin: RUNNER_CAP_ORIGIN,
       audience: ["runtime"],
@@ -7602,6 +7637,212 @@ function createSessionStimulusBus(opts) {
     }
   };
 }
+var HEARTBEAT_MS = 1e3;
+var DEFAULT_STALL_THRESHOLD_MS = 1e4;
+var PHASE_MAX_BYTES = 240;
+function wasProcessPaused(input) {
+  if (input.reported || !input.workerAlive) return false;
+  return input.workerSawOwnGap || input.now - input.workerLastTick > input.thresholdMs;
+}
+function resolveStallThresholdMs(raw = process.env.SKAILE_RUNNER_STALL_WATCHDOG_MS) {
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_STALL_THRESHOLD_MS;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0) return DEFAULT_STALL_THRESHOLD_MS;
+  return n;
+}
+var WORKER_SOURCE = `
+const { workerData } = require("node:worker_threads");
+const fs = require("node:fs");
+const hb = new BigInt64Array(workerData.heartbeat);
+const phaseLen = new Int32Array(workerData.phaseLen);
+const phaseBytes = new Uint8Array(workerData.phaseBytes);
+const workerTick = new BigInt64Array(workerData.workerTick);
+// [0] = reported the current stall.
+const flags = new Int32Array(workerData.flags);
+// When this thread last saw a gap of its own (the process was paused).
+const pausedAt = new BigInt64Array(workerData.pausedAt);
+const stallPhaseLen = new Int32Array(workerData.stallPhaseLen);
+const stallPhaseBytes = new Uint8Array(workerData.stallPhaseBytes);
+const decoder = new TextDecoder();
+const B32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function ulid(now) {
+  let t = "";
+  for (let i = 0, v = now; i < 10; i++) { t = B32[v % 32] + t; v = Math.floor(v / 32); }
+  let r = "";
+  for (let i = 0; i < 16; i++) r += B32[Math.floor(Math.random() * 32)];
+  return t + r;
+}
+function readPhase() {
+  const n = Math.max(0, Math.min(Atomics.load(phaseLen, 0), phaseBytes.length));
+  return decoder.decode(phaseBytes.slice(0, n));
+}
+function writeRow(entry) {
+  // Never create the file: a store that is not persistent has no logs.db to append to.
+  if (!workerData.logsDbPath || !fs.existsSync(workerData.logsDbPath)) return;
+  let db;
+  try {
+    if (typeof Bun !== "undefined") {
+      const { Database } = require("bun:sqlite");
+      db = new Database(workerData.logsDbPath);
+    } else {
+      const { DatabaseSync } = require("node:sqlite");
+      db = new DatabaseSync(workerData.logsDbPath);
+    }
+    db.exec("PRAGMA busy_timeout = 1000");
+    db.prepare(
+      "INSERT INTO log_entries (id, timestamp, session_id, kind, subkind, instance, level, message, data_json, error_json) " +
+      "VALUES ($id, $timestamp, $session_id, $kind, $subkind, $instance, $level, $message, $data_json, NULL)"
+    ).run({
+      $id: entry.id, $timestamp: entry.timestamp, $session_id: entry.sessionId, $kind: "runner",
+      $subkind: "session", $instance: entry.sessionId, $level: "warn", $message: entry.message,
+      $data_json: JSON.stringify(entry.data),
+    });
+  } catch (err) {
+    try { fs.writeSync(2, "[stall-watchdog] logs.db write failed: " + String(err && err.message || err) + "\\n"); } catch {}
+  } finally {
+    try { db && db.close(); } catch {}
+  }
+}
+let reportedFor = 0n;
+let lastWorkerTick = Date.now();
+setInterval(() => {
+  const now = Date.now();
+  const selfGap = now - lastWorkerTick;
+  lastWorkerTick = now;
+  Atomics.store(workerTick, 0, BigInt(now));
+  const last = Atomics.load(hb, 0);
+  // This thread stopped too, so the whole process was paused: not a main-thread stall.
+  if (selfGap > workerData.thresholdMs) {
+    Atomics.store(pausedAt, 0, BigInt(now));
+    reportedFor = last;
+    return;
+  }
+  if (last === reportedFor) return;
+  const age = now - Number(last);
+  if (age <= workerData.thresholdMs) return;
+  reportedFor = last;
+  const phase = readPhase();
+  // Handed to the main thread, which may have moved to the next phase before it logs the end.
+  Atomics.store(stallPhaseLen, 0, 0);
+  const n = Math.min(phaseBytes.length, Atomics.load(phaseLen, 0));
+  stallPhaseBytes.set(phaseBytes.subarray(0, n));
+  Atomics.store(stallPhaseLen, 0, n);
+  Atomics.store(flags, 0, 1);
+  const entry = {
+    id: ulid(now),
+    timestamp: new Date(now).toISOString(),
+    sessionId: workerData.sessionId,
+    message: "runner main thread stalled",
+    data: { phase, stalledForMs: age, thresholdMs: workerData.thresholdMs },
+  };
+  try {
+    // The StdoutSink's JSON line shape, so the container log reads like every other entry.
+    fs.writeSync(2, JSON.stringify({ id: entry.id, timestamp: entry.timestamp, sessionId: entry.sessionId,
+      source: { kind: "runner", subkind: "session", instance: entry.sessionId }, level: "warn",
+      message: entry.message, data: entry.data }) + "\\n");
+  } catch {}
+  writeRow(entry);
+}, workerData.intervalMs);
+`;
+function startStallWatchdog(opts) {
+  const thresholdMs = opts.thresholdMs ?? resolveStallThresholdMs();
+  const intervalMs = opts.intervalMs ?? HEARTBEAT_MS;
+  const heartbeat = new BigInt64Array(new SharedArrayBuffer(8));
+  const phaseLen = new Int32Array(new SharedArrayBuffer(4));
+  const phaseBytes = new Uint8Array(new SharedArrayBuffer(PHASE_MAX_BYTES));
+  const workerTick = new BigInt64Array(new SharedArrayBuffer(8));
+  const flags = new Int32Array(new SharedArrayBuffer(4));
+  const pausedAt = new BigInt64Array(new SharedArrayBuffer(8));
+  const stallPhaseLen = new Int32Array(new SharedArrayBuffer(4));
+  const stallPhaseBytes = new Uint8Array(new SharedArrayBuffer(PHASE_MAX_BYTES));
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let phase = "starting";
+  const markPhase = (next) => {
+    phase = next;
+    Atomics.store(phaseLen, 0, 0);
+    const { written } = encoder.encodeInto(next, phaseBytes);
+    Atomics.store(phaseLen, 0, written);
+  };
+  markPhase(phase);
+  if (thresholdMs <= 0) return { markPhase: () => {
+  }, stop: async () => {
+  } };
+  let worker;
+  try {
+    worker = new Worker(WORKER_SOURCE, {
+      eval: true,
+      workerData: {
+        heartbeat: heartbeat.buffer,
+        phaseLen: phaseLen.buffer,
+        phaseBytes: phaseBytes.buffer,
+        workerTick: workerTick.buffer,
+        flags: flags.buffer,
+        pausedAt: pausedAt.buffer,
+        stallPhaseLen: stallPhaseLen.buffer,
+        stallPhaseBytes: stallPhaseBytes.buffer,
+        thresholdMs,
+        intervalMs,
+        sessionId: opts.sessionId,
+        logsDbPath: opts.logsDbPath ?? null
+      }
+    });
+  } catch {
+    return { markPhase: () => {
+    }, stop: async () => {
+    } };
+  }
+  worker.unref();
+  let workerAlive = true;
+  worker.on("error", (err) => {
+    workerAlive = false;
+    try {
+      process.stderr.write(
+        `[stall-watchdog] worker died, stalls are no longer recorded: ${String(err)}
+`
+      );
+    } catch {
+    }
+  });
+  worker.on("exit", () => {
+    workerAlive = false;
+  });
+  let lastTick = Date.now();
+  Atomics.store(heartbeat, 0, BigInt(lastTick));
+  Atomics.store(workerTick, 0, BigInt(lastTick));
+  const timer = setInterval(() => {
+    const now = Date.now();
+    const gap = now - lastTick;
+    const prevTick = lastTick;
+    lastTick = now;
+    Atomics.store(heartbeat, 0, BigInt(now));
+    if (gap > thresholdMs) {
+      const reported = Atomics.exchange(flags, 0, 0) === 1;
+      const paused = wasProcessPaused({
+        now,
+        workerLastTick: Number(Atomics.load(workerTick, 0)),
+        // Only a gap the worker saw inside this one counts; an old one is stale.
+        workerSawOwnGap: Number(Atomics.load(pausedAt, 0)) > prevTick,
+        workerAlive,
+        reported,
+        thresholdMs
+      });
+      const stallPhase = reported ? decoder.decode(stallPhaseBytes.slice(0, Math.max(0, Atomics.load(stallPhaseLen, 0)))) : phase;
+      try {
+        opts.onRecovered({ stallMs: gap, phase: stallPhase, paused });
+      } catch {
+      }
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return {
+    markPhase,
+    stop: async () => {
+      clearInterval(timer);
+      await worker.terminate().catch(() => 0);
+    }
+  };
+}
 
 // runner/src/turn-status-replay.ts
 var TurnStatusTracker = class {
@@ -8480,7 +8721,11 @@ async function startAgentServer(opts) {
   const wsConfig = resolveSkWorkspaceConfig(opts.projectDir);
   if (managedHost && wsConfig.agent?.["prompt-extensions"]?.length)
     throw new Error("CODEX_MANAGED_PROMPT_EXTENSIONS_UNSUPPORTED");
-  const { store: logStore, dispose: disposeLogStore } = bootstrapRunnerLogStore({
+  const {
+    store: logStore,
+    dispose: disposeLogStoreOnly,
+    logsDbPath
+  } = bootstrapRunnerLogStore({
     sessionId,
     projectDir: opts.projectDir,
     yamlBlock: wsConfig.logging,
@@ -8501,7 +8746,20 @@ async function startAgentServer(opts) {
     serverLog.warn("ws auth token file could not be removed", {
       code: takenAuthToken.unlinkError
     });
-  const logPhase = (phase, startedAt, data) => serverLog.info(`[serve] phase ${phase}`, { ...data, phase, elapsedMs: Date.now() - startedAt });
+  const stallWatchdog = startStallWatchdog({
+    sessionId,
+    logsDbPath,
+    onRecovered: ({ stallMs, phase, paused }) => paused ? serverLog.info("runner process was paused", { pausedMs: stallMs, phase }) : serverLog.warn("runner main thread stall ended", { stallMs, phase })
+  });
+  const markPhase = (phase) => stallWatchdog.markPhase(phase);
+  const disposeLogStore = () => {
+    void stallWatchdog.stop();
+    disposeLogStoreOnly();
+  };
+  const logPhase = (phase, startedAt, data) => {
+    markPhase(phase);
+    serverLog.info(`[serve] phase ${phase}`, { ...data, phase, elapsedMs: Date.now() - startedAt });
+  };
   const exitOnBrokenPipe = opts.exitOnBrokenPipe ?? false;
   const stopOutputWatch = watchOutputStream({ exitOnBrokenPipe });
   let teardownProcessHandlers = stopOutputWatch;
@@ -9829,11 +10087,14 @@ async function startAgentServer(opts) {
   }
   async function rebuildAgentSession(overrides) {
     const disposedManager = agentSession.resourceManager;
+    markPhase("session rebuild: snapshotting shared state");
     const sharedStateSnapshots = await snapshotInitSharedState();
     const disposeStartedAt = Date.now();
+    markPhase("session rebuild: disposing the old session");
     await agentSession.dispose();
     if (managedHost && managedBootstrapClosed) throw new Error("CODEX_RUNTIME_UNSUPPORTED");
     const createStartedAt = Date.now();
+    markPhase("session rebuild: creating the new session");
     agentSession = await createAgentSession({ ...sessionConfig, ...overrides });
     if (managedHost && managedBootstrapClosed) {
       await agentSession.dispose();
@@ -10106,6 +10367,7 @@ async function startAgentServer(opts) {
       }
       const prevSessionId = driver.runtimeSessionId;
       log(`[serve] restarting driver to pick up ${reason} (resume=${prevSessionId ?? "none"})`);
+      markPhase(`driver restart: ${reason}`);
       return { resumeSessionId: prevSessionId };
     });
   }
@@ -10304,6 +10566,7 @@ async function startAgentServer(opts) {
       });
     const buildSession = async () => {
       const firstBuildStartedAt = Date.now();
+      markPhase("session_init: building the session");
       const { needsWireFallbackRecreate, needsWireAgentConfigRecreate } = await buildSessionFromInit(cmd.secrets, resolvedConfigToDeclarations(cmd.resolvedConfig));
       logPhase("session_build", firstBuildStartedAt, {
         resumeRequested: !!cmd.resume?.sessionId
@@ -10357,6 +10620,7 @@ async function startAgentServer(opts) {
       }
       if (pendingResumeSessionId || cfg.subagents || needsWireFallbackRecreate || needsWireAgentConfigRecreate) {
         log("[serve] session_init: consolidated session recreate");
+        markPhase("session_init: consolidated session recreate");
         const recreateStartedAt = Date.now();
         await recreateSessionForInit(pendingResumeSessionId);
         if (needsWireFallbackRecreate) wireConnectorDeclarationsApplied = true;
@@ -11119,5 +11383,5 @@ function touchSession(state) {
 }
 
 export { CLAUDE_CODE_CREDENTIALS_KEY, COMPILE_MANIFEST_FILENAME, CONNECTOR_MUTATE_NOT_READY, CapabilityRegistry, DEFAULT_CAPABILITY_CALL_TIMEOUT_MS, DEFAULT_COALESCE_MS, DEFAULT_FLOW_MUTATE_CONNECTOR_WAIT_MS, MOUNT_LIST_MAX_DEPTH, MOUNT_LIST_MAX_ENTRIES, MOUNT_READ_DEADLINE_FACTOR, MOUNT_READ_MAX_CHUNK_BYTES, MOUNT_STAT_BUDGET_MS, MOUNT_STAT_MAX_ENTRIES, MOUNT_TREE_OP_DEADLINE_FACTOR, MarkdownStreamer, PreInitRingSink, ResourceOperationError, SESSION_ROOT_WRITABLE_DIRS, SESSION_ROOT_WRITABLE_FILES, WS_AUTH_TOKEN_ENV, WS_AUTH_TOKEN_FILE_ENV, agentDefinitionExists, bootstrapCapabilityRegistry, bootstrapRunnerLogStore, buildAgentResources, buildClientCapabilityHandler, buildConnectorTokenMediator, buildContextSection, buildEnvironmentSection, buildResourcesAvailablePayload, buildStoreSnapshotReplay, builtinCapabilities, capabilityLogInstance, clearPreInitRingSink, clearSession, compileComposition, computeCapabilitySignature, computeDirectoryTotals, connectorRefreshKind, createAgentSession, createFlowConnectorReadiness, createManagedCodexSubpromptDriver, createSessionStimulusBus, defineCapability, deleteSession, dispatchResourceRequest, dispatchRunnerCapabilityInvocation, emitSystemPromptComposed, ensureClaudeSettingsDisablesConnectors, ensureGitConfigInclude, executeConnectorMutate, extractClaudeAiOauthExpiresAt, flowRunDrivesTurns, flowStartNeedsDriverRestart, getPreInitRingSink, handleMountResourceRequest, handleResourceRequest, handleSessionRootResourceRequest, hasNonTerminalFlow, hostOpResumeStimulus, installPreInitRingSink, isSessionRootPathAllowed, isTerminalFlowStatus, listSessions, loadAgentManifest, loadCompileManifest, loadCompileManifestFromDir, loadManagedCodexHostConfig, loadSession, loadSessionById, mcpAuthSecretKey, newSession, nulTailPaddingLength, pickChatFlowTarget, pickFlowToolTarget, pickRepointedManager, planFlowMutate, prepareCodexTools, reconcilePendingDecisions, recreateKeepingLiveFlows, registerActiveFlow, registerCompositionCapabilities, rejectCapabilityOnApprovalDeny, rejectPendingCapabilityCallsOnDisconnect, resetRunnerLogStore, resolveAgentComposition, resolveAgentMixins, resolveBinding, resolveCapabilityCallTimeoutMs, resolveCapabilityResult, resolveComposition, resolveFlowMutateConnectorWaitMs, resolveMixin, restoredRunHasWorkToResume, runAgentChat, saveSession, setCurrentSession, setUpFlowConnector, startAgentServer, stimulusFromMetas, supportsLiveToolUpdates, takeRunnerWsAuthToken, toActiveFlowTarget, touchSession, validateInputResponse, writeClaudeCodeCredentialsFile };
-//# sourceMappingURL=chunk-EOX3QH74.js.map
-//# sourceMappingURL=chunk-EOX3QH74.js.map
+//# sourceMappingURL=chunk-3C6Q6TCZ.js.map
+//# sourceMappingURL=chunk-3C6Q6TCZ.js.map