mixdog 1.4.2 → 1.4.3

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

@@ -6,6 +6,7 @@
  * to channel tools.
  */
 import { clean } from '../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { settingDisabledIn } from '../runtime/agent/orchestrator/runtime-core/tool-availability.mjs';
 import { createAskUserToolHandlers } from './internal-tool-executor/ask-user-tool.mjs';
 import { createBridgeToolHandlers } from './internal-tool-executor/bridge-tools.mjs';
 import { createFeatureToolHandlers } from './internal-tool-executor/feature-tools.mjs';
@@ -19,11 +20,7 @@ export function createInternalToolExecutor({
   goalRuntime,
   agentTool,
   setupTool,
-  webSearchEnabled,
-  memoryToolsEnabled,
-  officeToolsEnabled,
-  mediaToolEnabled,
-  tidyToolEnabled = () => true,
+  featureDisallowedTools = () => [],
   getWebSearchModule,
   getMemoryModule,
   getCodeGraphModule,
@@ -42,7 +39,7 @@ export function createInternalToolExecutor({
     ...createBridgeToolHandlers({ rt }),
     ...createAskUserToolHandlers({ rt }),
     ...createReactionToolHandlers({ rt }),
-    ...createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }),
+    ...createFeatureToolHandlers({ rt, setupTool }),
     ...createKnowledgeToolHandlers({
       rt,
       getWebSearchModule,
@@ -67,24 +64,20 @@ export function createInternalToolExecutor({
     }),
   };
 
-  // Settings-disabled features are refused for model-initiated calls before
-  // any handler runs; the tool list is refreshed by a new session.
-  const guardModelCall = (name) => {
-    if ((name === 'web_search' || name === 'web_fetch') && !webSearchEnabled()) {
-      throw new Error('web search is disabled in settings; start a new session to refresh the tool list');
-    }
-    if ((name === 'memory' || name === 'recall') && !memoryToolsEnabled()) {
-      throw new Error(
-        'memory tools are disabled in settings; background memory and manual core memory remain available'
-      );
-    }
-  };
+  // A model call of a tool a setting turned off is refused at dispatch
+  // (tool-exec/dispatch.mjs settingDisabledTool, built-ins such as git
+  // included); a model-tool call reaching this executor directly takes the
+  // same check against this runtime's live gate list.
 
   return async (name, args, callerCtx = {}) => {
     const callerCwd = clean(callerCtx?.callerCwd) || rt.currentCwd;
     // The Reactions setting gates the tool whoever calls it, not only the model.
     if (name === 'react' && rt.config?.reactions === false) throw new Error('reactions are turned off in settings');
-    if (callerCtx?.invocationSource === 'model-tool') guardModelCall(name);
+    const disabled =
+      callerCtx?.invocationSource === 'model-tool' ? settingDisabledIn(name, featureDisallowedTools()) : null;
+    if (disabled) {
+      throw new Error(`${disabled} is disabled in settings by the user; do not retry unless the user turns it back on`);
+    }
     if (Object.hasOwn(handlers, name)) return handlers[name](args, { name, callerCtx, callerCwd });
     if (channels.isChannelTool(name)) {
       return await channels.execute(name, args || {});

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

@@ -35,9 +35,16 @@ const SOURCE_RUNTIME_FIELDS = [
   'toolApprovalHook',
   '_providerPrefixGuardState',
   'activeTurnCheckpoint',
+  // The source's durable transcript identity (store/transcript-durability.mjs).
+  'transcriptEpoch',
+  'turnCoverage',
   'deferredInitialRefreshPending',
   'pendingGoalReminder',
   'goalReminderRevision',
+  'goalStalledNotice',
+  // The source's own step list and its reminder cycle.
+  'todo',
+  'todoCheck',
   'pendingCacheBreakIntent',
   'contextPressureUnanchoredAfterRestart',
   'contextPressureUnanchoredReason',

package/src/session-runtime/lifecycle/memory-ingest.mjs

@@ -4,9 +4,9 @@
  */
 const INGEST_DEADLINE_MS = 2500;
 
-// Sessions that never compacted had NO session-sourced rows (ingest_session
-// previously ran only inside compaction), so recall could not reconstruct
-// the most recent conversations. Deadline-capped: the row inserts are fast
+// Sessions that never compacted have no session-sourced rows unless ingested
+// here, and recall could not reconstruct the most recent conversations
+// without them. Deadline-capped: the row inserts are fast
 // and committed even if the bounded wait elapses during the trailing
 // embedding flush (the raw-embedding backlog sweep embeds them later). Never
 // loads the memory runtime just for this — a null module promise means

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

@@ -14,6 +14,7 @@ import {
 import { SESSION_ID_PATTERN, closeManagedSession } from '../shared.mjs';
 import { replacementSessionCwd } from '../../workspace/workspace-state.mjs';
 import { isHistoricalAutomaticClosure } from '../../../runtime/agent/orchestrator/session/historical-session-closure.mjs';
+import { readSessionSidebarState } from '../../../runtime/shared/session-sidebar-host.mjs';
 
 export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   const {
@@ -38,12 +39,13 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
   // Availability is one strict read of the session's own file, filtered like
   // the session catalog (an unreadable, foreign, closed or non-catalogued
   // record is not deletable). No catalog rebuild, no folder scan.
-  function isAvailableSession(sessionId) {
+  function availableRecord(sessionId) {
     const stored = _storedSessionFromFile(getStoreDir(), `${sessionId}.json`);
-    if (!stored || stored === STORED_SESSION_UNREADABLE) return false;
-    if (stored.closed === true && !isHistoricalAutomaticClosure(stored)) return false;
-    return leadSessionRow(stored) !== null;
+    if (!stored || stored === STORED_SESSION_UNREADABLE) return null;
+    if (stored.closed === true && !isHistoricalAutomaticClosure(stored)) return null;
+    return leadSessionRow(stored) !== null ? stored : null;
   }
+  const isAvailableSession = (sessionId) => availableRecord(sessionId) !== null;
 
   // The deleted task's worktree: the autoCleanup setting decides (clean and
   // merged → removed; otherwise kept). Off the deletion path; never fails it.
@@ -102,5 +104,51 @@ export function createSessionDelete(deps, { cancelBackgroundTasks }) {
     return true;
   }
 
-  return { releaseSessionWork, deleteSession };
+  /**
+   * The desktop's auto-delete of an archived session: only one that is still
+   * archived, not a favorite, idle (no turn running, waiting for its ask lock
+   * or queued) and unchanged since the caller looked (`expected.lastUsedAt`,
+   * which every turn moves). It holds the session's ask lock, which every
+   * turn takes, and runs its last checks, the close and the delete in one
+   * synchronous stretch, so no turn can start in between. A refusal closes
+   * and deletes nothing: `{ deleted: false, reason }`. `isHostedBusy` (the
+   * session service) reports queued input in a runtime hosting the session.
+   */
+  async function deleteSessionIfIdle(id, expected = {}, { isHostedBusy = null } = {}) {
+    const sessionId = clean(id);
+    const refuse = (reason) => ({ deleted: false, reason });
+    if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return refuse('invalid');
+    if (typeof isHostedBusy !== 'function') return refuse('unguarded');
+    if (getSession()?.id === sessionId) return refuse('current');
+    const unlock = mgr.tryAcquireSessionLock(sessionId);
+    if (!unlock) return refuse('busy');
+    try {
+      // The archive and favorite flags are the desktop's.
+      const sidebar = await readSessionSidebarState();
+      if (!sidebar || !Object.hasOwn(sidebar.archived ?? {}, sessionId)) return refuse('not-archived');
+      if (Object.hasOwn(sidebar.favorites ?? {}, sessionId)) return refuse('favorite');
+      // From here to the delete: synchronous.
+      if (mgr.sessionLockContended(sessionId)) return refuse('turn-waiting');
+      if (mgr.isSessionTurnInFlight(sessionId) || mgr.hasUnsettledTurn(sessionId)) return refuse('busy');
+      if (mgr.hasPendingMessages(sessionId) || isHostedBusy(sessionId)) return refuse('queued');
+      const stored = availableRecord(sessionId);
+      if (!stored) return refuse('missing');
+      if ((Number(stored.lastUsedAt) || 0) !== (Number(expected?.lastUsedAt) || 0)) return refuse('changed');
+      const reason = 'desktop-auto-delete';
+      // The blocking close: its barrier lands before this stretch yields.
+      if (closeManagedSession(mgr, sessionId, reason, { tombstone: false }, false) !== true) {
+        return refuse('close-failed');
+      }
+      agentTool?.forgetLeadSession?.(sessionId);
+      releaseSessionWork(sessionId, reason);
+      if (mgr.deleteSession(sessionId, { fenceWrites: true }) !== true) return refuse('delete-failed');
+      void forgetSessionSearch(sessionId);
+      void releaseDeletedWorktree(sessionId);
+      return { deleted: true };
+    } finally {
+      unlock();
+    }
+  }
+
+  return { releaseSessionWork, deleteSession, deleteSessionIfIdle };
 }

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

@@ -15,7 +15,9 @@ export { resolveResumeCwd } from './session-switch/resume.mjs';
 
 export function createSessionSwitching(deps, { ingestSessionIntoMemory, closeSurfaceSession, cancelBackgroundTasks }) {
   const { mgr, getMode } = deps;
-  const { releaseSessionWork, deleteSession } = createSessionDelete(deps, { cancelBackgroundTasks });
+  const { releaseSessionWork, deleteSession, deleteSessionIfIdle } = createSessionDelete(deps, {
+    cancelBackgroundTasks,
+  });
   const { switchContext, newSession } = createContextSwitch(deps, {
     ingestSessionIntoMemory,
     closeSurfaceSession,
@@ -41,5 +43,14 @@ export function createSessionSwitching(deps, { ingestSessionIntoMemory, closeSur
     return mgr.prefetchSession?.(id, toolSpecForMode(getMode())) === true;
   }
 
-  return { listSessions, sessionStoreDir, deleteSession, switchContext, newSession, prefetchSession, resume };
+  return {
+    listSessions,
+    sessionStoreDir,
+    deleteSession,
+    deleteSessionIfIdle,
+    switchContext,
+    newSession,
+    prefetchSession,
+    resume,
+  };
 }

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

@@ -35,10 +35,10 @@ export async function dispatchSessionEnd(deps, reason) {
   }
 }
 
-// Runtime stop/exit (TUI Ctrl-C, process exit) previously always tombstoned
-// the current session, so a session you were mid-conversation in vanished
-// from the Resume list the instant you quit and was hard-deleted by the 24h
-// tombstone sweep. Only tombstone truly-empty scratch sessions.
+// Runtime stop/exit (TUI Ctrl-C, process exit) must not tombstone a session
+// you were mid-conversation in: it would vanish from the Resume list the
+// instant you quit and be hard-deleted by the 24h tombstone sweep. Only
+// tombstone truly-empty scratch sessions.
 export function closeOwnSession(deps, closeSurfaceSession, reason) {
   const {
     getSession,

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

@@ -38,6 +38,7 @@ export function createLifecycleApi(deps) {
     listSessions: switching.listSessions,
     sessionStoreDir: switching.sessionStoreDir,
     deleteSession: switching.deleteSession,
+    deleteSessionIfIdle: switching.deleteSessionIfIdle,
     switchContext: switching.switchContext,
     newSession: switching.newSession,
     prefetchSession: switching.prefetchSession,

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

@@ -4,12 +4,16 @@
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import {
   connectorAccountEnabled,
+  connectorAccountId,
   connectorAccountServer,
   connectorAccountsOf,
   connectorOfServer,
   gmailAppPasswordAccount,
 } from '../../runtime/shared/connector-catalog.mjs';
-import { connectorAccountHealth, connectorAccountInUse } from '../../runtime/connectors/connector-accounts-mcp.mjs';
+import {
+  connectorAccountHealth,
+  connectorAccountInUseRecord,
+} from '../../runtime/connectors/connector-accounts-mcp.mjs';
 import { googleOAuthClient } from '../../runtime/shared/google-oauth-client.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
 import { resolveMcpServerCatalog } from './plugin-servers.mjs';
@@ -158,8 +162,15 @@ export function createMcpServerCatalog({
       const stored = entry.owner ? [] : connectorAccountsOf(cfg);
       // The connector's last-used account (none when that one was removed),
       // else its topmost switched-on one.
-      const recorded = stored.length ? connectorAccountInUse(connectorOfServer(cfg)) : '';
-      const inUse = recorded || stored.find(connectorAccountEnabled)?.name;
+      // A record names an account only while that account is still it (a new
+      // account given a removed one's name is not).
+      const record = stored.length ? connectorAccountInUseRecord(connectorOfServer(cfg)) : null;
+      const recorded = record
+        ? stored.find(
+            (account) => account.name === record.name && record.id && connectorAccountId(cfg, account) === record.id
+          )?.name
+        : '';
+      const inUse = record ? recorded : stored.find(connectorAccountEnabled)?.name;
       const accounts = stored.map((account) =>
         accountRow(connectorAccountServer(cfg, account), connectorAccountEnabled(account), account.name === inUse)
       );

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

@@ -18,20 +18,23 @@ export function createServerConnection({
   // 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.
+  // Answers the connect's failure (recorded in state.mcpFailures), null once
+  // it connected or disconnected. The server's fingerprint is recorded only
+  // once it connected, so one that failed is connected again by the next
+  // reconcile although its config is unchanged.
   async function applyMcpServerConnection(name, enabled, servers = resolveEffectiveMcpServers().servers, login = null) {
     const target = clean(name);
-    if (!target) return;
+    if (!target) return null;
     // Changing this server's state clears any stale failure record for it.
     if (Array.isArray(state.mcpFailures)) {
       state.mcpFailures = state.mcpFailures.filter((row) => row.name !== target);
     }
     const cfg = servers[target];
+    applied().delete(target);
     if (enabled === false || !cfg || cfg.enabled === false) {
-      applied().delete(target);
       await mcpClient.disconnectMcpServer?.(target, scopeOptions());
-      return;
+      return null;
     }
-    applied().set(target, fingerprint(cfg));
     // Close-then-connect as one generation-guarded op: a shutdown landing
     // between the close and the connect never resurrects the server.
     try {
@@ -42,29 +45,52 @@ export function createServerConnection({
         cfg,
         login ? { interactive: true, openBrowser: login.openBrowser } : {}
       );
+      applied().set(target, fingerprint(cfg));
+      return null;
     } catch (error) {
       const failure = { name: target, msg: error?.message || String(error) };
       if (error?.authRequired) failure.authRequired = true;
       const failures = Array.isArray(error?.failures) ? error.failures : [failure];
       state.mcpFailures = [...(state.mcpFailures || []), ...failures];
+      return failure;
     }
   }
 
   // Bring the registry in line with the effective set: drop servers that are
   // gone or disabled, (re)connect servers that are new or whose resolved
-  // config changed; untouched servers keep their connection.
+  // config changed; untouched servers keep their connection. A server whose
+  // last connect failed is retried too (one the full connect recorded as
+  // connected included): reconcile also runs when a sign-in or a stored
+  // credential changed (possibly in another process), which leaves its
+  // config, and so its fingerprint, as it was; so is a connection the client
+  // reports dead. Answers the failures of this run that are not a needed
+  // sign-in (that waits on the user, whose sign-in reconciles again); they
+  // stay in the status, which the change step checks to retry them.
   async function reconcileServers() {
     syncScopeRoot();
     const { servers } = resolveEffectiveMcpServers();
     const known = applied();
-    const drops = [...known.keys()].filter((name) => !servers[name] || servers[name].enabled === false);
+    const dead = (mcpClient.getMcpServerStatus?.(getMcpScopeId()) || [])
+      .filter((row) => row.alive === false || row.connected === false)
+      .map((row) => row.name);
+    const failed = new Set([
+      ...(Array.isArray(state.mcpFailures) ? state.mcpFailures : []).map((row) => row.name),
+      ...dead,
+    ]);
+    const drops = [...new Set([...known.keys(), ...failed])].filter(
+      (name) => !servers[name] || servers[name].enabled === false
+    );
     const connects = Object.entries(servers)
-      .filter(([name, cfg]) => cfg?.enabled !== false && known.get(name) !== fingerprint(cfg))
+      .filter(([name, cfg]) => cfg?.enabled !== false && (known.get(name) !== fingerprint(cfg) || failed.has(name)))
       .map(([name]) => name);
-    await Promise.allSettled([
+    const results = await Promise.allSettled([
       ...drops.map((name) => applyMcpServerConnection(name, false, servers)),
       ...connects.map((name) => applyMcpServerConnection(name, true, servers)),
     ]);
+    return results.flatMap((one) => {
+      if (one.status === 'rejected') return [{ msg: one.reason?.message || String(one.reason) }];
+      return one.value && !one.value.authRequired ? [one.value] : [];
+    });
   }
 
   return { applyMcpServerConnection, reconcileServers };

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

@@ -136,6 +136,23 @@ function refreshSessionFallbacks(deps, session) {
   deps.mgr.updateSessionRoute?.(session.id, fields, { session });
 }
 
+/** The route fields a model pick held for the next turn keeps on its session. */
+function heldRoutePick(route) {
+  const pick = {
+    provider: route.provider,
+    model: route.model,
+    ...(route.preset ? { preset: route.preset } : {}),
+    ...(route.effort !== undefined ? { effort: route.effort } : {}),
+    fast: route.fast === true,
+    ...(route.autoEffort === false ? { autoEffort: false } : {}),
+    ...(route.modelParameters ? { modelParameters: route.modelParameters } : {}),
+    ...(route.contextPercent !== undefined ? { contextPercent: route.contextPercent } : {}),
+    ...(route.contextTokens ? { contextTokens: route.contextTokens } : {}),
+    ...(route.selectedContextWindow ? { selectedContextWindow: route.selectedContextWindow } : {}),
+  };
+  return pick;
+}
+
 /** Rewrite the addressed empty session to the route it was asked to run on. */
 function updateSessionInPlace(deps, session, updateOptions) {
   const { getRoute, getSession, setSession, mgr, statusRoutes } = deps;
@@ -386,9 +403,16 @@ export function createSetRoute(deps, persist) {
     const session = getSession();
     if (options.deferUntilNextTurn === true) {
       pending = session?.id ? { generation: lease.token } : null;
+      // Held on the session too (saved like a pending workflow switch), so a
+      // restart before the next turn still applies it.
+      if (session?.id) {
+        session.pendingRoute = heldRoutePick(getRoute());
+        deps.persistSession?.(session);
+      }
       return getRoute();
     }
     pending = null;
+    if (session?.pendingRoute) delete session.pendingRoute;
     // A session the user has already talked in or compacted keeps its route
     // unless the selection was addressed to it. A current session with no
     // model reply, no compaction summary and no in-flight first turn — empty,
@@ -436,21 +460,30 @@ export function createSetRoute(deps, persist) {
     return getRoute();
   }
   setRoute.applyPendingRoute = () => {
-    if (!pending) return null;
-    const selection = pending;
-    if (selection.generation !== getSessionGeneration()) {
+    const session = getSession();
+    const held = session?.pendingRoute;
+    if (session && held) delete session.pendingRoute;
+    if (pending) {
+      const selection = pending;
       pending = null;
+      if (selection.generation !== getSessionGeneration()) return null;
+      // The live route is the latest selection: effort/Fast tuned after the
+      // deferred model choice replace it.
+    } else if (held?.provider && held.model) {
+      // Held by an earlier process (a restart in between): the saved pick
+      // becomes the live route again.
+      deps.setRouteState(deps.resolveRoute(deps.getConfig(), held));
+    } else {
       return null;
     }
-    // The live route is the latest selection: effort/Fast tuned after the
-    // deferred model choice replace it, so no snapshot is kept.
-    const modelSwitch = switchSessionInPlace(deps, getSession());
+    const modelSwitch = switchSessionInPlace(deps, session);
     invalidateContextStatusCache();
-    pending = null;
     return modelSwitch;
   };
   setRoute.clearPendingRoute = () => {
     pending = null;
+    const session = getSession();
+    if (session?.pendingRoute) delete session.pendingRoute;
   };
   return setRoute;
 }

package/src/session-runtime/native-web-search/routes.mjs

@@ -46,9 +46,9 @@ export function createWebSearchRouteCandidates({
     await awaitKeychainPrewarm();
     const cfg = ensureFullConfig();
     // An unset webSearchRoute IS the default ("follow the Main Model") — the
-    // sidebar has always presented it that way. Materialize it here instead of
-    // treating a missing key as "not configured", which used to fail the search
-    // before the Main Model was ever consulted.
+    // sidebar presents it that way. Materialize it here instead of treating a
+    // missing key as "not configured", which would fail the search before the
+    // Main Model is consulted.
     const webSearchRoute = webSearchRouteOrDefault(cfg.webSearchRoute, getWebSearchRoute());
     setWebSearchRoute(webSearchRoute);
     const candidates = [];

package/src/session-runtime/provider-auth/refresh.mjs

@@ -3,7 +3,7 @@
 import { resetProviderAdmissionCooldowns } from '../../runtime/agent/orchestrator/providers/admission-scheduler.mjs';
 
 export function createAuthRefresh({
-  reloadFullConfig,
+  applyConfigChange,
   invalidateProviderCaches,
   warmProviderModelCache,
   refreshProviderCatalogs,
@@ -42,14 +42,17 @@ export function createAuthRefresh({
     warmProviderModelCache();
   }
 
+  // The change step (reload + effects keyed by the config/secret change) runs
+  // here at once rather than on the notification that follows, so this
+  // runtime's notification finds the change already applied.
   function afterCredentialChange() {
-    reloadFullConfig();
+    applyConfigChange();
     adoptCredentials();
   }
 
   /** Usage-dashboard credentials affect no admission lane or catalog. */
   function afterUsageAuthChange() {
-    reloadFullConfig();
+    applyConfigChange();
     invalidateProviderCaches();
   }
 

package/src/session-runtime/provider-auth/setup.mjs

@@ -48,7 +48,7 @@ export function createSetupApi({
         return cachedProviderSetup({ force: force || options?.recheckKeychain === true });
       }
       // An unforced read never blocks: the authoritative setup waits on the OS
-      // keychain, which can take seconds on a cold start and used to stall the
+      // keychain, which can take seconds on a cold start and would stall the
       // whole settings sweep behind it. Serve
       // the no-secrets snapshot until the real one is cached — flagged, so the
       // caller shows "checking" instead of a wrong "not connected" — and let the

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

@@ -51,6 +51,13 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
   const providerModelCaches = { ...emptyModelCaches(), providerModelsLoadSeq: 0 };
   const providerUsageCaches = emptyUsageCaches();
   const providerInitPromises = new Map();
+  // Whether this runtime has started its providers: a rebuild after a change
+  // follows it, a failed initialization (whose gate is dropped) included.
+  let providersStarted = false;
+  // Advances whenever the init gates are cleared (a provider config or
+  // credential change): an initialization registered before it is superseded
+  // and never writes the shared registry.
+  let providerInitGeneration = 0;
 
   function invalidateProviderCaches(options = {}) {
     // Auth/account/config changes alter what providers list: the process-wide
@@ -59,7 +66,10 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
     Object.assign(providerModelCaches, emptyModelCaches());
     providerModelCaches.providerModelsLoadSeq += 1;
     Object.assign(providerUsageCaches, emptyUsageCaches());
-    if (options.preserveProviderInit !== true) providerInitPromises.clear();
+    if (options.preserveProviderInit !== true) {
+      providerInitPromises.clear();
+      providerInitGeneration += 1;
+    }
     modelMetaByRoute.clear();
   }
 
@@ -67,19 +77,44 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
   // absent (provider setup, init gates) is stale.
   keychain.onKeychainRecovered?.(() => invalidateProviderCaches());
 
-  async function ensureProvidersReady(providerConfig = rt.config.providers || {}) {
+  // The one edit a caller makes to the provider config it passes is turning a
+  // route's provider on (ensureProviderEnabled); those providers, judged
+  // against the runtime's config when the request was made.
+  function forcedProviders(requested, base) {
+    return Object.keys(requested || {}).filter(
+      (name) => requested[name]?.enabled === true && base?.[name]?.enabled !== true
+    );
+  }
+
+  // Waits for the keychain, then initializes the registry with
+  // `providerConfig` unless a change superseded it meanwhile: a superseded
+  // request is replayed on the latest config (with the providers it turned on),
+  // so the latest config always wins.
+  async function initializeProviders(providerConfig) {
+    const generation = providerInitGeneration;
+    const forced = forcedProviders(providerConfig, rt.config.providers);
     await awaitKeychainPrewarm();
     if (rt.closeRequested) throw new Error('runtime is closing');
+    if (generation === providerInitGeneration) return getReg().initProviders(providerConfig);
+    const latest = { ...(rt.config.providers || {}) };
+    for (const name of forced) latest[name] = { ...(latest[name] || {}), enabled: true };
+    return ensureProvidersReady(latest);
+  }
+
+  async function ensureProvidersReady(providerConfig = rt.config.providers || {}) {
+    if (rt.closeRequested) throw new Error('runtime is closing');
+    providersStarted = true;
     const initKey = providerInitCacheKey(providerConfig);
     // Provider initialization is idempotent for one normalized config. Keep
     // the fulfilled promise, not only the in-flight one: session resume used
     // to rerun registry/keychain setup on every click even though neither the
     // provider config nor the registry had changed. Auth/config mutations call
     // invalidateProviderCaches(), which clears this gate and preserves the
-    // existing refresh semantics.
+    // existing refresh semantics. Registered before any await, so a change
+    // applied while it waits on the keychain sees (and supersedes) it.
     let providerInitPromise = providerInitPromises.get(initKey);
     if (!providerInitPromise) {
-      providerInitPromise = Promise.resolve().then(() => getReg().initProviders(providerConfig));
+      providerInitPromise = initializeProviders(providerConfig);
       providerInitPromises.set(initKey, providerInitPromise);
     }
     let result;
@@ -125,9 +160,23 @@ export function createProviderReadiness({ rt, keychain, getReg, getWarmProviderM
     return result;
   }
 
+  // Provider config or secrets changed: drop everything keyed to the old ones
+  // and, when this runtime had initialized providers, rebuild the shared
+  // registry from its reloaded config now, so no runtime's stale copy is the
+  // last one to have initialized it. Rejects when that rebuild failed.
+  function reinitProviders() {
+    invalidateProviderCaches();
+    if (!providersStarted || rt.closeRequested) return Promise.resolve();
+    return ensureProvidersReady().catch((error) => {
+      bootProfile('providers:reinit-failed', { error: error?.message || String(error) });
+      throw error;
+    });
+  }
+
   return {
     awaitKeychainPrewarm,
     invalidateProviderCaches,
+    reinitProviders,
     ensureProvidersReady,
     modelMetaByRoute,
     providerModelCaches,

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

@@ -31,7 +31,7 @@ export function createResourceApi(deps) {
         throw new Error(`extension scope kind must be one of ${EXTENSION_SCOPE_KINDS.join(', ')}`);
       }
       // A connector is on in every project unless a project switches it off
-      // (setProjectConnectorEnabled); "only in this project" no longer exists.
+      // (setProjectConnectorEnabled); there is no "only in this project" scope.
       if (scopeKind === 'mcp') {
         throw new Error('MCP servers are switched off per project in Project settings (setProjectConnectorEnabled)');
       }

package/src/session-runtime/resource-extension-sync.mjs

@@ -7,7 +7,6 @@ export function createExtensionSync({
   connectConfiguredMcp,
   cancelMcpLogin,
   invalidatePreSessionToolSurface,
-  refreshEmptySessionToolPolicy,
   reloadFullConfig,
   invalidateSkills,
 }) {
@@ -19,14 +18,11 @@ export function createExtensionSync({
   // session.
   const mcpToggleChains = new Map(); // name -> { desired, running }
 
-  async function refreshSurface(kind) {
+  // The invalidation moves the surface generation: an empty session rebuilds
+  // at its next turn start (reconcileTurnSettings); MCP has its own
+  // first-turn/late-tool reconciliation against the live connection registry.
+  async function refreshSurface() {
     invalidatePreSessionToolSurface();
-    // Existing conversations retain their stable prompt/session identity.
-    // Empty sessions can safely rebuild their policy in place; MCP has its own
-    // first-turn/late-tool reconciliation against the live connection registry.
-    if ((kind === 'skills' || kind === 'plugins') && typeof refreshEmptySessionToolPolicy === 'function') {
-      await refreshEmptySessionToolPolicy();
-    }
   }
 
   // Apply per-server MCP changes in order, then reconcile: a configured server

package/src/session-runtime/resource-mcp-connector-accounts.mjs

@@ -80,7 +80,9 @@ export function createConnectorAccountEdits({
       throw nameTakenError(servers, name);
     }
     const accountName = serverName ? freeName(servers, name) : name;
-    const account = connectorAccountEntry(accountName, accountCfg);
+    // A fresh identity: a conversation that used a removed account of this
+    // name never takes this one for it (connector-accounts-mcp.mjs).
+    const account = { ...connectorAccountEntry(accountName, accountCfg), id: randomUUID() };
     // A sign-in is stored per exact URL: another account signing in at the
     // same URL gets its own key, so the two never share tokens.
     const asServer = connectorAccountServer({ connector }, account);
@@ -141,6 +143,8 @@ export function createConnectorAccountEdits({
         entry.name === account.name
           ? {
               ...connectorAccountEntry(account.name, next),
+              // An edit keeps the account's identity.
+              ...(entry.id ? { id: entry.id } : {}),
               ...(connectorAccountEnabled(entry) ? {} : { enabled: false }),
             }
           : entry