mixdog 1.4.1 → 1.4.2

package/src/session-runtime/internal-tool-executor/workspace-tools.mjs

@@ -42,6 +42,140 @@ function callerAttachmentParts(rt, args, callerCwd, surface) {
   }).parts;
 }
 
+/** `session` actions that act on another session through session control
+ *  (list, bots, read, send, cancel, delete, create, status of a target). */
+async function runSessionControl(
+  { rt, executeSessionControl, listBots, getSessionManager },
+  args,
+  { action, target, callerSessionId, callerCwd }
+) {
+  // `callerAgentId`: the bot whose conversation gets results reported
+  // back; `callerBotId`: the bot the caller acts as, attended or not,
+  // for what only a bot's own sessions allow (an effort change).
+  const callerAgentId = attendedAgentOf(rt.session);
+  const acting = resolveSessionMode({ session: rt.session });
+  const callerBotId = acting.mode === AGENT_MODE ? acting.agentId : '';
+  if (action === 'create' && !callerAgentId) {
+    throw new Error(
+      'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
+    );
+  }
+  // A bot id names that bot's home chat; every check below and in the
+  // control runs on the chat it resolves to.
+  const sessionTarget = BOT_TARGET_ACTIONS.has(action) && target ? await resolveBotTarget(target, listBots) : target;
+  // A task session reaches its agent only through its reported result.
+  const origin = rt.session?.taskOrigin;
+  if (
+    action === 'send' &&
+    origin &&
+    (sessionTarget === origin.sessionId || agentIdOfHomeSession(sessionTarget) === origin.agentId)
+  ) {
+    throw new Error('session: a task session reports to its agent only through its result');
+  }
+  if (typeof executeSessionControl !== 'function') {
+    throw new Error('session: cross-session control is unavailable in this runtime');
+  }
+  const { attachments, ...rest } = args || {};
+  if (attachments !== undefined && action !== 'send' && action !== 'create') {
+    throw new Error(`session: attachments apply to send and create, not action=${action}`);
+  }
+  const attachmentParts = callerAttachmentParts(rt, args, callerCwd, 'session');
+  return JSON.stringify(
+    await executeSessionControl(
+      { ...rest, action, ...(sessionTarget !== target ? { session_id: sessionTarget } : {}) },
+      {
+        callerSessionId,
+        callerAgentId,
+        callerBotId,
+        callerCwd,
+        ...(action === 'send' || action === 'create'
+          ? {
+              callerHop: turnHopOf(rt.session),
+              // The bot chain this turn acts in (bot-chain.mjs), checked
+              // against the target and carried to the turn it starts —
+              // only when the sender is a bot conversation (a bot's chat,
+              // room seat or run); any other session hands work to any
+              // bot as before, whatever started its turn (the hop limit
+              // still bounds a loop).
+              callerBotChain: callerBotId
+                ? delegationChainOf(callerSessionId, (id) =>
+                    id === rt.session?.id ? rt.session : getSessionManager()?.getSession?.(id) || null
+                  )
+                : [],
+            }
+          : {}),
+        // Whether a create may provision a worktree (worktree-access.mjs).
+        ...(action === 'create' ? { callerScope: worktreeCallerScope(rt.session) } : {}),
+        // Which bots and sessions it may see (bot-status.mjs).
+        ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
+        ...(attachmentParts.length ? { attachmentParts } : {}),
+      }
+    )
+  );
+}
+
+/** `session action=rename`: the AI title of the Lead session, mirrored onto the live session. */
+async function renameSession({ rt, getSessionManager }, action, sessionId, args) {
+  if (rt.config?.aiSessionTitles === false) throw new Error('session: AI session titles are disabled in settings');
+  const title = clean(args?.title);
+  if (!title) throw new Error('session: title is required for action=rename');
+  const result = await getSessionManager()?.updateSessionAiTitle(sessionId, title);
+  if (!result?.ok) {
+    throw new Error(
+      result?.reason === 'user-title' ? USER_TITLE_ERROR : `session: rename failed (${result?.reason || 'unavailable'})`
+    );
+  }
+  // Mirror the store's truth onto the live session, never the AI title
+  // itself: a manual rename that landed while the save was awaited wins.
+  const stored = getSessionManager()?.getSession?.(sessionId);
+  if (stored && rt.session?.id === sessionId && stored !== rt.session) {
+    rt.session.title = stored.title;
+    rt.session.titleLocked = stored.titleLocked;
+    rt.session.titleSource = stored.titleSource;
+    rt.session.titleUpdatedAt = stored.titleUpdatedAt;
+  }
+  if (stored && stored.titleSource === 'user') throw new Error(USER_TITLE_ERROR);
+  return JSON.stringify({ action, sessionId, title: result.title }, null, 2);
+}
+
+/** `session action=fork`: inherit the Lead session into a new one. */
+async function forkSession(getLifecycleApi, action, sessionId, args) {
+  const lifecycle = getLifecycleApi();
+  if (typeof lifecycle?.inheritToNewSession !== 'function') {
+    throw new Error('session: fork is unavailable in this runtime');
+  }
+  const result = await lifecycle.inheritToNewSession(sessionId, {
+    compact: args?.compact === true,
+    titleSuffix: ' (Fork)',
+  });
+  return JSON.stringify(
+    { action, sourceSessionId: sessionId, sessionId: result.sessionId, compacted: result.compacted === true },
+    null,
+    2
+  );
+}
+
+/** `session action=status`: the current session's identity, folder and route. */
+function sessionStatusJson(rt, callerCtx, currentCwd) {
+  const current = rt.session;
+  return JSON.stringify(
+    {
+      sessionId: callerCtx?.callerSessionId || current?.id || null,
+      title: current?.title || null,
+      titleSource: current?.titleSource || null,
+      cwd: currentCwd,
+      project: current?.workspace?.projectPath || current?.desktopSession?.projectPath || currentCwd,
+      provider: current?.provider || null,
+      model: current?.model || null,
+      effort: current?.effort || null,
+      autoEffort: current?.autoEffort !== false,
+      fast: current?.fast === true,
+    },
+    null,
+    2
+  );
+}
+
 export function createWorkspaceToolHandlers({
   rt,
   goalRuntime,
@@ -101,70 +235,12 @@ export function createWorkspaceToolHandlers({
       (action === 'status' && target)
     ) {
       const callerSessionId = assertLead(action, callerCtx);
-      // `callerAgentId`: the bot whose conversation gets results reported
-      // back; `callerBotId`: the bot the caller acts as, attended or not,
-      // for what only a bot's own sessions allow (an effort change).
-      const callerAgentId = attendedAgentOf(rt.session);
-      const acting = resolveSessionMode({ session: rt.session });
-      const callerBotId = acting.mode === AGENT_MODE ? acting.agentId : '';
-      if (action === 'create' && !callerAgentId) {
-        throw new Error(
-          'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
-        );
-      }
-      // A bot id names that bot's home chat; every check below and in the
-      // control runs on the chat it resolves to.
-      const sessionTarget =
-        BOT_TARGET_ACTIONS.has(action) && target ? await resolveBotTarget(target, listBots) : target;
-      // A task session reaches its agent only through its reported result.
-      const origin = rt.session?.taskOrigin;
-      if (
-        action === 'send' &&
-        origin &&
-        (sessionTarget === origin.sessionId || agentIdOfHomeSession(sessionTarget) === origin.agentId)
-      ) {
-        throw new Error('session: a task session reports to its agent only through its result');
-      }
-      if (typeof executeSessionControl !== 'function') {
-        throw new Error('session: cross-session control is unavailable in this runtime');
-      }
-      const { attachments, ...rest } = args || {};
-      if (attachments !== undefined && action !== 'send' && action !== 'create') {
-        throw new Error(`session: attachments apply to send and create, not action=${action}`);
-      }
-      const attachmentParts = callerAttachmentParts(rt, args, callerCwd, 'session');
-      return JSON.stringify(
-        await executeSessionControl(
-          { ...rest, action, ...(sessionTarget !== target ? { session_id: sessionTarget } : {}) },
-          {
-            callerSessionId,
-            callerAgentId,
-            callerBotId,
-            callerCwd,
-            ...(action === 'send' || action === 'create'
-              ? {
-                  callerHop: turnHopOf(rt.session),
-                  // The bot chain this turn acts in (bot-chain.mjs), checked
-                  // against the target and carried to the turn it starts —
-                  // only when the sender is a bot conversation (a bot's chat,
-                  // room seat or run); any other session hands work to any
-                  // bot as before, whatever started its turn (the hop limit
-                  // still bounds a loop).
-                  callerBotChain: callerBotId
-                    ? delegationChainOf(callerSessionId, (id) =>
-                        id === rt.session?.id ? rt.session : getSessionManager()?.getSession?.(id) || null
-                      )
-                    : [],
-                }
-              : {}),
-            // Whether a create may provision a worktree (worktree-access.mjs).
-            ...(action === 'create' ? { callerScope: worktreeCallerScope(rt.session) } : {}),
-            // Which bots and sessions it may see (bot-status.mjs).
-            ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
-            ...(attachmentParts.length ? { attachmentParts } : {}),
-          }
-        )
-      );
+      return runSessionControl({ rt, executeSessionControl, listBots, getSessionManager }, args, {
+        action,
+        target,
+        callerSessionId,
+        callerCwd,
+      });
     }
     // Mixy's proposals to the user (mixy-heartbeat.mjs): kept so none repeats.
     if (action === 'suggest') {
@@ -184,28 +260,7 @@ export function createWorkspaceToolHandlers({
     if (action === 'status' || action === 'list-projects' || action === 'set-project') assertLead(action, callerCtx);
     if (action === 'rename') {
       const sessionId = assertLead(action, callerCtx);
-      if (rt.config?.aiSessionTitles === false) throw new Error('session: AI session titles are disabled in settings');
-      const title = clean(args?.title);
-      if (!title) throw new Error('session: title is required for action=rename');
-      const result = await getSessionManager()?.updateSessionAiTitle(sessionId, title);
-      if (!result?.ok) {
-        throw new Error(
-          result?.reason === 'user-title'
-            ? USER_TITLE_ERROR
-            : `session: rename failed (${result?.reason || 'unavailable'})`
-        );
-      }
-      // Mirror the store's truth onto the live session, never the AI title
-      // itself: a manual rename that landed while the save was awaited wins.
-      const stored = getSessionManager()?.getSession?.(sessionId);
-      if (stored && rt.session?.id === sessionId && stored !== rt.session) {
-        rt.session.title = stored.title;
-        rt.session.titleLocked = stored.titleLocked;
-        rt.session.titleSource = stored.titleSource;
-        rt.session.titleUpdatedAt = stored.titleUpdatedAt;
-      }
-      if (stored && stored.titleSource === 'user') throw new Error(USER_TITLE_ERROR);
-      return JSON.stringify({ action, sessionId, title: result.title }, null, 2);
+      return renameSession({ rt, getSessionManager }, action, sessionId, args);
     }
     if (action === 'compact') {
       const sessionId = assertLead(action, callerCtx);
@@ -219,38 +274,10 @@ export function createWorkspaceToolHandlers({
     }
     if (action === 'fork') {
       const sessionId = assertLead(action, callerCtx);
-      const lifecycle = getLifecycleApi();
-      if (typeof lifecycle?.inheritToNewSession !== 'function') {
-        throw new Error('session: fork is unavailable in this runtime');
-      }
-      const result = await lifecycle.inheritToNewSession(sessionId, {
-        compact: args?.compact === true,
-        titleSuffix: ' (Fork)',
-      });
-      return JSON.stringify(
-        { action, sourceSessionId: sessionId, sessionId: result.sessionId, compacted: result.compacted === true },
-        null,
-        2
-      );
+      return forkSession(getLifecycleApi, action, sessionId, args);
     }
     if (action === 'status') {
-      const current = rt.session;
-      return JSON.stringify(
-        {
-          sessionId: callerCtx?.callerSessionId || current?.id || null,
-          title: current?.title || null,
-          titleSource: current?.titleSource || null,
-          cwd: currentCwd,
-          project: current?.workspace?.projectPath || current?.desktopSession?.projectPath || currentCwd,
-          provider: current?.provider || null,
-          model: current?.model || null,
-          effort: current?.effort || null,
-          autoEffort: current?.autoEffort !== false,
-          fast: current?.fast === true,
-        },
-        null,
-        2
-      );
+      return sessionStatusJson(rt, callerCtx, currentCwd);
     }
     if (action === 'list-projects') {
       return JSON.stringify(

package/src/session-runtime/lifecycle/teardown/session-close.mjs

@@ -4,6 +4,7 @@
  * tombstone barrier and the turn abort.
  */
 import { SessionClosedError } from '../../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
+import { armTurnTimeout } from '../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 import { isScratchSession } from '../shared.mjs';
 
 // SessionEnd reason mapped to standard values ('clear'/'exit' where
@@ -88,11 +89,15 @@ export function closeCanonicalSession(deps, reason = 'canonical-session-close',
   return true;
 }
 
-export function abortRuntime(deps, reason = 'cli-abort') {
+/** `options.timeout` is the progress watchdog's explicit "this abort is a
+ *  timeout": the reap is armed before either abort runs, while the turn is
+ *  still un-aborted (the outer abort cascades into the manager's controller). */
+export function abortRuntime(deps, reason = 'cli-abort', { timeout = false } = {}) {
   const { getSession, getReservedSessionId, abortActiveTurns, mgr } = deps;
   const session = getSession();
   const sessionId = session?.id || getReservedSessionId?.() || 'pending';
   const abortError = new SessionClosedError(sessionId, `runtime abort (reason=${reason})`, reason);
+  if (timeout && session?.id) armTurnTimeout(session.id);
   let outerAborted = false;
   try {
     outerAborted = abortActiveTurns?.(abortError) === true;

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

@@ -281,6 +281,6 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
   return {
     closeCanonicalSession: (reason, options) => closeCanonicalSession(deps, reason, options),
     close,
-    abort: (reason) => abortRuntime(deps, reason),
+    abort: (reason, options) => abortRuntime(deps, reason, options),
   };
 }

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

@@ -9,7 +9,7 @@ import {
   connectorOfServer,
   gmailAppPasswordAccount,
 } from '../../runtime/shared/connector-catalog.mjs';
-import { connectorAccountHealth } from '../../runtime/connectors/connector-accounts-mcp.mjs';
+import { connectorAccountHealth, connectorAccountInUse } from '../../runtime/connectors/connector-accounts-mcp.mjs';
 import { googleOAuthClient } from '../../runtime/shared/google-oauth-client.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
 import { resolveMcpServerCatalog } from './plugin-servers.mjs';
@@ -119,10 +119,12 @@ export function createMcpServerCatalog({
     };
   }
 
-  /** One account of a multi-account connector server, as its row lists it:
-   *  `{ name, email, enabled?, appPassword?, oauth?, ownClient?, error?, authRequired? }`
-   *  (`enabled: false` only for an account that is switched off). */
-  function accountRow(accountCfg, enabled) {
+  /** One account of a connector server, as its row lists it:
+   *  `{ name, email, enabled?, inUse?, appPassword?, oauth?, ownClient?, error?, authRequired? }`
+   *  (`enabled: false` only for an account that is switched off; `inUse:
+   *  true` only for the connector's last-used account, the one a call
+   *  without a conversation history uses). */
+  function accountRow(accountCfg, enabled, inUse) {
     const address = gmailAppPasswordAccount(accountCfg);
     const oauth = address ? null : mcpClient.getMcpServerOAuthState?.(accountCfg);
     const state = connectorAccountHealth(accountCfg.name);
@@ -130,6 +132,7 @@ export function createMcpServerCatalog({
     return {
       name: accountCfg.name,
       ...(enabled ? {} : { enabled: false }),
+      ...(inUse ? { inUse: true } : {}),
       email: address || oauth?.account || state?.email || '',
       ...(address ? { appPassword: { account: address } } : {}),
       ...(oauth ? { oauth } : {}),
@@ -152,11 +155,14 @@ export function createMcpServerCatalog({
         failures.get(name) || (dead ? { msg: live.error || live.lastError || 'MCP server is not alive' } : undefined);
       const entry = entries[name] || {};
       const loginPending = !(live && !dead) && mcpClient.isMcpLoginPending?.(name, getMcpScopeId()) === true;
-      const accounts = entry.owner
-        ? []
-        : connectorAccountsOf(cfg).map((account) =>
-            accountRow(connectorAccountServer(cfg, account), connectorAccountEnabled(account))
-          );
+      const stored = entry.owner ? [] : connectorAccountsOf(cfg);
+      // The connector's last-used account (none when that one was removed),
+      // else its topmost switched-on one.
+      const recorded = stored.length ? connectorAccountInUse(connectorOfServer(cfg)) : '';
+      const inUse = recorded || stored.find(connectorAccountEnabled)?.name;
+      const accounts = stored.map((account) =>
+        accountRow(connectorAccountServer(cfg, account), connectorAccountEnabled(account), account.name === inUse)
+      );
       // A connector server none of whose accounts is signed in needs a sign-in, not a repair.
       const accountsSignIn = accounts.length > 0 && accounts.every((account) => account.authRequired === true);
       const status = mcpServerStatus(

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

@@ -79,8 +79,11 @@ export function createMcpServerInput({ mcpClient, getCurrentCwd }) {
     const type = clean(input.type).toLowerCase();
     if (url) {
       const kind = URL_TRANSPORT_TYPES.get(type) || (/^wss?:\/\//i.test(url) ? 'ws' : 'http');
-      const secureUrl =
+      const normalizedUrl =
         typeof mcpClient.normalizeMcpTransportUrl === 'function' ? mcpClient.normalizeMcpTransportUrl(url, kind) : url;
+      // URL parsing adds a "/" to a bare origin (`https://mcp.stripe.com`):
+      // keep the address as it was given, as the catalog and legacy entries do.
+      const secureUrl = normalizedUrl === `${url}/` ? url : normalizedUrl;
       return { name, config: withOptionalHeaders({ type: kind, url: secureUrl }) };
     }
     const command = clean(input.command);

package/src/session-runtime/mixy-heartbeat.mjs

@@ -635,7 +635,7 @@ export function createMixyHeartbeat({
   now = Date.now,
   path = defaultStatePath(),
   isEnabled = async () =>
-    (await import('../runtime/agent/orchestrator/config.mjs')).loadConfig({ secrets: false }).heartbeat !== false,
+    (await import('../runtime/agent/orchestrator/config.mjs')).loadConfig({ secrets: false }).heartbeat === true,
   // Whether the representative bot exists (mixy-presence.mjs, the rule the
   // desktop and her routines follow): without it no check runs at all.
   mixyExists = async () => (await import('./routine-owner.mjs')).readMixyExists(),

package/src/session-runtime/provider-auth/login.mjs

@@ -61,8 +61,8 @@ export function createLoginApi({ cfgMod, awaitKeychainPrewarm, reloadFullConfig,
       reloadFullConfig();
       return completeOAuthLogin(result);
     },
-    async saveProviderApiKey(providerId, secret) {
-      const result = await saveProviderApiKey(cfgMod, providerId, secret);
+    async saveProviderApiKey(providerId, secret, options) {
+      const result = await saveProviderApiKey(cfgMod, providerId, secret, options);
       refresh.afterCredentialChange();
       return result;
     },

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

@@ -14,9 +14,11 @@ import { migrateMergedConnectorServers } from './connector-merge-migration.mjs';
 import {
   connectorAccountServers,
   connectorAccountsOf,
+  connectorAppPasswordOnly,
   connectorById,
-  connectorMultiAccount,
+  connectorServerInput,
   gmailAppPasswordAccount,
+  gmailAppPasswordServerInput,
   mergeConnectorAccountServers,
 } from '../runtime/shared/connector-catalog.mjs';
 import { saveMcpOAuthClientSecret } from '../runtime/agent/orchestrator/mcp/oauth-client.mjs';
@@ -75,14 +77,24 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     resolveMcpCatalog,
     pluginMcpServer,
   });
-  const { storeOAuthClientSecret, storeGmailAppPassword, releaseOAuth, forgetUnusedGmailAppPassword, releaseAccount } =
-    createMcpServerSecrets({
-      gmailAppPassword,
-      saveOAuthClientSecret,
-      clearMcpServerOAuth,
-      resolveConfiguredMcpCatalog,
-    });
-  const { addConnectorAccount, saveConnectorAccount, setConnectorAccountEnabled } = createConnectorAccountEdits({
+  const {
+    storeOAuthClientSecret,
+    storeGmailAppPassword,
+    releaseOAuth,
+    forgetUnusedGmailAppPassword,
+    forgetStoredSecrets,
+    releaseAccount,
+  } = createMcpServerSecrets({
+    gmailAppPassword,
+    saveOAuthClientSecret,
+    clearMcpServerOAuth,
+    resolveConfiguredMcpCatalog,
+  });
+  const {
+    addConnectorAccount: joinConnectorAccount,
+    saveConnectorAccount,
+    setConnectorAccountEnabled,
+  } = createConnectorAccountEdits({
     normalizeMcpServerInput,
     pluginMcpServer,
     sync,
@@ -91,16 +103,65 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     storeOAuthClientSecret,
     storeGmailAppPassword,
     forgetUnusedGmailAppPassword,
+    forgetStoredSecrets,
     releaseOAuth,
   });
   // Peers reload config from disk on receipt: land the write before publishing.
   const persisted = async () => {
     await flushSkillsSave?.();
   };
+  // One account addition of a connector at a time, each reading the servers
+  // the one before it saved: two at once never take the same name, nor does
+  // one's save drop the other's account.
+  const connectorAdds = new Map();
+  const oneAddAtATime = (connector, run) => {
+    const next = (connectorAdds.get(connector) || Promise.resolve()).then(run, run);
+    const settled = next.then(
+      () => {},
+      () => {}
+    );
+    connectorAdds.set(connector, settled);
+    void settled.then(() => {
+      if (connectorAdds.get(connector) === settled) connectorAdds.delete(connector);
+    });
+    return next;
+  };
+
+  async function addMcpServer(input = {}) {
+    // A catalog connector's account (as its own server config) joins that
+    // connector's one server.
+    const connector = clean(input.connector);
+    if (connector && !Array.isArray(input.accounts)) return oneAddAtATime(connector, () => addServerNow(input));
+    return addServerNow(input);
+  }
+
+  async function addServerNow(input) {
+    const { name, config: serverConfig } = normalizeMcpServerInput(input);
+    // A catalog connector's server keeps its catalog id (connector-catalog.mjs).
+    const connector = clean(input.connector);
+    if (connector) {
+      if (!connectorById(connector)) throw new Error(`Unknown connector: ${connector}`);
+      serverConfig.connector = connector;
+    }
+    const servers = userServers();
+    if (connector && !Array.isArray(input.accounts)) {
+      return joinConnectorAccount(servers, connector, name, serverConfig, input);
+    }
+    if (Object.hasOwn(servers, name) || accountTarget(servers, name)) {
+      throw nameTakenError(servers, name);
+    }
+    const owned = pluginMcpServer(name);
+    if (owned) throw new Error(`MCP server already exists: ${name} (provided by plugin "${owned.owner.id}")`);
+    await storeOAuthClientSecret(input, serverConfig);
+    await storeGmailAppPassword(input, serverConfig, true);
+    saveServers({ ...servers, [name]: serverConfig });
+    const status = await sync.reconnectMcpAndAnnounce({ only: name, enabled: serverConfig.enabled !== false });
+    return { name, status };
+  }
 
   return {
-    /** One-time, idempotent: merge the one-account servers of a multi-account
-     *  connector (`gmail`, `gmail-2`…) into one server holding the accounts
+    /** One-time, idempotent: merge the one-account servers of a catalog
+     *  connector (`notion`, `notion-2`…) into one server holding the accounts
      *  (connector-catalog.mjs mergeConnectorAccountServers). Every account
      *  keeps its address, so its stored sign-in and app password stay as
      *  they are. Settings keyed by a merged-away server name go with it:
@@ -155,30 +216,32 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     },
     // Sign-in / sign-out (resource-mcp-oauth-api.mjs), in this key position.
     ...oauthApi,
-    async addMcpServer(input = {}) {
-      const { name, config: serverConfig } = normalizeMcpServerInput(input);
-      // A catalog connector's server keeps its catalog id (connector-catalog.mjs).
-      const connector = clean(input.connector);
-      if (connector) {
-        if (!connectorById(connector)) throw new Error(`Unknown connector: ${connector}`);
-        serverConfig.connector = connector;
-      }
-      const servers = userServers();
-      // A multi-account connector's account (as its own server config) joins
-      // that connector's one server.
-      if (connector && connectorMultiAccount(connectorById(connector)) && !Array.isArray(input.accounts)) {
-        return addConnectorAccount(servers, connector, name, serverConfig, input);
-      }
-      if (Object.hasOwn(servers, name) || accountTarget(servers, name)) {
-        throw nameTakenError(servers, name);
-      }
-      const owned = pluginMcpServer(name);
-      if (owned) throw new Error(`MCP server already exists: ${name} (provided by plugin "${owned.owner.id}")`);
-      await storeOAuthClientSecret(input, serverConfig);
-      await storeGmailAppPassword(input, serverConfig, true);
-      saveServers({ ...servers, [name]: serverConfig });
-      const status = await sync.reconnectMcpAndAnnounce({ only: name, enabled: serverConfig.enabled !== false });
-      return { name, status };
+    addMcpServer,
+    /** One more account of catalog connector `input.connector`, connected as
+     *  its catalog entry says: `key` for an API-key service (Hugging Face,
+     *  Stripe; Postgres takes its connection string), `email` and
+     *  `appPassword` for Gmail, nothing more for a sign-in service (the
+     *  account then signs in with beginMcpOAuthLogin(account)); the user's own
+     *  OAuth client rides on `oauthClientId` / `oauthClientSecret`. The account
+     *  gets a free name (`notion`, `notion-2`…) and joins the connector's one
+     *  server, which is made when there is none. Resolves `{ name, account,
+     *  status }`: the server's name and the new account's (for a Gmail
+     *  address already connected, that account, which took the new password). */
+    async addConnectorAccount(input = {}) {
+      const entry = connectorById(clean(input.connector));
+      if (!entry) throw new Error(`Unknown connector: ${clean(input.connector)}`);
+      // Its name is picked from the servers the additions before it saved.
+      return oneAddAtATime(entry.id, () => {
+        const name = freeName(userServers(), entry.id);
+        const account = connectorAppPasswordOnly(entry)
+          ? gmailAppPasswordServerInput(name, input.email, input.appPassword)
+          : connectorServerInput(entry, name, input.key);
+        const ownClient = clean(input.oauthClientId);
+        return addServerNow({
+          ...account,
+          ...(ownClient ? { oauthClientId: ownClient, oauthClientSecret: input.oauthClientSecret } : {}),
+        });
+      });
     },
     async saveMcpServer(input = {}) {
       const servers = userServers();