mixdog 1.4.1 → 1.4.3

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

@@ -4,6 +4,7 @@
  * tombstone barrier and the turn abort.
  */
 import { SessionClosedError } from '../../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
+import { armTurnTimeout } from '../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 import { isScratchSession } from '../shared.mjs';
 
 // SessionEnd reason mapped to standard values ('clear'/'exit' where
@@ -34,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,
@@ -88,11 +89,15 @@ export function closeCanonicalSession(deps, reason = 'canonical-session-close',
   return true;
 }
 
-export function abortRuntime(deps, reason = 'cli-abort') {
+/** `options.timeout` is the progress watchdog's explicit "this abort is a
+ *  timeout": the reap is armed before either abort runs, while the turn is
+ *  still un-aborted (the outer abort cascades into the manager's controller). */
+export function abortRuntime(deps, reason = 'cli-abort', { timeout = false } = {}) {
   const { getSession, getReservedSessionId, abortActiveTurns, mgr } = deps;
   const session = getSession();
   const sessionId = session?.id || getReservedSessionId?.() || 'pending';
   const abortError = new SessionClosedError(sessionId, `runtime abort (reason=${reason})`, reason);
+  if (timeout && session?.id) armTurnTimeout(session.id);
   let outerAborted = false;
   try {
     outerAborted = abortActiveTurns?.(abortError) === true;

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

@@ -281,6 +281,6 @@ export function createTeardown(deps, { ingestSessionIntoMemory, closeSurfaceSess
   return {
     closeCanonicalSession: (reason, options) => closeCanonicalSession(deps, reason, options),
     close,
-    abort: (reason) => abortRuntime(deps, reason),
+    abort: (reason, options) => abortRuntime(deps, reason, options),
   };
 }

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 } 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';
@@ -119,10 +123,12 @@ export function createMcpServerCatalog({
     };
   }
 
-  /** One account of a multi-account connector server, as its row lists it:
-   *  `{ name, email, enabled?, appPassword?, oauth?, ownClient?, error?, authRequired? }`
-   *  (`enabled: false` only for an account that is switched off). */
-  function accountRow(accountCfg, enabled) {
+  /** One account of a connector server, as its row lists it:
+   *  `{ name, email, enabled?, inUse?, appPassword?, oauth?, ownClient?, error?, authRequired? }`
+   *  (`enabled: false` only for an account that is switched off; `inUse:
+   *  true` only for the connector's last-used account, the one a call
+   *  without a conversation history uses). */
+  function accountRow(accountCfg, enabled, inUse) {
     const address = gmailAppPasswordAccount(accountCfg);
     const oauth = address ? null : mcpClient.getMcpServerOAuthState?.(accountCfg);
     const state = connectorAccountHealth(accountCfg.name);
@@ -130,6 +136,7 @@ export function createMcpServerCatalog({
     return {
       name: accountCfg.name,
       ...(enabled ? {} : { enabled: false }),
+      ...(inUse ? { inUse: true } : {}),
       email: address || oauth?.account || state?.email || '',
       ...(address ? { appPassword: { account: address } } : {}),
       ...(oauth ? { oauth } : {}),
@@ -152,11 +159,21 @@ export function createMcpServerCatalog({
         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 accounts = entry.owner
-        ? []
-        : connectorAccountsOf(cfg).map((account) =>
-            accountRow(connectorAccountServer(cfg, account), connectorAccountEnabled(account))
-          );
+      const stored = entry.owner ? [] : connectorAccountsOf(cfg);
+      // The connector's last-used account (none when that one was removed),
+      // else its topmost switched-on one.
+      // 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)
+      );
       // A connector server none of whose accounts is signed in needs a sign-in, not a repair.
       const accountsSignIn = accounts.length > 0 && accounts.every((account) => account.authRequired === true);
       const status = mcpServerStatus(

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/mcp-glue/server-input.mjs

@@ -79,8 +79,11 @@ export function createMcpServerInput({ mcpClient, getCurrentCwd }) {
     const type = clean(input.type).toLowerCase();
     if (url) {
       const kind = URL_TRANSPORT_TYPES.get(type) || (/^wss?:\/\//i.test(url) ? 'ws' : 'http');
-      const secureUrl =
+      const normalizedUrl =
         typeof mcpClient.normalizeMcpTransportUrl === 'function' ? mcpClient.normalizeMcpTransportUrl(url, kind) : url;
+      // URL parsing adds a "/" to a bare origin (`https://mcp.stripe.com`):
+      // keep the address as it was given, as the catalog and legacy entries do.
+      const secureUrl = normalizedUrl === `${url}/` ? url : normalizedUrl;
       return { name, config: withOptionalHeaders({ type: kind, url: secureUrl }) };
     }
     const command = clean(input.command);

package/src/session-runtime/mixy-heartbeat.mjs

@@ -635,7 +635,7 @@ export function createMixyHeartbeat({
   now = Date.now,
   path = defaultStatePath(),
   isEnabled = async () =>
-    (await import('../runtime/agent/orchestrator/config.mjs')).loadConfig({ secrets: false }).heartbeat !== false,
+    (await import('../runtime/agent/orchestrator/config.mjs')).loadConfig({ secrets: false }).heartbeat === true,
   // Whether the representative bot exists (mixy-presence.mjs, the rule the
   // desktop and her routines follow): without it no check runs at all.
   mixyExists = async () => (await import('./routine-owner.mjs')).readMixyExists(),

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/login.mjs

@@ -61,8 +61,8 @@ export function createLoginApi({ cfgMod, awaitKeychainPrewarm, reloadFullConfig,
       reloadFullConfig();
       return completeOAuthLogin(result);
     },
-    async saveProviderApiKey(providerId, secret) {
-      const result = await saveProviderApiKey(cfgMod, providerId, secret);
+    async saveProviderApiKey(providerId, secret, options) {
+      const result = await saveProviderApiKey(cfgMod, providerId, secret, options);
       refresh.afterCredentialChange();
       return result;
     },

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