mixdog 1.1.2 → 1.2.1

package/src/headless-command.mjs

@@ -1,5 +1,12 @@
+import { worktreeNameError } from './runtime/shared/worktrees/contract.mjs';
+
 const VALUE_OPTIONS = new Set(['--provider', '--model', '--effort', '--workflow']);
+// `--worktree [name]` takes an optional value; `--worktree=<name>` is the
+// unambiguous spelling.
+const WORKTREE_OPTION = '--worktree';
+const NO_WORKTREE_OPTION = '--no-worktree';
 const FLAG_OPTIONS = new Set([
+  NO_WORKTREE_OPTION,
   '--readonly',
   '--help',
   '-h',
@@ -12,7 +19,7 @@ const FLAG_OPTIONS = new Set([
   '--memory',
   '--json',
 ]);
-const EXEC_UNSUPPORTED_FLAGS = new Set(['--readonly', '--remote', '--onboarding', '--memory']);
+const EXEC_UNSUPPORTED_FLAGS = new Set(['--readonly', '--remote', '--onboarding', '--memory', NO_WORKTREE_OPTION]);
 const HEADLESS_WORKFLOW_ERROR = 'option --workflow is not supported for mixdog exec';
 
 function roleKey(value) {
@@ -22,6 +29,16 @@ function roleKey(value) {
     .replace(/[\s_]+/g, '-');
 }
 
+const isWorktreeOption = (arg) => arg === WORKTREE_OPTION || arg.startsWith(`${WORKTREE_OPTION}=`);
+
+/** The token after a bare `--worktree` is its name unless it is an option or the exec verb. */
+function worktreeNameToken(value) {
+  if (value === undefined || value === null) return null;
+  const text = String(value);
+  if (!text || text.startsWith('-') || roleKey(text) === 'exec') return null;
+  return text;
+}
+
 function argvIndicatesExec(argv) {
   for (let index = 0; index < argv.length; index += 1) {
     const arg = String(argv[index] ?? '');
@@ -29,6 +46,11 @@ function argvIndicatesExec(argv) {
       index += 1;
       continue;
     }
+    if (arg === WORKTREE_OPTION) {
+      if (worktreeNameToken(argv[index + 1]) !== null) index += 1;
+      continue;
+    }
+    if (isWorktreeOption(arg)) continue;
     if (arg === '--') continue;
     if (FLAG_OPTIONS.has(arg) || arg.startsWith('-')) continue;
     return roleKey(arg) === 'exec';
@@ -39,9 +61,23 @@ function argvIndicatesExec(argv) {
 function parseTokens(argv, { strictValues = true } = {}) {
   const positional = [];
   const values = {};
+  let worktree;
   const allowHeadlessIntent = strictValues && !argv.includes('--react');
   for (let index = 0; index < argv.length; index += 1) {
     const arg = String(argv[index] ?? '');
+    if (isWorktreeOption(arg)) {
+      let name = arg === WORKTREE_OPTION ? null : arg.slice(WORKTREE_OPTION.length + 1);
+      if (name === null) {
+        name = worktreeNameToken(argv[index + 1]);
+        if (name !== null) index += 1;
+      }
+      const nameError = name === null ? null : worktreeNameError(name);
+      if (nameError && strictValues) {
+        return { error: `option --worktree name ${JSON.stringify(name)} is invalid: ${nameError}` };
+      }
+      worktree = { mode: 'worktree', name: nameError ? null : name };
+      continue;
+    }
     if (VALUE_OPTIONS.has(arg)) {
       const value = argv[index + 1];
       if (value === undefined || value === '' || String(value).startsWith('-')) {
@@ -87,7 +123,19 @@ function parseTokens(argv, { strictValues = true } = {}) {
     }
     positional.push(arg);
   }
-  return { positional, values };
+  return { positional, values, worktree };
+}
+
+/**
+ * Session creation intent from `--worktree [name]` / `--no-worktree`:
+ * undefined follows the worktree settings default.
+ * @returns {{ worktree?: { mode: 'worktree', name: string|null } | { mode: 'branch' } } | { error: string }}
+ */
+function worktreeIntent(argv, parsed) {
+  const disabled = argv.includes(NO_WORKTREE_OPTION);
+  if (disabled && parsed.worktree) return { error: 'options --worktree and --no-worktree are mutually exclusive' };
+  if (disabled) return { worktree: { mode: 'branch' } };
+  return parsed.worktree ? { worktree: parsed.worktree } : {};
 }
 
 function execFromPositional(positional) {
@@ -103,7 +151,10 @@ export function classifyCliInvocation(argv = []) {
   const hasPlain = argv.includes('--plain');
   const parsed = parseTokens(argv, { strictValues: !hasHelp && !hasPlain });
   if (parsed.error) return { kind: 'error', ...parsed };
+  const intent = worktreeIntent(argv, parsed);
+  if (intent.error && !hasHelp && !hasPlain) return { kind: 'error', error: intent.error };
   const options = {
+    ...(intent.worktree ? { worktree: intent.worktree } : {}),
     provider: parsed.values['--provider'],
     model: parsed.values['--model'],
     effort: parsed.values['--effort'],
@@ -129,7 +180,9 @@ export function classifyCliInvocation(argv = []) {
         skipHostPrelude: true,
       };
     }
-    const unsupported = [...EXEC_UNSUPPORTED_FLAGS].find((flag) => argv.includes(flag));
+    const unsupported =
+      [...EXEC_UNSUPPORTED_FLAGS].find((flag) => argv.includes(flag)) ||
+      (parsed.worktree ? WORKTREE_OPTION : undefined);
     if (unsupported) {
       return {
         kind: 'error',

package/src/headless-exec.mjs

@@ -75,6 +75,7 @@ export async function runHeadlessExec({
   memoryRuntimeCleanup = stopStandaloneMemoryRuntimesForProcess,
   daemonRuntimeCleanup = shutdownDaemonForRuntimeRoot,
   usageLedgerCleanup = closeUsageLedgers,
+  sessionStoreDrain = drainHeadlessSessionStore,
   hasActiveTasks = hasActiveBackgroundTasks,
   installSignalCleanupFn = installProcessSignalCleanup,
 } = {}) {
@@ -122,6 +123,7 @@ export async function runHeadlessExec({
     memoryRuntimeCleanup,
     daemonRuntimeCleanup,
     usageLedgerCleanup,
+    sessionStoreDrain,
     hasActiveTasks,
     installSignalCleanupFn,
   });
@@ -155,6 +157,7 @@ async function executeHeadlessPrompt(
     memoryRuntimeCleanup,
     daemonRuntimeCleanup,
     usageLedgerCleanup,
+    sessionStoreDrain,
     hasActiveTasks,
     installSignalCleanupFn,
   }
@@ -172,6 +175,7 @@ async function executeHeadlessPrompt(
     writeErr,
     hasActiveTasks,
     usageLedgerCleanup,
+    sessionStoreDrain,
     daemonRuntimeCleanup,
     memoryRuntimeCleanup,
   });
@@ -266,7 +270,7 @@ function taskScopeFor(session) {
 // pristine root.
 function headlessCleanup(
   run,
-  { writeErr, hasActiveTasks, usageLedgerCleanup, daemonRuntimeCleanup, memoryRuntimeCleanup }
+  { writeErr, hasActiveTasks, usageLedgerCleanup, sessionStoreDrain, daemonRuntimeCleanup, memoryRuntimeCleanup }
 ) {
   let cleanupPromise = null;
   const shutdown = async (reason) => {
@@ -289,6 +293,13 @@ function headlessCleanup(
         await drainAgentTrace();
       }
     });
+    // The session store's process-exit hook flushes any save still pending
+    // at exit to the data dir resolved AT THAT MOMENT — by then the boundary
+    // has restored the host environment, so a late write would land in the
+    // host's session catalog. Flush while the pristine data dir is current.
+    await attemptShutdownStep(errors, async () => {
+      if (boundary) await sessionStoreDrain();
+    });
     // The usage ledger lives inside the pristine root. Its open SQLite
     // handle blocks the root removal below on Windows (EBUSY) for the whole
     // rmSync retry budget, so release it once the last usage row is in.
@@ -316,6 +327,11 @@ function headlessCleanup(
   };
 }
 
+async function drainHeadlessSessionStore() {
+  const { drainSessionStore } = await import('./runtime/agent/orchestrator/session/store.mjs');
+  drainSessionStore();
+}
+
 // Runs one shutdown step, collecting its failure so the remaining steps still
 // run; true when the step succeeded.
 async function attemptShutdownStep(errors, step) {

package/src/help.mjs

@@ -17,6 +17,8 @@ const HELP_LINES = [
   '  --web-search        enable web search and page retrieval for headless exec',
   '  --json              emit headless exec events as JSONL',
   '  --workflow <name>   start with the given workflow active',
+  '  --worktree [name]   run this session in a new git worktree (optionally named)',
+  '  --no-worktree       run this session on the current branch in the project folder',
   '  --readonly          read-only tool surface',
   '  --remote            enable remote/channel mode for this session',
   '  --onboarding        re-run the first-run setup wizard',

package/src/rules/shared/60-verification.md

@@ -5,7 +5,9 @@
   independent invariants, never from the output itself or from recall.
 - After all edits, cover each required check once: one runner per runtime,
   independent checks in parallel; no read/list/diff to confirm your own
-  writes; rerun only failed or invalidated checks.
+  writes; rerun only failed or invalidated checks. If repeated fixes leave
+  the same failure unchanged, test the underlying assumptions before
+  another fix.
 - Use supplied commands unchanged except inputs, else documented defaults; no
   stricter flags or unrequested suites.
 - Warnings or blocked checks never justify editing passing code. Fix obsolete

package/src/rules/shared/70-delivery.md

@@ -8,8 +8,10 @@
   `src/app.ts:42`); files outside the Project always by absolute path; never a
   bare name, a path relative to another folder, or a `file://` URI.
 - Deliver requested visual artifacts (SVG, diagrams, HTML pages) as saved files
-  and give their path; never paste their source as the answer unless the user
-  asks for the code.
+  and give their path; never open them in the system browser or paste their
+  source unless the user asks.
+<!-- tools: visualize -->
+- Open each finished artifact beside the chat with `visualize open` when available.
 
 <!-- tools: git -->
 - A commit request includes selecting and staging its changes; a stage-only

package/src/runtime/agent/orchestrator/agent-runtime/agent-dispatch/preset.mjs

@@ -35,6 +35,7 @@ function maintenanceRouteToPreset(routeOrName, agent) {
   const effort = String(routeOrName.effort || '').trim();
   if (effort) out.effort = effort;
   if (routeOrName.fast === true) out.fast = true;
+  if (routeOrName.autoEffort === false) out.autoEffort = false;
   if (routeOrName.modelParameters && typeof routeOrName.modelParameters === 'object') {
     out.modelParameters = { ...routeOrName.modelParameters };
   }

package/src/runtime/agent/orchestrator/agent-runtime/maintenance-route.mjs

@@ -12,6 +12,7 @@ function normalizeMaintenanceCandidate(candidate) {
     model,
     effort: String(candidate.effort || '').trim() || undefined,
     fast: candidate.fast === true,
+    ...(candidate.autoEffort === false ? { autoEffort: false } : {}),
   };
 }
 

package/src/runtime/agent/orchestrator/agent-runtime/session-builder.mjs

@@ -77,6 +77,7 @@ export function prepareAgentSession({
   sessionId,
   mcpScopeId,
   contextPercent,
+  contextTokens,
   selectedContextWindow,
 }) {
   const effectivePermission = resolveAgentSessionPermission(agent, permission);
@@ -115,6 +116,7 @@ export function prepareAgentSession({
     mcpScopeId: mcpScopeId || null,
   };
   if (contextPercent) sessionOpts.contextPercent = contextPercent;
+  if (contextTokens) sessionOpts.contextTokens = contextTokens;
   if (selectedContextWindow) sessionOpts.selectedContextWindow = selectedContextWindow;
   if (agentTag) sessionOpts.agentTag = agentTag;
   if (effectivePermission) sessionOpts.permission = effectivePermission;

package/src/runtime/agent/orchestrator/cache-mtime.mjs

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { statSync, readdirSync } from 'node:fs';
 
 /**
@@ -14,6 +15,28 @@ import { statSync, readdirSync } from 'node:fs';
  */
 export function maxMtimeRecursive(paths, depth = 3) {
   let max = 0;
+  walkMtimes(paths, depth, (_p, m) => {
+    if (m > max) max = m;
+  });
+  return max;
+}
+
+/**
+ * Exact change signature over the same walk as maxMtimeRecursive: every
+ * stat'ed path with its own mtime, so any single path changing (even to an
+ * older time) changes the result. Compare for equality only.
+ *
+ * @param {string[]} paths
+ * @param {number}   [depth=3]
+ * @returns {string}
+ */
+export function mtimeSignatureRecursive(paths, depth = 3) {
+  const parts = [];
+  walkMtimes(paths, depth, (p, m) => parts.push(`${p}:${m}`));
+  return createHash('sha1').update(parts.join('\n')).digest('hex');
+}
+
+function walkMtimes(paths, depth, visit) {
   function walk(p, d) {
     let st;
     try {
@@ -22,7 +45,7 @@ export function maxMtimeRecursive(paths, depth = 3) {
       return;
     }
     if (st.isDirectory()) {
-      if (st.mtimeMs > max) max = st.mtimeMs;
+      visit(p, st.mtimeMs);
       if (d <= 0) return;
       let entries;
       try {
@@ -36,17 +59,15 @@ export function maxMtimeRecursive(paths, depth = 3) {
           walk(child, d - 1);
         } else if (e.isFile() && (e.name.endsWith('.md') || e.name.endsWith('.json'))) {
           try {
-            const m = statSync(child).mtimeMs;
-            if (m > max) max = m;
+            visit(child, statSync(child).mtimeMs);
           } catch {
             /* unreadable entry: skipped like a missing path */
           }
         }
       }
     } else {
-      if (st.mtimeMs > max) max = st.mtimeMs;
+      visit(p, st.mtimeMs);
     }
   }
   for (const p of paths) walk(p, depth);
-  return max;
 }

package/src/runtime/agent/orchestrator/config-presets.mjs

@@ -141,6 +141,8 @@ export function normalizePreset(preset) {
   const out = { id, name, type: 'agent', provider, model };
   if (preset.effort) out.effort = String(preset.effort).trim();
   if (preset.fast === true && FAST_CAPABLE_PRESET_PROVIDERS.has(provider)) out.fast = true;
+  // Auto effort is on unless the preset opts out; only the off state is kept.
+  if (preset.autoEffort === false) out.autoEffort = false;
   out.tools = ['full', 'readonly', 'mcp'].includes(preset.tools) ? preset.tools : 'full';
   return out;
 }

package/src/runtime/agent/orchestrator/config-providers-merge.mjs

@@ -6,9 +6,21 @@
  * is dropped.
  */
 import { AGENT_PROVIDER_ENV, getAgentApiKey } from '../../shared/config.mjs';
+import { hasAgentApiKey } from '../../shared/provider-api-key.mjs';
 import { OPENAI_COMPAT_PRESETS } from './providers/openai-compat-presets.mjs';
 
-export function mergeStoredProviders({ raw, defaults, includeSecrets }) {
+/** `presenceOnly`: a stored key only marks its provider enabled; its value is
+ *  neither read nor attached. */
+export function mergeStoredProviders({ raw, defaults, includeSecrets, presenceOnly = false }) {
+  const storedKey = (name) => {
+    if (!presenceOnly) return getAgentApiKey(name);
+    return hasAgentApiKey(name) ? true : null;
+  };
+  const withKey = (entry, name, key) => ({
+    ...(entry || {}),
+    ...(presenceOnly ? {} : { apiKey: key }),
+    enabled: raw.providers?.[name]?.enabled !== false,
+  });
   // Deep-merge provider subkeys: unknown per-provider values are
   // preserved through save/load so future fields round-trip
   // without schema updates here.
@@ -39,14 +51,8 @@ export function mergeStoredProviders({ raw, defaults, includeSecrets }) {
   // stored key still ships 'no-key' → 401.
   if (includeSecrets) {
     for (const name of new Set([...Object.keys(AGENT_PROVIDER_ENV), ...Object.keys(OPENAI_COMPAT_PRESETS)])) {
-      const kc = getAgentApiKey(name);
-      if (kc) {
-        mergedProviders[name] = {
-          ...(mergedProviders[name] || {}),
-          apiKey: kc,
-          enabled: raw.providers?.[name]?.enabled !== false,
-        };
-      }
+      const kc = storedKey(name);
+      if (kc) mergedProviders[name] = withKey(mergedProviders[name], name, kc);
     }
   }
   // Custom providers: the keychain account is the generated custom-<uuid> id.
@@ -61,8 +67,8 @@ export function mergeStoredProviders({ raw, defaults, includeSecrets }) {
   if (includeSecrets) {
     for (const [name, val] of Object.entries(mergedProviders)) {
       if (val?.type !== 'custom' || !name.startsWith('custom-') || val.auth === 'none') continue;
-      const kc = getAgentApiKey(name);
-      if (kc) mergedProviders[name] = { ...val, apiKey: kc, enabled: raw.providers?.[name]?.enabled !== false };
+      const kc = storedKey(name);
+      if (kc) mergedProviders[name] = withKey(val, name, kc);
     }
   }
   // Cursor account access is OAuth-only. The dashboard's "API"

package/src/runtime/agent/orchestrator/config-storage.mjs

@@ -103,6 +103,7 @@ export function normalizeMaintenanceRoutes(rawMaint) {
     const effort = String(value.effort || '').trim();
     if (effort) route.effort = effort;
     if (value.fast === true) route.fast = true;
+    if (value.autoEffort === false) route.autoEffort = false;
     out[slot] = route;
   }
   return out;

package/src/runtime/agent/orchestrator/config.mjs

@@ -4,10 +4,7 @@ import { mergeStoredProviders } from './config-providers-merge.mjs';
 import { normalizeExtensionScopes } from '../../shared/extension-scopes.mjs';
 import { applyConfigPatch, diffConfig } from '../../shared/config-patch.mjs';
 import { normalizeWorkflowSelection } from '../../shared/orchestration.mjs';
-import {
-  DEFAULT_INSTRUCTION_FILES_MODE,
-  normalizeInstructionFilesMode,
-} from '../../shared/instruction-files-mode.mjs';
+import { DEFAULT_INSTRUCTION_FILES_MODE, normalizeInstructionFilesMode } from '../../shared/instruction-files-mode.mjs';
 import {
   DEFAULT_DISABLED_AGENT_ROSTER,
   canonicalizeAgentRouteStorage,
@@ -44,6 +41,8 @@ import {
 } from './config-storage.mjs';
 import { oauthCredentialProbeState, isOAuthProviderAvailable } from './providers/oauth-credential-probes.mjs';
 import { normalizeDeveloperConfig } from '../../shared/developer-options.mjs';
+import { normalizeWorktreeSettings } from '../../shared/worktrees/settings.mjs';
+import { normalizePluginMcpIntents } from './runtime-core/plugin-mcp.mjs';
 
 export const {
   PROFILE_LANGUAGES,
@@ -113,6 +112,8 @@ export function buildDefaultConfig(options = {}) {
   providers['grok-oauth'] = oauthEntry('grok-oauth');
   // Muse Code subscription (Meta Muse Spark), enabled from its stored key.
   providers['muse-code-oauth'] = oauthEntry('muse-code-oauth');
+  // Command Code Provider API, enabled from its stored Studio API key.
+  providers['command-code-oauth'] = oauthEntry('command-code-oauth');
   // Dev-only providers (Settings → Developer → Providers, one option each):
   // omitted entirely from the default config while their option is off so
   // they never surface in settings.
@@ -204,6 +205,10 @@ function storedInstructionFiles(agent) {
 
 export function loadConfig(options = {}) {
   const includeSecrets = options.secrets !== false;
+  // `secrets: 'presence'`: credentials are detected (env, OAuth files, which
+  // keychain entries exist) but no keychain value is read or attached — the
+  // availability view the model proxy answers a server with.
+  const presenceOnly = options.secrets === 'presence';
   try {
     ensureDefaultsSeparated({ stripRouteDefaults: separateStoredAgent });
   } catch (err) {
@@ -219,7 +224,7 @@ export function loadConfig(options = {}) {
       const storageNeedsMigration = agentConfigStorageNeedsMigration(raw);
       raw = canonicalizeAgentStorage(raw);
       const defaults = buildDefaultConfig({ detectCredentials: includeSecrets });
-      const mergedProviders = mergeStoredProviders({ raw, defaults, includeSecrets });
+      const mergedProviders = mergeStoredProviders({ raw, defaults, includeSecrets, presenceOnly });
       // Drop unknown maintenance keys (e.g. truly legacy slot names from
       // pre-removal installs). Every valid fallback slot lives in
       // DEFAULT_MAINTENANCE, so the allow-list below is the single
@@ -248,6 +253,7 @@ export function loadConfig(options = {}) {
       const loaded = canonicalizeAgentRouteStorage({
         providers: mergedProviders,
         mcpServers,
+        pluginMcp: normalizePluginMcpIntents(raw.pluginMcp),
         presets: withDefaultPresets(normalizedPresets),
         default: raw.default || null,
         maintenance: { ...DEFAULT_MAINTENANCE, ...normalizedMaint },
@@ -274,6 +280,7 @@ export function loadConfig(options = {}) {
         shell: raw.shell && typeof raw.shell === 'object' ? raw.shell : {},
         update: raw.update && typeof raw.update === 'object' ? { ...raw.update } : {},
         recap: recapConfig,
+        worktree: normalizeWorktreeSettings(raw.worktree),
         developer: normalizeDeveloperConfig(raw.developer),
         modules: canonicalizeModulesStorage(raw.modules) || {},
         ...(raw.builtins && typeof raw.builtins === 'object'
@@ -299,6 +306,7 @@ export function loadConfig(options = {}) {
   return {
     ...defaults,
     mcpServers: {},
+    pluginMcp: {},
     presets: DEFAULT_PRESETS.map((p) => ({ ...p })),
     default: null,
     maintenance: { ...DEFAULT_MAINTENANCE },
@@ -316,6 +324,7 @@ export function loadConfig(options = {}) {
     shell: {},
     update: {},
     recap: { enabled: true },
+    worktree: normalizeWorktreeSettings(null),
     developer: {},
     modules: {},
     // No stored section at all is a brand-new profile: its built-ins start
@@ -421,9 +430,14 @@ function buildAgentSaveBuilder(config) {
       shell,
       update: config.update || {},
       recap: config.recap || {},
+      ...(config.worktree ? { worktree: config.worktree } : {}),
       modules,
       builtins,
     };
+    // Per-server intent for plugin-declared MCP servers; empty stays absent.
+    const pluginMcp = normalizePluginMcpIntents(config.pluginMcp);
+    if (Object.keys(pluginMcp).length) next.pluginMcp = pluginMcp;
+    else delete next.pluginMcp;
     // Developer options (developer-options.mjs); an empty set stays absent.
     if (Object.keys(developer).length) next.developer = developer;
     else if (Object.hasOwn(config, 'developer')) delete next.developer;

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -13,11 +13,12 @@ export {
   collectSkillsCached,
   filterSkillsExcludingDisabled,
   invalidateSkillsCache,
-  invalidateSkillsMtimeGate,
   isSkillDisabled,
   loadSkillResource,
   skillBodyPresentInSession,
   skillMissingFeature,
+  skillOutsideScope,
+  skillOutsideScopeError,
 } from './skill-catalog.mjs';
 export {
   composeSystemPrompt,

package/src/runtime/agent/orchestrator/context/deferred-tools.mjs

@@ -1,4 +1,5 @@
 // Deferred-pool and MCP-instruction manifests injected into BP2.
+import { parseMcpToolName } from '../../../shared/tool-primitives.mjs';
 
 export function compactPromptManifestText(value, max = 250) {
   const text = String(value || '')
@@ -100,16 +101,21 @@ function sanitizeMcpInstructionText(text, max = MCP_INSTRUCTION_MAX_CHARS) {
  * names per server doubled the MCP share of the BP2 prefix (2026-08-05 audit).
  * Server membership stays evident from the mcp__<server>__ name prefix.
  */
-function buildMcpInstructionsManifest(mcpServerInstructions, poolNames) {
+function buildMcpInstructionsManifest(mcpServerInstructions, poolNames, catalog = []) {
   const map = mcpServerInstructions && typeof mcpServerInstructions === 'object' ? mcpServerInstructions : {};
   const pool = [
     ...new Set((Array.isArray(poolNames) ? poolNames : []).map((name) => sanitizeManifestName(name)).filter(Boolean)),
   ];
+  // Tool definitions carry their server (shortened names cannot be parsed).
+  const byName = new Map();
+  for (const tool of Array.isArray(catalog) ? catalog : []) {
+    const name = String(tool?.name || '').trim();
+    if (name && !byName.has(name)) byName.set(name, tool);
+  }
   const deferredServers = new Set();
   for (const name of pool) {
-    const match = name.match(/^mcp__(.+?)__(.+)$/);
-    if (!match) continue;
-    deferredServers.add(match[1]);
+    const server = parseMcpToolName(byName.get(name) || name)?.server;
+    if (server) deferredServers.add(server);
   }
   const servers = [...deferredServers]
     .filter((server) => sanitizeManifestName(server) && sanitizeMcpInstructionText(map[server]))
@@ -170,7 +176,7 @@ function composeDeferredBp2Manifest(session, pool) {
   const parts = [];
   const deferredManifest = buildDeferredToolManifest(deferredManifestEntries(session, pool));
   if (deferredManifest) parts.push(deferredManifest);
-  const mcpManifest = buildMcpInstructionsManifest(session.mcpServerInstructions, pool);
+  const mcpManifest = buildMcpInstructionsManifest(session.mcpServerInstructions, pool, session.deferredToolCatalog);
   if (mcpManifest) parts.push(mcpManifest);
   return parts.join('\n\n');
 }