mixdog 1.3.2 → 1.3.4

package/src/session-runtime/tool-policy/agent-profile-fold.mjs

@@ -2,6 +2,8 @@
 // changes (a switched workflow or mode, moved tool gates, changed shipped
 // rules) in where the provider cache is cold anyway.
 import { sessionHasConversationMessages } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { ORCHESTRATION_MODES } from '../../runtime/shared/orchestration.mjs';
+import { orchestrationModeFromPrompt } from '../../runtime/agent/orchestrator/session/manager/orchestration-mode-switch-notice.mjs';
 import { promptRulesRevision } from '../../runtime/agent/orchestrator/session/manager/rules-cache.mjs';
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
 import { AGENT_MODE, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
@@ -15,6 +17,7 @@ import {
   agentMcpToolPermission,
   connectorPolicyAgentOf,
 } from '../../runtime/agent/orchestrator/mcp/agent-connectors.mjs';
+import { agentListEntries } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { markToolSurfaceMigrated } from '../../runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs';
 import {
   agentProfileRevision,
@@ -50,6 +53,27 @@ const promptPrefix = (session) =>
 const rulesStale = (session) =>
   sessionModeOf(session) === AGENT_MODE && session.rulesRevision !== promptRulesRevision();
 
+// Before session-local modes were used by profile refreshes, changing the
+// roster could replace a coding Lead's mode rules with the configured default
+// while leaving its selected mode intact. This is not a normal mode overlay:
+// repair only a known generated mismatch, with no user switch still pending.
+function orchestrationRecoveryNeeded(session) {
+  if (
+    !session?.promptIdentity ||
+    session.promptIdentity.skipAgentRules ||
+    isAgentOwner(session) ||
+    sessionModeOf(session) === AGENT_MODE ||
+    !ORCHESTRATION_MODES.includes(session.orchestrationMode) ||
+    session.workflowOverlay ||
+    session.orchestrationModeOverlay ||
+    session.pendingWorkflowId !== undefined ||
+    session.pendingOrchestrationMode !== undefined
+  )
+    return false;
+  const presented = orchestrationModeFromPrompt(session);
+  return presented !== null && presented !== session.orchestrationMode;
+}
+
 // Changes the prompt does not carry yet: a workflow switched mid-conversation,
 // a bot's tool gates that moved, or shipped rules a release changed.
 const foldPending = (session) =>
@@ -130,6 +154,35 @@ function stageLiveToolChanges({ liveDeniedTools, modelStandaloneTools }, session
   return true;
 }
 
+// A coding Lead keeps `agent` whichever agents exist (workflow.mjs
+// workflowDisallowsAgentTool); a denial a session recorded under the older
+// rule, because no agent was enabled, is lifted as the live policy no longer
+// holds it: the tool becomes reachable by deferred loading and the next
+// turn's deferred_tools_delta names it. Nothing in the request prefix moves.
+// Returns true when the session changed.
+function liftAgentDenial({ liveDeniedTools, modelStandaloneTools }, session) {
+  const disallowed = (session.disallowedTools || []).map(String);
+  const overlayDenied = (session.workflowOverlay?.deniedTools || []).includes('agent');
+  if (!disallowed.includes('agent') && !overlayDenied) return false;
+  if (liveDeniedTools(session, session.workflow).includes('agent')) return false;
+  const known = new Map(schemaTools(session).map((tool) => [toolName(tool), tool]));
+  if (!known.has('agent')) {
+    const fresh = modelStandaloneTools().filter((tool) => toolName(tool) === 'agent');
+    if (!fresh.length) return false;
+    session.deferredToolCatalog = [...(session.deferredToolCatalog || []), ...fresh];
+    known.set('agent', fresh[0]);
+  }
+  session.disallowedTools = disallowed.filter((name) => name !== 'agent');
+  if (overlayDenied) {
+    session.workflowOverlay.deniedTools = session.workflowOverlay.deniedTools.filter((name) => name !== 'agent');
+  }
+  mergePendingDeferredToolDelta(session, {
+    added: [{ name: 'agent', description: known.get('agent')?.description || '' }],
+  });
+  session.updatedAt = Date.now();
+  return true;
+}
+
 export function createAgentProfileFold({
   getSession,
   getConfig,
@@ -189,9 +242,11 @@ export function createAgentProfileFold({
    * anything it embeds changed; a delegated worker keeps its prompt. The core
    * is rebuilt like a workflow switch's (the session's own workflow, the
    * workspace slices the model was told) and replaces the stored one, so the
-   * next turn sends it with one provider cache break; nothing is re-read per
-   * turn. That rewrite is immediate (one tagged cache break) and takes every
-   * pending fold with it (foldPrompt), moving all stamps.
+   * next turn sends it with one provider cache break. The prompt is not re-embedded
+   * per turn, but currentAgents() does resolve the agent catalog at each
+   * turn's preparation (for the listing reminder). That rewrite is immediate
+   * (one tagged cache break) and takes every pending fold with it
+   * (foldPrompt), moving all stamps.
    * What is not an edit never touches the prefix: a bot thread's feature gates
    * and connectors are staged live (stageLiveToolChanges), and shipped rules a
    * release changed wait silently; both are folded in at the next cold point
@@ -210,22 +265,29 @@ export function createAgentProfileFold({
     const workflowConfig = configForSession(getConfig(), promptWorkflowOf(session)?.id, promptMode(session));
     const { leadPromptParts, summary: workflow } = activeWorkflowContext(workflowConfig, getDataDir());
     const roster = leadRosterRevision(leadPartsFor(session, leadPromptParts));
-    const edited = session.agentProfileRevision !== revision || session.agentRosterRevision !== roster;
+    const recoverMode = orchestrationRecoveryNeeded(session);
+    // A coding Lead hears of its agents through the listing reminder each
+    // turn carries (agent-listing-notice.mjs), never a rewritten prompt;
+    // syncAgentListing only lifts a stale `agent` denial.
+    const edited =
+      recoverMode || session.agentProfileRevision !== revision || (agentMode && session.agentRosterRevision !== roster);
     // At a turn's start its own turn is the one counted; nothing runs yet.
     const busy = () => getSession?.() !== session || (trigger !== 'turn' && turnInFlight(session));
     if (busy()) {
       agentProfilePending = true;
       return false;
     }
-    const toolsChanged =
-      agentMode &&
-      stageLiveToolChanges({ liveDeniedTools, modelStandaloneTools }, session, workflow, {
-        edited: session.agentProfileRevision !== revision,
-      });
+    const toolsChanged = agentMode
+      ? stageLiveToolChanges({ liveDeniedTools, modelStandaloneTools }, session, workflow, {
+          edited: session.agentProfileRevision !== revision,
+        })
+      : trigger === 'resume' && syncAgentListing(session);
     if (!edited) return (trigger === 'resume' && (await foldPromptIfCold())) || toolsChanged;
     // A coding session from before profile stamps keeps its prompt when it
     // is reopened; a saved edit still reaches it.
-    if (session.agentProfileRevision === undefined && trigger === 'resume' && !agentMode) return toolsChanged;
+    if (session.agentProfileRevision === undefined && trigger === 'resume' && !agentMode && !recoverMode) {
+      return toolsChanged;
+    }
     if (foldPending(session)) {
       await foldPrompt(session, AGENT_PROFILE_INTENT);
       return true;
@@ -241,7 +303,7 @@ export function createAgentProfileFold({
     if (staged.core === presentedBp3Core(session)) return toolsChanged;
     rewriteConversationBp3Core(session, staged.core);
     // The request prefix changed: one cache break, tagged on the next send.
-    markToolSurfaceMigrated(session, AGENT_PROFILE_INTENT);
+    markToolSurfaceMigrated(session, recoverMode ? PROMPT_FOLD_INTENT : AGENT_PROFILE_INTENT);
     return true;
   }
 
@@ -254,12 +316,34 @@ export function createAgentProfileFold({
     if (session?.id && sessionModeOf(session) === AGENT_MODE && !Array.isArray(session.agentConnectorTools)) {
       session.agentConnectorTools = connectorTools(session, schemaTools(session).map(toolName));
     }
-    if (agentProfilePending) {
+    if (agentProfilePending || orchestrationRecoveryNeeded(session)) {
       agentProfilePending = false;
       changed = await refreshAgentProfile({ trigger: 'turn' });
     }
-    return (await foldPromptIfCold()) || changed;
+    changed = (await foldPromptIfCold()) || changed;
+    return syncAgentListing(session) || changed;
+  }
+
+  // A coding Lead hears of its agents through the agent list reminder.
+  const codingLead = (session) =>
+    Boolean(session?.id && session.promptIdentity && !isAgentOwner(session) && sessionModeOf(session) !== AGENT_MODE);
+
+  /** A coding Lead keeps `agent` reachable (liftAgentDenial). Returns true
+   *  when the session changed. */
+  function syncAgentListing(session) {
+    return codingLead(session) && liftAgentDenial({ liveDeniedTools, modelStandaloneTools }, session);
+  }
+
+  /** The agents a coding Lead may delegate to now, as its prompt would list
+   *  them: the turn's input to the agent list reminder (manager/
+   *  agent-listing-notice.mjs); undefined for any other session. */
+  function currentAgents() {
+    const session = getSession?.();
+    if (!codingLead(session)) return undefined;
+    const config = configForSession(getConfig(), session.workflow?.id, currentMode(session));
+    const { leadPromptParts } = activeWorkflowContext(config, getDataDir());
+    return agentListEntries(leadPartsFor(session, leadPromptParts).agentCatalogContext) || [];
   }
 
-  return { refreshAgentProfile, applyPendingAgentProfile };
+  return { refreshAgentProfile, applyPendingAgentProfile, currentAgents };
 }

package/src/session-runtime/tool-policy/policy-stage.mjs

@@ -1,6 +1,9 @@
 // Staging and applying the tool/prompt policy a config gives a Lead session:
 // the tools it is denied, its BP1 rules and its BP3 core.
-import { toSessionWorkflowMeta } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
+import {
+  toSessionWorkflowMeta,
+  workflowDisallowsAgentTool,
+} from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import {
   applyDeferredToolSurface,
   filterDisallowedTools,
@@ -20,7 +23,10 @@ import { finalizeSessionToolList } from '../../runtime/agent/orchestrator/sessio
 import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
 import { AGENT_MODE, sessionModeOf } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
 import { unusedModelEditToolName } from '../../runtime/shared/edit-tool-dialect.mjs';
-import { withPresentedWorkspaceSlices } from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+import {
+  presentedAgentCatalogSlice,
+  withPresentedWorkspaceSlices,
+} from '../../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import { leadPartsFor, rewriteSystemHeading, toolNames } from './surface-helpers.mjs';
 
 export function createPolicyStage({
@@ -34,12 +40,14 @@ export function createPolicyStage({
   activeWorkflowContext,
 }) {
   // The tools `session` is denied now: its caller's denials, the feature gates
-  // as they stand, and the agent tool when its workflow delegates to no one.
+  // as they stand, and an agent-mode Lead's agent tool when its workflow
+  // delegates to no one (a coding Lead keeps it: workflow.mjs
+  // workflowDisallowsAgentTool).
   function liveDeniedTools(session, workflow) {
     return [
       ...session.callerDisallowedTools,
       ...featureDisallowedTools(),
-      ...(workflow?.delegatesAgents === false ? ['agent'] : []),
+      ...(workflowDisallowsAgentTool(workflow, { agentMode: sessionModeOf(session) === AGENT_MODE }) ? ['agent'] : []),
     ]
       .map((name) => String(name || ''))
       .filter(Boolean);
@@ -100,7 +108,17 @@ export function createPolicyStage({
     } = activeWorkflowContext(config, getDataDir());
     const sessionMode = sessionModeOf(session);
     const agentMode = sessionMode === AGENT_MODE;
-    const leadWorkflowParts = ownerIsAgent ? {} : leadPartsFor(session, leadPromptParts);
+    // A coding Lead's conversation keeps the agent list it was built with, as
+    // it keeps the workspace slices: agents switched on or off since reach it
+    // as reminders on top of that list (agent-listing-notice.mjs). A slice
+    // that is not one generated list is rebuilt as before.
+    const presentedCatalog = conversation && !agentMode ? presentedAgentCatalogSlice(session) : null;
+    const leadWorkflowParts = ownerIsAgent
+      ? {}
+      : {
+          ...leadPartsFor(session, leadPromptParts),
+          ...(presentedCatalog !== null ? { agentCatalogContext: presentedCatalog } : {}),
+        };
     const denied = liveDeniedTools(session, workflow);
 
     const baseRules =

package/src/session-runtime/tool-policy-refresh.mjs

@@ -101,5 +101,6 @@ export function createToolPolicyRefresh({
     applyPendingSessionSwitches: switches.applyPendingSessionSwitches,
     refreshAgentProfile: profile.refreshAgentProfile,
     applyPendingAgentProfile: profile.applyPendingAgentProfile,
+    currentAgents: profile.currentAgents,
   };
 }

package/src/session-runtime/tool-surface.mjs

@@ -17,6 +17,7 @@ import {
 import { workflowDisallowsAgentTool } from '../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { promptWorkflowOf } from '../runtime/agent/orchestrator/session/manager/workflow-switch-notice.mjs';
 import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
+import { isAgentModeSession } from '../runtime/agent/orchestrator/session/agent-mode.mjs';
 
 export function createToolSurface({
   mgr,
@@ -36,15 +37,18 @@ export function createToolSurface({
 }) {
   let preSessionSurface = null;
 
-  // A live session keeps its frozen capability (the workflow its prompt was
-  // built with, even after a mid-conversation switch); a new session uses
-  // current agents. Solo still offers the tool (deferred) for explicit user requests.
+  // A coding Lead keeps `agent` whichever agents exist (the agents reach it as
+  // a listing reminder); Solo still offers it (deferred) for explicit user
+  // requests. An agent-mode Lead keeps its frozen capability once live (the
+  // workflow its prompt was built with, even after a mid-conversation switch)
+  // and a new one gets it with current agents.
   function workflowAllowsAgents() {
     const session = getSession();
+    const agentMode = isAgentModeSession(session || {});
     if (session?.id || session?.workflow || session?.orchestrationMode) {
-      return !workflowDisallowsAgentTool(promptWorkflowOf(session));
+      return !workflowDisallowsAgentTool(promptWorkflowOf(session), { agentMode });
     }
-    return (delegatableAgentIds?.(getConfig(), cfgMod.getPluginData?.() || dataDir).length ?? 1) > 0;
+    return !agentMode || (delegatableAgentIds?.(getConfig(), cfgMod.getPluginData?.() || dataDir).length ?? 1) > 0;
   }
 
   function modelStandaloneTools() {

package/src/session-runtime/turn/session-ops.mjs

@@ -5,6 +5,7 @@
 import { normalizeToolMode } from '../../runtime/agent/orchestrator/runtime-core/effort.mjs';
 import { interruptTaskWaitForSession } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
 import { markPendingGoalReminder } from '../../runtime/agent/orchestrator/runtime-core/goal-reminder.mjs';
+import { rearmLateDeferredTools } from '../../runtime/agent/orchestrator/runtime-core/tool-catalog.mjs';
 
 export function createSessionOps(deps) {
   const {
@@ -55,6 +56,7 @@ export function createSessionOps(deps) {
     if (!session?.id) return null;
     const result = await mgr.rewindSessionMessagesTo?.(session.id, options);
     if (!result) return null;
+    if (options.dryRun === true) return result;
     setSession(mgr.getSession(session.id) || session);
     invalidateContextStatusCache();
     return result;
@@ -96,6 +98,12 @@ export function createSessionOps(deps) {
     } catch {
       /* best-effort: a Goal reminder must never break manual compact */
     }
+    // The same compaction strips late MCP tool announcements from older turns.
+    try {
+      rearmLateDeferredTools(getSession());
+    } catch {
+      /* best-effort: a tool reminder must never break manual compact */
+    }
     if (options.recoverAgent === true) recoverAgentWorkers();
     invalidateContextStatusCache();
     return result;

package/src/session-runtime/turn/turn-run.mjs

@@ -28,6 +28,7 @@ export function createTurnRunner(deps) {
     completeTurnSnapshotForTurn = completeTurnSnapshot,
     turnCleanupSettleMs = 2_000,
     getConfig = () => null,
+    currentAgents,
   } = deps;
   const transcript = createTurnTranscript(deps);
   const openTurn = createTurnOpener({
@@ -81,7 +82,10 @@ export function createTurnRunner(deps) {
           plannedToolCalls(session0, options),
           getCurrentCwd(),
           options.prefetch || null,
-          callbacks
+          // The agents enabled now (coding Leads), asked for each user turn
+          // the ask prepares, for its agent list reminder
+          // (manager/agent-listing-notice.mjs).
+          { ...callbacks, agentsNow: currentAgents }
         );
       } finally {
         releaseWebSearchUsage?.();

package/src/session-runtime/usage-stats-api.mjs

@@ -203,7 +203,7 @@ export function createUsageStatsApi({
       // beyond a clock captured before the import started.
       const now = Date.now();
       const period = usagePeriodFor(options, now);
-      // The rollup query runs off the event loop (usage-rollup-worker.mjs).
+      // The rollup query runs off the event loop (usage-ledger-worker.mjs).
       const rollup = await store.rollupAsync(usageRollupQuery(period));
       // The ledger returns the same rollup object while nothing was committed
       // (and while a rolling window lost no record), so identical back-to-back

package/src/session-runtime/workflow-agents-api/agent-editor.mjs

@@ -420,7 +420,7 @@ function customAvatarImages(dir, avatar) {
 // from Mixy's identity folder: bots/mixy once the bot store is active,
 // agents/lead before (mixyIdentityDir, agent-store.mjs). Saved empty, the
 // file goes. `dataDirOf()` resolves the data folder on each call.
-function createLeadIdentityApi(dataDirOf) {
+function createLeadIdentityApi(dataDirOf, mainRoute) {
   const leadDir = () => mixyIdentityDir(dataDirOf());
   function readLeadFile(file) {
     return readTextOrEmpty(join(leadDir(), file));
@@ -462,6 +462,8 @@ function createLeadIdentityApi(dataDirOf) {
       route: readMixyRoute(dataDirOf()),
     };
   }
+  // The route Mixy's thread follows: its own, else Main's (an override cleared).
+  const getLeadHomeRoute = () => readMixyRoute(dataDirOf()) ?? mainRoute();
   // Mixy's name and face, chosen in the 대표 에이전트 dialog or its profile:
   // a name '' and an avatar null go back to the defaults; absent keys are kept.
   function saveLeadIdentity(payload = {}) {
@@ -511,6 +513,7 @@ function createLeadIdentityApi(dataDirOf) {
     getLeadAgentBody: () => readLeadFile('AGENT.md'),
     saveLeadAgentBody: (text) => saveLeadFile('AGENT.md', text),
     getLeadStatus,
+    getLeadHomeRoute,
     saveLeadIdentity,
     setLeadCreated,
     // Mixy's connector policy, in its agent.json (`next` null removes it).
@@ -932,11 +935,15 @@ export function createAgentEditorApi(deps) {
     getLeadAgentBody,
     saveLeadAgentBody,
     getLeadStatus,
+    getLeadHomeRoute,
     saveLeadIdentity,
     setLeadCreated,
     getLeadConnectorPolicy,
     setLeadConnectorPolicy,
-  } = createLeadIdentityApi(() => resolveDataDir(deps));
+  } = createLeadIdentityApi(
+    () => resolveDataDir(deps),
+    () => normalizeWorkflowRoute(deps.resolveRoute(getConfig(), {}))
+  );
 
   // The agent's connector policy (see runtime/.../mcp/agent-connectors.mjs),
   // or null when its definition has none: every connector is on. Read as the
@@ -979,6 +986,7 @@ export function createAgentEditorApi(deps) {
     getLeadAgentBody,
     saveLeadAgentBody,
     getLeadStatus,
+    getLeadHomeRoute,
     setLeadCreated,
     saveLeadIdentity,
     saveAgentDefinition,

package/src/session-runtime/workflow-agents-api/agent-route.mjs

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from 'node:util';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { hasOwn } from '../../runtime/shared/object.mjs';
 import { isHiddenAgent } from '../../runtime/agent/orchestrator/internal-agents.mjs';
@@ -10,6 +11,7 @@ import {
   withAgentDisabled,
 } from '../../runtime/shared/agent-route-config.mjs';
 import { agentEditorId, resolveDataDir } from './shared.mjs';
+import { publishAgentRouteChange } from '../agent-profile-changes.mjs';
 import {
   isStoreBot,
   readBotRoute,
@@ -101,21 +103,38 @@ export function createAgentRouteApi(deps) {
     saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
   }
 
+  // The route a bot saved of its own ({} when none).
+  function ownRoute(id) {
+    if (isMixy(id)) return readMixyRoute(dataDir()) || {};
+    if (storeBot(id)) return readBotRoute(dataDir(), id) || {};
+    return agentRouteFromConfig(getConfig(), id) || {};
+  }
+  // The route a bot's chats run on: its own, else Main's.
+  const chatRoute = (id) => {
+    const own = ownRoute(id);
+    return normalizeWorkflowRoute(own.provider ? own : resolveRoute(getConfig(), {}));
+  };
+  // Structural, so equivalent parameter objects in another key order are the same route.
+  const plainRoute = (route) => JSON.parse(JSON.stringify(normalizeWorkflowRoute(route) ?? null));
+  const sameRoute = (a, b) => isDeepStrictEqual(plainRoute(a), plainRoute(b));
+
   // Only an explicitly empty provider removes an override: the agent inherits Main.
-  function clearOverride(id) {
+  async function clearOverride(id) {
+    const before = chatRoute(id);
     if (isMixy(id) || storeBot(id)) {
       if (isMixy(id)) writeMixyRoute(dataDir(), null);
       else writeBotRoute(dataDir(), id, null);
-      const inherited = normalizeWorkflowRoute(resolveRoute(getConfig(), {}));
-      return { ...(inherited || {}), inherited: true };
+    } else {
+      const nextConfig = { ...getConfig() };
+      const agents = { ...(nextConfig.agents || {}) };
+      const hadOverride = Object.hasOwn(agents, id);
+      delete agents[id];
+      nextConfig.agents = agents;
+      if (hadOverride) saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
     }
-    const nextConfig = { ...getConfig() };
-    const agents = { ...(nextConfig.agents || {}) };
-    const hadOverride = Object.hasOwn(agents, id);
-    delete agents[id];
-    nextConfig.agents = agents;
-    if (hadOverride) saveConfigAndAdopt(canonicalizeAgentRouteStorage(nextConfig));
     const inherited = normalizeWorkflowRoute(resolveRoute(getConfig(), {}));
+    // The bot's chats follow Main from their next turn (unless they already do).
+    if (inherited && !sameRoute(before, inherited)) await publishAgentRouteChange(id, inherited);
     return { ...(inherited || {}), inherited: true };
   }
 
@@ -128,16 +147,16 @@ export function createAgentRouteApi(deps) {
     // picked while the model resolved below stays (answered with `skipped`).
     const onlyIfEmpty = requested.onlyIfEmpty === true;
     delete requested.onlyIfEmpty;
-    const readStored = () => {
-      if (isMixy(id)) return readMixyRoute(dataDir()) || {};
-      if (storeBot(id)) return readBotRoute(dataDir(), id) || {};
-      return agentRouteFromConfig(getConfig(), id) || {};
-    };
+    const readStored = () => ownRoute(id);
     const kept = () => ({ ...readStored(), id, skipped: true });
     const stored = readStored();
     if (onlyIfEmpty && clean(stored.provider)) return kept();
-    // Mixy is never off: its route request is a model pick alone.
-    if (isMixy(id)) delete requested.disabled;
+    // Mixy is never off: its route request is a model pick alone, and an
+    // on/off request alone changes nothing.
+    if (isMixy(id) && hasOwn(requested, 'disabled')) {
+      delete requested.disabled;
+      if (!Object.keys(requested).length) return { ...stored, id };
+    }
     // Off is an explicit state, stored apart from the route so the model the
     // user picked survives and comes back when the agent is switched on. An
     // off request that also carries a model saves that model and stays off.
@@ -147,7 +166,7 @@ export function createAgentRouteApi(deps) {
       // An explicitly empty provider still asks to drop the override, as it
       // does for an agent that stays on: off and inheriting Main.
       if (hasOwn(requested, 'provider') && !clean(requested.provider)) {
-        return { ...clearOverride(id), id, disabled: true };
+        return { ...(await clearOverride(id)), id, disabled: true };
       }
       return { ...stored, id, disabled: true };
     }
@@ -189,7 +208,10 @@ export function createAgentRouteApi(deps) {
     if (onlyIfEmpty && clean(readStored().provider)) return kept();
     const stayOff = onlyIfEmpty ? isAgentDisabled(getConfig(), id) : keepOff;
     // Picking a model is also the "on" switch unless the request keeps it off.
+    const before = chatRoute(id);
     saveRoute(id, routeToSave, stayOff);
+    // The bot's existing chats move onto it from their next turn (unless they already run it).
+    if (!sameRoute(before, routeToSave)) await publishAgentRouteChange(id, routeToSave);
     return stayOff ? { ...routeToSave, id, disabled: true } : routeToSave;
   }
 

package/src/session-runtime/workspace/transition-steps.mjs

@@ -251,7 +251,6 @@ export function createTransitionSteps({
     const projectPath = previous.projectPath;
     const project = await inspectProject(projectPath, { signal });
     let entry = await backendApi.getSessionWorktree(session.id);
-    const created = !entry;
     if (entry) {
       if (!existsSync(entry.path)) {
         throw worktreeError('WORKTREE_MISSING', undefined, { worktreeId: entry.id, path: entry.path });
@@ -333,18 +332,9 @@ export function createTransitionSteps({
       await backendApi.dropCarryRecoveryRef({ projectPath, recoveryRef: entry.changes.recoveryRef }).catch(() => {});
     }
     // Creation notes (submodules, include entries missing or already present).
-    // `created`: a new checkout, whose first-turn preparation still awaits
-    // (`prepared`: what creation did and what the turn still has to run).
+    // A new checkout's first-turn preparation stays pending in its registry entry.
     return {
       ...entered,
-      ...(created
-        ? {
-            created: {
-              prepared: entry.prepared ?? null,
-              root: entry.prepared?.root || project.topLevel || projectPath,
-            },
-          }
-        : {}),
       warnings: Array.isArray(entry.warnings) ? [...entry.warnings] : [],
       ...(entry.changes ? { changes: { mode: entry.changes.mode, count: entry.changes.count } } : {}),
     };
@@ -395,13 +385,6 @@ export function createTransitionSteps({
       journal.push(() => backendApi.claimWorktreeOwner(previous.worktreeId, owner(session.id)));
       await releaseOwner(backendApi, previous.worktreeId, session.id, { forgetReference: true });
     }
-    // A managed worktree made for the branch: its first-turn preparation awaits.
-    if (resolved.created === true && entry) {
-      return {
-        ...result,
-        created: { prepared: entry.prepared ?? null, root: entry.prepared?.root || project.topLevel || projectPath },
-      };
-    }
     return result;
   }