mixdog 0.9.52 → 0.9.53

package/src/session-runtime/lifecycle-api.mjs

@@ -32,13 +32,15 @@ export function resolveResumeCwd(session, currentCwd) {
 // getters/setters for the mutable session/route/cwd locals plus the closure
 // callbacks and long-lived handles (managers, timers, channel/agent/mcp).
 export function createLifecycleApi(deps) {
+  const cancelBackgroundTasksForLifecycle = deps.cancelBackgroundTasks || cancelBackgroundTasks;
   const {
     getSession, setSession, getRoute, setRoute, getConfig, getMode, getCurrentCwd,
+    getDesktopSession, setDesktopSession,
     setCloseRequested, getMemoryModPromise, setMemoryModPromise,
     setSessionNeedsCwdRefresh,
     hooks, hookCommonPayload, mgr, statusRoutes, channels, agentTool, mcpClient,
     warmupTimers, prewarmTimers,
-    flushConfigSave, flushBackendSave, flushOutputStyleSave,
+    flushAllConfigSavesAsync,
     withTeardownDeadline, closePatchRuntimeIfLoaded,
     createCurrentSession, refreshRouteEffort,
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
@@ -76,12 +78,10 @@ export function createLifecycleApi(deps) {
           );
         }
       } catch { /* best-effort: SessionEnd hook must never wedge teardown */ }
-      // Persist any change that is still sitting in the debounce window so a
-      // toggle made right before exit is not lost. Synchronous + best-effort:
-      // teardown must continue even if the final write fails.
-      try { flushConfigSave(); } catch {}
-      try { flushBackendSave(); } catch {}
-      try { flushOutputStyleSave(); } catch {}
+      // Teardown stays async end-to-end across every writer sharing the config
+      // lock. Never start a synchronous lock wait while an in-process async
+      // holder still needs the event loop to finish and release it.
+      try { await flushAllConfigSavesAsync(); } catch {}
       try { hooks.flushRules?.(); } catch {}
       if (prewarmTimers.channelStartTimer) {
         clearTimeout(prewarmTimers.channelStartTimer);
@@ -226,6 +226,32 @@ export function createLifecycleApi(deps) {
         };
       }).filter(Boolean);
     },
+    async switchContext({ cwd, desktopSession: nextDesktopSession } = {}) {
+      const session = getSession();
+      if (session?.id) {
+        const cleanupReason = 'desktop-context-switch';
+        try {
+          cancelBackgroundTasksForLifecycle({
+            reason: cleanupReason,
+            notify: false,
+            callerSessionId: session.id,
+          });
+        } catch {}
+        try { agentTool?.closeAll?.(cleanupReason); } catch {}
+        statusRoutes?.clearGatewaySessionRoute?.(session.id);
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        mgr.closeSession(session.id, cleanupReason, { tombstone });
+        setSession(null);
+      }
+      setDesktopSession(nextDesktopSession && typeof nextDesktopSession === 'object'
+        ? nextDesktopSession
+        : null);
+      await applyResolvedCwd(cwd, { markRefresh: false, waitForMcpReset: true });
+      invalidateContextStatusCache();
+      invalidatePreSessionToolSurface();
+      return true;
+    },
     async newSession() {
       const session = getSession();
       if (session?.id) {
@@ -247,8 +273,9 @@ export function createLifecycleApi(deps) {
       const previousId = prev?.id || null;
       const previousMessages = prev?.messages || null;
       const previousLive = prev?.liveTurnMessages || null;
-      const resumeOptions = desktopSession && typeof desktopSession === 'object'
-        ? { desktopSession }
+      const activeDesktopSession = getDesktopSession?.() ?? desktopSession;
+      const resumeOptions = activeDesktopSession && typeof activeDesktopSession === 'object'
+        ? { desktopSession: activeDesktopSession }
         : undefined;
       const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()), resumeOptions);
       if (!resumed) return null;

package/src/session-runtime/mcp-glue.mjs

@@ -1,12 +1,10 @@
-// MCP config/status/connect glue, extracted from mixdog-session-runtime.mjs.
-// Dependency-injected factory: all live state (config, currentCwd, connect
-// generation/in-flight/failures) is threaded through accessors + a caller-owned
-// `state` object so the facade's teardown/reconnect paths still observe it.
-// Method behavior is byte-for-byte identical; only grouping changes.
+// MCP config/status/connect glue. Mutable runtime state is dependency-injected
+// through accessors and the caller-owned `state` object.
 import { resolve } from 'node:path';
 import { statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { normalizeMcpProjectPathKey, readProjectMcpServers } from './plugin-mcp.mjs';
+import { envFlag } from './env.mjs';
 
 // Cache project-local `.mcp.json` reads by path + mtime so repeated mcpStatus()
 // calls skip existsSync+readFileSync+JSON.parse when the file is unchanged.
@@ -16,9 +14,6 @@ const PROJECT_MCP_CACHE_MAX = 32;
 export function invalidateProjectMcpCache(cwd) {
   projectMcpCache.delete(resolve(cwd || '.', '.mcp.json'));
 }
-function mcpDisabled() {
-  return /^(?:1|true|on|yes)$/i.test(String(process.env.MIXDOG_DISABLE_MCP || ''));
-}
 function cachedProjectMcpServers(cwd) {
   const path = resolve(cwd || '.', '.mcp.json');
   let mtimeMs = 0;
@@ -55,7 +50,7 @@ export function createMcpGlue({
   // origin ('config' | 'project') for status reporting.
   function resolveEffectiveMcpServers() {
     // Benchmark/embedding guard: do not even inspect project `.mcp.json`.
-    if (mcpDisabled()) return { servers: {}, sources: {} };
+    if (envFlag('MIXDOG_DISABLE_MCP')) return { servers: {}, sources: {} };
     const config = getConfig();
     const configured = config?.mcpServers && typeof config.mcpServers === 'object'
       ? config.mcpServers
@@ -78,7 +73,7 @@ export function createMcpGlue({
   }
 
   function mcpStatus() {
-    if (mcpDisabled()) {
+    if (envFlag('MIXDOG_DISABLE_MCP')) {
       return { servers: [], configuredCount: 0, connectedCount: 0, failedCount: 0 };
     }
     const { servers: configured, sources } = resolveEffectiveMcpServers();
@@ -149,7 +144,7 @@ export function createMcpGlue({
   }
 
   async function connectConfiguredMcp({ reset = false, only = null, enabled = true } = {}) {
-    if (mcpDisabled()) {
+    if (envFlag('MIXDOG_DISABLE_MCP')) {
       ++state.mcpConnectGeneration;
       state.mcpFailures = [];
       if (only) await mcpClient.disconnectMcpServer?.(only);

package/src/session-runtime/provider-init-key.mjs

@@ -0,0 +1,17 @@
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const key of Object.keys(value).sort()) out[key] = sortKeysDeep(value[key]);
+    return out;
+  }
+  return value;
+}
+
+export function providerInitCacheKey(value) {
+  try {
+    return JSON.stringify(sortKeysDeep(value));
+  } catch {
+    return `uncacheable:${Date.now()}:${Math.random()}`;
+  }
+}

package/src/session-runtime/runtime-core.mjs

@@ -1,9 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
 import httpMod from 'node:http';
+import './hitch-profile.mjs';
 import { ensureStandaloneEnvironment } from '../standalone/seeds.mjs';
 import { createStandaloneAgent } from '../standalone/agent-tool.mjs';
 import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
@@ -19,7 +18,6 @@ import { checkLatestVersion, localPackageVersion, isDevInstall } from '../runtim
 import { spawnStagedInstall, runStagedInstall, isStagedComplete } from '../runtime/shared/staged-update.mjs';
 import {
   modelVisibleToolCompletionMessage,
-  shouldPersistModelVisibleToolCompletion,
 } from '../runtime/shared/tool-execution-contract.mjs';
 import {
   channelNotificationModelContent,
@@ -120,7 +118,6 @@ import {
   fastCapableFor,
   makeSearchCapableFor,
   fastPreferenceFor,
-  saveModelSettings,
 } from './model-capabilities.mjs';
 import {
   DEFAULT_PROVIDER,
@@ -248,6 +245,35 @@ import { createResourceApi } from './resource-api.mjs';
 import { createModelRouteApi } from './model-route-api.mjs';
 import { createWorkflowAgentsApi } from './workflow-agents-api.mjs';
 import { createSessionTurnApi } from './session-turn-api.mjs';
+import { providerInitCacheKey } from './provider-init-key.mjs';
+import {
+  RUNTIME,
+  SEARCH_RUNTIME,
+  SEARCH_TOOL_DEFS,
+  MEMORY_TOOL_DEFS,
+  MEMORY_RUNTIME,
+  CHANNEL_TOOL_DEFS,
+  CHANNEL_WORKER_ENTRY,
+  CODE_GRAPH_TOOL_DEFS,
+  CODE_GRAPH_RUNTIME,
+  STATUSLINE_SESSION_ROUTES,
+  SESSION_RUNTIME_DIR,
+  STANDALONE_SOURCE_ROOT,
+  STANDALONE_ROOT,
+  STANDALONE_DATA_DIR,
+} from './runtime-paths.mjs';
+import {
+  dispatchSearchRuntimeTool,
+  memoryToolArgsForCaller,
+  shouldMirrorCompletionToPendingQueue,
+} from './runtime-tool-routing.mjs';
+export {
+  __renderToolSearchForTest,
+  __saveModelSettingsForTest,
+  dispatchSearchRuntimeTool,
+  memoryToolArgsForCaller,
+  shouldMirrorCompletionToPendingQueue,
+} from './runtime-tool-routing.mjs';
 // Re-exported for external consumers (scripts/tool-smoke.mjs) that imported
 // these from this module before the tool-defs extraction.
 export { TOOL_SEARCH_TOOL, SKILL_TOOL };
@@ -256,26 +282,6 @@ export function __applyStandaloneToolDefaultsForTest(tool) {
   return applyStandaloneToolDefaults(tool);
 }
 
-const RUNTIME = '../runtime/agent/orchestrator';
-const SEARCH_RUNTIME = '../runtime/search/index.mjs';
-const SEARCH_TOOL_DEFS = '../runtime/search/tool-defs.mjs';
-const MEMORY_TOOL_DEFS = '../runtime/memory/tool-defs.mjs';
-const MEMORY_RUNTIME = '../runtime/memory/index.mjs';
-const CHANNEL_TOOL_DEFS = '../runtime/channels/tool-defs.mjs';
-const CHANNEL_WORKER_ENTRY = '../runtime/channels/index.mjs';
-const CODE_GRAPH_TOOL_DEFS = '../runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
-const CODE_GRAPH_RUNTIME = '../runtime/agent/orchestrator/tools/code-graph.mjs';
-const STATUSLINE_SESSION_ROUTES = '../vendor/statusline/src/gateway/session-routes.mjs';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-// This module lives in src/session-runtime/, but the resource root must remain
-// src/ (defaults/, rules/, runtime/, vendor/ live there), so climb one level.
-const STANDALONE_SOURCE_ROOT = dirname(__dirname);
-// Resource root stays at src/ because defaults/, rules/, runtime/, vendor/ live
-// there. User-owned standalone state lives under MIXDOG_HOME (~/.mixdog).
-const STANDALONE_ROOT = STANDALONE_SOURCE_ROOT;
-const MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
-const STANDALONE_DATA_DIR = process.env.MIXDOG_DATA_DIR || join(MIXDOG_HOME, 'data');
-
 const resolveDefaultProvider = makeResolveDefaultProvider(isKnownProvider);
 const resolveRoute = makeResolveRoute(resolveDefaultProvider);
 const searchCapableFor = makeSearchCapableFor(normalizeSearchProviderId, isSearchCapableProvider);
@@ -303,68 +309,15 @@ const {
   agentRouteFromConfig,
 } = createWorkflowRouteHelpers({ resolveDefaultProvider, findPreset });
 
-export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full', options = {}) {
-  return renderToolSearch(args, session, mode, options);
-}
-
-export function __saveModelSettingsForTest(cfgMod, route, options = {}) {
-  return saveModelSettings(cfgMod, route, options);
-}
-
-// Decide whether notifyFnForSession should mirror a terminal tool completion
-// into the pending-message queue. Only the TUI execution-ui path actually
-// injects the model-visible twin of the completion into the active loop, and it
-// signals that with an EXPLICIT ack (modelVisibleDelivered) — never a generic
-// truthy onNotification return. Skipping the mirror on a bare `handled===true`
-// would let a display-only / API listener suppress the sole model-visible copy,
-// so the model would never see the completion body. Mirror UNLESS the body was
-// explicitly delivered; unknown/generic-handled → keep the mirror.
-export function shouldMirrorCompletionToPendingQueue({
-  callerSessionId,
-  modelVisibleDelivered,
-  hasEnqueue,
-  text,
-  meta = {},
-} = {}) {
-  if (!callerSessionId || !hasEnqueue) return false;
-  if (modelVisibleDelivered) return false;
-  return shouldPersistModelVisibleToolCompletion(text, meta);
-}
-
-export async function dispatchSearchRuntimeTool(name, args, callerCtx = {}, {
-  getSearchModule,
-  getCurrentCwd,
-  getSession,
-  notifyFnForSession,
-  runNativeWebSearch,
-} = {}) {
-  const currentSession = typeof getSession === 'function' ? getSession() : null;
-  const callerCwd = callerCtx?.callerCwd || (typeof getCurrentCwd === 'function' ? getCurrentCwd() : process.cwd());
-  const callerSessionId = callerCtx?.callerSessionId || currentSession?.id || null;
-  const callerSignal = callerCtx?.signal || currentSession?.controller?.signal;
-  const searchMod = await getSearchModule();
-  if (!searchMod?.handleToolCall) throw new Error('search runtime is not available');
-  return await searchMod.handleToolCall(name, args || {}, {
-    callerCwd,
-    callerSessionId,
-    routingSessionId: callerSessionId,
-    clientHostPid: callerCtx?.clientHostPid || currentSession?.clientHostPid || process.pid,
-    notifyFn: notifyFnForSession(callerSessionId),
-    signal: callerSignal,
-    nativeSearch: name === 'search'
-      ? async (searchArgs) => runNativeWebSearch(searchArgs, { signal: callerSignal })
-      : undefined,
-  });
-}
-
 export async function createMixdogSessionRuntime({
   provider,
   model,
   cwd = process.cwd(),
   toolMode = 'full',
   remote = false,
-  desktopSession = null,
+  desktopSession: initialDesktopSession = null,
 } = {}) {
+  let desktopSession = initialDesktopSession;
   bootProfile('session-runtime:start', { provider, model, toolMode, cwd });
   let remoteEnabled = remote === true;
   // Transient marker: an AUTO start (config/delayed autoStart) has forked the
@@ -434,7 +387,7 @@ export async function createMixdogSessionRuntime({
   const memoryRuntime = createStandaloneMemoryRuntime({
     // Entry constants are module-relative ('../runtime/...'); resolve against
     // this module's dir, not STANDALONE_ROOT, or the 'src/' segment is lost.
-    entry: join(__dirname, MEMORY_RUNTIME),
+    entry: join(SESSION_RUNTIME_DIR, MEMORY_RUNTIME),
     dataDir: pluginDataDir,
     cwd,
   });
@@ -656,6 +609,8 @@ export async function createMixdogSessionRuntime({
     mcpClient,
     getConfig: () => config,
     getCurrentCwd: () => currentCwd,
+    getDesktopSession: () => desktopSession,
+    setDesktopSession: (v) => { desktopSession = v; },
     state: mcpState,
   });
   let preSessionToolSurface = null;
@@ -1031,7 +986,7 @@ export async function createMixdogSessionRuntime({
   };
   const channelsStartedAt = performance.now();
   const channels = createStandaloneChannelWorker({
-    entry: join(__dirname, CHANNEL_WORKER_ENTRY),
+    entry: join(SESSION_RUNTIME_DIR, CHANNEL_WORKER_ENTRY),
     rootDir: STANDALONE_ROOT,
     dataDir: cfgMod.getPluginData(),
     cwd,
@@ -1146,7 +1101,7 @@ export async function createMixdogSessionRuntime({
       if (name === 'recall' || name === 'memory' || name === 'search_memories') {
         const memoryMod = await getMemoryModule();
         if (!memoryMod?.handleToolCall) throw new Error('memory runtime is not available');
-        return await memoryMod.handleToolCall(name, args || {});
+        return await memoryMod.handleToolCall(name, memoryToolArgsForCaller(args, callerCwd));
       }
       if (name === 'code_graph') {
         const codeGraphMod = await getCodeGraphModule();
@@ -1267,6 +1222,7 @@ export async function createMixdogSessionRuntime({
     flushSkillsSave,
     flushOutputStyleSave,
     scheduleOutputStyleSave,
+    flushAllConfigSavesAsync,
     reloadFullConfig,
     ensureFullConfig,
     displayConfig,
@@ -1293,23 +1249,6 @@ export async function createMixdogSessionRuntime({
     STANDALONE_DATA_DIR,
   });
 
-  function providerInitCacheKey(value) {
-    function sortKeysDeep(v) {
-      if (Array.isArray(v)) return v.map(sortKeysDeep);
-      if (v && typeof v === 'object') {
-        const out = {};
-        for (const key of Object.keys(v).sort()) out[key] = sortKeysDeep(v[key]);
-        return out;
-      }
-      return v;
-    }
-    try {
-      return JSON.stringify(sortKeysDeep(value));
-    } catch {
-      return `uncacheable:${Date.now()}:${Math.random()}`;
-    }
-  }
-
   async function ensureProvidersReady(providerConfig = config.providers || {}) {
     const initKey = providerInitCacheKey(providerConfig);
     const existing = providerInitPromises.get(initKey);
@@ -1879,10 +1818,6 @@ export async function createMixdogSessionRuntime({
     // No-op when the session has not been created yet (lazy mode); that
     // case is covered by the turn-start rebind in ask().
     ensureRemoteTranscriptWriter();
-    // A backend switch may still be sitting in its debounce window; flush it
-    // so the channel worker boots against the backend the user just chose,
-    // not the previous on-disk value.
-    try { flushBackendSave(); } catch {}
     if (envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
       bootProfile('channels:start-skipped');
       return true;
@@ -1898,6 +1833,9 @@ export async function createMixdogSessionRuntime({
     }
     bootProfile('channels:start-scheduled', { delayMs: 0, immediate: true });
     void (async () => {
+      // A backend switch may still be pending or writing asynchronously. Drain
+      // it before the worker reads config; never race it with a sync lock wait.
+      try { await flushBackendSave(); } catch {}
       // Yield before the createCurrentSession/transcript/fork chain below —
       // same rationale as the memory-eager-init yield above: this detached
       // chain runs synchronous config/fs work (createCurrentSession, backend
@@ -2130,6 +2068,8 @@ export async function createMixdogSessionRuntime({
     getConfig: () => config,
     getMode: () => mode,
     getCurrentCwd: () => currentCwd,
+    getDesktopSession: () => desktopSession,
+    setDesktopSession: (v) => { desktopSession = v; },
     setCloseRequested: (v) => { closeRequested = v; },
     getMemoryModPromise: () => memoryModPromise,
     setMemoryModPromise: (v) => { memoryModPromise = v; },
@@ -2147,6 +2087,7 @@ export async function createMixdogSessionRuntime({
     flushConfigSave,
     flushBackendSave,
     flushOutputStyleSave,
+    flushAllConfigSavesAsync,
     withTeardownDeadline,
     closePatchRuntimeIfLoaded,
     createCurrentSession,

package/src/session-runtime/runtime-paths.mjs

@@ -0,0 +1,20 @@
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const RUNTIME = '../runtime/agent/orchestrator';
+export const SEARCH_RUNTIME = '../runtime/search/index.mjs';
+export const SEARCH_TOOL_DEFS = '../runtime/search/tool-defs.mjs';
+export const MEMORY_TOOL_DEFS = '../runtime/memory/tool-defs.mjs';
+export const MEMORY_RUNTIME = '../runtime/memory/index.mjs';
+export const CHANNEL_TOOL_DEFS = '../runtime/channels/tool-defs.mjs';
+export const CHANNEL_WORKER_ENTRY = '../runtime/channels/index.mjs';
+export const CODE_GRAPH_TOOL_DEFS = '../runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
+export const CODE_GRAPH_RUNTIME = '../runtime/agent/orchestrator/tools/code-graph.mjs';
+export const STATUSLINE_SESSION_ROUTES = '../vendor/statusline/src/gateway/session-routes.mjs';
+
+export const SESSION_RUNTIME_DIR = dirname(fileURLToPath(import.meta.url));
+export const STANDALONE_SOURCE_ROOT = dirname(SESSION_RUNTIME_DIR);
+export const STANDALONE_ROOT = STANDALONE_SOURCE_ROOT;
+const mixdogHome = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
+export const STANDALONE_DATA_DIR = process.env.MIXDOG_DATA_DIR || join(mixdogHome, 'data');

package/src/session-runtime/runtime-tool-routing.mjs

@@ -0,0 +1,55 @@
+import { shouldPersistModelVisibleToolCompletion } from '../runtime/shared/tool-execution-contract.mjs';
+import { saveModelSettings } from './model-capabilities.mjs';
+import { renderToolSearch } from './tool-catalog.mjs';
+
+export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full', options = {}) {
+  return renderToolSearch(args, session, mode, options);
+}
+
+export function __saveModelSettingsForTest(cfgMod, route, options = {}) {
+  return saveModelSettings(cfgMod, route, options);
+}
+
+export function shouldMirrorCompletionToPendingQueue({
+  callerSessionId,
+  modelVisibleDelivered,
+  hasEnqueue,
+  text,
+  meta = {},
+} = {}) {
+  if (!callerSessionId || !hasEnqueue || modelVisibleDelivered) return false;
+  return shouldPersistModelVisibleToolCompletion(text, meta);
+}
+
+export async function dispatchSearchRuntimeTool(name, args, callerCtx = {}, {
+  getSearchModule,
+  getCurrentCwd,
+  getSession,
+  notifyFnForSession,
+  runNativeWebSearch,
+} = {}) {
+  const currentSession = typeof getSession === 'function' ? getSession() : null;
+  const callerCwd = callerCtx?.callerCwd || (typeof getCurrentCwd === 'function' ? getCurrentCwd() : process.cwd());
+  const callerSessionId = callerCtx?.callerSessionId || currentSession?.id || null;
+  const callerSignal = callerCtx?.signal || currentSession?.controller?.signal;
+  const searchMod = await getSearchModule();
+  if (!searchMod?.handleToolCall) throw new Error('search runtime is not available');
+  return await searchMod.handleToolCall(name, args || {}, {
+    callerCwd,
+    callerSessionId,
+    routingSessionId: callerSessionId,
+    clientHostPid: callerCtx?.clientHostPid || currentSession?.clientHostPid || process.pid,
+    notifyFn: notifyFnForSession(callerSessionId),
+    signal: callerSignal,
+    nativeSearch: name === 'search'
+      ? async (searchArgs) => runNativeWebSearch(searchArgs, { signal: callerSignal })
+      : undefined,
+  });
+}
+
+export function memoryToolArgsForCaller(args, callerCwd) {
+  const input = args && typeof args === 'object' && !Array.isArray(args) ? args : {};
+  return typeof input.cwd === 'string' && input.cwd.trim()
+    ? input
+    : { ...input, cwd: callerCwd };
+}

package/src/session-runtime/tool-catalog-data.mjs

@@ -0,0 +1,51 @@
+export const MEASURED_TOOL_USAGE = Object.freeze({
+  read: 710,
+  code_graph: 520,
+  grep: 500,
+  find: 480,
+  glob: 460,
+  list: 430,
+  apply_patch: 400,
+  explore: 360,
+  agent: 330,
+  shell: 81,
+  cwd: 2,
+  recall: 2,
+  search: 2,
+  web_fetch: 2,
+});
+export const MEASURED_TOOL_ORDER = Object.freeze(Object.keys(MEASURED_TOOL_USAGE));
+
+export const DEFERRED_DEFAULT_FULL_TOOLS = Object.freeze([
+  'read', 'code_graph', 'grep', 'find', 'glob', 'list', 'explore',
+  'apply_patch', 'Skill', 'load_tool',
+]);
+export const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
+  'read', 'code_graph', 'grep', 'find', 'glob', 'list', 'explore',
+  'Skill', 'load_tool',
+]);
+export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
+  'read', 'code_graph', 'grep', 'find', 'glob', 'list', 'shell', 'task',
+  'explore', 'apply_patch', 'agent', 'recall', 'search', 'web_fetch', 'cwd',
+  'session_manage', 'Skill', 'load_tool',
+]);
+
+export const READONLY_TOOL_NAMES = new Set([
+  'read', 'list', 'grep', 'find', 'glob', 'code_graph', 'search',
+  'web_fetch', 'recall', 'memory', 'fetch', 'Skill',
+]);
+
+export const DEFERRED_SELECT_ALIASES = {
+  filesystem: ['read', 'list', 'grep', 'find', 'glob'],
+  search: ['search', 'web_fetch'],
+  web: ['web_fetch', 'search'],
+  memory: ['memory', 'recall'],
+  channels: ['reply', 'fetch'],
+  discord: ['reply', 'fetch'],
+  explore: ['explore'],
+  discovery: ['explore'],
+  agent: ['agent'],
+  graph: ['code_graph'],
+  code: ['code_graph'],
+  shell: ['shell', 'task'],
+};

package/src/session-runtime/tool-catalog.mjs

@@ -17,24 +17,22 @@ import {
   finalizeProviderRequestTools,
   providerNativeToolPrefixCount,
 } from './provider-request-tools.mjs';
+import {
+  DEFERRED_DEFAULT_FULL_TOOLS,
+  DEFERRED_DEFAULT_LEAD_TOOLS,
+  DEFERRED_DEFAULT_READONLY_TOOLS,
+  DEFERRED_SELECT_ALIASES,
+  MEASURED_TOOL_ORDER,
+  MEASURED_TOOL_USAGE,
+  READONLY_TOOL_NAMES,
+} from './tool-catalog-data.mjs';
+export {
+  DEFERRED_DEFAULT_FULL_TOOLS,
+  DEFERRED_DEFAULT_LEAD_TOOLS,
+  DEFERRED_DEFAULT_READONLY_TOOLS,
+  MEASURED_TOOL_USAGE,
+} from './tool-catalog-data.mjs';
 
-export const MEASURED_TOOL_USAGE = Object.freeze({
-  read: 710,
-  code_graph: 520,
-  grep: 500,
-  find: 480,
-  glob: 460,
-  list: 430,
-  apply_patch: 400,
-  explore: 360,
-  agent: 330,
-  shell: 81,
-  cwd: 2,
-  recall: 2,
-  search: 2,
-  web_fetch: 2,
-});
-const MEASURED_TOOL_ORDER = Object.freeze(Object.keys(MEASURED_TOOL_USAGE));
 const toolSchemaBreakdownMemo = new WeakMap();
 
 function sameToolSchemaEntries(cached, tools) {
@@ -81,78 +79,6 @@ function toolSchemaEntry(tool, native = false) {
     wireSignature: toolSchemaSignature(toolMeteringList(tool, native)),
   };
 }
-export const DEFERRED_DEFAULT_FULL_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'explore',
-  'apply_patch',
-  'Skill',
-  'load_tool',
-]);
-export const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'explore',
-  'Skill',
-  'load_tool',
-]);
-export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'shell',
-  'task',
-  'explore',
-  'apply_patch',
-  'agent',
-  'recall',
-  'search',
-  'web_fetch',
-  'cwd',
-    'session_manage',
-  'Skill',
-  'load_tool',
-]);
-const READONLY_TOOL_NAMES = new Set([
-  'read',
-  'list',
-  'grep',
-  'find',
-  'glob',
-  'code_graph',
-  'search',
-  'web_fetch',
-  'recall',
-  'memory',
-  'fetch',
-  'Skill',
-]);
-const DEFERRED_SELECT_ALIASES = {
-  filesystem: ['read', 'list', 'grep', 'find', 'glob'],
-  search: ['search', 'web_fetch'],
-  web: ['web_fetch', 'search'],
-  memory: ['memory', 'recall'],
-  channels: ['reply', 'fetch'],
-  discord: ['reply', 'fetch'],
-  explore: ['explore'],
-  discovery: ['explore'],
-  agent: ['agent'],
-  graph: ['code_graph'],
-  code: ['code_graph'],
-  shell: ['shell', 'task'],
-};
-
 export function toolKind(tool) {
   const name = clean(tool?.name);
   if (name.startsWith('mcp__')) return 'mcp';