mixdog 1.4.0 → 1.4.1

package/src/session-runtime/handoff-attachments.mjs

@@ -453,8 +453,9 @@ function callArgs(call) {
   return args && typeof args === 'object' ? args : {};
 }
 
-/** The paths one tool call wrote or produced. */
-function toolCallOutputs(call) {
+/** The paths one tool call wrote or produced; `written`: only those it
+ *  actually created or modified (opening a file in visualize does neither). */
+function toolCallOutputs(call, written) {
   const name = String(call?.function?.name || call?.name || '');
   const args = callArgs(call);
   const text = (value) => (typeof value === 'string' && value.trim() ? [value.trim()] : []);
@@ -464,7 +465,7 @@ function toolCallOutputs(call) {
   if (name === 'office') return OFFICE_WRITE_ACTIONS.has(args.action) ? [...text(args.output), ...text(args.path)] : [];
   if (name === 'visualize') {
     const input = args.input && typeof args.input === 'object' ? args.input : {};
-    const targets = args.action === 'open' && Array.isArray(input.targets) ? input.targets : [];
+    const targets = !written && args.action === 'open' && Array.isArray(input.targets) ? input.targets : [];
     return [
       ...text(input.output),
       ...targets.filter((target) => typeof target === 'string' && !/^[a-z][a-z0-9+.-]*:\/\//i.test(target)),
@@ -520,8 +521,9 @@ export function turnSlice(messages, { runId = '', since = 0 } = {}) {
 
 /** The candidate artifact paths of a turn's messages, most relevant first:
  *  what its final reply names, then media/office/visualize outputs, then the
- *  files it edited. */
-export function turnArtifactCandidates(messages) {
+ *  files it edited. `written`: only the files it created or modified (no
+ *  reply paths, no visualize open targets). */
+export function turnArtifactCandidates(messages, { written = false } = {}) {
   const list = Array.isArray(messages) ? messages : [];
   const reply = list.findLast((message) => message?.role === 'assistant' && textOf(message.content).trim());
   const produced = [];
@@ -535,10 +537,10 @@ export function turnArtifactCandidates(messages) {
         : [];
     for (const call of calls) {
       const name = String(call?.function?.name || call?.name || '');
-      (name === 'edit' || name === 'apply_patch' ? edited : produced).push(...toolCallOutputs(call));
+      (name === 'edit' || name === 'apply_patch' ? edited : produced).push(...toolCallOutputs(call, written));
     }
   }
-  return [...(reply ? replyPaths(textOf(reply.content)) : []), ...produced, ...edited];
+  return [...(!written && reply ? replyPaths(textOf(reply.content)) : []), ...produced, ...edited];
 }
 
 /**
@@ -549,38 +551,16 @@ export function turnArtifactCandidates(messages) {
  * the roots are left out silently; at most HANDOFF_LIMITS.count are kept.
  */
 export function collectTurnArtifacts(messages, { cwd = '', roots = [] } = {}) {
-  const seen = new Set();
   const files = [];
   let omitted = 0;
   const budget = createBudget();
-  for (const candidate of turnArtifactCandidates(messages)) {
-    // A candidate is a lexical path; its canonical form dedupes after the read.
-    const lexical = samePlatformPath(
-      isAbsolute(candidate) ? resolve(candidate) : resolve(cwd || process.cwd(), candidate)
-    );
-    if (seen.has(lexical)) continue;
-    seen.add(lexical);
-    let file;
-    try {
-      file = readContained(candidate, { cwd, roots, surface: 'artifact' });
-    } catch {
-      continue;
-    }
-    const key = samePlatformPath(file.path);
-    if (key !== lexical && seen.has(key)) continue;
-    seen.add(key);
+  for (const { file } of readableCandidates(turnArtifactCandidates(messages), { cwd, roots })) {
     if (files.length >= HANDOFF_LIMITS.count) {
       omitted += 1;
       continue;
     }
     const { type, bytes } = file;
-    const entry = {
-      path: file.path,
-      name: file.name,
-      kind: type?.kind || 'file',
-      mimeType: type?.mimeType || 'application/octet-stream',
-      size: file.size,
-    };
+    const entry = pathEntry(file);
     const storable = bytes && (type.kind !== 'image' || SUPPORTED_IMAGE_MIME_TYPES.has(type.mimeType));
     if (storable && budget.take(type.kind, bytes.length)) {
       try {
@@ -591,3 +571,74 @@ export function collectTurnArtifacts(messages, { cwd = '', roots = [] } = {}) {
   }
   return { files, omitted };
 }
+
+/**
+ * The files `messages` (one turn) created or modified, inside `roots`, that
+ * `report` (the text handed to the Lead) does not name: `{ files, omitted }`
+ * as path-only entries, which the Lead forwards by path. Nothing is stored.
+ */
+export function collectUnreportedWrites(messages, { cwd = '', roots = [], report }) {
+  const found = [...readableCandidates(turnArtifactCandidates(messages, { written: true }), { cwd, roots })];
+  const unnamed = found.filter((item) => !reportNames(report, item, found, cwd));
+  return {
+    files: unnamed.slice(0, HANDOFF_LIMITS.count).map(({ file }) => pathEntry(file)),
+    omitted: Math.max(0, unnamed.length - HANDOFF_LIMITS.count),
+  };
+}
+
+const lexicalKey = (path, cwd) => samePlatformPath(resolve(cwd || process.cwd(), path));
+
+const pathEntry = (file) => ({
+  path: file.path,
+  name: file.name,
+  kind: file.type?.kind || 'file',
+  mimeType: file.type?.mimeType || 'application/octet-stream',
+  size: file.size,
+});
+
+/** The distinct files among `candidates` that can be read inside `roots`, with
+ *  their lexical and canonical keys. A candidate is a lexical path; its
+ *  canonical form dedupes after the read. */
+function* readableCandidates(candidates, { cwd, roots }) {
+  const seen = new Set();
+  for (const candidate of candidates) {
+    const lexical = lexicalKey(candidate, cwd);
+    if (seen.has(lexical)) continue;
+    seen.add(lexical);
+    let file;
+    try {
+      file = readContained(candidate, { cwd, roots, surface: 'artifact' });
+    } catch {
+      continue;
+    }
+    const key = samePlatformPath(file.path);
+    if (key !== lexical && seen.has(key)) continue;
+    seen.add(key);
+    yield { file, lexical, key };
+  }
+}
+
+/** Whether `report` names the produced file `item` among `found`: by its full
+ *  path or a cwd-relative path resolving to it exactly, or by its bare file name
+ *  when no other produced file shares that name. */
+function reportNames(report, { file, lexical, key }, found, cwd) {
+  const flat = (value) => String(value).replaceAll('\\', '/');
+  const filePath = flat(file.path);
+  if (flat(report).includes(filePath)) return true;
+  const plain = report
+    .split(/[\s`"'<>()[\],;|]+/)
+    .map((token) => token.replace(/:\d+(?::\d+)?$/, '').replace(/[.:!?]+$/, ''))
+    .filter((token) => /\.[A-Za-z0-9]{1,8}$/.test(token) && !/^[a-z][a-z0-9+.-]*:\/\//i.test(token));
+  const refs = new Set([...replyPaths(report), ...plain]);
+  const unique = found.filter((other) => other.file.name === file.name).length === 1;
+  for (const ref of refs) {
+    const normalized = flat(ref).replace(/^(?:\.\/)+/, '');
+    if (!normalized.includes('/')) {
+      if (unique && normalized === file.name) return true;
+      continue;
+    }
+    const refKey = lexicalKey(ref, cwd);
+    if (refKey === lexical || refKey === key) return true;
+  }
+  return false;
+}

package/src/session-runtime/internal-tool-executor/ask-user-tool.mjs

@@ -1,8 +1,9 @@
 // ask_user: put 1-4 multiple-choice questions to the user through the session's
 // tool-approval hook (kind: 'question') and report the answers to the model.
+// handoff_user (the secret / takeover handoff) shares this module's human-gate code.
 import { randomUUID } from 'node:crypto';
 import {
-  validateAskUserHandoff,
+  validateUserHandoff,
   validateAskUserQuestions,
   ASK_USER_MAX_TEXT,
 } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
@@ -78,7 +79,7 @@ export async function runAskUserHandoff(handoff, { hook, sessionId, toolCallId,
   const gate = {
     agentId: agentIdForSession(sessionId),
     kind: handoff.kind,
-    tool: `ask_user:${handoff.surface}`,
+    tool: `handoff_user:${handoff.surface}`,
     target: handoff.target || handoff.field || '',
   };
   // A schedule or webhook run has nobody to take over: the step ends it now,
@@ -133,7 +134,7 @@ export async function runAskUserHandoff(handoff, { hook, sessionId, toolCallId,
     }
     const result = await runAbortable(signal, () =>
       hook({
-        name: 'ask_user',
+        name: 'handoff_user',
         kind: 'secret',
         secret: { requestId, surface: handoff.surface, target: handoff.target, field: handoff.field, ...bound },
         reason: '',
@@ -171,7 +172,7 @@ export async function runAskUserHandoff(handoff, { hook, sessionId, toolCallId,
     : null;
   const result = await runAbortable(signal, () =>
     hook({
-      name: 'ask_user',
+      name: 'handoff_user',
       kind: 'takeover',
       takeover: {
         surface: handoff.surface,
@@ -278,16 +279,14 @@ function formatAskUserResult(questions, answers, reply) {
 export function createAskUserToolHandlers({ rt }) {
   const { sessionIdFor, signalFor } = createCallerContextResolvers(rt);
   return {
+    handoff_user: async (args, { callerCtx }) =>
+      runAskUserHandoff(validateUserHandoff(args), {
+        hook: callerCtx?.toolApprovalHook,
+        sessionId: sessionIdFor(callerCtx),
+        toolCallId: callerCtx?.toolCallId || null,
+        signal: signalFor(callerCtx),
+      }),
     ask_user: async (args, { callerCtx }) => {
-      const handoff = validateAskUserHandoff(args);
-      if (handoff) {
-        return runAskUserHandoff(handoff, {
-          hook: callerCtx?.toolApprovalHook,
-          sessionId: sessionIdFor(callerCtx),
-          toolCallId: callerCtx?.toolCallId || null,
-          signal: signalFor(callerCtx),
-        });
-      }
       const questions = validateAskUserQuestions(args);
       const hook = callerCtx?.toolApprovalHook;
       if (typeof hook !== 'function') return NO_USER;

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

@@ -83,6 +83,7 @@ export function createBridgeToolHandlers({ rt }) {
     }
     return await executeVisualizeTool(args, {
       sessionId: sessionIdFor(callerCtx),
+      callId: callerCtx?.toolCallId,
       cwd: callerCwd,
       signal: signalFor(callerCtx),
     });

package/src/session-runtime/internal-tool-executor/reaction-tool.mjs

@@ -4,7 +4,10 @@
 // the message is the user's row in the room's log. Never a coding session, a
 // delegated worker, or a run nobody attends.
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
-import { noteReactionTarget, validateReactionArgs } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
+import {
+  noteReactionTarget,
+  validateReactionArgs,
+} from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { roomMemberOfSession, roomSessionId } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
 import { reactInSession } from '../../runtime/agent/orchestrator/session/message-reactions.mjs';

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

@@ -17,6 +17,7 @@ import { scheduleCallerScope } from '../services/schedule-access.mjs';
 import { worktreeCallerScope } from '../services/worktree-access.mjs';
 import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
 import { delegationChainOf } from '../bot-chain.mjs';
+import { BOT_TARGET_ACTIONS, resolveBotTarget } from '../bot-target.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
 
@@ -50,6 +51,7 @@ export function createWorkspaceToolHandlers({
   getSessionManager = () => null,
   getLifecycleApi = () => null,
   executeSessionControl = null,
+  listBots,
 }) {
   const assertLead = (action, callerCtx) => {
     const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
@@ -110,12 +112,16 @@ export function createWorkspaceToolHandlers({
           'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
         );
       }
+      // A bot id names that bot's home chat; every check below and in the
+      // control runs on the chat it resolves to.
+      const sessionTarget =
+        BOT_TARGET_ACTIONS.has(action) && target ? await resolveBotTarget(target, listBots) : target;
       // A task session reaches its agent only through its reported result.
       const origin = rt.session?.taskOrigin;
       if (
         action === 'send' &&
         origin &&
-        (target === origin.sessionId || agentIdOfHomeSession(target) === origin.agentId)
+        (sessionTarget === origin.sessionId || agentIdOfHomeSession(sessionTarget) === origin.agentId)
       ) {
         throw new Error('session: a task session reports to its agent only through its result');
       }
@@ -129,7 +135,7 @@ export function createWorkspaceToolHandlers({
       const attachmentParts = callerAttachmentParts(rt, args, callerCwd, 'session');
       return JSON.stringify(
         await executeSessionControl(
-          { ...rest, action },
+          { ...rest, action, ...(sessionTarget !== target ? { session_id: sessionTarget } : {}) },
           {
             callerSessionId,
             callerAgentId,

package/src/session-runtime/lifecycle/cold-heir.mjs

@@ -150,14 +150,19 @@ export function buildColdHeir(source, now = Date.now()) {
   // earlier folder) is the source's own: the heir's prompt is built for the
   // folder it actually starts in. Project memory follows the Project, which a
   // worktree shares, so the source's current memory slice carries over.
+  // In the same folder only the environment facts are rebuilt: they name the
+  // heir's own scratch directory, never the source's, while the inherited
+  // instruction files and memory stay as the source presented them.
   const pending = source.workspaceReroot;
   delete heir.workspaceReroot;
-  if ((projectFolder || pending) && heir.cwd) {
-    refreshSessionWorkspaceContext(heir, {
-      cwd: heir.cwd,
-      ...buildWorkspacePromptContext(heir, heir.cwd),
-      coreMemoryContext: pending?.target?.coreMemoryContext,
-    });
+  if (heir.cwd) {
+    const context = buildWorkspacePromptContext(heir, heir.cwd);
+    refreshSessionWorkspaceContext(
+      heir,
+      projectFolder || pending
+        ? { cwd: heir.cwd, ...context, coreMemoryContext: pending?.target?.coreMemoryContext }
+        : { cwd: heir.cwd, environmentContext: context.environmentContext }
+    );
   }
   invalidateContextUsageSnapshot(heir);
   invalidateProviderContextBaseline(heir);

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

@@ -21,7 +21,11 @@ import {
   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';
+import {
+  compactCount as compactCountOf,
+  compactCountField,
+  realTurnCount as realTurnCountOf,
+} from '../../runtime/agent/orchestrator/session/store-summary-fields.mjs';
 
 const VISIBLE_OWNERS = ['cli', 'user', 'mixdog'];
 
@@ -107,6 +111,10 @@ export function leadSessionRow(s, working = false) {
     // 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 } : {}),
+    // The numbering epoch of messageCount: each compaction restarts it. A
+    // summary row carries it at the top; a stored session in its compaction
+    // record. Unknown stays absent.
+    ...compactCountField(compactCountOf(s) === null ? s.compaction : s),
     title: cleanSessionPreview(s.title || '', 100),
     preview,
     // The latest user or assistant line (an agent contact's row shows it).

package/src/session-runtime/model-route/set-route.mjs

@@ -217,11 +217,20 @@ function switchSessionInPlace(deps, session) {
 
 /** The Lead's fallback models after this selection, checked like an agent's
  *  chain (leaf routes, distinct providers): an explicit list replaces the
- *  stored one ([] clears it), a selection without one keeps it. */
+ *  stored one ([] clears it), a selection without one keeps it as stored — a
+ *  fallback on the new main model's provider stays saved and is inactive
+ *  (executionFallbacks). */
 async function leadFallbackChain(deps, next, primary) {
   const storedPreset = findPreset(deps.getConfig(), workflowPresetId('lead'));
-  const requested = hasOwn(next || {}, 'fallbacks') ? next.fallbacks : storedPreset?.fallbacks;
+  const explicit = hasOwn(next || {}, 'fallbacks');
+  const requested = explicit ? next.fallbacks : storedPreset?.fallbacks;
   if (!Array.isArray(requested) || !requested.length) return [];
+  if (!explicit) {
+    return (
+      normalizeWorkflowRoute({ provider: primary.provider, model: primary.model, fallbacks: requested })?.fallbacks ||
+      []
+    );
+  }
   const chain = routeChain({ provider: primary.provider, model: primary.model, fallbacks: requested });
   validateRouteChainProviders(chain);
   const storedChain = routeChain(storedPreset || {});

package/src/session-runtime/provider-catalog-cache.mjs

@@ -37,6 +37,19 @@ let sharedPartialEntries = null;
 let sharedCatalogPromise = null;
 let sharedCatalogPromiseKey = null;
 let sharedCatalogPromiseForced = false;
+// Every read that publishes to the shared state (a full load or a scoped
+// refresh) runs through this queue, one at a time, so the last write is always
+// the newest successful answer.
+// A catalog state that moved on (new revision or account epoch) starts a fresh
+// queue: reads of the old state never publish, so nothing waits for them.
+let publishing = { key: null, tail: Promise.resolve() };
+function serial(key, run) {
+  if (publishing.key !== key) publishing = { key, tail: Promise.resolve() };
+  const queue = publishing;
+  const result = queue.tail.then(run);
+  queue.tail = result.catch(() => {});
+  return result;
+}
 
 export function catalogRevision(registry) {
   const value = Number(registry?.providerCatalogRevision?.());
@@ -60,6 +73,24 @@ export function invalidateSharedProviderCatalog() {
 
 const answered = (entry) => !Object.hasOwn(entry, 'error');
 
+/** Folds a scoped refresh into the shared state of `key`: only the providers it
+ *  answered are replaced; a failed entry replaces nothing. */
+function mergeScopedEntries(key, scoped) {
+  const fresh = new Map(scoped.filter(answered).map((entry) => [entry.name, entry]));
+  const merge = (current) => current.map((entry) => fresh.get(entry.name) ?? entry);
+  if (sharedCatalogKey === key) {
+    sharedCatalogEntries = merge(sharedCatalogEntries);
+  } else if (sharedPartialKey === key) {
+    const merged = merge(sharedPartialEntries);
+    if (merged.every(answered)) {
+      // The refresh answered the last missing provider: the catalog is whole.
+      [sharedCatalogKey, sharedCatalogEntries, sharedPartialKey, sharedPartialEntries] = [key, merged, null, null];
+    } else {
+      sharedPartialEntries = merged;
+    }
+  }
+}
+
 async function providerEntry(name, provider, timeoutMs, epoch) {
   if (typeof provider?.listModels !== 'function') return { name, models: [], ms: 0 };
   const startedAt = performance.now();
@@ -78,6 +109,23 @@ async function providerEntry(name, provider, timeoutMs, epoch) {
   return { name, models: Array.isArray(outcome.value) ? outcome.value : [], ms };
 }
 
+/** Fresh entries for just the named providers (an account-pool provider is one
+ *  entry, however many accounts it holds), merged into the shared catalog. */
+export function scopedProviderCatalog(registry, names, { timeoutMs = PROVIDER_CATALOG_TIMEOUT_MS } = {}) {
+  const key = catalogKey(registry);
+  const wanted = new Set(names);
+  return serial(key, async () => {
+    const entries = await Promise.all(
+      [...registry.getAllProviders()]
+        .filter(([name]) => wanted.has(name))
+        .map(([name, provider]) => providerEntry(name, provider, timeoutMs, key))
+    );
+    // A catalog state that moved on while this read ran is not written to.
+    if (catalogKey(registry) === key) mergeScopedEntries(key, entries);
+    return entries;
+  });
+}
+
 export async function sharedProviderCatalog(registry, { force = false, timeoutMs = PROVIDER_CATALOG_TIMEOUT_MS } = {}) {
   const key = catalogKey(registry);
   if (!force && sharedCatalogKey === key && Array.isArray(sharedCatalogEntries)) {
@@ -86,45 +134,43 @@ export async function sharedProviderCatalog(registry, { force = false, timeoutMs
   if (sharedCatalogPromise && sharedCatalogPromiseKey === key && (sharedCatalogPromiseForced || !force)) {
     return await sharedCatalogPromise;
   }
-  const kept = new Map();
-  if (!force && sharedPartialKey === key) {
-    const now = Date.now();
-    for (const entry of sharedPartialEntries) {
-      if (answered(entry) || now < entry.retryAt) kept.set(entry.name, entry);
-    }
-  }
-  const providers = [...registry.getAllProviders()];
-  // Every missing provider is still inside its backoff: the partial answer is
-  // the answer, without asking anyone.
-  if (providers.length > 0 && providers.every(([name]) => kept.has(name))) {
-    return providers.map(([name]) => kept.get(name));
-  }
-  // A pending list from an older catalog state (revision or account epoch) is
-  // not joined: its answer may describe the previous catalog.
-  const epoch = key;
   sharedCatalogPromiseKey = key;
   sharedCatalogPromiseForced = force;
-  const request = Promise.all(
-    providers.map(([name, provider]) => kept.get(name) || providerEntry(name, provider, timeoutMs, epoch))
-  )
-    .then((entries) => {
-      if (sharedCatalogPromise === request && catalogKey(registry) === key) {
-        const complete = entries.every(answered);
-        const partial = !complete && entries.some(answered);
-        sharedCatalogKey = complete ? key : null;
-        sharedCatalogEntries = complete ? entries : null;
-        sharedPartialKey = partial ? key : null;
-        sharedPartialEntries = partial ? entries : null;
+  const request = serial(key, async () => {
+    const kept = new Map();
+    if (!force && sharedPartialKey === key) {
+      const now = Date.now();
+      for (const entry of sharedPartialEntries) {
+        if (answered(entry) || now < entry.retryAt) kept.set(entry.name, entry);
       }
-      return entries;
-    })
-    .finally(() => {
-      if (sharedCatalogPromise === request) {
-        sharedCatalogPromise = null;
-        sharedCatalogPromiseKey = null;
-        sharedCatalogPromiseForced = false;
-      }
-    });
+    }
+    const providers = [...registry.getAllProviders()];
+    // Every missing provider is still inside its backoff: the partial answer is
+    // the answer, without asking anyone.
+    if (providers.length > 0 && providers.every(([name]) => kept.has(name))) {
+      return providers.map(([name]) => kept.get(name));
+    }
+    // A pending list from an older catalog state (revision or account epoch) is
+    // not joined: its answer may describe the previous catalog.
+    const entries = await Promise.all(
+      providers.map(([name, provider]) => kept.get(name) || providerEntry(name, provider, timeoutMs, key))
+    );
+    if (sharedCatalogPromise === request && catalogKey(registry) === key) {
+      const complete = entries.every(answered);
+      const partial = !complete && entries.some(answered);
+      sharedCatalogKey = complete ? key : null;
+      sharedCatalogEntries = complete ? entries : null;
+      sharedPartialKey = partial ? key : null;
+      sharedPartialEntries = partial ? entries : null;
+    }
+    return entries;
+  }).finally(() => {
+    if (sharedCatalogPromise === request) {
+      sharedCatalogPromise = null;
+      sharedCatalogPromiseKey = null;
+      sharedCatalogPromiseForced = false;
+    }
+  });
   sharedCatalogPromise = request;
   return await request;
 }

package/src/session-runtime/provider-models/catalog-load.mjs

@@ -4,7 +4,8 @@
 // catalog flattened into deduplicated rows with per-provider profiling.
 import { modelProxyClientMode } from '../../runtime/shared/model-proxy-mode.mjs';
 import { isSelectableLlmModel } from '../model-recency.mjs';
-import { sharedProviderCatalog } from '../provider-catalog-cache.mjs';
+import { scopedProviderCatalog, sharedProviderCatalog } from '../provider-catalog-cache.mjs';
+import { providerRows } from '../services/agent-tool/model-select.mjs';
 import { NO_ENABLED_PROVIDERS } from '../../runtime/agent/orchestrator/providers/registry-errors.mjs';
 
 export function createCatalogLoader({
@@ -42,7 +43,7 @@ export function createCatalogLoader({
    *  refresh invalidates it, leaving the UI on the stale first-open rows.
    *  Resolves false when no provider is enabled: a fresh install has nothing
    *  to load, and the registry refuses an all-disabled init by design. */
-  async function prepare({ forceRefresh, loadSecrets }) {
+  async function prepare({ forceRefresh, loadSecrets, provider }) {
     if (loadSecrets) {
       const secretsStartedAt = performance.now();
       await awaitKeychainPrewarm();
@@ -69,7 +70,15 @@ export function createCatalogLoader({
     if (!forceRefresh && typeof reg().refreshProviderCatalogsOnStartup === 'function') {
       await reg().refreshProviderCatalogsOnStartup();
     }
-    if (forceRefresh && typeof reg().refreshCatalogs === 'function') {
+    if (forceRefresh && provider) {
+      // A provider-scoped refresh asks only the registry providers the name
+      // matches and folds their entries into the shared catalog; every other
+      // provider keeps what it loaded.
+      const known = [...reg().getAllProviders().keys()].map((name) => ({ provider: name }));
+      const names = providerRows(known, provider).map((row) => row.provider);
+      await reg().refreshProviderCatalogsFor(names);
+      await scopedProviderCatalog(reg(), names, { timeoutMs: providerTimeoutMs });
+    } else if (forceRefresh && typeof reg().refreshCatalogs === 'function') {
       await reg().refreshCatalogs({ force: true });
     }
     profile('catalog-refresh-ready', { ms: (performance.now() - refreshStartedAt).toFixed(1) });
@@ -81,13 +90,18 @@ export function createCatalogLoader({
    *  providers that failed or timed out, `request.partial` marks a load
    *  where some but not all providers answered, and `request.retryAt` is when
    *  the first missing provider may be asked again. */
-  return async function loadProviderModelsFresh({ forceRefresh = false, loadSecrets = true, request = null } = {}) {
+  return async function loadProviderModelsFresh({
+    forceRefresh = false,
+    loadSecrets = true,
+    request = null,
+    provider = null,
+  } = {}) {
     const startedAt = performance.now();
     profile('load:start', { forceRefresh, loadSecrets });
     // No enabled provider is an empty catalog, not a failure. The request
     // stays incomplete so this answer is never cached: connecting a provider
     // is picked up by the next read.
-    if (!(await prepare({ forceRefresh, loadSecrets }))) {
+    if (!(await prepare({ forceRefresh, loadSecrets, provider }))) {
       profile('load:done', { ms: (performance.now() - startedAt).toFixed(1), providers: 0, rows: 0 });
       return [];
     }
@@ -97,7 +111,10 @@ export function createCatalogLoader({
     // forward only for the still-current request, never for a superseded load.
     if (ownsLoad) request.seq = caches.providerModelsLoadSeq;
     const seq = request?.seq ?? caches.providerModelsLoadSeq;
-    const catalogEntries = await sharedProviderCatalog(reg(), { force: forceRefresh, timeoutMs: providerTimeoutMs });
+    const catalogEntries = await sharedProviderCatalog(reg(), {
+      force: forceRefresh && !provider,
+      timeoutMs: providerTimeoutMs,
+    });
     if (request) {
       const failed = catalogEntries.filter((entry) => Object.hasOwn(entry, 'error'));
       request.missing = failed.map((entry) => entry.name);

package/src/session-runtime/provider-models.mjs

@@ -156,7 +156,9 @@ export function createProviderModels({
     return promise;
   }
 
-  async function collectProviderModels({ force = false, quick = false } = {}) {
+  /** `provider` (a name or fragment of one) scopes a forced read: only the
+   *  providers it names are refreshed, the rest keep their loaded entries. */
+  async function collectProviderModels({ force = false, quick = false, provider = null } = {}) {
     meta.syncCatalogRevision();
     const cached = caches.providerModelsCache;
     if (!force && Array.isArray(cached.models)) {
@@ -180,7 +182,7 @@ export function createProviderModels({
     }
     if (force) {
       const request = { seq: ++caches.providerModelsLoadSeq };
-      const models = await loadProviderModelsFresh({ forceRefresh: true, loadSecrets: true, request });
+      const models = await loadProviderModelsFresh({ forceRefresh: true, loadSecrets: true, request, provider });
       adoptProviderModelCache(models, request);
       return withCatalogState(rows.providerModelsFromCacheRows(models), partialOf(request));
     }

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

@@ -1,6 +1,11 @@
 // Memory control and recall: the current session's own rows first, then the
 // memory runtime (with a forced ingest of the live session when it is empty).
-import { clean, toolResponseText, isEmptyRecallText, currentSessionRecallRows } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import {
+  clean,
+  toolResponseText,
+  isEmptyRecallText,
+  currentSessionRecallRows,
+} from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 
 function isIdentityRecallQuery(query) {
   const q = clean(query).toLowerCase().replace(/\s+/g, '');

package/src/session-runtime/runtime-feature-gates.mjs

@@ -4,7 +4,11 @@
 //
 // Key names mirror the dependency names of settings-api.mjs / the session-build
 // deps, so the runtime can hand them straight through.
-import { builtinFeatureActive, featureDisallowedToolsFor, localGitToolsActive } from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
+import {
+  builtinFeatureActive,
+  featureDisallowedToolsFor,
+  localGitToolsActive,
+} from '../runtime/agent/orchestrator/runtime-core/builtin-features.mjs';
 import { recapEnabled } from '../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { browserBridgeAvailableSync } from '../runtime/browser-bridge/client.mjs';
 import { computerBridgeAvailableSync } from '../runtime/computer-bridge/client.mjs';