mixdog 1.2.1 → 1.2.2

package/src/runtime/shared/turn-worktree-snapshot.mjs

@@ -169,8 +169,30 @@ export function noteTurnWorktreeChange(paths = null) {
   }
 }
 
-function withStateLock(state, task) {
-  const next = state.lock.then(task, task);
+// A lock hold (queue wait plus work) at least this long is logged, so a slow
+// review bar can be told apart as waiting behind other captures or slow git.
+const SLOW_LOCK_LOG_MS = 1_000;
+
+function withStateLock(state, task, op = 'task') {
+  const queuedAt = Date.now();
+  const queuedBehind = state.lockDepth || 0;
+  state.lockDepth = queuedBehind + 1;
+  let startedAt = 0;
+  const timed = async () => {
+    startedAt = Date.now();
+    return await task();
+  };
+  const next = state.lock.then(timed, timed).finally(() => {
+    state.lockDepth -= 1;
+    const finishedAt = Date.now();
+    const waitMs = (startedAt || finishedAt) - queuedAt;
+    if (finishedAt - queuedAt >= SLOW_LOCK_LOG_MS) {
+      console.info(
+        `[turn-snapshot-lock] op=${op} waitMs=${waitMs} workMs=${finishedAt - (startedAt || finishedAt)} ` +
+          `queuedBehind=${queuedBehind} root=${state.root}`
+      );
+    }
+  });
   state.lock = next.then(
     () => undefined,
     () => undefined
@@ -338,6 +360,7 @@ async function ensureState(state) {
 }
 
 async function resetShadowIndex(state) {
+  state.lastCapture = null;
   state.sourceIndexPath ??= await sourceGitPath(state.root, 'index');
   const sourceIndex = state.sourceIndexPath;
   const target = join(state.gitDir, 'index');
@@ -400,10 +423,33 @@ async function changedWorktreePaths(state) {
   };
 }
 
-async function captureTreeUnlocked(state, toolPaths = []) {
+/** The capture sequence a caller observes before queueing on the lock. */
+function captureSequence(state) {
+  return state.captureSeq || 0;
+}
+
+/** `after` (a captureSequence() read before queueing): a capture of this root
+ *  that began after that point, with no reported write since and covering
+ *  every explicit path, already is a capture that began after the call. Many
+ *  sessions of one repository queue reads together; they share that capture
+ *  instead of each re-scanning the worktree in turn. */
+async function captureTreeUnlocked(state, toolPaths = [], { after = -1 } = {}) {
   await ensureState(state);
-  const { paths, excludedUntracked } = await changedWorktreePaths(state);
   const explicit = new Set(toolPaths);
+  const last = state.lastCapture;
+  if (
+    after >= 0 &&
+    last &&
+    last.seq > after &&
+    last.stamp === state.changeStamp &&
+    [...explicit].every((rel) => last.explicit.has(rel))
+  ) {
+    return last.tree;
+  }
+  state.captureSeq = captureSequence(state) + 1;
+  const capture = { seq: state.captureSeq, stamp: state.changeStamp, explicit, tree: '' };
+  state.lastCapture = null;
+  const { paths, excludedUntracked } = await changedWorktreePaths(state);
   for (const rel of explicit) {
     try {
       const stat = await lstat(resolve(state.root, rel));
@@ -432,7 +478,9 @@ async function captureTreeUnlocked(state, toolPaths = []) {
     });
   }
   const tree = await runGit(shadowArgs(state, ['write-tree']), { cwd: state.root });
-  return clean(tree.stdout);
+  capture.tree = clean(tree.stdout);
+  state.lastCapture = capture;
+  return capture.tree;
 }
 
 /** Only explicit tool targets bypass ignore/size filters. Their first-before
@@ -875,39 +923,74 @@ export async function resumeTurnWorktreeSnapshot(
   const root = await repositoryRoot(worktree).catch(() => null);
   if (!root) return null;
   const state = stateForRoot(root);
-  return await withStateLock(state, async () => {
-    await ensureState(state);
-    // A collected or never-written baseline restores nothing. Report that as
-    // "no snapshot" instead of failing every later call made against it.
-    const kind = await runGit(shadowArgs(state, ['cat-file', '-t', tree]), {
+  const after = captureSequence(state);
+  return await withStateLock(
+    state,
+    async () => {
+      await ensureState(state);
+      // A collected or never-written baseline restores nothing. Report that as
+      // "no snapshot" instead of failing every later call made against it.
+      const kind = await runGit(shadowArgs(state, ['cat-file', '-t', tree]), {
+        cwd: state.root,
+        allowFailure: true,
+      });
+      if (kind.code !== 0 || clean(kind.stdout) !== 'tree') return null;
+      const scopePaths = Array.isArray(paths) && paths.length > 0 ? [...new Set(paths)] : null;
+      const applied = await applyBaselineFilesUnlocked(state, tree, baselineFiles || []);
+      const snapshot = {
+        state,
+        root,
+        baselineTree: applied.tree,
+        currentTree: tree,
+        patch: '',
+        files: [],
+        patchTruncated: false,
+        scopePaths,
+        toolPaths: new Set(scopePaths || []),
+        pendingBaselines: new Map(),
+        baselineFiles: new Map(applied.files.map((entry) => [pathKey(entry.path), entry])),
+      };
+      const currentTree = await captureTreeUnlocked(state, snapshot.toolPaths, { after });
+      Object.assign(
+        snapshot,
+        withOmittedBaselines(
+          snapshot,
+          await diffTreesUnlocked(state, snapshot.baselineTree, currentTree, scopePaths, { omitPatch })
+        )
+      );
+      return snapshot;
+    },
+    'resume'
+  );
+}
+
+// Git's well-known empty tree: what an unborn HEAD (no commit yet) compares as.
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+
+/** The files among `paths` whose bytes in the snapshot's last capture still
+ *  differ from the source repository's current HEAD (staged or not), with
+ *  their counts against HEAD; no patch text. An ignored file that HEAD does
+ *  not hold is no uncommitted change and is left out. */
+export async function diffTurnWorktreeHead(snapshot, paths) {
+  const scope = [...new Set((paths || []).filter(Boolean))];
+  if (!snapshot?.state || !snapshot.currentTree || scope.length === 0) return [];
+  return await withStateLock(snapshot.state, async () => {
+    const { state } = snapshot;
+    const head = await runGit(['rev-parse', '--verify', '--quiet', 'HEAD^{tree}'], {
       cwd: state.root,
       allowFailure: true,
     });
-    if (kind.code !== 0 || clean(kind.stdout) !== 'tree') return null;
-    const scopePaths = Array.isArray(paths) && paths.length > 0 ? [...new Set(paths)] : null;
-    const applied = await applyBaselineFilesUnlocked(state, tree, baselineFiles || []);
-    const snapshot = {
-      state,
-      root,
-      baselineTree: applied.tree,
-      currentTree: tree,
-      patch: '',
-      files: [],
-      patchTruncated: false,
-      scopePaths,
-      toolPaths: new Set(scopePaths || []),
-      pendingBaselines: new Map(),
-      baselineFiles: new Map(applied.files.map((entry) => [pathKey(entry.path), entry])),
-    };
-    const currentTree = await captureTreeUnlocked(state, snapshot.toolPaths);
-    Object.assign(
-      snapshot,
-      withOmittedBaselines(
-        snapshot,
-        await diffTreesUnlocked(state, snapshot.baselineTree, currentTree, scopePaths, { omitPatch })
-      )
-    );
-    return snapshot;
+    const headTree = head.code === 0 ? clean(head.stdout) : EMPTY_TREE;
+    const { files } = await diffTreesUnlocked(state, headTree, snapshot.currentTree, scope, { omitPatch: true });
+    const added = files.filter((file) => file.status === 'A').map((file) => file.path);
+    if (added.length === 0) return files;
+    const ignored = await runGit(['check-ignore', '-z', '--stdin'], {
+      cwd: state.root,
+      input: `${added.join('\0')}\0`,
+      allowFailure: true,
+    });
+    const skip = new Set(splitNulList(ignored.stdout).map(pathKey));
+    return files.filter((file) => file.status !== 'A' || !skip.has(pathKey(file.path)));
   });
 }
 
@@ -930,17 +1013,22 @@ function startRefresh(snapshot) {
   const flight = { seq: (snapshot.refreshSeq || 0) + 1, promise: null };
   snapshot.refreshSeq = flight.seq;
   snapshot.refreshing = flight;
-  flight.promise = withStateLock(snapshot.state, async () => {
-    const mark = await captureMark(snapshot.state);
-    await materializeToolBaselines(snapshot);
-    const currentTree = await captureTreeUnlocked(snapshot.state, snapshot.toolPaths);
-    if (currentTree !== snapshot.currentTree) {
-      const review = await diffTreesUnlocked(snapshot.state, snapshot.baselineTree, currentTree, snapshot.scopePaths);
-      Object.assign(snapshot, withOmittedBaselines(snapshot, review));
-    }
-    snapshot.captured = mark;
-    return snapshot;
-  }).finally(() => {
+  const after = captureSequence(snapshot.state);
+  flight.promise = withStateLock(
+    snapshot.state,
+    async () => {
+      const mark = await captureMark(snapshot.state);
+      await materializeToolBaselines(snapshot);
+      const currentTree = await captureTreeUnlocked(snapshot.state, snapshot.toolPaths, { after });
+      if (currentTree !== snapshot.currentTree) {
+        const review = await diffTreesUnlocked(snapshot.state, snapshot.baselineTree, currentTree, snapshot.scopePaths);
+        Object.assign(snapshot, withOmittedBaselines(snapshot, review));
+      }
+      snapshot.captured = mark;
+      return snapshot;
+    },
+    'refresh'
+  ).finally(() => {
     if (snapshot.refreshing === flight) snapshot.refreshing = null;
   });
   return flight.promise;
@@ -982,6 +1070,7 @@ function safeRelativePath(root, value) {
 }
 
 async function restorePathFromTree(snapshot, rel) {
+  snapshot.state.lastCapture = null;
   const listed = await runGit(
     shadowArgs(snapshot.state, ['ls-tree', '-z', '--name-only', snapshot.baselineTree, '--', rel]),
     { cwd: snapshot.root }

package/src/runtime/shared/worktrees/contract.mjs

@@ -19,7 +19,6 @@ export const DEFAULT_WORKTREE_BRANCH_PREFIX = 'mixdog/';
 
 export const WORKSPACE_TRANSITION_STATES = Object.freeze(['idle', 'provisioning', 'switching', 'removing', 'recovery']);
 const WORKTREE_ENTRY_STATES = Object.freeze(['creating', 'ready', 'deleting', 'recovery']);
-const BRANCH_OCCUPANCY_KINDS = Object.freeze(['current', 'session', 'external', 'free']);
 
 /**
  * Stable error codes. Clients branch on `error.code`, never on message text.
@@ -302,29 +301,6 @@ export function normalizeWorktreeOwner(input) {
  * @typedef {{ branch: string, kind: BranchOccupancyKind, sessionId?: string, path?: string }} BranchOccupancy
  */
 
-/**
- * @param {unknown} input
- * @returns {BranchOccupancy}
- */
-export function normalizeBranchOccupancy(input) {
-  const value = record(input, 'occupancy');
-  const branch = text(value.branch, 'occupancy.branch');
-  const kind = oneOf(value.kind, BRANCH_OCCUPANCY_KINDS, 'occupancy.kind');
-  if (kind === 'free') {
-    if (value.sessionId != null || value.path != null) {
-      throw new TypeError('A free branch carries no sessionId or path.');
-    }
-    return { branch, kind };
-  }
-  if (kind !== 'session' && value.sessionId != null) {
-    throw new TypeError('Only a session occupancy carries a sessionId.');
-  }
-  const occupancy = { branch, kind };
-  if (kind === 'session') occupancy.sessionId = text(value.sessionId, 'occupancy.sessionId');
-  if (value.path != null) occupancy.path = text(value.path, 'occupancy.path');
-  return occupancy;
-}
-
 /**
  * The branch menu's rows (the desktop DesktopGitBranch shape) for the local
  * branch names the manager lists: `current` marks the branch checked out in

package/src/runtime/shared/worktrees/test-support.mjs

@@ -1,6 +1,6 @@
 // Temporary git repositories and data dirs for the worktree suites.
 import { execFileSync } from 'node:child_process';
-import { chmodSync, mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
+import { chmodSync, cpSync, existsSync, mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 
@@ -56,14 +56,29 @@ export function commitFile(cwd, rel, content, message = `edit ${rel}`) {
   return git(cwd, 'rev-parse', 'HEAD');
 }
 
-/** A repository on `main` with one commit. */
-export function makeRepo({ commit = true } = {}) {
-  const dir = tempDir('mixdog-wt-repo-');
+// Built once per process and copied per repository: the five or six git
+// spawns behind one fresh repository cost ~0.8 s on win32, and the worktree
+// suites make dozens. A non-bare repository holds no absolute paths, so a copy
+// is the same repository at its new location.
+const templates = new Map();
+
+function repoTemplate(commit) {
+  const existing = templates.get(commit);
+  if (existing && existsSync(existing)) return existing;
+  const dir = tempDir('mixdog-wt-template-');
   git(dir, 'init', '-q', '-b', 'main');
   git(dir, 'config', 'user.name', 'Mixdog Test');
   git(dir, 'config', 'user.email', 'mixdog@example.com');
   git(dir, 'config', 'core.autocrlf', 'false');
   if (commit) commitFile(dir, 'README.md', 'hello\n', 'initial');
+  templates.set(commit, dir);
+  return dir;
+}
+
+/** A repository on `main` with one commit. */
+export function makeRepo({ commit = true } = {}) {
+  const dir = tempDir('mixdog-wt-repo-');
+  cpSync(repoTemplate(commit), dir, { recursive: true });
   return dir;
 }
 

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

@@ -451,12 +451,18 @@ function resourceApiFor(boot) {
     STANDALONE_DATA_DIR,
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
     connectConfiguredMcp: boot.connectConfiguredMcp,
+    cancelMcpLogin: boot.cancelMcpLogin,
+    completeMcpLogin: boot.completeMcpLogin,
+    clearMcpServerOAuth: (cfg) => boot.mcpClient.clearMcpServerOAuth(cfg),
+    getMcpServerOAuthState: (cfg) => boot.mcpClient.getMcpServerOAuthState(cfg),
+    probeMcpServerAuth: (cfg) => boot.mcpClient.probeMcpServerAuth(cfg),
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
     refreshEmptySessionToolPolicy: boot.refreshEmptySessionToolPolicy,
     normalizeMcpServerInput: boot.normalizeMcpServerInput,
     mcpStatus: boot.mcpStatus,
     getMcpServerConfig: boot.getMcpServerConfig,
     resolveMcpCatalog: boot.resolveMcpCatalog,
+    resolveConfiguredMcpCatalog: boot.resolveConfiguredMcpCatalog,
     pluginMcpServer: boot.pluginMcpServer,
     skillsStatus: boot.skillsStatus,
     skillContent: boot.skillContent,

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

@@ -40,11 +40,14 @@ function wireMcp(boot) {
   const {
     mcpStatus,
     resolveMcpCatalog,
+    resolveConfiguredMcpCatalog,
     pluginMcpServer,
     pluginMcpSummary,
     getMcpServerConfig,
     connectConfiguredMcp,
     awaitInitialMcpConnect,
+    cancelMcpLogin,
+    completeMcpLogin,
     normalizeMcpServerInput,
   } = createMcpGlue({
     mcpClient,
@@ -59,11 +62,14 @@ function wireMcp(boot) {
   Object.assign(boot, {
     mcpStatus,
     resolveMcpCatalog,
+    resolveConfiguredMcpCatalog,
     pluginMcpServer,
     pluginMcpSummary,
     getMcpServerConfig,
     connectConfiguredMcp,
     awaitInitialMcpConnect,
+    cancelMcpLogin,
+    completeMcpLogin,
     normalizeMcpServerInput,
   });
 }

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

@@ -93,6 +93,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/teardown.mjs

@@ -178,7 +178,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/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 {
@@ -207,5 +227,5 @@ export function createMcpConnect({
     }
   }
 
-  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,
   };
 }