mixdog 1.2.1 → 1.2.3

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

@@ -1,7 +1,8 @@
 /**
  * src/session-runtime/lifecycle/inheritance.mjs - session inheritance
  * (/inherit): fit preflight and the carry of another session's conversation
- * into the freshly created heir.
+ * into the freshly created heir — the live one (inheritFrom) or a cold sibling
+ * persisted without switching (inheritToNewSession), through one carry core.
  */
 import { hasUserConversationMessage } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { stripEffortConfiguration } from '../../runtime/agent/orchestrator/providers/effort-configuration.mjs';
@@ -14,6 +15,7 @@ import {
   inheritanceRouteTarget,
 } from '../inheritance-fit.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { buildColdHeir, committedSource, persistColdHeir } from './cold-heir.mjs';
 
 export function createInheritance(deps, { compactConversation, saveSession }) {
   const { getSession, getRoute, mgr, createCurrentSession, invalidateContextStatusCache, getReservedSessionId } = deps;
@@ -143,6 +145,44 @@ export function createInheritance(deps, { compactConversation, saveSession }) {
     };
   }
 
+  /**
+   * The ONE carry every inheritance path shares: measure the source's
+   * conversation on the heir's scale, compact it for the heir when asked to
+   * or when it cannot fit, and append it to the (empty) heir with its
+   * inheritance boundary. Refusals throw before the heir is touched; the
+   * source is never mutated.
+   */
+  async function carryConversation(source, target, { compact = false } = {}) {
+    // System blocks belong to the session that BUILT them: the target's own
+    // prompt was composed for the current model, tool surface, and workflow.
+    // Only the conversation itself travels.
+    let carried = inheritableMessages(source.messages);
+    if (!hasUserConversationMessage(carried)) {
+      throw new Error('inheritFrom: the source session has no conversation to carry');
+    }
+    // Decide BEFORE anything moves, on the heir's own scale. This is the
+    // same function inheritancePreflight() answers with, so the surface that
+    // offered the carry and the runtime that performs it cannot disagree —
+    // and a refusal no longer has to unwind a half-filled transcript.
+    const fit = inheritanceFit(carried, target);
+    let compacted = false;
+    // compact:true summarizes even a conversation that fits; otherwise only
+    // one that cannot fit is compacted.
+    if (compact || (fit.known && !fit.fits)) {
+      const next = await fitConversationForHeir(source, target, carried, fit, { required: compact });
+      compacted = next !== carried;
+      carried = next;
+    }
+    target.messages.push(
+      ...stripEffortConfiguration(inheritedCompatReplayMessages(structuredClone(carried), source.provider))
+    );
+    target.inheritedFromSessionId = source.id;
+    target.updatedAt = Date.now();
+    recordInheritanceBoundary(target, source);
+    if (!clean(target.title) && clean(source.title)) target.title = source.title;
+    return { messages: carried.length, compacted };
+  }
+
   /**
    * Session inheritance (/inherit): carry another session's conversation
    * into THIS freshly created session, so the transcript continues under a
@@ -174,41 +214,45 @@ export function createInheritance(deps, { compactConversation, saveSession }) {
     }
     const source = mgr.getSession(id);
     if (!source) throw new Error(`inheritFrom: session ${id} was not found`);
-    // System blocks belong to the session that BUILT them: the target's own
-    // prompt was composed for the current model, tool surface, and workflow.
-    // Only the conversation itself travels.
-    let carried = inheritableMessages(source.messages);
-    if (!hasUserConversationMessage(carried)) {
-      throw new Error('inheritFrom: the source session has no conversation to carry');
-    }
-    // Decide BEFORE anything moves, on the heir's own scale. This is the
-    // same function inheritancePreflight() answers with, so the surface that
-    // offered the carry and the runtime that performs it cannot disagree —
-    // and a refusal no longer has to unwind a half-filled transcript.
-    const fit = inheritanceFit(carried, target);
-    // compact:true summarizes even a conversation that fits; otherwise only
-    // one that cannot fit is compacted.
-    if (compact || (fit.known && !fit.fits)) {
-      carried = await fitConversationForHeir(source, target, carried, fit, { required: compact });
-    }
-    target.messages.push(
-      ...stripEffortConfiguration(inheritedCompatReplayMessages(structuredClone(carried), source.provider))
-    );
+    const { messages } = await carryConversation(source, target, { compact });
     invalidateContextStatusCache();
-    target.inheritedFromSessionId = source.id;
-    target.updatedAt = Date.now();
-    recordInheritanceBoundary(target, source);
-    if (!clean(target.title) && clean(source.title)) target.title = source.title;
     saveSession(target, { immediate: true });
     invalidateContextStatusCache();
     return {
       sessionId: target.id,
       sourceSessionId: source.id,
-      messages: carried.length,
+      messages,
       provider: target.provider,
       model: target.model,
     };
   }
 
-  return { inheritancePreflight, inheritFrom };
+  /**
+   * Inheritance WITHOUT switching: carry a session's conversation (normally
+   * the live one, possibly mid-turn) into a NEW session on the same route,
+   * cwd and Project, persisted cold for a later resume. The live session
+   * stays the current one and is never mutated; only its committed turns
+   * travel. Same carry, compaction and refusals as inheritFrom().
+   */
+  async function inheritToNewSession(sourceSessionId, { compact = false, titleSuffix = '' } = {}) {
+    const live = getSession();
+    const id = clean(sourceSessionId) || clean(live?.id);
+    if (!id) throw new TypeError('inheritToNewSession: source session id is required');
+    const stored = id === clean(live?.id) ? live : mgr.getSession(id);
+    if (!stored) throw new Error(`inheritFrom: session ${id} was not found`);
+    const source = committedSource(stored);
+    const heir = buildColdHeir(source);
+    const { messages, compacted } = await carryConversation(source, heir, { compact: compact === true });
+    // A suffixed title ("… (Fork)") tells the copy apart in session lists;
+    // locked as a model title so auto-titling keeps it, renames still win.
+    if (titleSuffix && clean(heir.title)) {
+      heir.title = `${clean(heir.title)}${titleSuffix}`;
+      heir.titleLocked = true;
+      heir.titleSource = 'ai';
+    }
+    await persistColdHeir(heir);
+    return { sessionId: heir.id, messages, compacted };
+  }
+
+  return { inheritancePreflight, inheritFrom, inheritToNewSession };
 }

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

@@ -15,6 +15,9 @@ import {
   clean,
 } from '../../runtime/agent/orchestrator/runtime-core/session-text.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';
+
 const VISIBLE_OWNERS = ['cli', 'user', 'mixdog'];
 
 function isLeadShaped(s, owner, sourceType) {
@@ -39,7 +42,9 @@ function previewOf(s) {
   const rawPreview = s.preview || '';
   let preview = isSessionPreviewNoise(rawPreview) ? '' : cleanSessionPreview(rawPreview);
   let messageCount = Math.max(0, Number(s.messageCount) || 0);
+  let realTurnCount = realTurnCountOf(s);
   if (!preview && Array.isArray(s.messages)) {
+    realTurnCount = s.messages.filter(isRealTurnMessage).length;
     const msgs = s.messages;
     const userPreviews = msgs
       .filter((m) => m && m.role === 'user')
@@ -50,10 +55,10 @@ function previewOf(s) {
     preview = userPreviews[0] || '';
     messageCount = msgs.filter((m) => m && (m.role === 'user' || m.role === 'assistant')).length;
   }
-  return { preview, messageCount };
+  return { preview, messageCount, realTurnCount };
 }
 
-function leadSessionRow(s, heartbeatMtimes) {
+export function leadSessionRow(s, heartbeatMtimes) {
   // Durable visibility is the catalog boundary. Apply it before the legacy
   // lead-shape heuristics so an explicitly agent-only child cannot leak just
   // because its owner field looks ordinary.
@@ -66,10 +71,14 @@ function leadSessionRow(s, heartbeatMtimes) {
   // One-shot `mixdog exec` runs are never resumable conversations.
   if (sourceType === 'exec') return null;
   if (!isLeadShaped(s, owner, sourceType)) return null;
-  const { preview, messageCount } = previewOf(s);
+  const { preview, messageCount, realTurnCount } = previewOf(s);
   if (!preview && messageCount === 0) return null;
   return {
     id: s.id,
+    // Durable provenance the desktop uses to tell a real conversation from
+    // resume scratch or synthetic-only rows when no title source survives.
+    ...(realTurnCount === null ? {} : { realTurnCount }),
+    ...(s.detachedReason ? { detachedReason: s.detachedReason } : {}),
     updatedAt: s.updatedAt,
     // Conversation-activity timestamp for Recent ordering. Without this the
     // desktop falls back to updatedAt, which detach/resume bookkeeping
@@ -93,6 +102,8 @@ function leadSessionRow(s, heartbeatMtimes) {
     // sessions under the sidebar Automations section instead of Recent.
     sourceType: sourceType || null,
     sourceName: clean(s.sourceName || '') || null,
+    createdAt: Number(s.createdAt) || 0,
+    inheritedFromSessionId: clean(s.inheritedFromSessionId || '') || null,
   };
 }
 

package/src/session-runtime/lifecycle/session-switch/resume.mjs

@@ -13,6 +13,8 @@ import { isScratchConversation } from '../shared.mjs';
 import { compactionArchiveRange } from '../../../runtime/agent/orchestrator/session/compaction-archive.mjs';
 import { stampCompactionMessageIds } from '../../../runtime/agent/orchestrator/session/compaction-archive-capture.mjs';
 import { boundWorkspaceCwd, restoreWorkspaceAfterResume } from '../../workspace/workspace-state.mjs';
+import { toolExposureMigrationNeeded } from '../../../runtime/agent/orchestrator/runtime-core/tool-exposure.mjs';
+import { markToolSurfaceMigrated } from '../../../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
 
 export function resolveResumeCwd(session, currentCwd) {
   // A worktree-bound Lead resumes in its worktree whatever its desktop class;
@@ -61,10 +63,14 @@ export function createSessionResume(deps, { ingestSessionIntoMemory, closeSurfac
   } = deps;
 
   function restoreResumedToolSurface(target, targetRoute) {
+    // A surface persisted with another tool exposure (e.g. a pre-bridge
+    // fixed canonical surface) migrates here; legacy selections never widen it.
+    const migrating = toolExposureMigrationNeeded(target, targetRoute.provider);
     applyDeferredToolSurface(target, deferredSurfaceModeForLead(getMode()), getStandaloneTools(), {
       provider: targetRoute.provider,
       model: targetRoute.model,
     });
+    if (migrating) markToolSurfaceMigrated(target);
   }
 
   // The resumed session's OWN effort wins. resolveRoute always returns an

package/src/session-runtime/lifecycle/session-switch/session-delete.mjs

@@ -5,7 +5,12 @@
  */
 import { clean } from '../../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { forgetSessionSearch } from '../../../runtime/session-search/session-search-ingest.mjs';
-import { listLeadSessions } from '../session-catalog.mjs';
+import { leadSessionRow } from '../session-catalog.mjs';
+import { getStoreDir } from '../../../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
+import {
+  STORED_SESSION_UNREADABLE,
+  _storedSessionFromFile,
+} from '../../../runtime/agent/orchestrator/session/store/serialize.mjs';
 import { SESSION_ID_PATTERN } from '../shared.mjs';
 import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 
@@ -50,6 +55,15 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     }
   }
 
+  // Availability is one strict read of the session's own file, filtered like
+  // the Lead catalog (an unreadable, foreign, closed or non-Lead record is not
+  // deletable). No catalog rebuild, no folder scan.
+  function isAvailableLead(sessionId) {
+    const stored = _storedSessionFromFile(getStoreDir(), `${sessionId}.json`);
+    if (!stored || stored === STORED_SESSION_UNREADABLE || stored.closed === true) return false;
+    return leadSessionRow(stored, new Map()) !== null;
+  }
+
   // The deleted task's worktree: the autoCleanup setting decides (clean and
   // merged → removed; otherwise kept). Off the deletion path; never fails it.
   function releaseDeletedWorktree(sessionId) {
@@ -61,12 +75,18 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   async function deleteSession(id) {
     const sessionId = clean(id);
     if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return false;
-    const available = listLeadSessions(mgr, { refreshFromStorage: true }).some((row) => row.id === sessionId);
-    if (!available) return false;
+    if (!isAvailableLead(sessionId)) return false;
     const childIds = ownedAgentSessionIds(sessionId);
     const current = getSession();
+    const cleanupReason = 'desktop-session-delete';
     if (current?.id !== sessionId) {
-      const deleted = mgr.deleteSession(sessionId) === true;
+      // A turn can still be running in a session that is no longer current.
+      // Stop its runtime first (controller abort, shells, generation bump) and
+      // release its lead row, agents and tasks, so nothing can write it back.
+      if (mgr.closeSession(sessionId, cleanupReason, { tombstone: false }) !== true) return false;
+      agentTool?.forgetLeadSession?.(sessionId);
+      releaseSessionWork(sessionId, cleanupReason);
+      const deleted = mgr.deleteSession(sessionId, { fenceWrites: true }) === true;
       if (!deleted) return false;
       void forgetSessionSearch(sessionId);
       // The parent is already irreversibly gone, so child cleanup is
@@ -74,7 +94,7 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
       // because its retained-parent proof disappeared with the parent.
       for (const childId of childIds) {
         try {
-          mgr.deleteSession(childId);
+          mgr.deleteSession(childId, { fenceWrites: true });
         } catch {}
       }
       void releaseDeletedWorktree(sessionId);
@@ -83,12 +103,15 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     // Leaving a worktree-bound Lead: the replacement starts in the Project
     // folder, and the worktree can go once nothing runs in it.
     const projectFolder = replacementSessionCwd(current);
-    const cleanupReason = 'desktop-session-delete';
     releaseSessionWork(sessionId, cleanupReason);
     // Active sessions retain a tombstone until the normal sweep. Unlinking
     // immediately would let a late provider/save continuation resurrect the
     // deleted conversation after the user has moved to its replacement.
     if (mgr.closeSession(sessionId, cleanupReason, { tombstone: true }) !== true) return false;
+    // The unwinding turn's late saves and its idle lead-row upsert must not
+    // touch the deleted conversation (an unguarded save would pass the tombstone).
+    mgr.fenceSessionWrites?.(sessionId);
+    agentTool?.forgetLeadSession?.(sessionId);
     void forgetSessionSearch(sessionId);
     // Active parent deletion uses the same durable tombstone boundary for
     // every linked child. Their files then mature with the parent instead of

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

@@ -7,11 +7,13 @@
  */
 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 { 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';
 
-const PROCESS_EXIT_REASON = /exit|quit|shutdown|sighup|sigint|sigterm/;
+const CLOSE_ALL_DEADLINE_MS = 5000;
+const PROCESS_EXIT_REASON =/exit|quit|shutdown|sighup|sigint|sigterm/;
 const WARMUP_TIMER_KEYS = [
   'providerSetupWarmupTimer',
   'providerWarmupTimer',
@@ -118,6 +120,45 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
     } catch {}
   }
 
+  // Agent closes that have not settled yet (one per close invocation, kept
+  // past the bounded wait if it overran).
+  const outstandingCloses = new Set();
+
+  /** Persist every queued index write. A close only ever drains: the shared
+   *  indexes stay registered (exit hook included) for the closes still to come. */
+  async function drainIndexWrites() {
+    try {
+      await agentTool.flushIndexWrites?.();
+      await flushAllIndexWrites();
+    } catch {}
+  }
+
+  // The disposal in progress (if any). New closes wait for it before starting
+  // their own closeAll, so no close produces writes while registrations are
+  // being released.
+  let indexDisposal = null;
+
+  /** Release this runtime's per-runtime index registrations (exit callbacks,
+   *  approval writer, store refs) once its drain has completed. Idempotent. A
+   *  drain that cannot complete tears nothing down: the registrations stay until
+   *  a later close drains successfully. Exit flushing itself is process-owned. */
+  function disposeIndexes(settle) {
+    // Assign before disposal runs (deferred), clear on settlement: a synchronous
+    // dispose must not clear the slot before it is assigned.
+    indexDisposal ??= Promise.resolve()
+      .then(async () => {
+        if (typeof agentTool.disposeAsync === 'function') await agentTool.disposeAsync({ settle });
+        else agentTool.dispose?.({ settle });
+      })
+      .catch(() => {
+        /* drain failed: registrations are kept for a later retry */
+      })
+      .finally(() => {
+        indexDisposal = null;
+      });
+    return indexDisposal;
+  }
+
   async function close(reason = 'cli-exit', options = {}) {
     quiesce(reason);
     const scope = teardownScope(reason, options, String(getSession()?.id || ''));
@@ -160,16 +201,40 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
     // memory and must leave workers/rows for the re-materialized owner.
     // Scoped teardown closes only THIS session's workers — the worker index
     // is shared across every Lead in the process.
+    let closing = null;
+    while (indexDisposal) await indexDisposal;
     if (scope.teardownReapsWork) {
+      // Every close runs its OWN scope's closeAll: a scoped close for one Lead
+      // never stands in for a process-wide close. Closing produces final index
+      // writes (settled rows, tombstones); the deadline only bounds how long
+      // teardown waits and does not stop the close.
+      const settled = () => {
+        outstandingCloses.delete(closing);
+      };
+      closing = new Promise((resolve) =>
+        resolve(agentTool.closeAll(reason, scope.scopedTeardown ? { callerSessionId: scope.closingSessionId } : {}))
+      ).then(settled, settled);
+      outstandingCloses.add(closing);
       try {
-        agentTool.closeAll(reason, scope.scopedTeardown ? { callerSessionId: scope.closingSessionId } : {});
+        await withTeardownDeadline(closing, CLOSE_ALL_DEADLINE_MS, false);
       } catch {}
     }
-    // Release the worker/lead index exit registrations (persists pending rows
-    // first). Idempotent, so repeated closes of one runtime dispose once.
-    try {
-      agentTool.dispose?.({ settle: scope.teardownReapsWork === true });
-    } catch {}
+    // Drain after the closes settle, then release this runtime's index
+    // registrations. A close that overran its deadline chains this onto its
+    // settlement (teardown may return before then). The live outstanding set is
+    // re-checked after every wait and drain, so the single disposal runs only
+    // when no close is outstanding; the check and the disposal start share one
+    // tick, and closes admitted afterwards wait for it.
+    const finish = async () => {
+      for (;;) {
+        while (outstandingCloses.size > 0) await Promise.allSettled([...outstandingCloses]);
+        await drainIndexWrites();
+        if (outstandingCloses.size === 0) break;
+      }
+      await disposeIndexes(scope.teardownReapsWork === true);
+    };
+    if (outstandingCloses.size > 0) void finish();
+    else await finish();
     const { ok, stops } = await inOwnLoopTurn(() => {
       const runtimeStops = startRuntimeStops(deps, reason, scope);
       const closed = closeOwnSession(deps, closeSurfaceSession, reason);
@@ -178,7 +243,7 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
     if (scope.detach) await settleDetached(withTeardownDeadline, stops);
     else await settleAll(withTeardownDeadline, stops);
     // The session went away (idle eviction included): free its save baselines.
-    if (scope.closingSessionId) forgetSessionSaveBaseline(scope.closingSessionId);
+    if (scope.closingSessionId) forgetSessionSaveBaseline(scope.closingSessionId, { releaseWriteControl: true });
     // Self-update stages in the background and swaps on the next clean launch
     // (see staged-update.mjs) — nothing installs at shutdown. On a real
     // process exit we just drop this session's live-refcount pid file so a

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

@@ -42,5 +42,6 @@ export function createLifecycleApi(deps) {
     resume: switching.resume,
     inheritancePreflight: inheritance.inheritancePreflight,
     inheritFrom: inheritance.inheritFrom,
+    inheritToNewSession: inheritance.inheritToNewSession,
   };
 }

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

@@ -24,11 +24,17 @@ export function createMcpConnect({
   const fingerprint = (cfg) => JSON.stringify(cfg);
   // Roots advertised by cwd-following servers track this runtime's cwd.
   const syncScopeRoot = () => mcpClient.setMcpScopeRoot?.(getMcpScopeId(), clean(getCurrentCwd?.()));
+  // Abort the pending interactive OAuth login of one server's connect.
+  const cancelMcpLogin = (name) => mcpClient.cancelMcpLogin?.(clean(name), scopeOptions());
+  // 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.
-  async function applyMcpServerConnection(name, enabled, servers = resolveEffectiveMcpServers().servers) {
+  // 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.
@@ -46,11 +52,16 @@ export function createMcpConnect({
     // between the close and the connect never resurrects the server.
     try {
       ensurePluginServerData(cfg);
-      await mcpClient.reconnectSingleMcpServer(getMcpScopeId(), target, cfg);
+      await mcpClient.reconnectSingleMcpServer(
+        getMcpScopeId(),
+        target,
+        cfg,
+        login ? { interactive: true, openBrowser: login.openBrowser } : {}
+      );
     } catch (error) {
-      const failures = Array.isArray(error?.failures)
-        ? error.failures
-        : [{ name: target, msg: error?.message || String(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];
     }
   }
@@ -72,7 +83,13 @@ export function createMcpConnect({
     ]);
   }
 
-  async function connectConfiguredMcp({ reset = false, only = null, enabled = true, reconcile = false } = {}) {
+  async function connectConfiguredMcp({
+    reset = false,
+    only = null,
+    enabled = true,
+    reconcile = false,
+    login = null,
+  } = {}) {
     if (envFlag('MIXDOG_DISABLE_MCP')) {
       ++state.mcpConnectGeneration;
       state.mcpFailures = [];
@@ -87,6 +104,9 @@ export function createMcpConnect({
     // 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`
@@ -106,7 +126,7 @@ export function createMcpConnect({
         }
         if (gen !== state.mcpConnectGeneration) return;
         if (reconcile) await reconcileServers();
-        else await applyMcpServerConnection(only, enabled);
+        else await applyMcpServerConnection(only, enabled, undefined, login);
       })();
       state.mcpConnectInFlight = run;
       try {
@@ -189,23 +209,35 @@ export function createMcpConnect({
         budgetMs = Math.min(budgetMs, requestedMaxWaitMs);
       }
     }
-    // Swallow the in-flight rejection: failures are already captured in
-    // state.mcpFailures, and this gate must never reject the turn.
-    const settled = Promise.resolve(inFlight).catch(() => {});
     // 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(resolveBudget, budgetMs);
+      timer = setTimeout(() => {
+        expired = true;
+        resolveBudget();
+      }, budgetMs);
     });
     try {
-      await Promise.race([settled, budget]);
+      // 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 };
+  return { connectConfiguredMcp, awaitInitialMcpConnect, cancelMcpLogin, completeMcpLogin };
 }

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

@@ -5,9 +5,11 @@ import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-tex
 import { envFlag } from '../../runtime/shared/env.mjs';
 import { resolveMcpServerCatalog } from './plugin-servers.mjs';
 
-function mcpServerStatus(cfg, live, fail) {
+function mcpServerStatus(cfg, live, fail, loginPending) {
   if (cfg?.enabled === false) return 'disabled';
   if (live) return 'connected';
+  // Until an interactive sign-in completes the server still needs it.
+  if (loginPending || fail?.authRequired) return 'sign-in required';
   return fail ? 'failed' : 'disconnected';
 }
 
@@ -43,6 +45,12 @@ export function createMcpServerCatalog({
    *  runtime's session cwd. */
   function resolveCatalog() {
     if (envFlag('MIXDOG_DISABLE_MCP')) return EMPTY_CATALOG;
+    return resolveConfiguredCatalog();
+  }
+
+  /** Every configured server (user config plus plugin declarations, disabled
+   *  ones included) whether or not this runtime connects MCP at all. */
+  function resolveConfiguredCatalog() {
     let plugins = [];
     let registryWarning = null;
     try {
@@ -115,20 +123,28 @@ export function createMcpServerCatalog({
       const fail =
         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 status = mcpServerStatus(cfg, live && !dead, fail, loginPending);
+      // Needing an OAuth sign-in is a state, not an error.
+      const authRequired = status === 'sign-in required';
       const row = {
         name,
         configured: true,
         enabled: cfg?.enabled !== false,
         connected: Boolean(live) && !dead,
-        status: mcpServerStatus(cfg, live && !dead, fail),
+        status,
         transport: mcpTransportLabel(cfg),
         toolCount: live?.toolCount || 0,
         tools: live?.tools || [],
         capabilities: live?.capabilities || { tools: false, prompts: false, resources: false },
-        error: fail?.msg || null,
+        error: authRequired ? null : fail?.msg || null,
         warnings: [...(entry.warnings || []), ...(live?.warnings || [])],
         source: sources[name] || 'config',
       };
+      if (authRequired) row.authRequired = true;
+      const oauth = mcpClient.getMcpServerOAuthState?.(cfg);
+      // Why the last sign-in did not complete (already credential-scrubbed).
+      if (oauth) row.oauth = authRequired && fail?.msg ? { ...oauth, lastError: fail.msg } : oauth;
       if (entry.owner) {
         row.owner = entry.owner;
         row.pluginEnabled = entry.pluginEnabled;
@@ -180,6 +196,7 @@ export function createMcpServerCatalog({
   return {
     mcpTransportLabel,
     resolveCatalog,
+    resolveConfiguredCatalog,
     resolveEffectiveMcpServers,
     pluginServer,
     getMcpServerConfig,

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

@@ -37,11 +37,14 @@ export function createMcpGlue({
   return {
     mcpStatus: catalog.mcpStatus,
     resolveMcpCatalog: catalog.resolveCatalog,
+    resolveConfiguredMcpCatalog: catalog.resolveConfiguredCatalog,
     pluginMcpServer: catalog.pluginServer,
     pluginMcpSummary: catalog.pluginMcpSummary,
     getMcpServerConfig: catalog.getMcpServerConfig,
     connectConfiguredMcp: connect.connectConfiguredMcp,
     awaitInitialMcpConnect: connect.awaitInitialMcpConnect,
+    cancelMcpLogin: connect.cancelMcpLogin,
+    completeMcpLogin: connect.completeMcpLogin,
     normalizeMcpServerInput,
   };
 }