mixdog 1.4.2 → 1.4.3

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

@@ -11,9 +11,17 @@ export const WORKTREE_NEW_TASK_DEFAULTS = Object.freeze(['branch', 'worktree']);
 /**
  * @typedef {object} WorktreeSettings
  * @property {'branch'|'worktree'} newTaskDefault
- * @property {string} branchPrefix Ref prefix for created branches; ends with "/".
+ * @property {string} branchPrefix Ref prefix for created branches, ending with "/";
+ *   "" (default) names the branch after the task alone.
  * @property {number} sizeWarnBytes Repository size that asks for confirmation; 0 never asks.
  * @property {boolean} autoCleanup Remove clean, merged worktrees when their session ends.
+ *   The four settings below apply only while it is on.
+ * @property {number} maxWorktrees Keep at most this many managed worktrees (oldest
+ *   activity cleaned first); 0 keeps any number.
+ * @property {number} unusedDays Clean up worktrees unused this many days; 0 never.
+ * @property {boolean} cleanupArchived Archiving a session makes its worktrees disposable.
+ * @property {boolean} deleteBranch Cleanup deletes the worktree's branch too (its tip
+ *   stays under the recovery ref); off keeps the branch.
  */
 
 /** @type {Readonly<WorktreeSettings>} */
@@ -22,8 +30,15 @@ export const WORKTREE_SETTINGS_DEFAULTS = Object.freeze({
   branchPrefix: DEFAULT_WORKTREE_BRANCH_PREFIX,
   sizeWarnBytes: 2 * 1024 ** 3,
   autoCleanup: true,
+  maxWorktrees: 15,
+  unusedDays: 30,
+  cleanupArchived: true,
+  deleteBranch: false,
 });
 
+const WORKTREE_MAX_WORKTREES_LIMIT = 1000;
+const WORKTREE_UNUSED_DAYS_LIMIT = 3650;
+
 const KEYS = Object.keys(WORKTREE_SETTINGS_DEFAULTS);
 const PREFIX_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*(\/[A-Za-z0-9][A-Za-z0-9._-]*)*\/$/;
 
@@ -35,16 +50,27 @@ function fieldError(key, value) {
         ? null
         : `must be one of ${WORKTREE_NEW_TASK_DEFAULTS.join(', ')}`;
     case 'branchPrefix':
-      return typeof value === 'string' &&
-        value.length <= 64 &&
-        PREFIX_PATTERN.test(value) &&
-        !value.includes('..') &&
-        !/\.lock\//i.test(value)
+      return value === '' ||
+        (typeof value === 'string' &&
+          value.length <= 64 &&
+          PREFIX_PATTERN.test(value) &&
+          !value.includes('..') &&
+          !/\.lock\//i.test(value))
         ? null
-        : 'must be a ref path ending with "/", e.g. "mixdog/"';
+        : 'must be empty or a ref path ending with "/", e.g. "mixdog/"';
     case 'sizeWarnBytes':
       return Number.isSafeInteger(value) && value >= 0 ? null : 'must be a non-negative integer';
+    case 'maxWorktrees':
+      return Number.isSafeInteger(value) && value >= 0 && value <= WORKTREE_MAX_WORKTREES_LIMIT
+        ? null
+        : `must be an integer from 0 to ${WORKTREE_MAX_WORKTREES_LIMIT}`;
+    case 'unusedDays':
+      return Number.isSafeInteger(value) && value >= 0 && value <= WORKTREE_UNUSED_DAYS_LIMIT
+        ? null
+        : `must be an integer from 0 to ${WORKTREE_UNUSED_DAYS_LIMIT}`;
     case 'autoCleanup':
+    case 'cleanupArchived':
+    case 'deleteBranch':
       return typeof value === 'boolean' ? null : 'must be a boolean';
     default:
       return 'is not a worktree setting';

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

@@ -106,7 +106,11 @@ export async function createTestWorktree(projectPath, extra = {}) {
   return { entry, ...id, ...extra };
 }
 
-/** The repository's branches under the default managed prefix. */
+/** The branch prefix the suites configure (the default is none), so their
+ *  managed branches are told apart from the repository's own. */
+export const TEST_BRANCH_PREFIX = 'mixdog/';
+
+/** The repository's branches under TEST_BRANCH_PREFIX. */
 export function prefixedBranches(repo) {
   return git(repo, 'for-each-ref', '--format=%(refname:short)', 'refs/heads/mixdog/').split('\n').filter(Boolean);
 }

package/src/runtime/shared/worktrees/worker-snapshots.mjs

@@ -0,0 +1,82 @@
+// Read-only snapshot worktrees of delegated workers (`git worktree add
+// --detach` through the git tool): the worker's session holds each one, and
+// it is removed when that worker's turn settles (the session runtime's
+// unload), like the Lead's turn snapshots. What a removal leaves (something
+// still runs there, the process ends first) is the prune's and the startup
+// reconcile's: a snapshot never outlives its holder.
+//
+// Dependency-free at load (the manager loads on first use) and shared through
+// a global symbol, so every bundle copy of this module sees one ledger.
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+
+const STATE_KEY = Symbol.for('mixdog.workerSnapshots.v1');
+const RETRY_MS = 2_000;
+const RETRY_LIMIT = 5;
+
+const loadManager = () => import('./manager.mjs');
+
+function state() {
+  globalThis[STATE_KEY] ??= { runtimeToken: `worker-snapshots-${randomUUID()}`, turns: new Map() };
+  return globalThis[STATE_KEY];
+}
+
+/**
+ * A snapshot of `commit` in the repository at `projectPath`, held by worker
+ * session `sessionId` until its turn settles (releaseWorkerSnapshots).
+ * @param {{ sessionId: string, projectPath: string, commit: string, txId?: string, confirmLarge?: boolean, manager?: object }} input
+ */
+export async function createWorkerSnapshot({
+  sessionId,
+  projectPath,
+  commit,
+  txId = '',
+  confirmLarge = false,
+  manager = null,
+}) {
+  const id = String(sessionId || '').trim();
+  if (!id) throw new Error('A worker snapshot needs the worker session.');
+  const tx = String(txId || '').trim() || `worker-snapshot-${randomUUID()}`;
+  const backend = manager || (await loadManager());
+  const entry = await backend.createSnapshotWorktree({
+    projectPath,
+    sessionId: id,
+    runtimeToken: state().runtimeToken,
+    commit,
+    txId: tx,
+    confirmLarge: confirmLarge === true,
+  });
+  const { turns } = state();
+  if (!turns.has(id)) turns.set(id, new Set());
+  turns.get(id).add(tx);
+  return entry;
+}
+
+/**
+ * The worker's turn settled: remove the snapshots it made. One a worker or
+ * background shell still runs in is retried with a doubling delay a few
+ * times; the rest stays for the prune / startup reconcile.
+ * @returns {Promise<{ removed: string[], kept: object[] }>}
+ */
+export async function releaseWorkerSnapshots(
+  sessionId,
+  { manager = null, retryMs = RETRY_MS, retryLimit = RETRY_LIMIT } = {}
+) {
+  const id = String(sessionId || '');
+  const { turns } = state();
+  const made = turns.get(id);
+  const report = { removed: [], kept: [] };
+  if (!made?.size) return report;
+  turns.delete(id);
+  const backend = manager || (await loadManager());
+  let pending = [...made];
+  for (let attempt = 0; pending.length && attempt < retryLimit; attempt++) {
+    if (attempt > 0) await delay(retryMs * 2 ** (attempt - 1), undefined, { ref: false });
+    const result = await backend.removeSessionSnapshots(id, { txIds: pending });
+    report.removed.push(...result.removed);
+    const inUse = result.kept.filter((row) => row.reason === 'in-use');
+    report.kept = result.kept;
+    pending = inUse.map((row) => row.txId);
+  }
+  return report;
+}

package/src/runtime/tidy/process.mjs

@@ -5,6 +5,7 @@
 // parser.
 import { spawn } from 'node:child_process';
 import { existsSync, readdirSync, statSync } from 'node:fs';
+import { spawnTreeKill } from '../agent/orchestrator/mcp/child-tree.mjs';
 import { delimiter, extname, isAbsolute, join } from 'node:path';
 
 const DEFAULT_PROCESS_TIMEOUT_MS = 90_000;
@@ -166,7 +167,7 @@ export function runProcess(
       if (child.exitCode != null || child.signalCode != null) return;
       try {
         if (process.platform === 'win32' && child.pid) {
-          spawn('taskkill', ['/pid', String(child.pid), '/t', '/f'], { windowsHide: true, stdio: 'ignore' });
+          spawnTreeKill([child.pid], { root: child });
         } else {
           child.kill('SIGKILL');
         }

package/src/runtime/web-search/index.mjs

@@ -28,7 +28,6 @@ const webSearchArgsSchema = z.object({
     .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
     .describe('Search query string or array of queries.'),
   site: z.string().optional().describe('Restrict results to a specific domain.'),
-  type: z.enum(['web', 'news', 'images']).optional().describe('Search type. Default: web.'),
   maxResults: z.number().int().min(1).max(20).optional().describe('Maximum number of results to return (1-20).'),
   locale: z
     .union([
@@ -65,7 +64,7 @@ const urlArgsSchema = z.object({
   cwd: z.string().optional(),
 });
 
-const WEB_SEARCH_EMPTY_STRING_FIELDS = ['keywords', 'site', 'type', 'locale', 'contextSize'];
+const WEB_SEARCH_EMPTY_STRING_FIELDS = ['keywords', 'site', 'locale', 'contextSize'];
 
 function normalizeWebSearchArgs(rawArgs) {
   if (!rawArgs || typeof rawArgs !== 'object' || Array.isArray(rawArgs)) return rawArgs;
@@ -153,17 +152,7 @@ function dropInvalidWebSearchResults(payload) {
   };
 }
 
-function getWebSearchCacheTtlMs(type = 'web') {
-  switch (type) {
-    case 'news':
-      return 20 * 60 * 1000;
-    case 'images':
-      return 60 * 60 * 1000;
-    // 'web' and any unknown type.
-    default:
-      return 30 * 60 * 1000;
-  }
-}
+const WEB_SEARCH_CACHE_TTL_MS = 30 * 60 * 1000;
 
 const SCRAPE_CACHE_TTL_MS = 60 * 60 * 1000;
 
@@ -207,7 +196,6 @@ function webSearchArgsForCacheKey(args) {
   return {
     keywords,
     site: args.site || null,
-    type: args.type || 'web',
     locale: args.locale || null,
     contextSize: args.contextSize || 'low',
     maxResults: clampMaxResults(args.maxResults),
@@ -222,7 +210,6 @@ function buildAgentWebSearchPrompt(args) {
     '',
     `Query: ${query}`,
     args.site ? `Site/domain restriction: ${args.site}` : null,
-    args.type ? `Search type: ${args.type}` : null,
     args.locale ? `Locale: ${localeLabel}` : null,
     `Max results: ${clampMaxResults(args.maxResults)}`,
     '',
@@ -326,7 +313,6 @@ function normalizeNativeWebSearchPayload(result, args, startedAt) {
       usage: result?.usage || null,
       results,
       warnings,
-      type: cacheArgs.type,
       site: cacheArgs.site,
       locale: cacheArgs.locale,
     },
@@ -360,12 +346,7 @@ async function _webSearchCore(args, { cacheState, nativeWebSearch, signal }) {
         signal: controller.signal,
       });
       const payload = normalizeNativeWebSearchPayload(result, { ...args, ...cacheArgs }, startedAt);
-      const cachedEntry = setCachedEntry(
-        cacheState,
-        webSearchCacheKey,
-        payload,
-        getWebSearchCacheTtlMs(cacheArgs.type)
-      );
+      const cachedEntry = setCachedEntry(cacheState, webSearchCacheKey, payload, WEB_SEARCH_CACHE_TTL_MS);
       flushCacheState();
       return { ...payload, cache: buildCacheMeta(cachedEntry, false) };
     }

package/src/runtime/web-search/lib/web-tools.mjs

@@ -67,8 +67,8 @@ function _notifyPoolWaiter() {
 
 async function _acquirePoolSlot(signal) {
   const abortError = () => signal?.reason || new Error('aborted');
-  // Waiting for a pool slot used to be uncancellable: an aborted tool call kept
-  // queueing until a slot freed, then launched a page nobody was waiting for.
+  // Waiting for a pool slot is cancellable: otherwise an aborted tool call keeps
+  // queueing until a slot frees, then launches a page nobody was waiting for.
   while (_poolActive >= PUPPETEER_POOL_MAX_PAGES) {
     if (signal?.aborted) throw abortError();
     await new Promise((resolve, reject) => {

package/src/runtime/web-search/tool-defs.mjs

@@ -1,5 +1,8 @@
-import { TOOL_SYNC_EXECUTION_CONTRACT } from '../shared/tool-execution-contract.mjs';
-
+// Model-facing text is kept minimal: every constraint dropped from these schemas
+// (minLength, pattern, minItems, maxItems, format) is enforced by the zod
+// schemas in index.mjs, which trim blanks and reject empty or non-URL input.
+// `trigger` shows only in the deferred listing, so `description` carries the
+// when-to-use guidance itself.
 const TOOL_DEFS_PLACEHOLDER = Symbol('web-fetch-schema');
 
 export const TOOL_DEFS = [
@@ -7,21 +10,18 @@ export const TOOL_DEFS = [
     name: 'web_search',
     title: 'Mixdog Web Search',
     trigger: 'Unfamiliar names, products, models, recent or external facts; search before answering from memory.',
-    description: `Cached web/docs/current-info search; batch queries sharing filters. ${TOOL_SYNC_EXECUTION_CONTRACT}`,
+    description:
+      'Search the web for recent, external or unfamiliar facts (names, products, models) before answering from memory.',
     inputSchema: {
       type: 'object',
       properties: {
         query: {
-          anyOf: [
-            { type: 'string', minLength: 1, pattern: '\\S' },
-            { type: 'array', minItems: 1, items: { type: 'string', minLength: 1, pattern: '\\S' } },
-          ],
-          description: 'Non-empty query or array for lossless fan-out.',
+          anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+          description: 'One query, or an array run as a batch.',
         },
-        site: { type: 'string', description: 'Site/domain filter.' },
-        type: { type: 'string', enum: ['web', 'news', 'images'], description: 'Default web.' },
-        maxResults: { type: 'integer', minimum: 1, maximum: 20, description: 'Result count; default 10; 1-20.' },
-        locale: { type: 'string', description: 'Optional locale hint, e.g. ko-KR or a city/region name.' },
+        site: { type: 'string', description: 'Domain filter.' },
+        maxResults: { type: 'integer', minimum: 1, maximum: 20, description: 'Default 10.' },
+        locale: { type: 'string', description: 'e.g. ko-KR.' },
         contextSize: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Default low.' },
       },
       required: ['query'],
@@ -39,25 +39,16 @@ export const TOOL_DEFS = [
     name: 'web_fetch',
     title: 'Mixdog Web Fetch',
     trigger: 'Page or docs body from a known URL; not discovery (web_search).',
-    description: 'Fetch page/docs body from URL; batch known URLs with shared slice options.',
+    description: 'Fetch the page or docs body of known URLs; to find pages, use web_search.',
     inputSchema: {
       type: 'object',
       properties: {
         url: {
-          anyOf: [
-            { type: 'string', format: 'uri' },
-            { type: 'array', items: { type: 'string', format: 'uri' }, minItems: 1, maxItems: 10 },
-          ],
-          description:
-            'Public or loopback HTTP(S) URL, or an array of up to 10; keep loopback and public URLs in separate calls.',
-        },
-        startIndex: { type: 'integer', minimum: 0, description: 'Character offset; default 0.' },
-        maxLength: {
-          type: 'integer',
-          minimum: 0,
-          description:
-            'Maximum characters; default 20000; 0 unlimited. A cut page ends with [output capped …; startIndex:N for more].',
+          anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+          description: 'URL, or an array of up to 10; loopback and public URLs in separate calls.',
         },
+        startIndex: { type: 'integer', minimum: 0, description: 'Character offset.' },
+        maxLength: { type: 'integer', minimum: 0, description: 'Default 20000; 0 unlimited.' },
       },
       required: ['url'],
       additionalProperties: false,

package/src/session-runtime/agent-profile-changes.mjs

@@ -14,6 +14,18 @@ export function subscribeAgentProfileChanges(listener) {
   return { unsubscribe: () => listeners.delete(listener) };
 }
 
+/** The keys of a saved agent route its chats and reused workers follow. */
+export const AGENT_ROUTE_KEYS = Object.freeze([
+  'provider',
+  'model',
+  'effort',
+  'fast',
+  'autoEffort',
+  'modelParameters',
+  'contextPercent',
+  'contextTokens',
+]);
+
 // A bot's saved model route: the hosts of its chats (the session service)
 // move them onto it from their next turn.
 const routeListeners = new Set();
@@ -23,11 +35,50 @@ export function subscribeAgentRouteChanges(listener) {
   return { unsubscribe: () => routeListeners.delete(listener) };
 }
 
-/** Settles once every host has taken the route; one failing host never fails the save. */
-export async function publishAgentRouteChange(agentId, route) {
-  await Promise.allSettled(
+// Per bot, the route every host of this process took last (recorded only once
+// all of them took it), and the publication in flight.
+const publishedRoutes = new Map();
+const publishingRoutes = new Map();
+
+/** Every host takes the route; rejects with the hosts' failures. A
+ *  publication of the same route already in flight is joined, not repeated. */
+function deliverAgentRoute(agentId, route) {
+  const key = JSON.stringify(route ?? null);
+  const inFlight = publishingRoutes.get(agentId);
+  if (inFlight?.key === key) return inFlight.done;
+  const done = Promise.allSettled(
     [...routeListeners].map((listener) => Promise.resolve().then(() => listener(agentId, route)))
-  );
+  ).then((results) => {
+    if (publishingRoutes.get(agentId)?.done === done) publishingRoutes.delete(agentId);
+    const failures = results.filter((one) => one.status === 'rejected').map((one) => one.reason);
+    if (failures.length) {
+      throw new AggregateError(
+        failures,
+        `the ${agentId} route reached ${results.length - failures.length} of ${results.length} hosts`
+      );
+    }
+    publishedRoutes.set(agentId, key);
+  });
+  publishingRoutes.set(agentId, { key, done });
+  return done;
+}
+
+/** Settles once every host has taken the route; one failing host never fails
+ *  the save (the change step that follows it publishes the route again). */
+export async function publishAgentRouteChange(agentId, route) {
+  try {
+    await deliverAgentRoute(agentId, route);
+  } catch {}
+}
+
+/** A bot route read from a changed config (saved by another process, edited
+ *  by hand, or this process's own save): every runtime of the process applies
+ *  the same change, so the hosts hear each route once, unless one failed to
+ *  take it. Rejects when a host failed, so the change step retries it. */
+export function publishStoredAgentRoute(agentId, route) {
+  const inFlight = publishingRoutes.get(agentId);
+  if (!inFlight && publishedRoutes.get(agentId) === JSON.stringify(route ?? null)) return Promise.resolve();
+  return deliverAgentRoute(agentId, route);
 }
 
 /** Settles once every runtime has applied the edit; one failing runtime never fails the save. */

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

@@ -118,6 +118,8 @@ export function wireApis(boot) {
       console.warn(`[connectors] merging connector accounts failed: ${error?.message || error}`);
       bootProfile('connector-accounts:merge-failed', { error: error?.message || String(error) });
     }
+    // After the merge: every account has its identity before anything connects.
+    if (boot.ensureConnectorAccountIds()) boot.reloadFullConfig();
   }
   boot.disposeGlobalExtensionSubscription = () => {
     boot.disposeConfigSync?.();
@@ -164,12 +166,18 @@ export function wireApis(boot) {
     getSession: () => boot.rt.session,
     getSessionId: getFacadeSessionId,
     goalRuntime: boot.goalRuntime,
+    persistSession: (session) => saveSessionAsync(session, { expectedGeneration: session.generation }),
   });
 }
 
 function wireToolPolicyRefresh(boot) {
   const { rt, cfgMod } = boot;
   const {
+    reconcileTurnSettings,
+    reconcileEmptySession,
+    emptySessionStale,
+    noteToolAvailability,
+    settingsReachCurrentSession,
     refreshEmptySessionToolPolicy,
     switchSessionWorkflow,
     switchSessionOrchestrationMode,
@@ -196,7 +204,14 @@ function wireToolPolicyRefresh(boot) {
     // A switch is acknowledged only once saved; a session closed or replaced
     // since (its generation moved) is not resurrected.
     persistSession: (session) => saveSessionAsync(session, { expectedGeneration: session.generation }),
+    toolDefinitionsFor: boot.toolDefinitionsFor,
+    getSurfaceGeneration: boot.surfaceGeneration,
   });
+  boot.reconcileTurnSettings = reconcileTurnSettings;
+  boot.reconcileEmptySession = reconcileEmptySession;
+  boot.emptySessionStale = emptySessionStale;
+  boot.noteToolAvailability = noteToolAvailability;
+  boot.settingsReachCurrentSession = settingsReachCurrentSession;
   boot.refreshEmptySessionToolPolicy = refreshEmptySessionToolPolicy;
   boot.switchSessionWorkflow = switchSessionWorkflow;
   boot.switchSessionOrchestrationMode = switchSessionOrchestrationMode;
@@ -347,7 +362,6 @@ function settingsApiFor(boot) {
     getUpdateProcessState: () => selfUpdate.getProcessState(),
     invalidateContextStatusCache: (...a) => boot.invalidateContextStatusCache(...a),
     invalidatePreSessionToolSurface: (...a) => boot.invalidatePreSessionToolSurface(...a),
-    refreshEmptySessionToolPolicy: boot.refreshEmptySessionToolPolicy,
     scheduleChannelStart: (...a) => boot.scheduleChannelStart(...a),
     channels: boot.channels,
     clearChannelStartTimer: () => {
@@ -410,6 +424,7 @@ function providerAuthApiFor(boot) {
     saveConfigAndAdopt: boot.saveConfigAndAdopt,
     displayConfig: boot.displayConfig,
     reloadFullConfig: boot.reloadFullConfig,
+    applyConfigChange: boot.applyConfigChange,
     awaitKeychainPrewarm: boot.awaitKeychainPrewarm,
     isKeychainPrewarmReady: () => rt.keychainPrewarmWaitDone,
     hasProviderSetupCached: boot.hasProviderSetupCached,
@@ -527,7 +542,6 @@ function resourceApiFor(boot) {
     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,
@@ -561,6 +575,8 @@ function modelRouteApiFor(boot) {
     getSession: () => rt.session,
     getSessionGeneration: () => rt.sessionGeneration,
     setSession: boot.adoptSession,
+    // A held model pick is saved with its session (a replaced one is not resurrected).
+    persistSession: (session) => saveSessionAsync(session, { expectedGeneration: session.generation }).catch(() => {}),
     getAddressedSessionId: () => rt.addressedSessionId,
     getConfigHasSecrets: () => rt.configHasSecrets,
     getWebSearchRouteState: () => rt.webSearchRoute,
@@ -626,7 +642,7 @@ function workflowAgentsApiFor(boot) {
     scheduleOutputStyleSave: boot.scheduleOutputStyleSave,
     invalidateContextStatusCache: boot.invalidateContextStatusCache,
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,
-    refreshEmptySessionToolPolicy: boot.refreshEmptySessionToolPolicy,
+    settingsReachCurrentSession: () => boot.settingsReachCurrentSession(),
     switchSessionWorkflow: boot.switchSessionWorkflow,
     switchSessionOrchestrationMode: boot.switchSessionOrchestrationMode,
   });
@@ -653,7 +669,12 @@ function workspaceApiFor(boot) {
     // waits on the save worker, which may never come up.
     persistSession: (session) => saveSession(session, { sync: true }),
     refreshWorkspaceContext: (session, cwd, move) =>
-      refreshWorkspacePrompt(session, cwd, { loadCoreMemoryContext: boot.loadCoreMemoryContext, move }),
+      refreshWorkspacePrompt(session, cwd, {
+        loadCoreMemoryContext: boot.loadCoreMemoryContext,
+        move,
+        // The runtime's in-memory setting, not the debounced file.
+        instructionFilesMode: rt.config?.instructionFiles,
+      }),
     invalidateCaches: () => {
       boot.invalidateContextStatusCache();
       boot.invalidatePreSessionToolSurface();
@@ -671,6 +692,8 @@ function sessionTurnApiFor(boot) {
   return createSessionTurnApi({
     applyPendingRoute: () => boot.modelRouteApi.applyPendingRoute(),
     applyPendingAgentProfile: boot.applyPendingAgentProfile,
+    reconcileTurnSettings: boot.reconcileTurnSettings,
+    reconcileEmptySession: () => boot.reconcileEmptySession(),
     currentAgents: boot.currentAgents,
     applyPendingSessionSwitches: boot.applyPendingSessionSwitches,
     prepareTurnWorkspace: boot.workspaceApi.prepareTurnWorkspace,

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

@@ -35,6 +35,7 @@ export function beginBoot(params) {
   const {
     awaitKeychainPrewarm,
     invalidateProviderCaches,
+    reinitProviders,
     ensureProvidersReady,
     modelMetaByRoute,
     providerModelCaches,
@@ -54,6 +55,7 @@ export function beginBoot(params) {
   return Object.assign(boot, {
     awaitKeychainPrewarm,
     invalidateProviderCaches,
+    reinitProviders,
     ensureProvidersReady,
     modelMetaByRoute,
     providerModelCaches,

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

@@ -1,6 +1,7 @@
 // Boot stage 3: the initial config/route state, the runtime scalars, the
 // timer/prewarm holders teardown sweeps, and the env-tunable boot delays.
 import { performance } from 'node:perf_hooks';
+import { SessionClosedError } from '../../runtime/agent/orchestrator/session/manager/session-errors.mjs';
 import { setConfiguredShell } from '../../runtime/agent/orchestrator/tools/builtin/shell-runtime.mjs';
 import { LOCAL_PROVIDER_ID, configureLocalProviderIdleTtl } from '../../runtime/local-provider/managed-runtime.mjs';
 import { normalizeToolMode } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
@@ -26,6 +27,7 @@ export async function resolveConfig(boot) {
   } = resolveInitialConfigState({
     initialConfig: params.initialConfig,
     loadConfig: () => cfgMod.loadConfig({ secrets: false }),
+    readStoredOutputStyle: () => sharedCfgMod.readConfig?.()?.outputStyle,
     resolveRoute,
     provider: params.provider,
     model: params.model,
@@ -97,9 +99,16 @@ function initRuntimeState(rt, params) {
   rt.startupProviderCatalogRefreshPending = false;
 }
 
-function activeTurnControls(rt) {
+export function activeTurnControls(rt) {
   return {
     registerActiveTurnController: (controller) => {
+      // Close aborts the turns registered when it starts; a turn opened after
+      // that (a caller already past its own checks) starts aborted, so a
+      // closing runtime never reaches the provider again.
+      if (rt.closeRequested && !controller.signal.aborted) {
+        const sessionId = rt.session?.id || rt.reservedSessionId || 'pending';
+        controller.abort(new SessionClosedError(sessionId, 'runtime is closing', 'runtime-close'));
+      }
       rt.activeTurnAbortControllers.add(controller);
       return () => rt.activeTurnAbortControllers.delete(controller);
     },

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

@@ -118,6 +118,7 @@ function facadeGetters(boot) {
         : configuredOrchestrationMode(rt.config),
     getOutputStyle: () => boot.getOutputStyleStatusCached().current,
     getContextStatus: boot.computeContextStatus,
+    getContextStatusSettled: boot.computeContextStatusSettled,
     getContextStatusForSession: boot.computeContextStatusForSession,
     renameSessionTitle: (sessionId, title) => mgr.updateSessionManualTitle(sessionId, title),
   };