mixdog 1.2.0 → 1.2.2

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

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
-import { existsSync, realpathSync } from 'node:fs';
+import { existsSync, lstatSync, realpathSync } from 'node:fs';
 import { access, copyFile, lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { PATCH_EDIT_MAX_BYTES } from './bounded-file-read.mjs';
 import { cleanString as clean } from './clean.mjs';
 import { runGitOffThread } from './git-runner.mjs';
@@ -44,8 +44,26 @@ function pathKey(value) {
 
 /** `resolve` plus symlinks of the nearest existing ancestor: git reports the
  *  worktree root canonically (macOS /var -> /private/var), callers may not. */
-function canonicalPath(value) {
+function canonicalPath(value, dirs = null) {
   const full = resolve(value);
+  if (dirs) {
+    // Same result as the walk below without repeating it per file: the parent
+    // directory is canonicalized once per call; the final component only
+    // matters when it is itself a link (or its state is unknown).
+    const parent = dirname(full);
+    if (parent !== full) {
+      let canonicalParent = dirs.get(parent);
+      if (canonicalParent === undefined) {
+        canonicalParent = canonicalPath(parent);
+        dirs.set(parent, canonicalParent);
+      }
+      try {
+        if (!lstatSync(full).isSymbolicLink()) return join(canonicalParent, basename(full));
+      } catch (error) {
+        if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') return join(canonicalParent, basename(full));
+      }
+    }
+  }
   let head = full;
   while (!existsSync(head)) {
     const parent = dirname(head);
@@ -139,8 +157,10 @@ function stateForRoot(root) {
 /** Report written paths (or `null`: anything may have changed). The next
  *  review poll of an affected worktree captures instead of reusing. */
 export function noteTurnWorktreeChange(paths = null) {
+  if (states.size === 0) return;
   const list = Array.isArray(paths) ? paths.filter((value) => clean(value)) : [];
-  const keys = list.map((value) => pathKey(canonicalPath(value)));
+  const dirs = new Map();
+  const keys = list.map((value) => pathKey(canonicalPath(value, dirs)));
   for (const state of states.values()) {
     const root = pathKey(state.root);
     if (keys.length === 0 || keys.some((key) => key === root || key.startsWith(`${root}/`))) {
@@ -149,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
@@ -318,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');
@@ -380,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));
@@ -412,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
@@ -781,7 +849,7 @@ function scheduleShadowGc(state) {
 async function removeShadowDir(gitDir, removed, kept) {
   if (!(await exists(gitDir))) return;
   await rm(gitDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch(() => {});
-  (await exists(gitDir) ? kept : removed).push(gitDir);
+  ((await exists(gitDir)) ? kept : removed).push(gitDir);
 }
 
 /** Drop every trace of one worktree root: serialize behind its pending capture
@@ -855,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)));
   });
 }
 
@@ -910,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;
@@ -962,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/worker-requests.mjs

@@ -14,8 +14,11 @@ import { parentPort, Worker } from 'node:worker_threads';
  * worker is detached before it is terminated, so no request is ever sent to
  * (or lost with) a worker that is shutting down.
  * `request.running()` reports whether a worker thread is currently attached.
+ *
+ * `onEvent` (optional): receives what the worker sends with postWorkerEvent
+ * (messages that answer no request).
  */
-export function createWorkerRequestClient(url, { idleExitMs = 0, ...workerOptions } = {}) {
+export function createWorkerRequestClient(url, { idleExitMs = 0, onEvent = null, ...workerOptions } = {}) {
   let worker = null;
   let nextRequestId = 0;
   // Requests belong to the worker they were posted to: a replacement worker
@@ -50,7 +53,12 @@ export function createWorkerRequestClient(url, { idleExitMs = 0, ...workerOption
       owned.clear();
       for (const entry of entries) entry.reject(error);
     };
-    created.on('message', ({ id, result, error }) => {
+    created.on('message', (message) => {
+      if (message && Object.hasOwn(message, 'event')) {
+        onEvent?.(message.event);
+        return;
+      }
+      const { id, result, error } = message;
       const entry = owned.get(id);
       if (!entry) return;
       owned.delete(id);
@@ -109,6 +117,11 @@ export function createWorkerRequestClient(url, { idleExitMs = 0, ...workerOption
   return request;
 }
 
+/** Worker side: send `event` to the client's `onEvent`, outside any request. */
+export function postWorkerEvent(event) {
+  parentPort.postMessage({ event });
+}
+
 /** Worker side: answer every request with `handler(payload)` (sync or async). */
 export function serveWorkerRequests(handler) {
   parentPort.on('message', ({ id, payload }) => {

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/automation-agents.mjs

@@ -57,10 +57,16 @@ export function deliverAutomationCompletion(sessionId, text, meta = {}) {
   return true;
 }
 
+// Ask options for a follow-up turn fed by agent results: the runtime reporting
+// worker output, not the user — stored as a task notification and never a
+// source of explicit skill selection.
+export const AUTOMATION_RESULT_TURN_OPTS = Object.freeze({ promptSource: 'task-notification' });
+
 /**
  * Runs an automation conversation to its end: the first turn, then one more
  * turn per batch of agent results while agents it started are still out.
- * Resolves with the last turn's result.
+ * `nextTurn(text, askOpts)` receives AUTOMATION_RESULT_TURN_OPTS as the
+ * results' provenance. Resolves with the last turn's result.
  */
 export async function runAutomationTurns(sessionId, firstTurn, nextTurn, { waitMs = AGENT_RESULT_WAIT_MS } = {}) {
   const run = { pending: new Set(), ready: [], wake: null };
@@ -79,7 +85,7 @@ export async function runAutomationTurns(sessionId, firstTurn, nextTurn, { waitM
         run.wake = null;
         if (!arrived) break;
       }
-      result = await nextTurn(run.ready.splice(0).join('\n\n'));
+      result = await nextTurn(run.ready.splice(0).join('\n\n'), { ...AUTOMATION_RESULT_TURN_OPTS });
     }
     return result;
   } finally {

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

@@ -60,6 +60,10 @@ import { createGoalFacadeApi } from '../goal-facade-api.mjs';
 import { createRuntimeReviewApi } from '../runtime-review-api.mjs';
 import { createWorkspaceTransitions, refreshWorkspacePrompt } from '../workspace/transitions.mjs';
 import { saveSession } from '../../runtime/agent/orchestrator/session/store.mjs';
+import { modelToolSchemaAllowlist } from '../../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
+import { sessionOptions } from '../session-create/session-options.mjs';
+import { createConversationImportApi } from '../conversation-import/service.mjs';
+import { importError } from '../conversation-import/discovery.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
 import {
@@ -88,12 +92,22 @@ export function wireApis(boot) {
   });
   boot.providerAuthApi = providerAuthApiFor(boot);
   boot.mediaApi = createMediaApi();
+  boot.conversationImportApi = conversationImportApiFor(boot);
   boot.sessionTitles = createSessionTitleController({
     dataRoot: () => dataDirOf(boot.cfgMod),
     promoteGeneratedTitle: (sessionId, title, stage) => boot.mgr.updateSessionGeneratedTitle(sessionId, title, stage),
   });
   boot.lifecycleApi = lifecycleApiFor(boot);
   boot.resourceApi = resourceApiFor(boot);
+  // Plugin MCP servers are derived live; copies an earlier enable action wrote
+  // into mcpServers are adopted once (an injected headless config is left as is).
+  if (!boot.params.initialConfig || typeof boot.params.initialConfig !== 'object') {
+    try {
+      boot.resourceApi.migratePluginMcpCopies();
+    } catch (error) {
+      bootProfile('plugin-mcp:adopt-failed', { error: error?.message || String(error) });
+    }
+  }
   boot.disposeGlobalExtensionSubscription = () => {
     boot.disposeConfigSync?.();
     boot.resourceApi.disposeGlobalExtensionSubscription?.();
@@ -282,6 +296,45 @@ function settingsApiFor(boot) {
   });
 }
 
+// Conversation import: imported sessions are built with the Lead options a new
+// session of this runtime would get (current route, tools, workflow, memory),
+// minus its reservation, profile ownership and desktop placement.
+function conversationImportApiFor(boot) {
+  const { rt, mgr } = boot;
+  return createConversationImportApi({
+    // The async catalog (the daemon's SQLite catalog worker, else JSON),
+    // loaded on first use so boot does not pull in the cold reader.
+    listSessionSummaries: async () => {
+      const reader = await import('../../runtime/agent/orchestrator/session/store-summary-reader.mjs');
+      return reader.listStoredSessionSummariesAsync();
+    },
+    createSession: (options) => mgr.createSession(options),
+    prepareLeadOptions: async () => {
+      await boot.awaitKeychainPrewarm();
+      const route = rt.route?.provider && rt.route?.model ? rt.route : resolveRoute(rt.config, {});
+      if (!route?.provider || !route?.model) throw importError('noModelRoute');
+      await boot.ensureProvidersReady(rt.config.providers || {});
+      const coreMemoryContext = await boot.loadCoreMemoryContext();
+      const leadView = Object.assign(Object.create(rt), {
+        route,
+        reservedSessionId: null,
+        sessionProfile: null,
+        desktopSession: null,
+      });
+      return sessionOptions(
+        {
+          rt: leadView,
+          cfgMod: boot.cfgMod,
+          activeWorkflowContext: workflowHelpers.activeWorkflowContext,
+          schemaAllowedTools: modelToolSchemaAllowlist(rt.toolProfile),
+          featureDisallowedTools: boot.featureDisallowedTools,
+        },
+        coreMemoryContext
+      );
+    },
+  });
+}
+
 function providerAuthApiFor(boot) {
   const { rt, cfgMod, reg, ensureProvidersReady } = boot;
   return createProviderAuthApi({
@@ -398,11 +451,19 @@ 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,
     addGlobalSkill: boot.addGlobalSkill,

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

@@ -87,7 +87,8 @@ function initRuntimeState(rt, params) {
   rt.activeTurnAbortControllers = new Set();
   rt.firstTurnCompleted = false;
   rt.codeGraphFirstTurnPrewarmDone = false;
-  rt.startupProviderCatalogRefreshStarted = false;
+  // Last registry catalog-refresh promise this runtime attached handling to.
+  rt.startupProviderCatalogRefreshObserved = null;
   // True while the boot-time provider-catalog refresh is in flight: warming a
   // model cache it is about to invalidate only burns the load twice.
   rt.startupProviderCatalogRefreshPending = false;
@@ -106,7 +107,9 @@ function activeTurnControls(rt) {
         aborted = true;
         try {
           controller.abort(reason);
-        } catch {}
+        } catch {
+          // Best-effort: one throwing abort listener must not stop the others.
+        }
       }
       return aborted;
     },

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

@@ -18,6 +18,7 @@ export function buildFacade(boot) {
       ...boot.providerAuthApi,
       ...boot.usageStatsApi,
       ...boot.mediaApi,
+      ...boot.conversationImportApi,
       ...boot.runtimeReviewApi,
     },
     goalApi: boot.goalFacadeApi,

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

@@ -7,11 +7,7 @@ import { createStandaloneHookBus } from '../services/hook-bus.mjs';
 import { updateCurrentCwdOverride, writeLastSessionCwd } from '../../runtime/shared/user-cwd.mjs';
 import { listRegisteredPlugins, pluginAdminStatus } from '../services/plugin-admin.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
-import {
-  countSkillFiles,
-  pluginManifest,
-  pluginMcpServerName,
-} from '../../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { countSkillFiles, pluginManifest } from '../../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { createMcpGlue } from '../mcp-glue.mjs';
 import { createSelfUpdateController } from '../self-update.mjs';
@@ -41,23 +37,39 @@ function wireMcp(boot) {
     mcpConnectGeneration: 0,
     mcpConnectInFlight: null,
   };
-  const { mcpStatus, getMcpServerConfig, connectConfiguredMcp, awaitInitialMcpConnect, normalizeMcpServerInput } =
-    createMcpGlue({
-      mcpClient,
-      getConfig: () => rt.config,
-      getCurrentCwd: () => rt.currentCwd,
-      getMcpScopeId: () => rt.mcpScopeId,
-      getDesktopSession: () => rt.desktopSession,
-      setDesktopSession: (v) => {
-        rt.desktopSession = v;
-      },
-      state: mcpState,
-    });
+  const {
+    mcpStatus,
+    resolveMcpCatalog,
+    resolveConfiguredMcpCatalog,
+    pluginMcpServer,
+    pluginMcpSummary,
+    getMcpServerConfig,
+    connectConfiguredMcp,
+    awaitInitialMcpConnect,
+    cancelMcpLogin,
+    completeMcpLogin,
+    normalizeMcpServerInput,
+  } = createMcpGlue({
+    mcpClient,
+    getConfig: () => rt.config,
+    getCurrentCwd: () => rt.currentCwd,
+    getMcpScopeId: () => rt.mcpScopeId,
+    // Plugin-declared servers are derived from the registry on every resolve.
+    getPluginDataDir: () => dataDirOf(boot.cfgMod),
+    listPlugins: () => listRegisteredPlugins({ dataDir: boot.cfgMod.getPluginData() }),
+    state: mcpState,
+  });
   Object.assign(boot, {
     mcpStatus,
+    resolveMcpCatalog,
+    resolveConfiguredMcpCatalog,
+    pluginMcpServer,
+    pluginMcpSummary,
     getMcpServerConfig,
     connectConfiguredMcp,
     awaitInitialMcpConnect,
+    cancelMcpLogin,
+    completeMcpLogin,
     normalizeMcpServerInput,
   });
 }
@@ -250,7 +262,12 @@ function wireCwdPlugins(boot) {
     listRegisteredPlugins,
     pluginAdminStatus,
     pluginManifest,
-    pluginMcpServerName,
+    pluginMcpSummary: boot.pluginMcpSummary,
+    // Plugin MCP servers without a declared cwd follow this runtime's cwd:
+    // reconnect just those (and refresh advertised roots) in place.
+    onCwdChanged: () => {
+      void boot.connectConfiguredMcp({ reconcile: true }).catch(() => {});
+    },
     countSkillFiles,
     writeLastSessionCwd,
     updateCurrentCwdOverride,