mixdog 1.3.4 → 1.4.0

package/src/session-runtime/boot/apis.mjs

@@ -107,8 +107,17 @@ export function wireApis(boot) {
     try {
       boot.resourceApi.migratePluginMcpCopies();
     } catch (error) {
+      console.warn(`[mcp] adopting plugin MCP copies failed: ${error?.message || error}`);
       bootProfile('plugin-mcp:adopt-failed', { error: error?.message || String(error) });
     }
+    // One server per multi-account connector: `gmail`, `gmail-2`… merge into
+    // `gmail` holding the accounts (their sign-ins and app passwords stay).
+    try {
+      boot.resourceApi.migrateConnectorAccounts();
+    } catch (error) {
+      console.warn(`[connectors] merging connector accounts failed: ${error?.message || error}`);
+      bootProfile('connector-accounts:merge-failed', { error: error?.message || String(error) });
+    }
   }
   boot.disposeGlobalExtensionSubscription = () => {
     boot.disposeConfigSync?.();

package/src/session-runtime/boot/begin.mjs

@@ -8,7 +8,7 @@ import { createProviderReadiness } from '../provider-readiness.mjs';
 import { createRoutePreparationGate } from '../route-preparation.mjs';
 import { createRuntimeFeatureGates } from '../runtime-feature-gates.mjs';
 import { createLazyRuntimeModules } from '../runtime-modules.mjs';
-import { normalizeToolProfile } from '../../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
+import { sessionToolProfile } from '../../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
 
 // The boot record: `rt` (shared mutable runtime state, promoted from closure
 // `let`s so extracted modules read/write live values through one reference),
@@ -18,13 +18,14 @@ import { normalizeToolProfile } from '../../runtime/agent/orchestrator/runtime-c
 export function beginBoot(params) {
   const { provider, model, toolMode, cwd, toolProfile, approvalMode, disallowDelegation } = params;
   const rt = {};
-  rt.toolProfile = normalizeToolProfile(toolProfile);
   rt.approvalMode = approvalMode === 'implicit' ? 'implicit' : null;
   rt.disallowDelegation = disallowDelegation === true;
   rt.mcpScopeId = randomUUID();
   rt.desktopSession = params.desktopSession;
   rt.sessionProfile =
     params.sessionProfile && typeof params.sessionProfile === 'object' ? { ...params.sessionProfile } : null;
+  // A heartbeat run's session is fenced to its few tools (tool-profile.mjs).
+  rt.toolProfile = sessionToolProfile({ toolProfile, sessionProfile: rt.sessionProfile });
   bootProfile('session-runtime:start', { provider, model, toolMode, cwd });
   // Last assistant text handed to the transcript writer (via onAssistantText),
   // so the post-turn final-content append can skip an exact duplicate.

package/src/session-runtime/boot/infrastructure.mjs

@@ -20,6 +20,7 @@ import { listProjectsStrict } from '../../runtime/shared/projects.mjs';
 import { isWithin } from '../../runtime/shared/worktrees/paths.mjs';
 import { standaloneDataDir } from '../runtime-paths.mjs';
 import { SessionAddressError, isAdmissionOpen, ownerLifecycle } from '../session-address.mjs';
+import { syncSessionCompaction, usesInjectedConfig } from '../session-compaction-sync.mjs';
 import { dataDirOf } from './shared.mjs';
 
 export function wireInfrastructure(boot) {
@@ -187,6 +188,9 @@ export function sessionAdopter(boot) {
       }
     }
     rt.session = v;
+    // A resumed or swapped-in session keeps the compaction it was saved with
+    // unless it follows the current global settings (not on an injected config).
+    if (v?.id && !usesInjectedConfig(boot.params)) syncSessionCompaction(v, rt.config);
     // The PreToolUse/PostToolUse bridge is a non-enumerable property that
     // neither the store nor a resumed record carries: every session installed
     // here (create, resume, route swap, clear, the manager's copy) gets it, so

package/src/session-runtime/boot/providers.mjs

@@ -31,6 +31,7 @@ import {
 } from '../model-recency.mjs';
 import { createNativeWebSearch } from '../native-web-search.mjs';
 import { createConfigLifecycle } from '../config-lifecycle.mjs';
+import { usesInjectedConfig } from '../session-compaction-sync.mjs';
 import { createQuickModelRows } from '../quick-model-rows.mjs';
 import { createProviderModels } from '../provider-models.mjs';
 import { createProviderUsage } from '../provider-usage.mjs';
@@ -66,6 +67,8 @@ function wireConfigLifecycle(boot) {
       rt.configHasSecrets = next;
     },
     getRoute: () => rt.route,
+    getSession: () => rt.session,
+    fixedSessionCompaction: usesInjectedConfig(boot.params),
     setRouteState: (next) => {
       rt.route = next;
     },

package/src/session-runtime/boot/tools.mjs

@@ -9,6 +9,7 @@ import {
   channelNotificationSessionId,
 } from '../../runtime/shared/channel-notification-routing.mjs';
 import { CHANNEL_NOTIFICATION_METHOD } from '../services/channel-session-router.mjs';
+import { PROMPT_ORIGIN_CHANNEL } from '../../runtime/agent/orchestrator/session/manager/pending-message-entry.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
 // Desktop-app bridges: tiny fs/fetch clients, so a static import adds no
 // meaningful boot cost. The tools themselves are gated per session by the
@@ -22,6 +23,7 @@ import { TOOL_DEFS as MEDIA_TOOL_DEFS } from '../../runtime/media/tool-defs.mjs'
 import { TOOL_DEFS as TIDY_TOOL_DEFS } from '../../runtime/tidy/tool-defs.mjs';
 import { TOOL_DEFS as VISUALIZE_BRIDGE_TOOL_DEFS } from '../../runtime/visualize-bridge/tool-defs.mjs';
 import { ASK_USER_TOOL_DEFS } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
+import { REACTION_TOOL_DEFS } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { SETUP_TOOL_DEFS } from '../setup-tool/tool-defs.mjs';
 import { createSetupToolExecutor } from '../setup-tool/executor.mjs';
 import { bootProfile } from '../boot-profile.mjs';
@@ -143,7 +145,9 @@ function wireChannels(boot) {
       const meta = p.meta && typeof p.meta === 'object' ? p.meta : {};
       const content = channelNotificationModelContent(p);
       if (!content) return;
-      notifySession(channelNotificationSessionId(rt.session, rt.reservedSessionId), content, meta);
+      notifySession(channelNotificationSessionId(rt.session, rt.reservedSessionId), content, meta, {
+        origin: PROMPT_ORIGIN_CHANNEL,
+      });
     },
   });
   bootProfile('channels:worker-ready', { ms: (performance.now() - channelsStartedAt).toFixed(1) });
@@ -167,6 +171,7 @@ function wireToolSurface(boot) {
     visualizeToolDefs: VISUALIZE_BRIDGE_TOOL_DEFS,
     setupToolDefs: SETUP_TOOL_DEFS,
     askUserToolDefs: ASK_USER_TOOL_DEFS,
+    reactionToolDefs: REACTION_TOOL_DEFS,
     goalTools: goalRuntime.tools,
     agentTools: agentTool.tools,
     skillToolEnabled: !envFlag('MIXDOG_DISABLE_SKILLS'),
@@ -232,6 +237,8 @@ function wireInternalTools(boot) {
     getCallerSession: (sessionId) =>
       sessionId === rt.session?.id ? rt.session : boot.mgr?.getSession?.(sessionId) || null,
     flushSettings: () => boot.flushAllConfigSavesAsync({ requireSaved: true }),
+    // Another session's route and quota actions (daemon-session-control.mjs); null without a daemon.
+    executeSessionControl: boot.params.executeSessionControl || null,
   });
   const disposeInternalTools = internalTools.setInternalToolsProvider({
     scopeId: rt.mcpScopeId,

package/src/session-runtime/bot-chain.mjs

@@ -0,0 +1,32 @@
+// The bot-to-bot chain a session acts in (bot-hops.mjs botChainOf), from
+// trusted runtime state only: the session's own turn chain (stamped from the
+// submission that started it) and its delegation ancestry (parentSessionId /
+// ownerSessionId), never from tool input.
+import { resolveSessionMode } from '../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { botChainOf, turnBotChainOf } from '../runtime/shared/bot-hops.mjs';
+
+const clean = (value) => String(value ?? '').trim();
+
+/** The agent `session` acts as, by the session-mode resolver: a Lead its
+ *  resolved agent (a coding Lead Mixy), a delegated worker its role. */
+export function actingAgentOf(session, sessionId = '') {
+  const { agentId } = resolveSessionMode({ session, sessionId });
+  return clean(agentId || session?.agent);
+}
+
+/** The chain session `sessionId` acts in, oldest first, ending with the agent
+ *  it acts as (when it has one): walking parentSessionId/ownerSessionId up
+ *  from it, each session contributes its current turn's chain, then the
+ *  agent it acts as. The visited set ends a malformed cycle. */
+export function delegationChainOf(sessionId, getSession = () => null) {
+  const chain = [];
+  const seen = new Set();
+  for (let id = clean(sessionId); id && !seen.has(id); ) {
+    seen.add(id);
+    const session = getSession(id) || null;
+    const acting = actingAgentOf(session, id);
+    chain.unshift(...turnBotChainOf(session), ...(acting ? [acting] : []));
+    id = clean(session?.parentSessionId || session?.ownerSessionId);
+  }
+  return botChainOf(chain);
+}

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

@@ -20,7 +20,8 @@
  * — the human's own sessions (Mixy's home, an ordinary Lead session) see every
  * bot; a bot's chat, a room seat or an unattended run (a routine, even one in
  * Mixy's own chat) only its own bot; a background run none. `session list`
- * follows the same scope.
+ * names every session for every scope, but gives previews and bot details
+ * only for the sessions the scope sees here (a background run none).
  *
  * Titles and previews are other bots' words: tag-shaped text is escaped and
  * the answer says they are data, not instructions (UNTRUSTED_NOTE).
@@ -63,8 +64,10 @@ const cut = (text, max) => (text.length > max ? `${text.slice(0, Math.max(0, max
 export const quotedText = (value, max) => cut(escapeHarnessTags(oneLine(value)), max);
 const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`;
 const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
-const isWorking = (row) => row?.working === true || row?.agentWorking === true;
-const activityOf = (row) => Number(row?.lastUsedAt) || Number(row?.updatedAt) || 0;
+/** A catalog row whose session runs a turn now. */
+export const isWorking = (row) => row?.working === true || row?.agentWorking === true;
+/** A catalog row's last activity (epoch ms), 0 when unknown. */
+export const activityOf = (row) => Number(row?.lastUsedAt) || Number(row?.updatedAt) || 0;
 
 /** The bot a catalog row belongs to: its home chat, room seat or task origin; '' for none. */
 export function sessionBotOf(row) {
@@ -309,7 +312,7 @@ export function createBotStatus({
     const parts = [`${quotedText(bot.name, 40)} (${bot.id})`, `chat ${state.homeId}`];
     if (bot.self) parts.push('you');
     parts.push(state.working ? 'working' : 'idle');
-    if (state.flags.length) parts.push(`⚠ ${state.flags.join('; ')}`);
+    if (state.flags.length) parts.push(`attention: ${state.flags.join('; ')}`);
     parts.push(state.lastAt ? `last ${ago(state.lastAt, now)}` : 'no chat yet');
     if (state.running.length) {
       const [first] = state.running;

package/src/session-runtime/channel-config-api.mjs

@@ -3,19 +3,22 @@ import {
   deleteSchedule,
   deleteWebhook,
   getWebhookSecret,
+  renameScheduleHere,
   saveSchedule,
   saveWebhook,
   setScheduleEnabled,
   setWebhookEnabled,
   setWebhookConfigAsync,
   testWebhook,
+  withScheduleRenameReserved,
 } from './services/channel-admin.mjs';
-import { getSchedule, markScheduleFailure, markScheduleSuccess } from '../runtime/channels/lib/schedules-db.mjs';
+import { getSchedule, markScheduleFailure, markScheduleSkipped, markScheduleSuccess } from '../runtime/channels/lib/schedules-db.mjs';
+import { scheduleRenameUncertainError } from '../runtime/channels/lib/schedule-errors.mjs';
 import { loadEndpointConfig, readEndpointLastPayload } from '../runtime/channels/lib/webhooks-db.mjs';
 import { webhookEventSummary, webhookRunPrompt } from '../runtime/channels/lib/webhook/session-dispatch.mjs';
 import { runScheduleSession } from './schedule-session-run.mjs';
 import { runWebhookSession } from './webhook-session-run.mjs';
-import { retryRoutineDelivery } from './owned-automation-run.mjs';
+import { beginAutomationRename, retryRoutineDelivery } from './owned-automation-run.mjs';
 
 /** Why a "Run now" did not run: its owner bot is missing, or a run is going. */
 function skippedRunMessage(name, outcome) {
@@ -27,6 +30,36 @@ function skippedRunMessage(name, outcome) {
 // directly here and the runtime injects only the closure-owned callbacks
 // (channel worker handle, soft reload).
 export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAutomationRuntime = () => {} }) {
+  // The channels worker owns the scheduler and the runs it fires, so while it
+  // is up it performs the run check and the row move in one step
+  // (rename_schedule); this process's own runs ("Run now") are reserved around
+  // that call. Without a worker, the check and the move happen here.
+  async function renameSchedule(oldName, def, opts) {
+    if (!channels.status().running) return renameScheduleHere(oldName, def, opts);
+    return withScheduleRenameReserved(oldName, async () => {
+      try {
+        const reply = await channels.execute('rename_schedule', { name: oldName, def, ...opts });
+        const text = reply?.content?.[0]?.text ?? '';
+        if (reply?.isError === true) {
+          // The worker's refusal keeps its structured code and details.
+          throw Object.assign(
+            new Error(text.replace(/^rename_schedule failed: /, '')),
+            typeof reply.code === 'string' ? { code: reply.code } : {},
+            reply.details && typeof reply.details === 'object' ? { details: reply.details } : {}
+          );
+        }
+        return text ? JSON.parse(text) : null;
+      } catch (error) {
+        // Whatever the worker did, have it re-read the schedules.
+        reloadChannelsSoon();
+        // execute() already retried a transport failure (call timeout 120 s,
+        // same callId so the daemon runs the request once); what is left is
+        // an unanswered request.
+        if (error?.daemonTransportError) throw scheduleRenameUncertainError(error.message);
+        throw error;
+      }
+    });
+  }
   return {
     async getChannelSetup() {
       return channelSetup();
@@ -40,7 +73,7 @@ export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAut
       return result;
     },
     async saveSchedule(entry) {
-      const result = await saveSchedule(entry);
+      const result = await saveSchedule(entry, { rename: renameSchedule });
       reloadChannelsSoon();
       // First automation created while the app is already running: the boot-
       // time autostart check has passed, so kick the worker start path now
@@ -86,22 +119,35 @@ export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAut
     },
     async runScheduleNow(name) {
       const id = String(name || '').trim();
-      const schedule = await getSchedule(id);
-      if (!schedule) throw new Error(`schedule "${id}" does not exist`);
-      // Runs in the engine process as a turn in the owner bot's chat, so it
-      // works even while the channels worker is off.
-      let outcome;
+      // The name is held from the read of the row through the outcome stamps,
+      // so a rename can neither move the row this run read nor slip in before
+      // its stamps are written (they would land on no row).
+      const release = beginAutomationRename('schedule', id);
+      // A run or a rename holding it: not run, recorded as an overlap skip.
+      if (!release) {
+        await markScheduleSkipped(id, new Date()).catch(() => {});
+        throw new Error(skippedRunMessage(id, { reason: 'overlap' }));
+      }
       try {
-        // Asked for by a person: no failure backoff.
-        outcome = await runScheduleSession(schedule, { attended: true });
-      } catch (error) {
-        await markScheduleFailure(schedule.name, new Date()).catch(() => {});
-        throw error;
+        const schedule = await getSchedule(id);
+        if (!schedule) throw new Error(`schedule "${id}" does not exist`);
+        // Runs in the engine process as a turn in the owner bot's chat, so it
+        // works even while the channels worker is off.
+        let outcome;
+        try {
+          // Asked for by a person: no failure backoff.
+          outcome = await runScheduleSession(schedule, { attended: true, reserved: true });
+        } catch (error) {
+          await markScheduleFailure(schedule.name, new Date()).catch(() => {});
+          throw error;
+        }
+        if (outcome.skipped) throw new Error(skippedRunMessage(schedule.name, outcome));
+        // The run's outcome shows as the schedule's last run, like a timed fire.
+        await markScheduleSuccess(schedule.name, new Date()).catch(() => {});
+        return { name: schedule.name, ok: true, sessionId: outcome.sessionId, result: outcome.result };
+      } finally {
+        release();
       }
-      if (outcome.skipped) throw new Error(skippedRunMessage(schedule.name, outcome));
-      // The run's outcome shows as the schedule's last run, like a timed fire.
-      await markScheduleSuccess(schedule.name, new Date()).catch(() => {});
-      return { name: schedule.name, ok: true, sessionId: outcome.sessionId, result: outcome.result };
     },
     // Re-runs the endpoint on its latest received payload, with its current
     // instructions, behind the same untrusted-data fence as a live delivery.

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

@@ -17,6 +17,7 @@ import {
   stripStoredRouteDefaults,
   withDefaultPresets,
 } from '../runtime/agent/orchestrator/config-presets.mjs';
+import { syncSessionCompaction } from './session-compaction-sync.mjs';
 import { createConfigWriters } from './config-lifecycle/config-writers.mjs';
 import { createLeadRouteSync } from './config-lifecycle/lead-route-sync.mjs';
 import { createOutputStyleStatusCache } from './config-lifecycle/output-style-cache.mjs';
@@ -134,6 +135,10 @@ export function createConfigLifecycle({
   getConfigHasSecrets,
   setConfigHasSecrets,
   getRoute,
+  // The live session follows the reloaded global compaction settings, unless
+  // the runtime runs on an injected (headless) config.
+  getSession,
+  fixedSessionCompaction = false,
   // Main route sync on reload (both optional: a lifecycle without them never syncs)
   setRouteState,
   resolveRoute,
@@ -222,6 +227,7 @@ export function createConfigLifecycle({
     const adopted = adoptConfig(next, { hasSecrets: true });
     configSaveBaseline = structuredClone(adopted);
     leadRoute.syncEmptyMainRoute(adopted);
+    if (!fixedSessionCompaction) syncSessionCompaction(getSession?.(), adopted);
     return adopted;
   }
 

package/src/session-runtime/connector-merge-migration.mjs

@@ -0,0 +1,305 @@
+// After the multi-account connector merge (connector-catalog.mjs
+// mergeConnectorAccountServers) `gmail-2`, `google-calendar-2`… are accounts of
+// one server, no longer servers. Every store of ours that keys a setting by
+// MCP server name must name the surviving server instead:
+//   agents/<id>/agent.json, bots/<id>/agent.json   connectors.off / connectors.tools
+//                                                  (a legacy allow list too)
+//   <data>/project-connectors.json                 projects.<root>.off
+//   <data>/hooks.json, <data>/hooks/hooks.json     mcp_tool `server`, tool matchers
+// (extension scopes are the config's and are dropped by migrateConnectorAccounts;
+// an approval's "always allow" is the agent's connectors.tools; agent routes
+// name models, not servers.) Project and plugin hook files are the user's or
+// the plugin's own and are never rewritten here.
+//
+// Rule: the merged connector is OFF for an agent/project only when EVERY
+// merged server was off (the same rule as the merged server's `enabled`: one
+// working account keeps the connector usable). Per-tool permissions move to
+// the surviving name; where two merged servers disagree on a tool the MORE
+// PERMISSIVE permission wins, as "on beats off" does at server level. Entries
+// of a server that was off are dormant and are dropped when the connector
+// stays on, so they never become live. A setting that names no merged-away
+// server is never touched, which makes every run after the first a no-op.
+//
+// The merge is saved to the config once, so the rename mapping outlives it:
+// `<data>/connector-merge-pending.json` ({ merged: [{ name, from }] }) is
+// written before any store is touched and deleted only when every store
+// migrated. A store that fails (unreadable, malformed, not writable) is
+// reported and the others still go on; the next start retries them all.
+//
+// Hooks: only tool identifiers are rewritten — an `mcp_tool` handler's
+// `server`, and a matcher / tool-name field (or the tool part of an `if`
+// before its `(`) that is an `mcp__<server>__…` identifier or an
+// alternative of a pattern. Argument conditions such as `Bash(mcp__x__*)`
+// and any other data are never touched.
+import { readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { normalizeRules, standardConfigReport } from './services/hook-bus/config.mjs';
+import {
+  PERMISSION_RANK,
+  PROJECT_CONNECTORS_FILE,
+  connectorEnabled,
+  parseConnectorPolicy,
+  storedConnectorPolicy,
+} from '../runtime/agent/orchestrator/mcp/agent-connectors.mjs';
+import { parseJsonText, withFileLockSync, writeJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
+
+const unique = (list) => [...new Set(list)].sort();
+
+/** The policy `{ off, tools }` (or a legacy `{ allow, off, tools }`) with every
+ *  merged-away server of `merged` mapped onto its surviving one; null when it
+ *  names none. `merged` is mergeConnectorAccountServers' `merged`. */
+function mapMergedConnectorPolicy(policy, merged) {
+  let current = policy;
+  for (const { name, from } of merged) {
+    const gone = from.filter((server) => server !== name);
+    const named = (server) =>
+      current.off.includes(server) || current.allow?.includes(server) || Object.hasOwn(current.tools, server);
+    if (!gone.some(named)) continue;
+    const live = from.filter((server) => connectorEnabled(current, server));
+    const on = live.length > 0;
+    const off = current.off.filter((server) => !from.includes(server));
+    const allow = current.allow?.filter((server) => !from.includes(server));
+    if (allow && on) allow.push(name);
+    if (!allow && !on) off.push(name);
+    const tools = { ...current.tools };
+    for (const server of from) delete tools[server];
+    const moved = {};
+    for (const server of on ? live : from) {
+      for (const [tool, permission] of Object.entries(current.tools[server] || {})) {
+        if (!(tool in moved) || PERMISSION_RANK[permission] > PERMISSION_RANK[moved[tool]]) moved[tool] = permission;
+      }
+    }
+    if (Object.keys(moved).length) tools[name] = moved;
+    current = { ...(allow ? { allow: unique(allow) } : {}), off: unique(off), tools };
+  }
+  return current === policy ? null : current;
+}
+
+/** A mapped policy as the value the agent.json `connectors` field stores
+ *  (undefined: the field goes). */
+function storedValue(policy) {
+  if (!policy.allow) return storedConnectorPolicy(policy) ?? undefined;
+  const ids = unique([...policy.allow, ...Object.keys(policy.tools)]);
+  return ids.map((id) => ({
+    id,
+    enabled: policy.allow.includes(id),
+    ...(policy.tools[id] ? { tools: policy.tools[id] } : {}),
+  }));
+}
+
+export const PENDING_MERGE_FILE = 'connector-merge-pending.json';
+
+const warn = (file, error) => process.stderr.write(`[connectors] ${file} not migrated (${error?.message || error})\n`);
+
+/** The JSON at `file`; null when it does not exist. Any other failure throws. */
+function readJsonFile(file) {
+  try {
+    return parseJsonText(readFileSync(file, 'utf8'));
+  } catch (error) {
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') return null;
+    throw error;
+  }
+}
+
+const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+/** Runs `step` for one store; a failure is reported and returned, never thrown. */
+function attempt(file, step, outcome) {
+  try {
+    step();
+  } catch (error) {
+    warn(file, error);
+    outcome.failed.push(file);
+  }
+}
+
+function migrateAgentFiles(dataDir, merged, outcome, readdir) {
+  for (const store of ['agents', 'bots']) {
+    const dir = join(dataDir, store);
+    let entries;
+    try {
+      entries = readdir(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    } catch (error) {
+      // A store that does not exist has nothing to migrate; any other failure
+      // leaves its agents unprocessed, so the mapping must stay pending.
+      if (error?.code !== 'ENOENT') {
+        warn(dir, error);
+        outcome.failed.push(dir);
+      }
+      continue;
+    }
+    for (const entry of entries) {
+      const file = join(dataDir, store, entry.name, 'agent.json');
+      attempt(
+        file,
+        () => {
+          const manifest = readJsonFile(file);
+          if (!isRecord(manifest) || manifest.connectors == null) return;
+          const next = mapMergedConnectorPolicy(parseConnectorPolicy(manifest.connectors), merged);
+          if (!next) return;
+          const value = storedValue(next);
+          if (value) manifest.connectors = value;
+          else delete manifest.connectors;
+          writeJsonAtomicSync(file, manifest, { backup: true });
+          outcome.agents.push(`${store}/${entry.name}`);
+        },
+        outcome
+      );
+    }
+  }
+}
+
+function migrateProjectFile(dataDir, merged, outcome) {
+  const file = join(dataDir, PROJECT_CONNECTORS_FILE);
+  attempt(
+    file,
+    () => {
+      withFileLockSync(`${file}.lock`, () => {
+        const document = readJsonFile(file);
+        const projects = document?.projects;
+        if (!isRecord(projects)) return;
+        const changed = [];
+        for (const [root, entry] of Object.entries(projects)) {
+          if (!isRecord(entry) || !Array.isArray(entry.off)) continue;
+          const next = mapMergedConnectorPolicy({ off: entry.off.map(String), tools: {} }, merged);
+          if (!next) continue;
+          if (next.off.length) projects[root] = { ...entry, off: next.off };
+          else delete projects[root];
+          changed.push(root);
+        }
+        if (!changed.length) return;
+        writeJsonAtomicSync(file, document, { lock: false, backup: true });
+        outcome.projects.push(...changed);
+      });
+    },
+    outcome
+  );
+}
+
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/** A tool identifier or pattern (`mcp__a__x`, `^mcp__a__.*$`, `Bash|mcp__a__x`)
+ *  with each `mcp__<merged-away>` alternative renamed. */
+function renameToolPattern(value, renames) {
+  let next = value;
+  for (const [gone, name] of renames) {
+    const identifier = new RegExp(`(^|\\|)(\\^?)mcp__${escapeRegExp(gone)}(?=__|(?![A-Za-z0-9_-]))`, 'g');
+    next = next.replace(identifier, (_all, lead, anchor) => `${lead}${anchor}mcp__${name}`);
+  }
+  return next;
+}
+
+/** A condition `Tool(arguments)`: only the tool part is an identifier. */
+function renameCondition(value, renames) {
+  const open = value.indexOf('(');
+  return open < 0
+    ? renameToolPattern(value, renames)
+    : renameToolPattern(value.slice(0, open), renames) + value.slice(open);
+}
+
+/** Renames in the hook structures of `document` (in place); true when any changed. */
+function renameInHooks(document, renames) {
+  let changed = false;
+  const set = (owner, key, rename) => {
+    if (typeof owner[key] !== 'string') return;
+    const next = rename(owner[key], renames);
+    if (next === owner[key]) return;
+    owner[key] = next;
+    changed = true;
+  };
+  const handler = (hook) => {
+    if (!isRecord(hook)) return;
+    if (hook.type === 'mcp_tool') {
+      if (typeof hook.server === 'string' && renames.has(hook.server.trim())) {
+        hook.server = renames.get(hook.server.trim());
+        changed = true;
+      }
+      set(hook, 'tool', renameToolPattern);
+    }
+    set(hook, 'if', renameCondition);
+  };
+  if (standardConfigReport(document).standard) {
+    for (const groups of Object.values(document.hooks)) {
+      for (const group of Array.isArray(groups) ? groups : []) {
+        if (!isRecord(group)) continue;
+        set(group, 'matcher', renameToolPattern);
+        set(group, 'if', renameCondition);
+        for (const hook of Array.isArray(group.hooks) ? group.hooks : []) handler(hook);
+      }
+    }
+  } else {
+    for (const rule of normalizeRules(document)) {
+      if (!isRecord(rule)) continue;
+      set(rule, 'tool', renameToolPattern);
+      set(rule, 'name', renameToolPattern);
+      set(rule, 'if', renameCondition);
+    }
+  }
+  return changed;
+}
+
+function migrateHookFiles(dataDir, merged, outcome) {
+  const renames = new Map(
+    merged.flatMap(({ name, from }) => from.filter((server) => server !== name).map((gone) => [gone, name]))
+  );
+  for (const file of [join(dataDir, 'hooks.json'), join(dataDir, 'hooks', 'hooks.json')]) {
+    attempt(
+      file,
+      () => {
+        const document = readJsonFile(file);
+        if (!isRecord(document) && !Array.isArray(document)) return;
+        if (!renameInHooks(document, renames)) return;
+        writeJsonAtomicSync(file, document, { backup: true });
+        outcome.hooks.push(file);
+      },
+      outcome
+    );
+  }
+}
+
+const validGroup = (group) =>
+  isRecord(group) &&
+  typeof group.name === 'string' &&
+  Array.isArray(group.from) &&
+  group.from.every((n) => typeof n === 'string');
+
+/** Maps every per-server setting of `dataDir` onto the surviving servers of
+ *  `merged` (this start's merge, [] to only retry) plus any still pending from
+ *  an earlier start. Returns what it rewrote and the files that failed:
+ *  `{ agents, projects, hooks, failed, unrecorded? }`. The pending record is
+ *  removed only when `failed` is empty; `unrecorded` says it could not be
+ *  written, so the caller must not save the merge. `readdir` lists the agent
+ *  and bot directories. */
+export function migrateMergedConnectorServers(dataDir, merged, { readdir = readdirSync } = {}) {
+  const outcome = { agents: [], projects: [], hooks: [], failed: [] };
+  if (!dataDir) return outcome;
+  const pendingFile = join(dataDir, PENDING_MERGE_FILE);
+  let pending = [];
+  try {
+    const stored = readJsonFile(pendingFile)?.merged;
+    pending = Array.isArray(stored) ? stored.filter(validGroup).map(({ name, from }) => ({ name, from })) : [];
+  } catch (error) {
+    warn(pendingFile, error);
+  }
+  const groups = [...pending];
+  for (const { name, from } of merged) {
+    if (!groups.some((group) => group.name === name && JSON.stringify(group.from) === JSON.stringify(from))) {
+      groups.push({ name, from });
+    }
+  }
+  if (!groups.length) return outcome;
+  if (groups.length !== pending.length) {
+    try {
+      writeJsonAtomicSync(pendingFile, { merged: groups }, { backup: false });
+    } catch (error) {
+      warn(pendingFile, error);
+      // Nothing records the mapping: a failed store must keep the merge unsaved.
+      outcome.unrecorded = true;
+    }
+  }
+  migrateAgentFiles(dataDir, groups, outcome, readdir);
+  migrateProjectFile(dataDir, groups, outcome);
+  migrateHookFiles(dataDir, groups, outcome);
+  if (!outcome.failed.length) rmSync(pendingFile, { force: true });
+  return outcome;
+}