mixdog 1.3.5 → 1.4.1

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

@@ -5,55 +5,22 @@
  */
 
 import { clean } from '../runtime/shared/clean.mjs';
-
-const lower = (value) => clean(value).toLowerCase();
-
-// A pinned model named by its catalog display name ("GPT-6.1-Sol") is not a
-// wire id. Canonicalize it only on an unambiguous EXACT match: the id itself,
-// or a display name / label, case-insensitively, within the requested provider
-// (or across providers when none is given and exactly one row matches).
-// Anything else — no match, several matches, an empty or partial catalog —
-// returns the args unchanged: the catalog never refuses a model and never
-// substitutes a near one.
-export function canonicalizePinnedModel(args, rows) {
-  const model = clean(args?.model);
-  if (!model || !Array.isArray(rows)) return args;
-  const provider = lower(args.provider);
-  const pool = rows.filter((row) => row && (!provider || lower(row.provider) === provider));
-  const wanted = model.toLowerCase();
-  const exactId = pool.filter((row) => row.id === model);
-  // A partial catalog may lack the real id a display name collides with, so
-  // only an exact id can pass there; aliases wait for a complete catalog.
-  const partial = pool.some((row) => row.catalogPartial === true);
-  const hits = exactId.length
-    ? exactId
-    : partial
-      ? []
-      : pool.filter((row) => lower(row.id) === wanted || lower(row.display) === wanted || lower(row.label) === wanted);
-  const distinct = [...new Map(hits.map((row) => [`${row.provider}\n${row.id}`, row])).values()];
-  if (distinct.length !== 1) return args;
-  const [hit] = distinct;
-  if (hit.id === model && hit.provider === args.provider) return args;
-  return { ...args, provider: hit.provider, model: hit.id };
-}
+import { resolveRequestedModel } from './services/agent-tool/model-select.mjs';
 
 // `listProviderModels` is this runtime's provider catalog. The agent control
 // behind `executeAgentControl` (the daemon's canonical agent) has none, so a
-// display-name model is canonicalized here before it is forwarded. Only the
-// cached/quick catalog is read, so a spawn never waits on provider listings.
+// pinned model is resolved here, by the same rule the in-process agent tool
+// applies (exact id, display name, then every query word; ambiguous or
+// unknown names fail with candidates), and forwarded as the exact route.
 export function createRoutedAgentTool({ rt, agentTool, executeAgentControl = null, listProviderModels = null }) {
   const routedAgentTool = {
     ...agentTool,
     async execute(args, context = {}) {
       if (typeof executeAgentControl !== 'function') return agentTool.execute(args, context);
-      let routedArgs = args;
-      if (typeof listProviderModels === 'function' && clean(args?.model) && (clean(args.type) || 'spawn') === 'spawn') {
-        try {
-          routedArgs = canonicalizePinnedModel(args, await listProviderModels({ quick: true }));
-        } catch {
-          routedArgs = args;
-        }
-      }
+      const routedArgs =
+        typeof listProviderModels === 'function' && clean(args?.model) && (clean(args.type) || 'spawn') === 'spawn'
+          ? await resolveRequestedModel(args, listProviderModels)
+          : args;
       return executeAgentControl(routedArgs, context);
     },
     closeAll(reason, scope = {}) {

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/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
@@ -21,7 +22,10 @@ import { TOOL_DEFS as OFFICE_TOOL_DEFS } from '../../runtime/office/tool-defs.mj
 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 {
+  ASK_USER_TOOL_DEFS,
+  HANDOFF_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';
@@ -144,7 +148,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) });
@@ -168,6 +174,7 @@ function wireToolSurface(boot) {
     visualizeToolDefs: VISUALIZE_BRIDGE_TOOL_DEFS,
     setupToolDefs: SETUP_TOOL_DEFS,
     askUserToolDefs: ASK_USER_TOOL_DEFS,
+    handoffUserToolDefs: HANDOFF_USER_TOOL_DEFS,
     reactionToolDefs: REACTION_TOOL_DEFS,
     goalTools: goalRuntime.tools,
     agentTools: agentTool.tools,
@@ -234,6 +241,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-status.mjs

@@ -1,8 +1,9 @@
 /**
  * `session bots`: the state of the user's bots, read on demand (never injected
  * into a turn). One line per bot: its home chat (`sess_home_<id>`), the last
- * activity there and its latest line, whether it works now (its chat, or a
- * task session it runs), approvals waiting on the user, its routines and what
+ * activity there and its latest line, whether it works now (its chat, or work
+ * it sent running in a task session; a turn the user typed there is the
+ * user's), approvals waiting on the user, its routines and what
  * needs attention. With one bot (`session_id`: its id or chat id): its
  * routines, its held requests and its recent sessions.
  *
@@ -143,7 +144,7 @@ function span(ms) {
 const ago = (at, now) => `${span(now - at)} ago`;
 const until = (at, now) => (at <= now ? 'due now' : `in ${span(at - now)}`);
 
-async function defaultListBots() {
+export async function defaultListBots() {
   const [{ workflowHelpers }, { getPluginData, loadConfig }, { isAgentDisabled, isContactAgentId }] = await Promise.all(
     [
       import('./boot/shared.mjs'),
@@ -264,7 +265,12 @@ export function createBotStatus({
     const homeId = agentHomeSessionId(bot.id);
     const owned = ctx.owned.get(bot.id) || [];
     const home = ctx.rows.get(homeId) || null;
-    // Running task sessions: a turn whose report is still owed, or one working now.
+    // Work this bot sent that is running now: a session working with the bot's
+    // send in flight (`handedBy`, bot-owned-work.mjs). A turn the user typed
+    // in the bot's task session is the user's, not the bot working.
+    const sentWork = (row) => isWorking(row) && row.handedBy?.includes(bot.id) === true;
+    // Running task sessions: a turn whose report is still owed, or the bot's
+    // work running now.
     const tasks = new Map();
     const addTask = (id, title, at) => {
       const known = tasks.get(id);
@@ -276,7 +282,7 @@ export function createBotStatus({
       addTask(watch.taskSessionId, watch.title, Number(watch.at) || 0);
     }
     for (const row of owned) {
-      if (row.id === homeId || roomMemberOfSession(row.id) || !isWorking(row)) continue;
+      if (row.id === homeId || roomMemberOfSession(row.id) || !sentWork(row)) continue;
       addTask(row.id, row.title, Number(row.createdAt) || 0);
     }
     const running = [...tasks.values()].sort((left, right) => left.at - right.at || (left.id < right.id ? -1 : 1));
@@ -302,7 +308,7 @@ export function createBotStatus({
       approvals,
       routines,
       flags,
-      working: isWorking(home) || running.some((task) => isWorking(ctx.rows.get(task.id))),
+      working: isWorking(home) || running.some((task) => sentWork(ctx.rows.get(task.id))),
       lastAt: activityOf(home),
     };
   }

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

@@ -0,0 +1,38 @@
+// A bot id as the `session_id` of read, send and status: a bot's chat is a
+// session of its own (`sess_home_<id>`), but the schema also lets a model name
+// the bot (`bots` takes either), so the id resolves to that home chat — before
+// any check of the target, so the bot-chain, hop and task-origin checks see
+// the chat they would for `sess_home_<id>`. A minted session id always has an
+// underscore, a normalized bot id never does (agent-home.mjs), so only ids
+// shaped like a bot id are looked up.
+import { MIXY_AGENT_ID, agentHomeSessionId } from '../runtime/agent/orchestrator/session/agent-home.mjs';
+import { defaultListBots, quotedText } from './bot-status.mjs';
+
+const MAX_NAMED_BOTS = 30;
+/** The actions whose `session_id` may be a bot id. */
+export const BOT_TARGET_ACTIONS = new Set(['read', 'send', 'status']);
+
+/** The ids of the bots a send can reach: Mixy and every contact agent. */
+async function botIds(listBots) {
+  return [MIXY_AGENT_ID, ...(await listBots()).map((bot) => bot.id)];
+}
+
+/** `target`'s home chat when it is a known bot id, else `target` unchanged. */
+export async function resolveBotTarget(target, listBots = defaultListBots) {
+  const home = agentHomeSessionId(target);
+  return home && (await botIds(listBots)).includes(target) ? home : target;
+}
+
+/** Whether `target` is shaped like a bot id (so, with no session, a mistyped one). */
+export const isBotShaped = (target) => agentHomeSessionId(target) !== '';
+
+/** The error for a bot-shaped `target` that is neither a known bot nor a session. */
+export async function unknownBotError(target, listBots = defaultListBots, cause) {
+  const ids = await botIds(listBots);
+  const named = ids.slice(0, MAX_NAMED_BOTS).join(', ');
+  const more = ids.length > MAX_NAMED_BOTS ? `, … (${ids.length - MAX_NAMED_BOTS} more)` : '';
+  return new Error(
+    `session: "${quotedText(target, 64)}" is neither a session nor a known bot id; bot ids: ${named}${more}; session action=list finds session ids`,
+    cause ? { cause } : undefined
+  );
+}

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

@@ -12,7 +12,12 @@ import {
   testWebhook,
   withScheduleRenameReserved,
 } from './services/channel-admin.mjs';
-import { getSchedule, markScheduleFailure, markScheduleSkipped, 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';

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;
+}