mixdog 0.9.18 → 0.9.20

package/src/session-runtime/context-status.mjs

@@ -0,0 +1,181 @@
+import {
+  estimateRequestReserveTokens,
+  estimateToolSchemaTokens,
+  estimateTranscriptContextUsage,
+  resolveCompactBufferTokens,
+  resolveCompactTriggerTokens,
+  summarizeContextMessages,
+} from '../runtime/agent/orchestrator/session/context-utils.mjs';
+import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
+
+// Live /context gauge computation + its self-owned memoization cache. Extracted
+// verbatim from the runtime API object; the runtime injects live getters for
+// the mutable session/route/cwd/mode locals. The cache (key + value) is owned
+// here now, so invalidateContextStatusCache() is returned for the runtime to
+// call from the same places it used to clear the inline locals.
+export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMode }) {
+  let contextStatusCacheKey = null;
+  let contextStatusCacheValue = null;
+
+  function contextStatusCacheKeyFor({ messages, tools }) {
+    const session = getSession();
+    const route = getRoute();
+    const compaction = session?.compaction || {};
+    const lastMessage = messages[messages.length - 1] || null;
+    return {
+      session,
+      sessionId: session?.id || null,
+      provider: route.provider,
+      model: route.model,
+      cwd: getCurrentCwd(),
+      mode: getMode(),
+      messages,
+      messageCount: messages.length,
+      lastMessage,
+      lastMessageRole: lastMessage?.role || null,
+      lastMessageContent: lastMessage?.content || null,
+      tools,
+      toolCount: tools.length,
+      contextWindow: session?.contextWindow || null,
+      rawContextWindow: session?.rawContextWindow || null,
+      effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
+      autoCompactTokenLimit: Number(session?.autoCompactTokenLimit || 0),
+      lastContextTokens: Number(session?.lastContextTokens || 0),
+      lastContextTokensUpdatedAt: Number(session?.lastContextTokensUpdatedAt || 0),
+      lastContextTokensStaleAfterCompact: session?.lastContextTokensStaleAfterCompact === true,
+      lastInputTokens: Number(session?.lastInputTokens || 0),
+      lastUncachedInputTokens: Number(session?.lastUncachedInputTokens || 0),
+      lastOutputTokens: Number(session?.lastOutputTokens || 0),
+      lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
+      lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
+      totalInputTokens: Number(session?.totalInputTokens || 0),
+      totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
+      totalOutputTokens: Number(session?.totalOutputTokens || 0),
+      totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
+      totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+      compactBoundaryTokens: Number(session?.compactBoundaryTokens || 0),
+      compactionBoundaryTokens: Number(compaction.boundaryTokens || 0),
+      compactionTriggerTokens: Number(compaction.triggerTokens || 0),
+      compactionLastChangedAt: Number(compaction.lastChangedAt || 0),
+      compactionLastCompactAt: Number(compaction.lastCompactAt || 0),
+    };
+  }
+
+  function sameContextStatusCacheKey(a, b) {
+    if (!a || !b) return false;
+    for (const key of Object.keys(a)) {
+      if (!Object.is(a[key], b[key])) return false;
+    }
+    return true;
+  }
+
+  function invalidateContextStatusCache() {
+    contextStatusCacheKey = null;
+    contextStatusCacheValue = null;
+  }
+
+  function contextStatus() {
+    const session = getSession();
+    const route = getRoute();
+    // Prefer the in-flight working transcript while a turn is running so the
+    // context gauge reflects LIVE growth (user turn + tool calls/results) as
+    // it accumulates, instead of freezing at the pre-turn committed snapshot.
+    // askSession() sets session.liveTurnMessages for the turn duration and
+    // clears it on commit/cancel/error, after which we fall back to the
+    // authoritative committed transcript.
+    const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
+    const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
+    const tools = Array.isArray(session?.tools) ? session.tools : [];
+    const cacheKey = contextStatusCacheKeyFor({ messages, tools });
+    if (contextStatusCacheValue && sameContextStatusCacheKey(cacheKey, contextStatusCacheKey)) {
+      return contextStatusCacheValue;
+    }
+
+    const messageSummary = summarizeContextMessages(messages);
+    const toolSchemaTokens = estimateToolSchemaTokens(tools);
+    const toolSchemaBreakdown = estimateToolSchemaBreakdown(tools);
+    const requestReserveTokens = estimateRequestReserveTokens(tools);
+    const requestOverheadTokens = Math.max(0, requestReserveTokens - toolSchemaTokens);
+    const rawWindow = Number(session?.rawContextWindow || session?.contextWindow || 0);
+    const effectiveWindow = Number(session?.contextWindow || rawWindow || 0);
+    const lastContextTokens = Number(session?.lastContextTokens || 0);
+    const estimatedContextTokens = estimateTranscriptContextUsage(messages, tools, {
+      messageCount: messageSummary.count,
+    });
+    const compactAt = Number(session?.compaction?.lastChangedAt || session?.compaction?.lastCompactAt || 0);
+    const usageAt = Number(session?.lastContextTokensUpdatedAt || 0);
+    const lastUsageStale = !!lastContextTokens && (
+      session?.lastContextTokensStaleAfterCompact === true
+      || (compactAt > 0 && usageAt > 0 && usageAt <= compactAt)
+      || (compactAt > 0 && usageAt <= 0)
+    );
+    const compactBoundaryTokens = Number(session?.compactBoundaryTokens || session?.compaction?.boundaryTokens || 0);
+    const displayWindow = compactBoundaryTokens || effectiveWindow;
+    // The transcript estimate is the single source of truth for the displayed
+    // context footprint. Provider-reported input_tokens (lastContextTokens)
+    // swing non-monotonically and are not window-bounded on some providers
+    // (e.g. OpenAI gpt-5.5 Responses API), so they are kept only as secondary
+    // metadata (lastApiRequestTokens / usage.lastContextTokens) and never feed
+    // the gauge numerator.
+    const usedTokens = estimatedContextTokens;
+    const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
+    // Use the same shared compact-policy math as manager/loop. Do not trust
+    // persisted trigger telemetry as an independent policy input: it is an
+    // output snapshot and was the source of repeated /context false positives.
+    const compactTriggerTokens = resolveCompactTriggerTokens(session || {}, compactBoundaryTokens) || 0;
+    const compactBufferTokens = compactBoundaryTokens
+      ? Math.max(0, compactBoundaryTokens - compactTriggerTokens)
+      : resolveCompactBufferTokens(compactBoundaryTokens, session?.compaction || {});
+    const value = {
+      sessionId: session?.id || null,
+      provider: route.provider,
+      model: route.model,
+      cwd: getCurrentCwd(),
+      toolMode: getMode(),
+      contextWindow: displayWindow || effectiveWindow || null,
+      effectiveContextWindow: effectiveWindow || null,
+      rawContextWindow: rawWindow || null,
+      effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
+      usedTokens,
+      usedSource: 'estimated',
+      currentEstimatedTokens: estimatedContextTokens,
+      lastApiRequestTokens: lastContextTokens || 0,
+      lastApiRequestStale: lastUsageStale,
+      freeTokens,
+      compaction: {
+        ...(session?.compaction || {}),
+        boundaryTokens: compactBoundaryTokens || null,
+        triggerTokens: compactTriggerTokens || null,
+        bufferTokens: compactBufferTokens || null,
+        currentEstimatedTokens: estimatedContextTokens,
+        lastApiRequestTokens: lastContextTokens || 0,
+        lastApiRequestStale: lastUsageStale,
+      },
+      messages: messageSummary,
+      request: {
+        toolSchemaTokens,
+        toolSchemaBreakdown,
+        requestOverheadTokens,
+        reserveTokens: requestReserveTokens,
+      },
+      usage: {
+        lastInputTokens: Number(session?.lastInputTokens || 0),
+        lastUncachedInputTokens: Number(session?.lastUncachedInputTokens || 0),
+        lastOutputTokens: Number(session?.lastOutputTokens || 0),
+        lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
+        lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
+        lastContextTokens,
+        totalInputTokens: Number(session?.totalInputTokens || 0),
+        totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
+        totalOutputTokens: Number(session?.totalOutputTokens || 0),
+        totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
+        totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+      },
+    };
+    contextStatusCacheKey = cacheKey;
+    contextStatusCacheValue = value;
+    return value;
+  }
+
+  return { contextStatus, invalidateContextStatusCache };
+}

package/src/session-runtime/cwd-plugins.mjs

@@ -45,6 +45,48 @@ export function createCwdPlugins({
   cfgMod,
   STANDALONE_DATA_DIR,
 }) {
+  // Per-plugin-root caches for pluginsStatus(): manifest + MCP discovery keyed
+  // by root path + manifest mtime (invalidated on manifest edit); recursive
+  // skill-file count keyed by root with a ~5s TTL fallback (the walk has no
+  // single mtime to key on).
+  const pluginRootCache = new Map();
+  const skillCountCache = new Map();
+  const mcpDiscoveryCache = new Map();
+  function manifestMtimeKey(root) {
+    let key = '';
+    for (const rel of ['.codex-plugin/plugin.json', 'plugin.json']) {
+      try { key += `${statSync(resolve(root, rel)).mtimeMs}:`; } catch { key += '0:'; }
+    }
+    return key;
+  }
+  function cachedPluginData(root) {
+    const key = manifestMtimeKey(root);
+    const hit = pluginRootCache.get(root);
+    if (hit && hit.key === key) return hit;
+    const entry = { key, manifest: pluginManifest(root) };
+    pluginRootCache.set(root, entry);
+    return entry;
+  }
+  // MCP discovery probes candidate script files (.mcp.json, scripts/run-mcp.mjs,
+  // ...) whose add/remove is NOT reflected in the manifest mtime, so key it on a
+  // short TTL instead (~5s, like the skill-file count).
+  function cachedMcpDiscovery(root) {
+    const now = Date.now();
+    const hit = mcpDiscoveryCache.get(root);
+    if (hit && (now - hit.at) < 5000) return hit.mcp;
+    const mcp = discoverPluginMcp(root);
+    mcpDiscoveryCache.set(root, { at: now, mcp });
+    return mcp;
+  }
+  function cachedSkillCount(root) {
+    const now = Date.now();
+    const hit = skillCountCache.get(root);
+    if (hit && (now - hit.at) < 5000) return hit.count;
+    const count = countSkillFiles(root);
+    skillCountCache.set(root, { at: now, count });
+    return count;
+  }
+
   function resolveCwdPath(value) {
     const raw = clean(value);
     if (!raw) throw new Error('cwd: path is required for action=set');
@@ -125,7 +167,8 @@ export function createCwdPlugins({
     const addRegisteredPlugin = (entry) => {
       const root = clean(entry.root);
       if (!root || !existsSync(root)) return;
-      const manifest = pluginManifest(root);
+      const cached = cachedPluginData(root);
+      const manifest = cached.manifest;
       const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
       const plugin = {
         id: clean(entry.id) || name,
@@ -141,9 +184,9 @@ export function createCwdPlugins({
         root,
         installedAt: entry.installedAt || null,
         updatedAt: entry.updatedAt || null,
-        skillCount: countSkillFiles(root),
+        skillCount: cachedSkillCount(root),
         ...(() => {
-          const { mcpScript, mcpInline } = discoverPluginMcp(root);
+          const { mcpScript, mcpInline } = cachedMcpDiscovery(root);
           return { mcpScript, mcpInline };
         })(),
       };

package/src/session-runtime/env.mjs

@@ -0,0 +1,17 @@
+// Environment-variable coercion helpers shared by the session runtime.
+// Extracted verbatim from mixdog-session-runtime.mjs during the facade split.
+export function envFlag(name) {
+  return /^(1|true|yes|on)$/i.test(String(process.env[name] || ''));
+}
+
+export function envPresent(name) {
+  return process.env[name] !== undefined && process.env[name] !== '';
+}
+
+export function envDelayMs(name, fallback, { min = 0, max = 60_000 } = {}) {
+  const raw = process.env[name];
+  if (raw === undefined || raw === '') return fallback;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(n)));
+}

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

@@ -0,0 +1,242 @@
+import { cancelBackgroundTasks } from '../runtime/shared/background-tasks.mjs';
+import { hasUserConversationMessage } from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import { isAgentOwner } from '../runtime/agent/orchestrator/agent-owner.mjs';
+import { writeStatuslineRoute } from './statusline-route.mjs';
+import {
+  sessionMessageText,
+  isSessionPreviewNoise,
+  cleanSessionPreview,
+  clean,
+  hasOwn,
+} from './session-text.mjs';
+import { toolSpecForMode, deferredSurfaceModeForLead } from './effort.mjs';
+
+// Session lifecycle surface: teardown (close/abort), resume/new, and the
+// resumable-session listing. Extracted verbatim from the runtime API object;
+// stateless helpers are imported directly and the runtime injects live
+// 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 {
+    getSession, setSession, getRoute, setRoute, getConfig, getMode, getCurrentCwd,
+    setCloseRequested, getMemoryModPromise, setMemoryModPromise,
+    setSessionNeedsCwdRefresh,
+    hooks, hookCommonPayload, mgr, statusRoutes, channels, agentTool, mcpClient,
+    warmupTimers, prewarmTimers,
+    flushConfigSave, flushBackendSave, flushOutputStyleSave,
+    withTeardownDeadline, closePatchRuntimeIfLoaded,
+    createCurrentSession, refreshRouteEffort,
+    invalidateContextStatusCache, invalidatePreSessionToolSurface,
+    applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
+  } = deps;
+  return {
+    async close(reason = 'cli-exit', options = {}) {
+      const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
+      setCloseRequested(true);
+      // SessionEnd: bridge teardown to the standard hook bus. reason mapped to
+      // standard values ('clear'/'exit' where applicable, else 'other'). Short
+      // await guard so a slow hook cannot wedge teardown; best-effort.
+      try {
+        const rl = String(reason || '').toLowerCase();
+        const endReason = /clear/.test(rl) ? 'clear'
+          : /exit|quit|cli-exit|shutdown|sigint|sigterm/.test(rl) ? 'exit'
+          : 'other';
+        const session = getSession();
+        if (session?.id) {
+          await withTeardownDeadline(
+            Promise.resolve(hooks.dispatch('SessionEnd', hookCommonPayload({ session_id: session.id, reason: endReason }))).catch(() => {}),
+            300,
+            undefined,
+          );
+        }
+      } 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 {}
+      if (prewarmTimers.channelStartTimer) {
+        clearTimeout(prewarmTimers.channelStartTimer);
+        prewarmTimers.channelStartTimer = null;
+      }
+      for (const timerKey of [
+        'providerSetupWarmupTimer',
+        'providerWarmupTimer',
+        'providerModelWarmupTimer',
+        'modelCatalogWarmupTimer',
+      ]) {
+        if (warmupTimers[timerKey]) {
+          clearTimeout(warmupTimers[timerKey]);
+          warmupTimers[timerKey] = null;
+        }
+      }
+      if (prewarmTimers.codeGraphPrewarmTimer) {
+        clearTimeout(prewarmTimers.codeGraphPrewarmTimer);
+        prewarmTimers.codeGraphPrewarmTimer = null;
+      }
+      for (const timerKey of ['statuslineUsageWarmupTimer', 'statuslineUsageRefreshTimer']) {
+        if (warmupTimers[timerKey]) {
+          clearTimeout(warmupTimers[timerKey]);
+          warmupTimers[timerKey] = null;
+        }
+      }
+      try { cancelBackgroundTasks({ reason, notify: false }); } catch {}
+      const channelStop = channels.stop(reason, detach ? { waitForExit: false } : undefined);
+      try { agentTool.closeAll(reason); } catch {}
+      let mcpStop = null;
+      try { mcpStop = mcpClient.disconnectAll?.(); } catch {}
+      const openaiWsStop = globalThis.__mixdogOpenaiWsRuntimeLoaded === true
+        ? import('../runtime/agent/orchestrator/providers/openai-oauth-ws.mjs')
+          .then((mod) => mod?.drainOpenaiWsPool?.(reason))
+          .catch(() => {})
+        : null;
+      const patchStop = closePatchRuntimeIfLoaded(detach ? { waitForExit: false } : undefined);
+      const memoryModPromise = getMemoryModPromise();
+      const memoryStop = memoryModPromise
+        ? memoryModPromise
+          .then((mod) => (typeof mod?.stop === 'function' ? mod.stop() : null))
+          .catch(() => {})
+          .finally(() => {
+            setMemoryModPromise(null);
+          })
+        : null;
+      let ok = false;
+      const session = getSession();
+      if (session?.id) {
+        statusRoutes?.clearGatewaySessionRoute?.(session.id);
+        // Bug fix: runtime stop/exit (TUI Ctrl-C, process exit) previously
+        // always tombstoned the current session, so a session you were
+        // mid-conversation in vanished from the Resume list the instant you
+        // quit and was hard-deleted by the 24h tombstone sweep. Only
+        // tombstone truly-empty scratch sessions; non-empty sessions must
+        // survive exit resumable.
+        // liveTurnMessages holds the in-flight user prompt until turn
+        // commit — an active first-turn ask has its user message there,
+        // not yet in session.messages, so it must also be checked or a
+        // first-turn exit could still burn a real session.
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        ok = mgr.closeSession(session.id, reason, { tombstone });
+        setSession(null);
+      }
+      const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
+        ? import('../runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs')
+          .then((mod) => mod?.shutdownShellJobs?.(reason, { sync: !detach }))
+          .catch(() => {})
+        : null;
+      const bashSessionsStop = globalThis.__mixdogBashSessionRuntimeLoaded === true
+        ? import('../runtime/agent/orchestrator/tools/bash-session.mjs')
+          .then((mod) => mod?.shutdownBashSessions?.(reason))
+          .catch(() => {})
+        : null;
+      if (detach) {
+        try { await withTeardownDeadline(channelStop, 300, false); } catch {}
+        try { await withTeardownDeadline(shellJobsStop, 300, false); } catch {}
+        try { await withTeardownDeadline(bashSessionsStop, 300, false); } catch {}
+        try { await withTeardownDeadline(memoryStop, 1500, false); } catch {}
+        for (const stop of [mcpStop, openaiWsStop, patchStop]) {
+          Promise.resolve(stop).catch(() => {});
+        }
+        return ok;
+      }
+      await Promise.allSettled([
+        withTeardownDeadline(channelStop, 5500, false),
+        withTeardownDeadline(mcpStop, 1500, false),
+        withTeardownDeadline(openaiWsStop, 1500, false),
+        withTeardownDeadline(patchStop, 1500, false),
+        withTeardownDeadline(memoryStop, 5500, false),
+        withTeardownDeadline(shellJobsStop, 1500, false),
+        withTeardownDeadline(bashSessionsStop, 1500, false),
+      ]);
+      return ok;
+    },
+    abort(reason = 'cli-abort') {
+      const session = getSession();
+      if (!session?.id) return false;
+      return mgr.abortSessionTurn(session.id, reason);
+    },
+    listSessions() {
+      return mgr.listSessions({}).map(s => {
+        const owner = clean(s.owner || 'user').toLowerCase();
+        if (owner && !['cli', 'user', 'mixdog', 'legacy'].includes(owner)) return null;
+        const sourceType = clean(s.sourceType || '').toLowerCase();
+        const sourceName = clean(s.sourceName || '').toLowerCase();
+        const agent = clean(s.agent || '').toLowerCase();
+        const leadish = agent === 'lead'
+          || sourceType === 'lead'
+          || (sourceType === 'cli')
+          || (!sourceType && !sourceName && !isAgentOwner(owner));
+        if (!leadish) return null;
+        let preview = cleanSessionPreview(s.preview || '');
+        let messageCount = Math.max(0, Number(s.messageCount) || 0);
+        if (!preview && Array.isArray(s.messages)) {
+          const msgs = s.messages || [];
+          const userPreviews = msgs
+            .filter(m => m && m.role === 'user')
+            .map(m => cleanSessionPreview(sessionMessageText(m.content)))
+            .filter(text => !isSessionPreviewNoise(text));
+          preview = userPreviews[userPreviews.length - 1] || userPreviews[0] || '';
+          messageCount = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant')).length;
+        }
+        if (!preview && messageCount === 0) return null;
+        return {
+          id: s.id,
+          updatedAt: s.updatedAt,
+          cwd: s.cwd || '',
+          model: s.model,
+          provider: s.provider,
+          messageCount,
+          preview,
+        };
+      }).filter(Boolean);
+    },
+    async newSession() {
+      const session = getSession();
+      if (session?.id) {
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        mgr.closeSession(session.id, 'cli-new', { tombstone });
+        setSession(null);
+      }
+      invalidateContextStatusCache();
+      await createCurrentSession();
+      return getSession().id;
+    },
+    async resume(id) {
+      const prev = getSession();
+      const previousId = prev?.id || null;
+      const previousMessages = prev?.messages || null;
+      const previousLive = prev?.liveTurnMessages || null;
+      const resumed = await mgr.resumeSession(id, toolSpecForMode(getMode()));
+      if (!resumed) return null;
+      if (previousId && previousId !== resumed.id) {
+        statusRoutes?.clearGatewaySessionRoute?.(previousId);
+        const tombstone = !hasUserConversationMessage(previousMessages)
+          && !hasUserConversationMessage(previousLive);
+        mgr.closeSession(previousId, 'cli-resume', { tombstone });
+      }
+      setSession(resumed);
+      applyResolvedCwd(resumed.cwd || getCurrentCwd(), { markRefresh: false });
+      const route = getRoute();
+      const resumeEffort = hasOwn(route, 'effort') ? route.effort : resumed.effort;
+      setRoute(resolveRoute(getConfig(), { provider: resumed.provider, model: resumed.model, effort: resumeEffort }));
+      await refreshRouteEffort();
+      const session = getSession();
+      session.effort = getRoute().effectiveEffort || null;
+      session.cwd = getCurrentCwd();
+      applyDeferredToolSurface(session, deferredSurfaceModeForLead(getMode()), standaloneTools, { provider: getRoute().provider });
+      invalidatePreSessionToolSurface();
+      invalidateContextStatusCache();
+      setSessionNeedsCwdRefresh(false);
+      writeStatuslineRoute(statusRoutes, session, getRoute());
+      return {
+        id: resumed.id,
+        messages: resumed.messages || [],
+        cwd: getCurrentCwd(),
+        provider: resumed.provider,
+        model: resumed.model,
+      };
+    },
+  };
+}

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

@@ -4,9 +4,30 @@
 // `state` object so the facade's teardown/reconnect paths still observe it.
 // Method behavior is byte-for-byte identical; only grouping changes.
 import { resolve } from 'node:path';
+import { statSync } from 'node:fs';
 import { clean } from './session-text.mjs';
 import { readProjectMcpServers } from './plugin-mcp.mjs';
 
+// Cache project-local `.mcp.json` reads by path + mtime so repeated mcpStatus()
+// calls skip existsSync+readFileSync+JSON.parse when the file is unchanged.
+// Invalidated automatically on any mtime change (or create/delete via mtime=0).
+const projectMcpCache = new Map();
+const PROJECT_MCP_CACHE_MAX = 32;
+function cachedProjectMcpServers(cwd) {
+  const path = resolve(cwd || '.', '.mcp.json');
+  let mtimeMs = 0;
+  try { mtimeMs = statSync(path).mtimeMs; } catch { mtimeMs = 0; }
+  const hit = projectMcpCache.get(path);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.value;
+  const value = readProjectMcpServers(cwd);
+  // Bound the cache: Map preserves insertion order, so drop the oldest entry.
+  if (!projectMcpCache.has(path) && projectMcpCache.size >= PROJECT_MCP_CACHE_MAX) {
+    projectMcpCache.delete(projectMcpCache.keys().next().value);
+  }
+  projectMcpCache.set(path, { mtimeMs, value });
+  return value;
+}
+
 export function createMcpGlue({
   mcpClient,
   getConfig,
@@ -23,15 +44,15 @@ export function createMcpGlue({
   }
 
   // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
-  // On name collision the project-local `.mcp.json` entry WINS (Claude Code
-  // precedence: project > user config). `sources[name]` records each server's
+  // On name collision the project-local `.mcp.json` entry WINS
+  // (precedence: project > user config). `sources[name]` records each server's
   // origin ('config' | 'project') for status reporting.
   function resolveEffectiveMcpServers() {
     const config = getConfig();
     const configured = config?.mcpServers && typeof config.mcpServers === 'object'
       ? config.mcpServers
       : {};
-    const project = readProjectMcpServers(getCurrentCwd());
+    const project = cachedProjectMcpServers(getCurrentCwd());
     const servers = { ...configured, ...project };
     const sources = {};
     for (const name of Object.keys(configured)) sources[name] = 'config';