mixdog 1.4.1 → 1.4.3

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),
   };

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

@@ -31,13 +31,27 @@ import {
 } from '../model-recency.mjs';
 import { createNativeWebSearch } from '../native-web-search.mjs';
 import { createConfigLifecycle } from '../config-lifecycle.mjs';
+import { createConfigChangeEffects, SETTINGS_CHANGED_SETUP_ACTION } from '../config-change-effects.mjs';
+import { resetProviderAdmissionCooldowns } from '../../runtime/agent/orchestrator/providers/admission-scheduler.mjs';
 import { usesInjectedConfig } from '../session-compaction-sync.mjs';
 import { createQuickModelRows } from '../quick-model-rows.mjs';
 import { createProviderModels } from '../provider-models.mjs';
 import { createProviderUsage } from '../provider-usage.mjs';
 import { bootProfile } from '../boot-profile.mjs';
 import { standaloneDataDir } from '../runtime-paths.mjs';
-import { outputStyleStatus, resolveRoute, webSearchCapableFor } from './shared.mjs';
+import { noteCacheWarmingEnabled } from '../../runtime/agent/orchestrator/session/cache-warm.mjs';
+import { refreshLiveSessionsProviderCacheOpts } from '../../runtime/agent/orchestrator/session/manager/session-lifecycle.mjs';
+import { publishStoredAgentRoute } from '../agent-profile-changes.mjs';
+import {
+  ensureConnectorAccountIds,
+  forgetConversationConnectorAccounts,
+} from '../../runtime/connectors/connector-accounts-mcp.mjs';
+import { registerSessionPurgeHook } from '../../runtime/agent/orchestrator/session/store/session-observers.mjs';
+import { effectiveAgentRoute } from '../workflow-agents-api/shared.mjs';
+import { agentRouteFromConfig, outputStyleStatus, resolveRoute, webSearchCapableFor } from './shared.mjs';
+
+// A conversation's connector accounts go with its session (once per process).
+registerSessionPurgeHook((sessionId) => forgetConversationConnectorAccounts(sessionId));
 
 export function wireProviders(boot) {
   wireConfigLifecycle(boot);
@@ -52,6 +66,17 @@ export function wireProviders(boot) {
 // injection.
 function wireConfigLifecycle(boot) {
   const { rt, cfgMod, sharedCfgMod } = boot;
+  // Every stored connector account gets its identity (an injected config is
+  // not the stored one). True when the stored config changed.
+  boot.ensureConnectorAccountIds = () => {
+    if (usesInjectedConfig(boot.params)) return false;
+    try {
+      return ensureConnectorAccountIds();
+    } catch (error) {
+      console.warn(`[connectors] giving accounts their identity failed: ${error?.message || error}`);
+      return false;
+    }
+  };
   const lifecycle = createConfigLifecycle({
     getConfig: () => rt.config,
     setConfig: (next) => {
@@ -68,7 +93,7 @@ function wireConfigLifecycle(boot) {
     },
     getRoute: () => rt.route,
     getSession: () => rt.session,
-    fixedSessionCompaction: usesInjectedConfig(boot.params),
+    injectedConfig: usesInjectedConfig(boot.params),
     setRouteState: (next) => {
       rt.route = next;
     },
@@ -82,7 +107,47 @@ function wireConfigLifecycle(boot) {
     LAZY_SECRET_PROVIDERS,
     clean,
     resolve,
-    onConfigReloaded: () => boot.invalidateContextStatusCache?.(),
+    // Late-bound: the effect targets (notification bus, MCP connect, context
+    // status) are wired by later boot stages.
+    onConfigChanged: createConfigChangeEffects({
+      invalidateContextStatusCache: () => boot.invalidateContextStatusCache?.(),
+      reinitProviders: () => boot.reinitProviders(),
+      releaseAdmissionCooldowns: resetProviderAdmissionCooldowns,
+      // Fails (so the change step retries it) when a server failed to connect
+      // (other than needing a sign-in, which waits on the user) or the
+      // identities failed; the servers reconcile either way.
+      reconcileMcp: async () => {
+        // An account written by hand gets its identity; that write is one
+        // more change, reconciled in turn.
+        let idsError = null;
+        if (!usesInjectedConfig(boot.params)) {
+          try {
+            ensureConnectorAccountIds();
+          } catch (error) {
+            idsError = error;
+          }
+        }
+        const status = await boot.connectConfiguredMcp?.({ reconcile: true });
+        if (idsError) throw idsError;
+        const failed = (status?.servers || []).filter((row) => row.enabled !== false && row.status === 'failed');
+        if (failed.length) {
+          throw new Error(
+            `MCP servers failed to connect: ${failed.map((row) => `${row.name} (${row.error})`).join(', ')}`
+          );
+        }
+      },
+      noteCacheWarmingEnabled,
+      refreshLiveSessionsCacheOpts: (config) => refreshLiveSessionsProviderCacheOpts(config),
+      // A bot whose stored route was cleared follows Main.
+      publishAgentRoute: (id, config) =>
+        publishStoredAgentRoute(id, effectiveAgentRoute({ agentRouteFromConfig, resolveRoute }, config, id)),
+      // Attached surfaces (TUI, desktop session lanes) re-read open settings.
+      announceSettingsChange: () =>
+        boot.emitRuntimeNotification?.('Settings changed', {
+          kind: 'setup-changed',
+          action: SETTINGS_CHANGED_SETUP_ACTION,
+        }),
+    }),
     STANDALONE_DATA_DIR: standaloneDataDir(),
   });
   const {
@@ -98,11 +163,13 @@ function wireConfigLifecycle(boot) {
     scheduleOutputStyleSave,
     flushAllConfigSavesAsync,
     reloadFullConfig,
+    applyConfigChange,
     ensureFullConfig,
     displayConfig,
     ensureConfigForRouteProvider,
   } = lifecycle;
   Object.assign(boot, {
+    applyConfigChange,
     disposeConfigSync,
     getOutputStyleStatusCached,
     invalidateOutputStyleStatusCache,

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

@@ -51,6 +51,8 @@ export function wireSessionLifecycle(boot) {
     schemaAllowedTools: modelToolSchemaAllowlist(rt.toolProfile),
     featureDisallowedTools: boot.featureDisallowedTools,
     applyPreSessionToolSelection: boot.applyPreSessionToolSelection,
+    // Late-bound: the tool policy refresh is wired with the API slices.
+    noteToolAvailability: (session, coreMemory) => boot.noteToolAvailability?.(session, coreMemory),
     statusRoutes: boot.statusRoutes,
     warmupTimers: boot.warmupTimers,
     providerModelCaches: boot.providerModelCaches,

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

@@ -22,6 +22,7 @@ import { TOOL_DEFS as OFFICE_TOOL_DEFS } from '../../runtime/office/tool-defs.mj
 import { TOOL_DEFS as MEDIA_TOOL_DEFS } from '../../runtime/media/tool-defs.mjs';
 import { TOOL_DEFS as TIDY_TOOL_DEFS } from '../../runtime/tidy/tool-defs.mjs';
 import { TOOL_DEFS as VISUALIZE_BRIDGE_TOOL_DEFS } from '../../runtime/visualize-bridge/tool-defs.mjs';
+import { TOOL_DEFS as EXPLORE_TOOL_DEFS } from '../../runtime/explore/tool-defs.mjs';
 import {
   ASK_USER_TOOL_DEFS,
   HANDOFF_USER_TOOL_DEFS,
@@ -40,6 +41,7 @@ import {
 } from '../../runtime/agent/orchestrator/runtime-core/context-status.mjs';
 import { createInternalToolExecutor } from '../internal-tool-executor.mjs';
 import { registerWorktreeToolHost } from '../../runtime/shared/worktrees/tool-host.mjs';
+import { registerLiveFeatureGates } from '../../runtime/agent/orchestrator/runtime-core/tool-availability.mjs';
 import { createWorktreeToolHost } from '../workspace/worktree-tool.mjs';
 import { STANDALONE_ROOT, standaloneDataDir } from '../runtime-paths.mjs';
 import { dataDirOf, workflowHelpers } from './shared.mjs';
@@ -60,8 +62,14 @@ export function wireTools(boot) {
       })
     )
     .catch((error) => bootProfile('mcp:failed', { error: error?.message || String(error) }));
+  // A lost reload leaves the old timers armed; the scheduler re-reads each
+  // schedule before it fires (scheduler.mjs fireTimed), so it is only reported.
   boot.reloadChannelsSoon = () => {
-    boot.channels.execute('reload_config', {}).catch(() => {});
+    boot.channels
+      .execute('reload_config', {})
+      .catch((error) =>
+        process.stderr.write(`[channels] schedule reload failed: ${error?.message || String(error)}\n`)
+      );
   };
 }
 
@@ -172,6 +180,7 @@ function wireToolSurface(boot) {
     mediaToolDefs: MEDIA_TOOL_DEFS,
     tidyToolDefs: TIDY_TOOL_DEFS,
     visualizeToolDefs: VISUALIZE_BRIDGE_TOOL_DEFS,
+    exploreToolDefs: EXPLORE_TOOL_DEFS,
     setupToolDefs: SETUP_TOOL_DEFS,
     askUserToolDefs: ASK_USER_TOOL_DEFS,
     handoffUserToolDefs: HANDOFF_USER_TOOL_DEFS,
@@ -181,23 +190,29 @@ function wireToolSurface(boot) {
     skillToolEnabled: !envFlag('MIXDOG_DISABLE_SKILLS'),
   });
   bootProfile('tools:ready', { ms: (performance.now() - toolsStartedAt).toFixed(1), count: standaloneTools.length });
-  const { modelStandaloneTools, invalidatePreSessionToolSurface, activeToolSurface, applyPreSessionToolSelection } =
-    createToolSurface({
-      mgr,
-      mode: rt.mode,
-      standaloneTools,
-      agentToolNames,
-      getSession: () => rt.session,
-      getRoute: () => rt.route,
-      getConfig: () => rt.config,
-      getToolProfile: () => rt.toolProfile,
-      getMcpScopeId: () => rt.mcpScopeId,
-      getCurrentCwd: () => rt.currentCwd,
-      cfgMod,
-      delegatableAgentIds: workflowHelpers.delegatableAgentIds,
-      dataDir: standaloneDataDir(),
-      getFeatureDisallowedTools: featureDisallowedTools,
-    });
+  const {
+    modelStandaloneTools,
+    invalidatePreSessionToolSurface,
+    activeToolSurface,
+    applyPreSessionToolSelection,
+    toolDefinitionsFor,
+    surfaceGeneration,
+  } = createToolSurface({
+    mgr,
+    mode: rt.mode,
+    standaloneTools,
+    agentToolNames,
+    getSession: () => rt.session,
+    getRoute: () => rt.route,
+    getConfig: () => rt.config,
+    getToolProfile: () => rt.toolProfile,
+    getMcpScopeId: () => rt.mcpScopeId,
+    getCurrentCwd: () => rt.currentCwd,
+    cfgMod,
+    delegatableAgentIds: workflowHelpers.delegatableAgentIds,
+    dataDir: standaloneDataDir(),
+    getFeatureDisallowedTools: featureDisallowedTools,
+  });
   Object.assign(boot, {
     standaloneTools,
     internalToolDefs,
@@ -206,10 +221,15 @@ function wireToolSurface(boot) {
     invalidatePreSessionToolSurface,
     activeToolSurface,
     applyPreSessionToolSelection,
+    toolDefinitionsFor,
+    surfaceGeneration,
   });
 }
 
-function wireContextStatus(boot) {
+/** The setup-changed action of a context status an empty session's reconcile moved. */
+export const CONTEXT_STATUS_REFRESHED_ACTION = 'context_status_refreshed';
+
+export function wireContextStatus(boot) {
   const { rt } = boot;
   const { contextStatus: computeContextStatus, invalidateContextStatusCache } = createContextStatus({
     getSession: () => rt.session,
@@ -219,7 +239,33 @@ function wireContextStatus(boot) {
     getMode: () => rt.mode,
   });
   Object.assign(boot, {
-    computeContextStatus,
+    // The synchronous accessor (the local TUI): an empty session whose
+    // settings gates moved starts the shared turn-start reconcile
+    // (late-bound); when it rebuilt anything the cache is dropped and the
+    // attached surfaces are told to read again.
+    computeContextStatus: (...args) => {
+      if (boot.emptySessionStale?.()) {
+        boot
+          .reconcileEmptySession()
+          .then((result) => {
+            if (!result) return;
+            invalidateContextStatusCache();
+            boot.emitRuntimeNotification?.('Context status refreshed', {
+              kind: 'setup-changed',
+              action: CONTEXT_STATUS_REFRESHED_ACTION,
+            });
+          })
+          .catch(() => {});
+      }
+      return computeContextStatus(...args);
+    },
+    // Async boundaries (desktop, remote, IPC) wait for the same reconcile.
+    computeContextStatusSettled: async (...args) => {
+      if (boot.emptySessionStale?.()) {
+        if (await boot.reconcileEmptySession()) invalidateContextStatusCache();
+      }
+      return computeContextStatus(...args);
+    },
     invalidateContextStatusCache,
     computeContextStatusForSession: (session) =>
       contextStatusForSession(session, {
@@ -253,11 +299,7 @@ function wireInternalTools(boot) {
       goalRuntime: boot.goalRuntime,
       agentTool: boot.routedAgentTool,
       setupTool,
-      webSearchEnabled: boot.webSearchEnabled,
-      memoryToolsEnabled: boot.memoryToolsEnabledFn,
-      officeToolsEnabled: boot.officeToolsEnabledFn,
-      mediaToolEnabled: boot.mediaToolEnabledFn,
-      tidyToolEnabled: boot.tidyToolEnabledFn,
+      featureDisallowedTools: boot.featureDisallowedTools,
       getWebSearchModule: boot.getWebSearchModule,
       getMemoryModule: boot.getMemoryModule,
       getCodeGraphModule: boot.getCodeGraphModule,
@@ -286,9 +328,13 @@ function wireInternalTools(boot) {
       executeSessionControl: boot.params.executeSessionControl || null,
     }).run,
   });
+  // Dispatch refuses a model call of a tool a setting turned off from this
+  // runtime's live gates (a turn already running when it changed included).
+  const disposeLiveGates = registerLiveFeatureGates(rt.mcpScopeId, boot.featureDisallowedTools);
   Object.assign(boot, {
     setupTool,
     disposeInternalTools: () => {
+      disposeLiveGates();
       disposeWorktreeToolHost();
       // Its turn snapshot cleanups stop with the runtime (maintenance finishes them).
       boot.workspaceApi?.dispose();

package/src/session-runtime/bot-status.mjs

@@ -204,6 +204,109 @@ function routineDetail(routine, now) {
   return cut(`${routine.kind} ${quotedText(routine.name, 64)}: ${parts.join(', ')}`, 240);
 }
 
+/** Everything known about one bot, from the gathered state. */
+function botState(bot, ctx) {
+  const homeId = agentHomeSessionId(bot.id);
+  const owned = ctx.owned.get(bot.id) || [];
+  const home = ctx.rows.get(homeId) || null;
+  // Work this bot sent that is running now: a session working with the bot's
+  // send in flight (`handedBy`, bot-owned-work.mjs). A turn the user typed
+  // in the bot's task session is the user's, not the bot working.
+  const sentWork = (row) => isWorking(row) && row.handedBy?.includes(bot.id);
+  // Running task sessions: a turn whose report is still owed, or the bot's
+  // work running now.
+  const tasks = new Map();
+  const addTask = (id, title, at) => {
+    const known = tasks.get(id);
+    if (!known) tasks.set(id, { id, title, at });
+    else if (at && (!known.at || at < known.at)) known.at = at;
+  };
+  for (const watch of ctx.watches) {
+    if (watch.agentId !== bot.id || watch.target === 'session' || !watch.taskSessionId) continue;
+    addTask(watch.taskSessionId, watch.title, Number(watch.at) || 0);
+  }
+  for (const row of owned) {
+    if (row.id === homeId || roomMemberOfSession(row.id) || !sentWork(row)) continue;
+    addTask(row.id, row.title, Number(row.createdAt) || 0);
+  }
+  const running = [...tasks.values()].sort((left, right) => left.at - right.at || (left.id < right.id ? -1 : 1));
+  const held = ctx.held.filter((entry) => entry.agentId === bot.id);
+  const approvals = held.length + [homeId, ...running.map((task) => task.id)].filter(ctx.awaitingApproval).length;
+  const routines = ctx.routines.rows
+    .filter((routine) => (routine.owner || MIXY_AGENT_ID) === bot.id)
+    .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+  const flags = [];
+  if (approvals) flags.push(`${plural(approvals, 'approval')} waiting`);
+  for (const routine of routines) {
+    const trouble = routineTrouble(routine);
+    if (trouble.length) flags.push(`${quotedText(routine.name, 20)} ${trouble.join(', ')}`);
+  }
+  if (bot.disabled) flags.push('disabled');
+  return {
+    bot,
+    homeId,
+    home,
+    owned,
+    running,
+    held,
+    approvals,
+    routines,
+    flags,
+    working: isWorking(home) || running.some((task) => sentWork(ctx.rows.get(task.id))),
+    lastAt: activityOf(home),
+  };
+}
+
+function botLine(state, now) {
+  const { bot } = state;
+  const parts = [`${quotedText(bot.name, 40)} (${bot.id})`, `chat ${state.homeId}`];
+  if (bot.self) parts.push('you');
+  parts.push(state.working ? 'working' : 'idle');
+  if (state.flags.length) parts.push(`attention: ${state.flags.join('; ')}`);
+  parts.push(state.lastAt ? `last ${ago(state.lastAt, now)}` : 'no chat yet');
+  if (state.running.length) {
+    const [first] = state.running;
+    const more = state.running.length > 1 ? ` +${state.running.length - 1}` : '';
+    const count = state.running.length > 1 ? `${state.running.length} tasks:` : 'task';
+    parts.push(`${count} "${quotedText(first.title, 24)}"${first.at ? ` ${span(now - first.at)}` : ''}${more}`);
+  }
+  if (state.routines.length) {
+    const next = state.routines
+      .filter((routine) => routine.enabled !== false && epoch(routine.nextFireAt))
+      .sort((left, right) => epoch(left.nextFireAt) - epoch(right.nextFireAt))[0];
+    parts.push(
+      `${plural(state.routines.length, 'routine')}${next ? `, next ${quotedText(next.name, 20)} ${until(epoch(next.nextFireAt), now)}` : ''}`
+    );
+  }
+  const fixed = parts.join(' · ');
+  const preview = oneLine(state.home?.lastMessagePreview || state.home?.preview);
+  const room = BOT_LINE_LIMIT - fixed.length - 5;
+  return cut(preview && room >= MIN_PREVIEW ? `${fixed} · "${quotedText(preview, room)}"` : fixed, BOT_LINE_LIMIT);
+}
+
+const mixyBot = (ctx) => ({ id: MIXY_AGENT_ID, name: ctx.mixy, self: true });
+
+/** The bots the caller sees: every bot then Mixy when she has something to
+ *  show, or just the caller's own bot. */
+function visibleStates(ctx) {
+  if (ctx.own) {
+    const bot = ctx.own === MIXY_AGENT_ID ? mixyBot(ctx) : ctx.bots[0];
+    return bot ? [botState(bot, ctx)] : [];
+  }
+  const states = ctx.bots
+    .map((bot) => botState(bot, ctx))
+    .sort(
+      (left, right) =>
+        Number(right.flags.length > 0) - Number(left.flags.length > 0) ||
+        Number(right.working) - Number(left.working) ||
+        right.lastAt - left.lastAt ||
+        (left.bot.id < right.bot.id ? -1 : 1)
+    );
+  const mixy = botState(mixyBot(ctx), ctx);
+  if (mixy.routines.length || mixy.running.length || mixy.approvals) states.push(mixy);
+  return states;
+}
+
 export function createBotStatus({
   getSessionService,
   listBots = defaultListBots,
@@ -260,109 +363,6 @@ export function createBotStatus({
     };
   }
 
-  /** Everything known about one bot, from the gathered state. */
-  function botState(bot, ctx) {
-    const homeId = agentHomeSessionId(bot.id);
-    const owned = ctx.owned.get(bot.id) || [];
-    const home = ctx.rows.get(homeId) || null;
-    // Work this bot sent that is running now: a session working with the bot's
-    // send in flight (`handedBy`, bot-owned-work.mjs). A turn the user typed
-    // in the bot's task session is the user's, not the bot working.
-    const sentWork = (row) => isWorking(row) && row.handedBy?.includes(bot.id) === true;
-    // Running task sessions: a turn whose report is still owed, or the bot's
-    // work running now.
-    const tasks = new Map();
-    const addTask = (id, title, at) => {
-      const known = tasks.get(id);
-      if (!known) tasks.set(id, { id, title, at });
-      else if (at && (!known.at || at < known.at)) known.at = at;
-    };
-    for (const watch of ctx.watches) {
-      if (watch.agentId !== bot.id || watch.target === 'session' || !watch.taskSessionId) continue;
-      addTask(watch.taskSessionId, watch.title, Number(watch.at) || 0);
-    }
-    for (const row of owned) {
-      if (row.id === homeId || roomMemberOfSession(row.id) || !sentWork(row)) continue;
-      addTask(row.id, row.title, Number(row.createdAt) || 0);
-    }
-    const running = [...tasks.values()].sort((left, right) => left.at - right.at || (left.id < right.id ? -1 : 1));
-    const held = ctx.held.filter((entry) => entry.agentId === bot.id);
-    const approvals = held.length + [homeId, ...running.map((task) => task.id)].filter(ctx.awaitingApproval).length;
-    const routines = ctx.routines.rows
-      .filter((routine) => (routine.owner || MIXY_AGENT_ID) === bot.id)
-      .sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
-    const flags = [];
-    if (approvals) flags.push(`${plural(approvals, 'approval')} waiting`);
-    for (const routine of routines) {
-      const trouble = routineTrouble(routine);
-      if (trouble.length) flags.push(`${quotedText(routine.name, 20)} ${trouble.join(', ')}`);
-    }
-    if (bot.disabled) flags.push('disabled');
-    return {
-      bot,
-      homeId,
-      home,
-      owned,
-      running,
-      held,
-      approvals,
-      routines,
-      flags,
-      working: isWorking(home) || running.some((task) => sentWork(ctx.rows.get(task.id))),
-      lastAt: activityOf(home),
-    };
-  }
-
-  function botLine(state, now) {
-    const { bot } = state;
-    const parts = [`${quotedText(bot.name, 40)} (${bot.id})`, `chat ${state.homeId}`];
-    if (bot.self) parts.push('you');
-    parts.push(state.working ? 'working' : 'idle');
-    if (state.flags.length) parts.push(`attention: ${state.flags.join('; ')}`);
-    parts.push(state.lastAt ? `last ${ago(state.lastAt, now)}` : 'no chat yet');
-    if (state.running.length) {
-      const [first] = state.running;
-      const more = state.running.length > 1 ? ` +${state.running.length - 1}` : '';
-      const count = state.running.length > 1 ? `${state.running.length} tasks:` : 'task';
-      parts.push(`${count} "${quotedText(first.title, 24)}"${first.at ? ` ${span(now - first.at)}` : ''}${more}`);
-    }
-    if (state.routines.length) {
-      const next = state.routines
-        .filter((routine) => routine.enabled !== false && epoch(routine.nextFireAt))
-        .sort((left, right) => epoch(left.nextFireAt) - epoch(right.nextFireAt))[0];
-      parts.push(
-        `${plural(state.routines.length, 'routine')}${next ? `, next ${quotedText(next.name, 20)} ${until(epoch(next.nextFireAt), now)}` : ''}`
-      );
-    }
-    const fixed = parts.join(' · ');
-    const preview = oneLine(state.home?.lastMessagePreview || state.home?.preview);
-    const room = BOT_LINE_LIMIT - fixed.length - 5;
-    return cut(preview && room >= MIN_PREVIEW ? `${fixed} · "${quotedText(preview, room)}"` : fixed, BOT_LINE_LIMIT);
-  }
-
-  const mixyBot = (ctx) => ({ id: MIXY_AGENT_ID, name: ctx.mixy, self: true });
-
-  /** The bots the caller sees: every bot then Mixy when she has something to
-   *  show, or just the caller's own bot. */
-  function visibleStates(ctx) {
-    if (ctx.own) {
-      const bot = ctx.own === MIXY_AGENT_ID ? mixyBot(ctx) : ctx.bots[0];
-      return bot ? [botState(bot, ctx)] : [];
-    }
-    const states = ctx.bots
-      .map((bot) => botState(bot, ctx))
-      .sort(
-        (left, right) =>
-          Number(right.flags.length > 0) - Number(left.flags.length > 0) ||
-          Number(right.working) - Number(left.working) ||
-          right.lastAt - left.lastAt ||
-          (left.bot.id < right.bot.id ? -1 : 1)
-      );
-    const mixy = botState(mixyBot(ctx), ctx);
-    if (mixy.routines.length || mixy.running.length || mixy.approvals) states.push(mixy);
-    return states;
-  }
-
   async function overview(own) {
     const ctx = await gather(own);
     const states = visibleStates(ctx);