mixdog 0.9.22 → 0.9.23

package/src/runtime/shared/tool-surface.mjs

@@ -8,6 +8,9 @@ import {
   stripToolPrefix,
   parseMcpToolName,
   isMcpToolName,
+  isExternalMcpToolName,
+  isSelfMcpToolName,
+  titleCaseMcpServer,
   normalizeToolName,
   truncateToolText,
   truncateSingleLine,
@@ -68,7 +71,10 @@ export {
 };
 
 export function displayToolName(name, args = {}) {
-  if (isMcpToolName(name)) return 'MCP';
+  if (isExternalMcpToolName(name)) {
+    const mcp = parseMcpToolName(name);
+    return `MCP ${titleCaseMcpServer(mcp.server)}`;
+  }
   const normalized = normalizeToolName(name);
   switch (normalized) {
     case 'read':
@@ -94,7 +100,7 @@ export function displayToolName(name, args = {}) {
     case 'list':
     case 'ls':
       return 'Search';
-    case 'tool_search':
+    case 'load_tool':
       return toolSearchDisplayLabel(parseToolArgs(args));
     case 'search':
     case 'search_query':
@@ -145,10 +151,10 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
   const a = parseToolArgs(args);
   if (!a || typeof a !== 'object') return '';
   const normalized = normalizeToolName(name);
-  const mcpTarget = mcpToolTarget(name, max);
-  if (mcpTarget) {
+  if (isExternalMcpToolName(name)) {
+    const mcp = parseMcpToolName(name);
     return compactParts([
-      mcpTarget,
+      truncateToolText(mcp.tool, max),
       truncateToolText(firstText(a.query, a.q, a.text, a.prompt, a.path, a.uri, a.name, a.id, a.action), Math.min(max, 80)),
     ]);
   }
@@ -225,9 +231,9 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
         return formatCountedUnit(collectionCount(a.query, a.prompt, a.task, a.goal), 'query', 'queries');
       }
       return truncateSingleLine(firstText(a.query, a.prompt, a.task, a.goal, a.path), Math.min(max, 80));
-    case 'tool_search':
+    case 'load_tool':
       {
-        const selected = splitToolSearchSelection(a.select);
+        const selected = [...splitToolSearchSelection(a.names), ...splitToolSearchSelection(a.select)];
         if (selected.length) return truncateToolText(selected.map(displayToolSearchTarget).join(', '), max);
         return quoted(firstText(a.query, a.q, a.text), max);
       }
@@ -325,7 +331,7 @@ const TOOL_CATEGORY = new Map([
   ['glob', 'Search'],
   ['list', 'Search'],
   ['ls', 'Search'],
-  ['tool_search', 'Load'],
+  ['load_tool', 'Load'],
   ['search', 'Web Research'],
   ['web_search', 'Web Research'],
   ['search_query', 'Web Research'],
@@ -364,7 +370,7 @@ const TOOL_CATEGORY = new Map([
 
 /** Return the aggregate category for a tool name + args. */
 export function classifyToolCategory(name, args = {}) {
-  if (isMcpToolName(name)) return 'MCP';
+  if (isExternalMcpToolName(name)) return 'MCP';
   const normalized = normalizeToolName(name);
   if (normalized === 'code_graph') {
     const mode = String(args.mode || args.action || '').toLowerCase();
@@ -431,8 +437,12 @@ export function toolWorkUnit(name, args = {}, category = '') {
   const a = parseToolArgs(args);
   const normalized = normalizeToolName(name);
   const cat = category || classifyToolCategory(name, a);
-  if (isMcpToolName(name)) {
-    return unitDescriptor('MCP', { count: queryCount(a, 'query', 'q', 'text', 'prompt', 'path', 'uri', 'name', 'id', 'action') || 1 });
+  if (isExternalMcpToolName(name)) {
+    const mcp = parseMcpToolName(name);
+    return unitDescriptor('MCP', {
+      count: queryCount(a, 'query', 'q', 'text', 'prompt', 'path', 'uri', 'name', 'id', 'action') || 1,
+      noun: `${titleCaseMcpServer(mcp.server)} tool`,
+    });
   }
   switch (normalized) {
     case 'read':
@@ -470,8 +480,8 @@ export function toolWorkUnit(name, args = {}, category = '') {
     case 'list':
     case 'ls':
       return unitDescriptor('Search', { count: queryCount(a, 'path', 'paths', 'dir', 'dirs', 'cwd') || 1, active: 'Listing', done: 'Listed', noun: 'directory', pluralNoun: 'directories' });
-    case 'tool_search': {
-      const selected = splitToolSearchSelection(a.select);
+    case 'load_tool': {
+      const selected = [...splitToolSearchSelection(a.names), ...splitToolSearchSelection(a.select)];
       if (selected.length) return unitDescriptor('Load', { count: selected.length, noun: 'tool' });
       return unitDescriptor('Load', { count: queryCount(a, 'query', 'q', 'text') || 1, noun: 'query', pluralNoun: 'queries' });
     }

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

@@ -98,14 +98,24 @@ export function createConfigLifecycle({
       clearTimeout(configSaveTimer);
       configSaveTimer = null;
     }
-    if (pendingConfigToSave === null) return;
-    const snapshot = pendingConfigToSave;
-    pendingConfigToSave = null;
-    try {
-      cfgMod.saveConfig(snapshot);
-    } catch (err) {
-      process.stderr.write(`[config] debounced saveConfig failed: ${err?.message || err}\n`);
+    if (pendingConfigToSave !== null) {
+      const snapshot = pendingConfigToSave;
+      pendingConfigToSave = null;
+      try {
+        cfgMod.saveConfig(snapshot);
+      } catch (err) {
+        process.stderr.write(`[config] debounced saveConfig failed: ${err?.message || err}\n`);
+      }
     }
+    // Config-save flush points (reloadFullConfig re-read, runtime teardown) are
+    // exactly where a pending skills.disabled patch must also land, so piggyback
+    // the skills flush here — AFTER saveConfig: the whole-section snapshot may
+    // predate the latest skills toggle (stale snapshot.skills), so the in-lock
+    // skills patch must be the last writer. When the snapshot is newer than the
+    // toggle it already carries the same skills value, so the order is always
+    // safe. Runs even when no config snapshot is pending (early return above
+    // must not skip it).
+    flushSkillsSave();
   }
 
   function saveConfigAndAdopt(nextConfig, { hasSecrets = getConfigHasSecrets() } = {}) {
@@ -147,6 +157,35 @@ export function createConfigLifecycle({
     backendSaveTimer.unref?.();
   }
 
+  // --- debounced skills.disabled persist -------------------------------------
+  // In-memory skills state is adopted synchronously by setDisabledSkills; the
+  // heavy in-lock file RMW (cfgMod.patchSkillsDisabled) is deferred here so a
+  // burst of settings-toggle key presses collapses into one disk write.
+  let pendingSkillsNames = null;
+  let skillsSaveTimer = null;
+
+  function flushSkillsSave() {
+    if (skillsSaveTimer) {
+      clearTimeout(skillsSaveTimer);
+      skillsSaveTimer = null;
+    }
+    if (pendingSkillsNames === null) return;
+    const names = pendingSkillsNames;
+    pendingSkillsNames = null;
+    try {
+      cfgMod.patchSkillsDisabled(names);
+    } catch (err) {
+      process.stderr.write(`[config] debounced patchSkillsDisabled failed: ${err?.message || err}\n`);
+    }
+  }
+
+  function scheduleSkillsSave(names) {
+    pendingSkillsNames = names;
+    if (skillsSaveTimer) clearTimeout(skillsSaveTimer);
+    skillsSaveTimer = setTimeout(flushSkillsSave, CONFIG_SAVE_DEBOUNCE_MS);
+    skillsSaveTimer.unref?.();
+  }
+
   // --- debounced top-level outputStyle persist -------------------------------
   let pendingOutputStyleId = null;
   let outputStyleSaveTimer = null;
@@ -221,6 +260,8 @@ export function createConfigLifecycle({
     flushConfigSave,
     flushBackendSave,
     scheduleBackendSave,
+    flushSkillsSave,
+    scheduleSkillsSave,
     flushOutputStyleSave,
     scheduleOutputStyleSave,
     // reload / ensure

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

@@ -28,6 +28,7 @@ export function createLifecycleApi(deps) {
     createCurrentSession, refreshRouteEffort,
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, standaloneTools,
+    pushTranscriptRebind,
   } = deps;
   return {
     async close(reason = 'cli-exit', options = {}) {
@@ -56,6 +57,7 @@ export function createLifecycleApi(deps) {
       try { flushConfigSave(); } catch {}
       try { flushBackendSave(); } catch {}
       try { flushOutputStyleSave(); } catch {}
+      try { hooks.flushRules?.(); } catch {}
       if (prewarmTimers.channelStartTimer) {
         clearTimeout(prewarmTimers.channelStartTimer);
         prewarmTimers.channelStartTimer = null;
@@ -201,6 +203,10 @@ export function createLifecycleApi(deps) {
       }
       invalidateContextStatusCache();
       await createCurrentSession();
+      // New session.id => the worker's binding (and persisted status) now point
+      // at the previous session's transcript. Push the current transcript so
+      // outbound forwarding repoints immediately (best-effort, remote-gated).
+      pushTranscriptRebind?.();
       return getSession().id;
     },
     async resume(id) {
@@ -230,6 +236,9 @@ export function createLifecycleApi(deps) {
       invalidateContextStatusCache();
       setSessionNeedsCwdRefresh(false);
       writeStatuslineRoute(statusRoutes, session, getRoute());
+      // Session swapped to the resumed one: repoint the worker to the current
+      // transcript instead of waiting for the next inbound steal.
+      pushTranscriptRebind?.();
       return {
         id: resumed.id,
         messages: resumed.messages || [],

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

@@ -94,7 +94,69 @@ export function createMcpGlue({
     };
   }
 
-  async function connectConfiguredMcp({ reset = false } = {}) {
+  // Connect/disconnect exactly one server in the live registry, leaving all
+  // others untouched. Used by the enable/disable toggle so a single-server
+  // change never triggers a full disconnectAll()/reconnect freeze.
+  async function applyMcpServerConnection(name, enabled) {
+    const target = clean(name);
+    if (!target) return;
+    const { servers, sources } = resolveEffectiveMcpServers();
+    // A project-local `.mcp.json` entry WINS over config for this name, so the
+    // config enable/disable flag doesn't change what's actually connected.
+    // Only act when the effective entry is config-sourced (or absent).
+    if (sources[target] && sources[target] !== 'config') return;
+    // Changing this server's state clears any stale failure record for it.
+    if (Array.isArray(state.mcpFailures)) {
+      state.mcpFailures = state.mcpFailures.filter((row) => row.name !== target);
+    }
+    if (enabled === false) {
+      await mcpClient.disconnectMcpServer?.(target);
+      return;
+    }
+    const cfg = servers[target];
+    if (!cfg) return;
+    // Drop any existing live entry first so connectMcpServers doesn't overwrite
+    // the registry Map entry and leak the old transport/process.
+    await mcpClient.disconnectMcpServer?.(target);
+    try {
+      await mcpClient.connectMcpServers({ [target]: cfg });
+    } catch (error) {
+      const failures = Array.isArray(error?.failures)
+        ? error.failures
+        : [{ name: target, msg: error?.message || String(error) }];
+      state.mcpFailures = [...(state.mcpFailures || []), ...failures];
+    }
+  }
+
+  async function connectConfiguredMcp({ reset = false, only = null, enabled = true } = {}) {
+    // Scoped single-server toggle: non-superseding. It must NEVER cancel a
+    // pending full {reset} (cwd-change/boot). So do not bump the generation;
+    // just wait for any in-flight run, then bail if a newer full reset has
+    // been requested in the meantime. Registering as in-flight makes a later
+    // reset serialize behind us instead of interleaving disconnect/connect.
+    if (only) {
+      // Atomically capture the current generation AND the prior in-flight
+      // promise in the same synchronous step, then chain our op onto it. No
+      // await sits between the capture and the `state.mcpConnectInFlight = run`
+      // assignment, so concurrent {only} calls queue FIFO instead of resuming
+      // together and clobbering the in-flight slot. We never bump the
+      // generation; a {reset} does, so any {only} queued behind a reset sees
+      // the newer generation when its turn comes and bails.
+      const gen = state.mcpConnectGeneration;
+      const prev = state.mcpConnectInFlight;
+      const run = (async () => {
+        if (prev) { try { await prev; } catch { /* prior run's failures already captured */ } }
+        if (gen !== state.mcpConnectGeneration) return;
+        await applyMcpServerConnection(only, enabled);
+      })();
+      state.mcpConnectInFlight = run;
+      try {
+        await run;
+      } finally {
+        if (state.mcpConnectInFlight === run) state.mcpConnectInFlight = null;
+      }
+      return mcpStatus();
+    }
     // Serialize reconnects: boot connect, cwd-change reset, and rapid cwd
     // switches must never interleave their disconnect/connect phases, or an
     // older run finishing after a newer reset could re-add stale servers into

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

@@ -29,8 +29,56 @@ export function createResourceApi(deps) {
     saveConfigAndAdopt, connectConfiguredMcp, invalidatePreSessionToolSurface,
     recreateCurrentSessionIfReady, normalizeMcpServerInput, mcpStatus,
     skillsStatus, skillContent, addProjectSkill, pluginsStatus, getMemoryModule,
-    reloadFullConfig,
+    reloadFullConfig, getActiveTurnCount,
   } = deps;
+  // Per-server MCP toggle serialization. The synchronous config adopt in
+  // setMcpServerEnabled has already made the intent durable; the heavy
+  // connectConfiguredMcp (process spawn/handshake) + session close/recreate
+  // run here off the toggle's critical path. Rapid re-toggles on one server
+  // update `desired` and ride the in-flight chain so it converges to the last
+  // requested state, closing/recreating the session only once at the end.
+  const mcpToggleChains = new Map(); // name -> { desired, running }
+  // Close/recreate the live session only at a turn boundary: a background
+  // toggle must never abort an in-flight turn. If a turn is active, poll until
+  // it ends, then swap the session so it picks up the new tool surface.
+  function applyMcpToggleRecreate(serverName) {
+    if (typeof getActiveTurnCount === 'function' && getActiveTurnCount() > 0) {
+      const timer = setTimeout(() => applyMcpToggleRecreate(serverName), 250);
+      timer.unref?.();
+      return;
+    }
+    invalidatePreSessionToolSurface();
+    const session = getSession();
+    if (session?.id) mgr.closeSession(session.id, 'cli-mcp-toggle');
+    // Recreate off the critical path (see removeMcpServer notes): the next
+    // on-demand createCurrentSession dedupes onto this in-flight create.
+    void recreateCurrentSessionIfReady().catch((err) => {
+      process.stderr.write(`[mcp] session recreate after toggle failed: ${err?.message || err}\n`);
+    });
+  }
+  function scheduleMcpToggle(serverName, enabled) {
+    const chain = mcpToggleChains.get(serverName) || { desired: enabled, running: null };
+    chain.desired = enabled;
+    mcpToggleChains.set(serverName, chain);
+    if (!chain.running) {
+      chain.running = (async () => {
+        let status;
+        try {
+          let want;
+          do {
+            want = chain.desired;
+            status = await connectConfiguredMcp({ only: serverName, enabled: want });
+          } while (chain.desired !== want);
+          // Turn-safe: defers until any active turn ends (never aborts it).
+          applyMcpToggleRecreate(serverName);
+        } finally {
+          chain.running = null;
+        }
+        return status;
+      })();
+    }
+    return chain.running;
+  }
   return {
     mcpStatus() {
       return mcpStatus();
@@ -78,7 +126,7 @@ export function createResourceApi(deps) {
       await recreateCurrentSessionIfReady();
       return status;
     },
-    async setMcpServerEnabled(name, enabled) {
+    setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
       const nextConfig = { ...getConfig() };
@@ -88,14 +136,20 @@ export function createResourceApi(deps) {
       if (!Object.prototype.hasOwnProperty.call(current, serverName)) {
         throw new Error(`MCP server not configured: ${serverName}`);
       }
+      // A project-local `.mcp.json` entry WINS over config for this name, so a
+      // config enable/disable flag would persist but never change live state.
+      // Surface that to the caller instead of reporting a silent success.
+      const shadowRow = mcpStatus().servers.find((s) => s.name === serverName);
+      if (shadowRow && shadowRow.source === 'project') {
+        throw new Error(`'${serverName}' is defined by project .mcp.json — config toggle has no effect`);
+      }
+      // Adopt + persist config synchronously (fast) so intent is durable, then
+      // hand the heavy connect/close/recreate to the per-server background
+      // chain. Return that chain's promise so callers can settle the picker on
+      // completion, but the store no longer blocks on it.
       current[serverName] = { ...(current[serverName] || {}), enabled: enabled !== false };
       saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
-      const status = await connectConfiguredMcp({ reset: true });
-      invalidatePreSessionToolSurface();
-      const session = getSession();
-      if (session?.id) mgr.closeSession(session.id, 'cli-mcp-toggle');
-      await recreateCurrentSessionIfReady();
-      return status;
+      return scheduleMcpToggle(serverName, enabled !== false);
     },
     skillsStatus() {
       return skillsStatus();

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

@@ -903,6 +903,11 @@ export async function createMixdogSessionRuntime({
         if (msg?.params?.state === 'acquired' && !remoteEnabled) {
           remoteEnabled = true;
           ensureRemoteTranscriptWriter();
+          // Auto-acquire: the worker restored yesterday's transcript from
+          // persisted status and we just created the CURRENT writer. Push the
+          // repoint now instead of waiting for the next inbound parent-chain
+          // steal, so outbound forwarding never tails a stale transcript.
+          pushTranscriptRebind();
           emitRemoteStateChange(true, 'acquired');
         }
         return;
@@ -1001,8 +1006,8 @@ export async function createMixdogSessionRuntime({
         if (!codeGraphMod?.executeCodeGraphTool) throw new Error('code_graph runtime is not available');
         return await codeGraphMod.executeCodeGraphTool(name, args || {}, args?.cwd || callerCwd);
       }
-      if (name === 'tool_search') {
-        return renderToolSearch(args, activeToolSurface(), mode);
+      if (name === 'tool_search' || name === 'load_tool') {
+        return renderToolSearch(args, activeToolSurface(), mode, { mcpStatus });
       }
       if (name === 'explore') {
         const callerSessionId = callerCtx?.callerSessionId || session?.id || null;
@@ -1107,6 +1112,8 @@ export async function createMixdogSessionRuntime({
     flushConfigSave,
     flushBackendSave,
     scheduleBackendSave,
+    scheduleSkillsSave,
+    flushSkillsSave,
     flushOutputStyleSave,
     scheduleOutputStyleSave,
     reloadFullConfig,
@@ -1523,6 +1530,25 @@ export async function createMixdogSessionRuntime({
     return _transcriptWriter != null;
   }
 
+  // Push the CURRENT transcript path to the channel worker so outbound
+  // forwarding repoints immediately at the moments the binding can go stale
+  // (auto-acquire, newSession/resume, clear) instead of waiting for the next
+  // inbound parent-chain steal. Best-effort: ensures the writer, then fires
+  // the dedicated idempotent worker op — a missing/not-ready worker or a bind
+  // failure must never throw into the lead paths that call this.
+  function pushTranscriptRebind() {
+    if (!remoteEnabled) return;
+    if (!ensureRemoteTranscriptWriter()) return;
+    const transcriptPath = _transcriptWriter?.transcriptPath;
+    if (!transcriptPath || !channelsEnabled()) return;
+    try {
+      void channels.execute('rebind_current_transcript', { transcriptPath })
+        .catch((error) => bootProfile('channels:rebind-push-failed', { error: error?.message || String(error) }));
+    } catch (error) {
+      bootProfile('channels:rebind-push-failed', { error: error?.message || String(error) });
+    }
+  }
+
   // Remote (Discord channel) mode is opt-in per session. Only a session that
   // explicitly enables remote — via `mixdog --remote` or the runtime toggle —
   // boots the channel worker and contends for channel ownership.
@@ -1783,6 +1809,7 @@ export async function createMixdogSessionRuntime({
     adoptConfig,
     saveConfigAndAdopt,
     scheduleBackendSave,
+    scheduleSkillsSave,
     cfgMod,
     hasOwn,
     normalizeAutoClearConfig,
@@ -1859,6 +1886,7 @@ export async function createMixdogSessionRuntime({
     statusRoutes,
     channels,
     agentTool,
+    pushTranscriptRebind,
     mcpClient,
     warmupTimers,
     prewarmTimers,
@@ -1896,6 +1924,7 @@ export async function createMixdogSessionRuntime({
     pluginsStatus,
     getMemoryModule,
     reloadFullConfig,
+    getActiveTurnCount: () => activeTurnCount,
   });
   const modelRouteApi = createModelRouteApi({
     getConfig: () => config,
@@ -1978,6 +2007,7 @@ export async function createMixdogSessionRuntime({
     refreshSessionForCwdIfNeeded,
     createCurrentSession,
     ensureRemoteTranscriptWriter,
+    pushTranscriptRebind,
     channelsEnabled,
     invokeChannelStart,
     channels,

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

@@ -32,6 +32,7 @@ export function isSessionPreviewNoise(text) {
   return !value
     || value.startsWith('<system-reminder>')
     || value.startsWith('</system-reminder>')
+    || isLateToolAnnouncement(value)
     || /^#\s*permission\b/i.test(value)
     || /^permission:\s*/i.test(value)
     || /^cwd:\s*/i.test(value);
@@ -45,6 +46,46 @@ export function cleanSessionPreview(text) {
     .slice(0, 160);
 }
 
+// Stable sentinel carried in every late-tool (deferred MCP) announcement
+// reminder — must stay byte-identical to LATE_TOOL_REMINDER_SENTINEL in
+// src/session-runtime/tool-catalog.mjs. Detection keys on this exact string
+// (never fuzzy matching) so the raw announcement block can be hidden from
+// user-facing surfaces while the model context stays untouched.
+export const LATE_TOOL_ANNOUNCEMENT_SENTINEL = 'connected after this session started';
+
+export function isLateToolAnnouncement(text) {
+  const value = String(text || '');
+  return value.includes(LATE_TOOL_ANNOUNCEMENT_SENTINEL)
+    && /<available-deferred-tools>/i.test(value);
+}
+
+// Derive a muted one-line notice from a late-tool announcement body, e.g.
+// "MCP tools available: UnityMCP (12 tools)". MCP tool entries in the manifest
+// are `- mcp__<server>__<tool>: ...` lines; the server name is the segment
+// after the `mcp__` prefix. Returns '' for non-announcement text.
+export function summarizeLateToolAnnouncement(text) {
+  const value = String(text || '');
+  if (!isLateToolAnnouncement(value)) return '';
+  const block = value.match(/<available-deferred-tools>([\s\S]*?)<\/available-deferred-tools>/i);
+  const body = block ? block[1] : value;
+  const names = [];
+  const lineRe = /^\s*-\s+([A-Za-z0-9_.:-]+)/gm;
+  let m;
+  while ((m = lineRe.exec(body))) names.push(m[1]);
+  const servers = new Set();
+  for (const name of names) {
+    const seg = name.startsWith('mcp__') ? name.slice(5) : name;
+    const server = seg.split('__')[0];
+    if (server) servers.add(server);
+  }
+  const count = names.length;
+  const label = servers.size === 1
+    ? [...servers][0]
+    : (servers.size ? `${servers.size} MCP servers` : 'MCP');
+  if (!count) return `MCP tools available: ${label}`;
+  return `MCP tools available: ${label} (${count} ${count === 1 ? 'tool' : 'tools'})`;
+}
+
 export function clean(value) {
   return String(value ?? '').trim();
 }

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

@@ -6,7 +6,9 @@ import {
   toolSearchMatches,
   sortedNamesByMeasuredUsage,
   selectDeferredTools,
+  reconcileDeferredMcpToolCatalog,
 } from './tool-catalog.mjs';
+import { getMcpTools } from '../runtime/agent/orchestrator/mcp/client.mjs';
 
 // Turn execution (ask) + session-manage/tool-surface/agent surfaces. Extracted
 // verbatim from the runtime API object; stateless helpers are imported directly
@@ -22,6 +24,7 @@ export function createSessionTurnApi(deps) {
     getTranscriptWriter, getTwKey, getLastAppendedAssistant, setLastAppendedAssistant,
     scheduleCodeGraphPrewarm, refreshSessionForCwdIfNeeded, createCurrentSession,
     ensureRemoteTranscriptWriter, channelsEnabled, invokeChannelStart, channels,
+    pushTranscriptRebind,
     hooks, hookCommonPayload, mgr, notifyFnForSession, bootProfile,
     scheduleProviderWarmup, scheduleProviderModelWarmup, invalidateContextStatusCache,
     agentTool, recreateCurrentSessionIfReady, invalidatePreSessionToolSurface,
@@ -56,6 +59,22 @@ export function createSessionTurnApi(deps) {
           }
         }
         const session0 = getSession();
+        // Turn-boundary snapshot: fold in MCP tools whose servers finished their
+        // handshake after this session was created, and announce the newly
+        // available deferred tool names via ONE appended, persistent
+        // system-reminder (append-only — never rewrites BP1 or touches the
+        // active tool surface, so the prompt-cache prefix stays intact).
+        try {
+          reconcileDeferredMcpToolCatalog(session0, getMcpTools(), {
+            // Deliver the late-tool announcement through the pending-message
+            // queue so it rides inside the next real user turn as a persisted
+            // system-reminder (no synthetic user + '.' assistant pair).
+            enqueue: (text) => (typeof mgr.enqueuePendingMessage === 'function'
+              ? mgr.enqueuePendingMessage(session0.id, text) > 0
+              : false),
+          });
+        }
+        catch { /* MCP delta must never break the turn */ }
         hooks.emit('turn:start', { sessionId: session0.id, prompt, cwd: getCurrentCwd() });
         // UserPromptSubmit: a hook FAILURE must not block the turn, but blocked===true MUST throw.
         let promptDispatch = null;
@@ -180,6 +199,11 @@ export function createSessionTurnApi(deps) {
         try { agentTool.recoverWorkers?.({ clientHostPid: getSession()?.clientHostPid || process.pid }); } catch {}
       }
       invalidateContextStatusCache();
+      // clearSessionMessages swaps the live session object; the worker binding
+      // + persisted status still reference the pre-clear transcript. Push the
+      // current transcript so outbound forwarding repoints now, not on the next
+      // inbound steal (best-effort, remote-gated inside pushTranscriptRebind).
+      pushTranscriptRebind?.();
       return true;
     },
     // session_manage tool handoff: the engine polls this at turn end and, if

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

@@ -16,6 +16,7 @@ export function createSettingsApi({
   adoptConfig,
   saveConfigAndAdopt,
   scheduleBackendSave,
+  scheduleSkillsSave,
   // normalizers / helpers
   cfgMod,
   hasOwn,
@@ -139,8 +140,14 @@ export function createSettingsApi({
       const names = disabled instanceof Set
         ? [...disabled]
         : (Array.isArray(disabled) ? disabled : []);
-      const nextSkills = cfgMod.patchSkillsDisabled(names);
+      // Adopt in-memory synchronously so getDisabledSkills reflects the new
+      // value on the same tick (matches normalizeSkillsConfig({ disabled })
+      // used by patchSkillsDisabled). Defer the heavy in-lock file RMW through
+      // the skills debounce channel so the settings-toggle key handler does not
+      // hitch on a synchronous disk write.
+      const nextSkills = cfgMod.normalizeSkillsConfig({ disabled: names });
       adoptConfig({ ...getConfig(), skills: nextSkills });
+      scheduleSkillsSave(names);
       return this.getDisabledSkills();
     },
     setProfile(input = {}) {