mixdog 1.3.1 → 1.3.2

package/src/session-runtime/held-requests.mjs

@@ -1,12 +1,14 @@
 /**
- * Held requests: unattended runs never auto-approve. In a schedule, webhook or
- * group-room-member run, an approval-needing call is HELD instead of shown as
+ * Unattended runs. A schedule or webhook run never asks (its saved routine is
+ * the user's grant; human-gate/run-policy.mjs), so only group-room members
+ * still use held requests: an approval-needing call is HELD instead of shown as
  * a card: the run pauses on it, a structured held-request row lands in the
  * owning agent's home thread (agent-home-delivery.mjs queue), a phone push
  * says only "<agent>가 승인을 기다립니다" (no tool, arguments or text), and the
- * request expires after HELD_REQUEST_EXPIRY_MS into a deny, so the run goes
- * on with the denial. The user answers from the home thread through the
- * ordinary approval call with the held id (runtime/shared/held-request-host.mjs).
+ * request waits, like any approval, until the user answers it (Approve/Deny,
+ * through the ordinary approval call with the held id,
+ * runtime/shared/held-request-host.mjs) or the run is cancelled (Stop, abort,
+ * app quit), which denies it. It never expires on a timer.
  *
  * Importing this module installs the unattended port of human-gate/gate.mjs.
  * Rooms: a room member session counts as unattended by its id; a surface that
@@ -23,20 +25,13 @@ import {
 } from '../runtime/agent/orchestrator/session/human-gate/gate.mjs';
 import { normalizeHumanResponse } from '../runtime/agent/orchestrator/session/human-gate/requests.mjs';
 import { normalizeHeldRequest } from '../runtime/agent/orchestrator/session/human-gate/held-message.mjs';
+import { delegationOf } from '../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import {
   notifyHeldRequest,
   recordRunOwner,
   registerHeldRequestResolver,
 } from '../runtime/shared/held-request-host.mjs';
 
-/** Default expiry; MIXDOG_HELD_REQUEST_EXPIRY_MS overrides it. */
-export const HELD_REQUEST_EXPIRY_MS = 5 * 60_000;
-
-function configuredExpiryMs() {
-  const value = Number(process.env.MIXDOG_HELD_REQUEST_EXPIRY_MS);
-  return Number.isFinite(value) && value > 0 ? value : HELD_REQUEST_EXPIRY_MS;
-}
-
 const runs = new Map(); // sessionId → { kind, agentId, name }
 
 /** Mark `sessionId` as an unattended schedule/webhook run of `agentId`. */
@@ -54,12 +49,28 @@ export function markUnattendedRun(sessionId, { kind, agentId, name = '' }) {
   };
 }
 
-/** The unattended run `sessionId` belongs to, or null for an attended session. */
+/** The unattended run `sessionId` belongs to, or null for an attended session.
+ *  Work delegated from a run or a room (a sub-agent at any depth, a task
+ *  session the bot created) belongs to it by the origin recorded on its own
+ *  session record when it was created (human-gate/delegation.mjs) — however
+ *  long ago that run ended, across restarts: its approvals are held like the
+ *  run's own. */
 export function unattendedRunOf(sessionId) {
   const run = runs.get(sessionId);
   if (run) return run;
   const member = roomMemberOfSession(sessionId);
-  return member ? { kind: 'room', agentId: member.agentId, name: member.roomId } : null;
+  if (member) return { kind: 'room', agentId: member.agentId, name: member.roomId };
+  const delegation = delegationOf(sessionId);
+  if (delegation.state !== 'resolved') return null;
+  if (delegation.via === 'run') {
+    return {
+      kind: delegation.run.kind === 'webhook' ? 'webhook' : 'schedule',
+      agentId: delegation.rootAgentId,
+      name: String(delegation.run.name || ''),
+    };
+  }
+  const root = delegation.via === 'room' ? roomMemberOfSession(delegation.rootSessionId) : null;
+  return root ? { kind: 'room', agentId: root.agentId, name: root.roomId } : null;
 }
 
 /**
@@ -98,9 +109,7 @@ export function createHeldRequests({
   push = notifyHeldRequest,
   record = recordHumanDecision,
   agentName = defaultAgentName,
-  expiryMs = configuredExpiryMs,
   runOf = unattendedRunOf,
-  now = Date.now,
   log = (line) => process.stderr.write(`mixdog held-requests: ${line}\n`),
 }) {
   const pending = new Map();
@@ -113,7 +122,6 @@ export function createHeldRequests({
     const entry = pending.get(id);
     if (!entry) return false;
     pending.delete(id);
-    clearTimeout(entry.timer);
     entry.release();
     void post(entry.agentId, { ...entry.held, status, ...(approval.device ? { device: approval.device } : {}) });
     void Promise.resolve()
@@ -123,11 +131,10 @@ export function createHeldRequests({
     return true;
   }
 
-  /** Hold `request` (the approval hook's payload) until answered or expired. */
+  /** Hold `request` (the approval hook's payload) until answered or the run is cancelled. */
   function hold(request = {}, { signal } = {}) {
     const run = runOf(request.sessionId) || { kind: 'schedule', agentId: MIXY_AGENT_ID, name: '' };
     const id = `held_${randomUUID()}`;
-    const ms = typeof expiryMs === 'function' ? expiryMs() : expiryMs;
     const held = normalizeHeldRequest({
       id,
       status: 'pending',
@@ -145,12 +152,13 @@ export function createHeldRequests({
             details: request.outbound?.details,
           }
         : {}),
-      remember: request.remember || ['once'],
+      // An unattended run never remembers: its held row offers once only.
+      remember: ['once'],
       run: { kind: run.kind, name: run.name, sessionId: request.sessionId },
-      expiresAt: now() + ms,
     });
-    const shape = { kind: held.kind, outbound: request.outbound, remember: request.remember || ['once'] };
+    const shape = { kind: held.kind, outbound: request.outbound, remember: ['once'] };
     const gate = {
+      remember: ['once'],
       agentId: run.agentId,
       kind: held.kind,
       ...(held.action ? { action: held.action } : {}),
@@ -167,17 +175,7 @@ export function createHeldRequests({
         agentId: run.agentId,
         resolve,
         release: () => signal?.removeEventListener?.('abort', onAbort),
-        timer: setTimeout(
-          () =>
-            settle(
-              id,
-              { ...normalizeHumanResponse(shape, false), reason: 'held request expired', timedOut: true },
-              'expired'
-            ),
-          ms
-        ),
       };
-      entry.timer.unref?.();
       pending.set(id, entry);
       void post(run.agentId, held);
       try {
@@ -219,6 +217,11 @@ function heldRequests() {
   return processHeld;
 }
 
+/** The held requests still waiting for an answer (session bots reads them). */
+export function pendingHeldRequests() {
+  return processHeld ? processHeld.pending() : [];
+}
+
 /** Hold one request for its session's agent (rooms call this from their own hook). */
 export function holdApprovalRequest(request, options) {
   return heldRequests().hold(request, options);

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

@@ -6,6 +6,8 @@ import { executeTerminalTool } from '../../runtime/terminal-bridge/client.mjs';
 import { executeVisualizeTool } from '../../runtime/visualize-bridge/client.mjs';
 import { featureEnvOverride, moduleEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
+import { unattendedApprovalPort } from '../../runtime/agent/orchestrator/session/human-gate/unattended-port.mjs';
+import { isGrantedRun } from '../../runtime/agent/orchestrator/session/human-gate/run-policy.mjs';
 
 export function createBridgeToolHandlers({ rt }) {
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
@@ -19,9 +21,16 @@ export function createBridgeToolHandlers({ rt }) {
     if (environmentDisabled(callerCtx, 'MIXDOG_FEATURE_BROWSER')) {
       throw new Error('the browser tool is disabled in this environment');
     }
+    const sessionId = sessionIdFor(callerCtx);
+    const run = unattendedApprovalPort()?.runOf?.(sessionId);
     return await executeBrowserTool(args, {
       tool: name,
-      sessionId: sessionIdFor(callerCtx),
+      sessionId,
+      // A schedule/webhook run never asks for form submits, posts or uploads;
+      // the bot that owns the run comes from the run's record, so its `block`
+      // applies whatever the display metadata says.
+      unattendedRun: isGrantedRun(run),
+      unattendedAgent: run?.agentId || '',
       turnId: callerCtx?.turnId || rt.session?.usageMetricsTurnId,
       signal: signalFor(callerCtx),
     });

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

@@ -1,6 +1,6 @@
 // Optional feature tools gated by settings for model-initiated calls: office,
 // media and tidy (each loaded on first use), and the setup tool.
-import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
+import { standaloneDataDir } from '../runtime-paths.mjs';
 import { createCallerContextResolvers } from './caller-context.mjs';
 
 export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }) {
@@ -17,7 +17,7 @@ export function createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, m
       const { executeOfficeTool } = await import('../../runtime/office/index.mjs');
       return await executeOfficeTool(args, {
         cwd: callerCwd,
-        dataDir: STANDALONE_DATA_DIR,
+        dataDir: standaloneDataDir(),
         requestApproval: callerCtx?.toolApprovalHook,
         sessionId: callerCtx?.sessionId,
         toolCallId: callerCtx?.toolCallId,

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

@@ -7,18 +7,20 @@ import { applySessionSidebarChange } from '../../runtime/shared/session-sidebar-
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
 import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { turnHopOf } from '../../runtime/shared/bot-hops.mjs';
 import { scheduleCallerScope } from '../services/schedule-access.mjs';
 import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
 
-/** The agent an attended agent conversation (an agent's home thread) acts as;
+/** The agent an attended agent conversation (an agent's home thread, or its
+ *  member session in a group room, where the user is present too) acts as;
  *  '' for every other caller: delegated workers, coding sessions (task
  *  sessions included) and unattended schedule/webhook runs. */
 function attendedAgentOf(session) {
   const { mode, agentId } = resolveSessionMode({ session });
   const { kind } = scheduleCallerScope(session);
-  return mode === AGENT_MODE && (kind === 'human' || kind === 'agent') ? agentId : '';
+  return mode === AGENT_MODE && (kind === 'human' || kind === 'agent' || kind === 'room-member') ? agentId : '';
 }
 
 /** The caller's `attachments` as stored prompt parts, resolved against its own
@@ -89,7 +91,10 @@ export function createWorkspaceToolHandlers({
   const session = async (args, { callerCtx, callerCwd }) => {
     const action = clean(args?.action || (args?.path ? 'set-project' : 'status')).toLowerCase();
     const target = clean(args?.session_id);
-    if (['list', 'read', 'send', 'cancel', 'delete', 'create'].includes(action) || (action === 'status' && target)) {
+    if (
+      ['list', 'bots', 'read', 'send', 'cancel', 'delete', 'create'].includes(action) ||
+      (action === 'status' && target)
+    ) {
       const callerSessionId = assertLead(action, callerCtx);
       const callerAgentId = attendedAgentOf(rt.session);
       if (action === 'create' && !callerAgentId) {
@@ -117,7 +122,15 @@ export function createWorkspaceToolHandlers({
       return JSON.stringify(
         await executeSessionControl(
           { ...rest, action },
-          { callerSessionId, callerAgentId, callerCwd, ...(attachmentParts.length ? { attachmentParts } : {}) }
+          {
+            callerSessionId,
+            callerAgentId,
+            callerCwd,
+            ...(action === 'send' || action === 'create' ? { callerHop: turnHopOf(rt.session) } : {}),
+            // Which bots and sessions it may see (bot-status.mjs).
+            ...(action === 'bots' || action === 'list' ? { callerScope: scheduleCallerScope(rt.session) } : {}),
+            ...(attachmentParts.length ? { attachmentParts } : {}),
+          }
         )
       );
     }
@@ -252,6 +265,8 @@ export function createWorkspaceToolHandlers({
         clientHostPid: callerCtx?.clientHostPid || rt.session?.clientHostPid || process.pid,
         signal: callerCtx?.signal,
         notifyFn: notifyFnForSession(callerSessionId),
+        // The jobs this call starts are recorded under it (agent-task-starts.mjs).
+        ...(callerCtx?.toolCallId ? { toolCallId: callerCtx.toolCallId } : {}),
       });
     },
   };

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

@@ -16,6 +16,10 @@ import {
   clean,
 } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
+import {
+  incomingTailOf,
+  wantsIncomingTail,
+} from '../../runtime/agent/orchestrator/session/store-summary-last-message.mjs';
 import { isRealTurnMessage } from '../../runtime/agent/orchestrator/session/compact/user-message-kind.mjs';
 import { realTurnCount as realTurnCountOf } from '../../runtime/agent/orchestrator/session/store-summary-fields.mjs';
 
@@ -44,6 +48,7 @@ function previewOf(s) {
   let preview = isSessionPreviewNoise(rawPreview) ? '' : cleanSessionPreview(rawPreview);
   let messageCount = Math.max(0, Number(s.messageCount) || 0);
   let realTurnCount = realTurnCountOf(s);
+  let incomingTail = Array.isArray(s.incomingTail) ? s.incomingTail : null;
   if (!preview && Array.isArray(s.messages)) {
     realTurnCount = s.messages.filter(isRealTurnMessage).length;
     const msgs = s.messages;
@@ -55,8 +60,9 @@ function previewOf(s) {
       .filter(Boolean);
     preview = userPreviews[0] || '';
     messageCount = msgs.filter((m) => m && (m.role === 'user' || m.role === 'assistant')).length;
+    if (wantsIncomingTail(s.id)) incomingTail = incomingTailOf(msgs);
   }
-  return { preview, messageCount, realTurnCount };
+  return { preview, messageCount, realTurnCount, incomingTail };
 }
 
 /** `working`: this session's turn is running in the daemon right now. */
@@ -70,7 +76,7 @@ export function leadSessionRow(s, working = false) {
   // One-shot `mixdog exec` runs are never resumable conversations.
   if (sourceType === 'exec') return null;
   if (!agentSession && !isLeadShaped(s, owner, sourceType)) return null;
-  const { preview, messageCount, realTurnCount } = previewOf(s);
+  const { preview, messageCount, realTurnCount, incomingTail } = previewOf(s);
   if (!preview && messageCount === 0) return null;
   const lastMessageRoutine = normalizeRoutineProvenance(s.lastMessageRoutine);
   return {
@@ -95,6 +101,10 @@ export function leadSessionRow(s, working = false) {
     model: s.model,
     provider: s.provider,
     messageCount,
+    // Where the messages that arrived (not the user's own, not tool calls)
+    // sit among the counted ones: a bot row's unread pill counts those past
+    // the read cursor. Absent when unknown; clients then show one.
+    ...(incomingTail ? { incomingTail } : {}),
     title: cleanSessionPreview(s.title || '', 100),
     preview,
     // The latest user or assistant line (an agent contact's row shows it).

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

@@ -8,6 +8,7 @@
 import { SessionClosedError } from '../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
 import { forgetSessionSaveBaseline } from '../../runtime/agent/orchestrator/session/store/save-worker.mjs';
 import { flushAllIndexWrites } from '../services/agent-tool/index-write-queue.mjs';
+import { PROCESS_RESTART_FAILURE } from '../services/agent-tool/worker-index/row-liveness.mjs';
 import { unregisterLiveSession } from '../../runtime/shared/staged-update.mjs';
 import { abortRuntime, closeCanonicalSession, closeOwnSession, dispatchSessionEnd } from './teardown/session-close.mjs';
 import { settleAll, settleDetached, startRuntimeStops, startWorkStops } from './teardown/runtime-stops.mjs';
@@ -111,11 +112,14 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
   function reapWork(reason, scope) {
     if (!scope.teardownReapsWork) return;
     try {
-      // A task that dies for a reason its owner never asked for must still be reported.
+      // A task that dies for a reason its owner never asked for must still be
+      // reported: now for a scoped close; for a process exit (its owner is
+      // closing too) by the next process, which tells the owner of each agent
+      // turn the exit cut off (agent-tool restart-notify).
       cancelBackgroundTasks(
         scope.scopedTeardown
           ? { reason, notify: true, executionSessionId: scope.closingSessionId }
-          : { reason, notify: false }
+          : { reason, notify: false, terminalReason: PROCESS_RESTART_FAILURE }
       );
     } catch {}
   }
@@ -204,7 +208,11 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
       const settled = () => {
         outstandingCloses.delete(closing);
       };
-      closing = new Promise((resolve) => resolve(agentTool.closeAll(reason, {}))).then(settled, settled);
+      // processExit: the workers close, their rows stay for the next process.
+      closing = new Promise((resolve) => resolve(agentTool.closeAll(reason, { processExit: true }))).then(
+        settled,
+        settled
+      );
       outstandingCloses.add(closing);
       try {
         await withTeardownDeadline(closing, CLOSE_ALL_DEADLINE_MS, false);

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

@@ -3,7 +3,9 @@
 // connect. All mutable progress lives on the caller-owned `state`.
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
+import { awaitInitialConnect } from './initial-connect-gate.mjs';
 import { ensurePluginServerData } from './plugin-servers.mjs';
+import { createServerConnection } from './server-connection.mjs';
 
 export function createMcpConnect({
   mcpClient,
@@ -29,58 +31,100 @@ export function createMcpConnect({
   // Answer it with the redirect URL pasted from the browser.
   const completeMcpLogin = (name, callbackUrl) => mcpClient.completeMcpLogin(clean(name), callbackUrl, scopeOptions());
 
-  // Connect/disconnect exactly one server in the live registry, leaving all
-  // others untouched. Used by the enable/disable toggle so a single-server
-  // change never triggers a full disconnectAll()/reconnect freeze. Only an
-  // explicit sign-in passes `login` ({ openBrowser }): every other connect is
-  // non-interactive and reports a server that needs one as sign-in required.
-  async function applyMcpServerConnection(name, enabled, servers = resolveEffectiveMcpServers().servers, login = null) {
-    const target = clean(name);
-    if (!target) return;
-    // Changing this server's state clears any stale failure record for it.
-    if (Array.isArray(state.mcpFailures)) {
-      state.mcpFailures = state.mcpFailures.filter((row) => row.name !== target);
-    }
-    const cfg = servers[target];
-    if (enabled === false || !cfg || cfg.enabled === false) {
-      applied().delete(target);
-      await mcpClient.disconnectMcpServer?.(target, scopeOptions());
-      return;
+  const { applyMcpServerConnection, reconcileServers } = createServerConnection({
+    mcpClient,
+    state,
+    resolveEffectiveMcpServers,
+    getMcpScopeId,
+    scopeOptions,
+    applied,
+    fingerprint,
+    syncScopeRoot,
+  });
+
+  // Wait for a prior run (its failures were already captured in state).
+  async function settled(prior) {
+    if (!prior) return;
+    try {
+      await prior;
+    } catch {
+      /* prior run's failures already captured */
     }
-    applied().set(target, fingerprint(cfg));
-    // Close-then-connect as one generation-guarded op: a shutdown landing
-    // between the close and the connect never resurrects the server.
+  }
+
+  // Register `run` as the in-flight connect so a later reset serializes
+  // behind it instead of interleaving disconnect/connect.
+  async function trackInFlight(run) {
+    state.mcpConnectInFlight = run;
     try {
-      ensurePluginServerData(cfg);
-      await mcpClient.reconnectSingleMcpServer(
-        getMcpScopeId(),
-        target,
-        cfg,
-        login ? { interactive: true, openBrowser: login.openBrowser } : {}
-      );
-    } catch (error) {
-      const failure = { name: target, msg: error?.message || String(error) };
-      if (error?.authRequired) failure.authRequired = true;
-      const failures = Array.isArray(error?.failures) ? error.failures : [failure];
-      state.mcpFailures = [...(state.mcpFailures || []), ...failures];
+      await run;
+    } finally {
+      if (state.mcpConnectInFlight === run) state.mcpConnectInFlight = null;
     }
   }
 
-  // Bring the registry in line with the effective set: drop servers that are
-  // gone or disabled, (re)connect servers that are new or whose resolved
-  // config changed; untouched servers keep their connection.
-  async function reconcileServers() {
-    syncScopeRoot();
-    const { servers } = resolveEffectiveMcpServers();
-    const known = applied();
-    const drops = [...known.keys()].filter((name) => !servers[name] || servers[name].enabled === false);
-    const connects = Object.entries(servers)
-      .filter(([name, cfg]) => cfg?.enabled !== false && known.get(name) !== fingerprint(cfg))
-      .map(([name]) => name);
-    await Promise.allSettled([
-      ...drops.map((name) => applyMcpServerConnection(name, false, servers)),
-      ...connects.map((name) => applyMcpServerConnection(name, true, servers)),
-    ]);
+  // Scoped single-server toggle (or reconcile): non-superseding. It must NEVER
+  // cancel a pending full {reset} (cwd-change/boot). So do not bump the
+  // generation; just wait for any in-flight run, then bail if a newer full
+  // reset has been requested in the meantime.
+  async function connectScoped({ only, enabled, reconcile, login }) {
+    // A disable/remove must not wait out an interactive login of the
+    // connect it queues behind: cancel that login first.
+    if (only && enabled === false) cancelMcpLogin(only);
+    // Atomically capture the current generation AND the prior in-flight
+    // promise in the same synchronous step, then chain our op onto it. No
+    // await sits between the capture and the `state.mcpConnectInFlight = run`
+    // assignment, so concurrent {only} calls queue FIFO instead of resuming
+    // together and clobbering the in-flight slot. We never bump the
+    // generation; a {reset} does, so any {only} queued behind a reset sees
+    // the newer generation when its turn comes and bails.
+    const gen = state.mcpConnectGeneration;
+    const prev = state.mcpConnectInFlight;
+    await trackInFlight(
+      (async () => {
+        await settled(prev);
+        if (gen !== state.mcpConnectGeneration) return;
+        if (reconcile) await reconcileServers();
+        else await applyMcpServerConnection(only, enabled, undefined, login);
+      })()
+    );
+  }
+
+  // Serialize reconnects: boot connect, cwd-change reset, and rapid cwd
+  // switches must never interleave their disconnect/connect phases, or an
+  // older run finishing after a newer reset could re-add stale servers into
+  // the shared client registry. Approach: a generation token + a single
+  // in-flight promise. Each call bumps the generation, waits for any prior
+  // run to finish, then bails if a newer call has superseded it — leaving the
+  // latest requested effective-server-set in the registry.
+  async function connectAll({ reset }) {
+    const gen = ++state.mcpConnectGeneration;
+    await settled(state.mcpConnectInFlight);
+    if (gen !== state.mcpConnectGeneration) return;
+    await trackInFlight(
+      (async () => {
+        if (reset) {
+          await mcpClient.disconnectAll?.(scopeOptions());
+          applied().clear();
+        }
+        state.mcpFailures = [];
+        syncScopeRoot();
+        const { servers } = resolveEffectiveMcpServers();
+        for (const [name, cfg] of Object.entries(servers)) {
+          if (cfg?.enabled === false) applied().delete(name);
+          else applied().set(name, fingerprint(cfg));
+        }
+        if (Object.keys(servers).length === 0) return;
+        try {
+          for (const cfg of Object.values(servers)) if (cfg?.enabled !== false) ensurePluginServerData(cfg);
+          await mcpClient.connectMcpServers(servers, scopeOptions());
+        } catch (error) {
+          state.mcpFailures = Array.isArray(error?.failures)
+            ? error.failures
+            : [{ name: 'mcp', msg: error?.message || String(error) }];
+        }
+      })()
+    );
   }
 
   async function connectConfiguredMcp({
@@ -98,146 +142,16 @@ export function createMcpConnect({
       else await mcpClient.disconnectAll?.(scopeOptions());
       return mcpStatus();
     }
-    // Scoped single-server toggle: non-superseding. It must NEVER cancel a
-    // pending full {reset} (cwd-change/boot). So do not bump the generation;
-    // just wait for any in-flight run, then bail if a newer full reset has
-    // been requested in the meantime. Registering as in-flight makes a later
-    // reset serialize behind us instead of interleaving disconnect/connect.
-    if (only || reconcile) {
-      // A disable/remove must not wait out an interactive login of the
-      // connect it queues behind: cancel that login first.
-      if (only && enabled === false) cancelMcpLogin(only);
-      // Atomically capture the current generation AND the prior in-flight
-      // promise in the same synchronous step, then chain our op onto it. No
-      // await sits between the capture and the `state.mcpConnectInFlight = run`
-      // assignment, so concurrent {only} calls queue FIFO instead of resuming
-      // together and clobbering the in-flight slot. We never bump the
-      // generation; a {reset} does, so any {only} queued behind a reset sees
-      // the newer generation when its turn comes and bails.
-      const gen = state.mcpConnectGeneration;
-      const prev = state.mcpConnectInFlight;
-      const run = (async () => {
-        if (prev) {
-          try {
-            await prev;
-          } catch {
-            /* prior run's failures already captured */
-          }
-        }
-        if (gen !== state.mcpConnectGeneration) return;
-        if (reconcile) await reconcileServers();
-        else await applyMcpServerConnection(only, enabled, undefined, login);
-      })();
-      state.mcpConnectInFlight = run;
-      try {
-        await run;
-      } finally {
-        if (state.mcpConnectInFlight === run) state.mcpConnectInFlight = null;
-      }
-      return mcpStatus();
-    }
-    // Serialize reconnects: boot connect, cwd-change reset, and rapid cwd
-    // switches must never interleave their disconnect/connect phases, or an
-    // older run finishing after a newer reset could re-add stale servers into
-    // the shared client registry. Approach: a generation token + a single
-    // in-flight promise. Each call bumps the generation, waits for any prior
-    // run to finish, then bails if a newer call has superseded it — leaving the
-    // latest requested effective-server-set in the registry.
-    const gen = ++state.mcpConnectGeneration;
-    if (state.mcpConnectInFlight) {
-      try {
-        await state.mcpConnectInFlight;
-      } catch {
-        /* prior run's failures already captured */
-      }
-    }
-    if (gen !== state.mcpConnectGeneration) return mcpStatus();
-    const run = (async () => {
-      if (reset) {
-        await mcpClient.disconnectAll?.(scopeOptions());
-        applied().clear();
-      }
-      state.mcpFailures = [];
-      syncScopeRoot();
-      const { servers } = resolveEffectiveMcpServers();
-      for (const [name, cfg] of Object.entries(servers)) {
-        if (cfg?.enabled === false) applied().delete(name);
-        else applied().set(name, fingerprint(cfg));
-      }
-      if (Object.keys(servers).length === 0) return;
-      try {
-        for (const cfg of Object.values(servers)) if (cfg?.enabled !== false) ensurePluginServerData(cfg);
-        await mcpClient.connectMcpServers(servers, scopeOptions());
-      } catch (error) {
-        state.mcpFailures = Array.isArray(error?.failures)
-          ? error.failures
-          : [{ name: 'mcp', msg: error?.message || String(error) }];
-      }
-    })();
-    state.mcpConnectInFlight = run;
-    try {
-      await run;
-    } finally {
-      if (state.mcpConnectInFlight === run) state.mcpConnectInFlight = null;
-    }
+    if (only || reconcile) await connectScoped({ only, enabled, reconcile, login });
+    else await connectAll({ reset });
     return mcpStatus();
   }
 
-  // Turn gate: await the in-flight INITIAL connect, bounded by both the global
-  // server startup budget and the caller's TTFT grace. A server still
-  // connecting after the grace flows through the existing late-tool deferred
-  // announcement path unchanged.
-  async function awaitInitialMcpConnect(maxWaitMs = undefined) {
-    const inFlight = state.mcpConnectInFlight;
-    if (!inFlight) return;
-    let budgetMs = 10000;
-    try {
-      // The gate must outlast the slowest enabled server's own startup budget;
-      // a server with its budget disabled (0) means the connect may never
-      // settle, so the whole gate is disabled (handled below).
-      const configs = Object.values(resolveEffectiveMcpServers().servers).filter((cfg) => cfg?.enabled !== false);
-      const budgets = (configs.length > 0 ? configs : [{}])
-        .map((cfg) => mcpClient.resolveMcpStartupTimeoutMs?.(cfg))
-        .filter((value) => Number.isFinite(value));
-      if (budgets.length > 0) budgetMs = budgets.includes(0) ? 0 : Math.max(...budgets);
-    } catch {
-      /* fall back to default budget */
-    }
-    if (maxWaitMs !== null && maxWaitMs !== undefined) {
-      const requestedMaxWaitMs = Number(maxWaitMs);
-      if (Number.isFinite(requestedMaxWaitMs) && requestedMaxWaitMs >= 0) {
-        budgetMs = Math.min(budgetMs, requestedMaxWaitMs);
-      }
-    }
-    // Budget disabled (0/off) = no per-server startup timeout, so the connect
-    // promise may never settle; never gate the turn on it — fall back to the
-    // legacy fire-and-forget behavior (late servers use the deferred path).
-    if (!(budgetMs > 0)) return;
-    let timer = null;
-    let expired = false;
-    const budget = new Promise((resolveBudget) => {
-      timer = setTimeout(() => {
-        expired = true;
-        resolveBudget();
-      }, budgetMs);
-    });
-    try {
-      // Follow replacement connects (a reconnect queued behind the captured
-      // run installs a new in-flight promise) inside ONE fixed deadline.
-      // Failures are already captured in state.mcpFailures, so rejections are
-      // swallowed: this gate must never reject the turn.
-      let current = inFlight;
-      while (current && !expired) {
-        await Promise.race([Promise.resolve(current).catch(() => {}), budget]);
-        if (expired) break;
-        // Let a queued reconnect install its promise before re-checking.
-        await Promise.race([new Promise((resolveTick) => setImmediate(resolveTick)), budget]);
-        current = state.mcpConnectInFlight;
-      }
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-
-  return { connectConfiguredMcp, awaitInitialMcpConnect, cancelMcpLogin, completeMcpLogin };
+  return {
+    connectConfiguredMcp,
+    awaitInitialMcpConnect: (maxWaitMs) =>
+      awaitInitialConnect({ state, mcpClient, resolveEffectiveMcpServers }, maxWaitMs),
+    cancelMcpLogin,
+    completeMcpLogin,
+  };
 }