mixdog 1.3.0 → 1.3.2

package/src/runtime/agent/orchestrator/session/manager/orchestration-mode-switch-notice.mjs

@@ -0,0 +1,99 @@
+// manager/orchestration-mode-switch-notice.mjs
+// A mid-conversation delegation (orchestration) mode switch
+// (session-runtime/tool-policy-refresh.mjs switchSessionOrchestrationMode),
+// on the workflow switch's pattern (workflow-switch-notice.mjs): the request
+// prefix — system blocks and tool schemas — stays byte-identical, so the
+// provider cache survives. The switch lives in two pieces of session state:
+//   session.orchestrationModeOverlay — while the session's mode differs from
+//     the one its system prompt carries: the prompt's mode (`prompt`), the
+//     new mode, the tools the model must load before using them
+//     (`loadableTools`) and the self-contained reminder (`content`) with the
+//     new mode's rules (the same block BP3 carries). It is folded into the
+//     prompt (and dropped) at the next point where the cache is cold anyway.
+//   session.orchestrationModeSwitch — the notice the next user turn carries
+//     in its reminder block: snapshot when the turn is built, acknowledge once
+//     the provider accepted it. `from` is the mode the model was last told
+//     about, `to` the session's mode now.
+// Every notice says it replaces the earlier ones, so the latest one wins.
+import { normalizeOrchestrationMode } from '../../../../shared/orchestration.mjs';
+import { orchestrationInstructions } from '../../runtime-core/orchestration.mjs';
+
+/** The mode's name as its BP3 block titles it (`# Orchestration Mode: …`). */
+export function orchestrationModeName(value) {
+  const mode = normalizeOrchestrationMode(value);
+  return mode === 'none' ? 'Solo' : `${mode[0].toUpperCase()}${mode.slice(1)}`;
+}
+
+/** The mode the session's system prompt and tool surface were built with. */
+export function promptOrchestrationModeOf(session) {
+  if (session?.workflowOverlay) return session.workflowOverlay.promptOrchestrationMode;
+  if (session?.orchestrationModeOverlay) return session.orchestrationModeOverlay.prompt;
+  return session?.orchestrationMode;
+}
+
+const listed = (names) => names.map((name) => `\`${name}\``).join(', ');
+
+/** The reminder that makes the Lead follow `mode`: self-contained (the mode's
+ *  rules) and superseding every earlier one. `carried`: the system prompt
+ *  carries this mode itself (a switch back, or the overlay folded in). */
+export function orchestrationModeNoticeContent({ mode, carried = false, loadableTools = [] }) {
+  const name = orchestrationModeName(mode);
+  const lead = carried
+    ? `This conversation now uses the ${name} orchestration mode, the one the system prompt carries.`
+    : `This conversation now uses the ${name} orchestration mode. The system prompt's Orchestration Mode no longer applies; follow ${name}'s below instead.`;
+  const pronoun = loadableTools.length === 1 ? 'it' : 'them';
+  return [
+    '<system-reminder>',
+    '# Orchestration Mode Changed',
+    `${lead} This replaces every earlier Orchestration Mode Changed reminder in this conversation.`,
+    ...(loadableTools.length
+      ? [
+          `${listed(loadableTools)}: not among your directly defined tools yet; load ${pronoun} with \`load_tool\` before the first call.`,
+        ]
+      : []),
+    `Agents already started keep running with their own instructions; new delegation follows ${name}.`,
+    '',
+    orchestrationInstructions(mode),
+    '</system-reminder>',
+  ].join('\n');
+}
+
+/** Stage the notice of a switch from `from` to `to`; a switch back to what the
+ *  model was last told drops it. Returns the staged state or null. */
+export function stageOrchestrationModeSwitchNotice(session, from, to) {
+  const prior = session.orchestrationModeSwitch;
+  const told = prior ? prior.from : from;
+  if (!to || told === to) {
+    delete session.orchestrationModeSwitch;
+    return null;
+  }
+  session.orchestrationModeSwitch = {
+    version: 1,
+    revision: (Number(prior?.revision) || 0) + 1,
+    from: told,
+    to,
+  };
+  return session.orchestrationModeSwitch;
+}
+
+/**
+ * The orchestration mode notice the next user turn carries, or null.
+ * @returns {{ revision: number, content: string } | null}
+ */
+export function snapshotPendingOrchestrationModeNotice(session) {
+  const pending = session?.orchestrationModeSwitch;
+  if (!pending?.to) return null;
+  const overlay = session.orchestrationModeOverlay;
+  const content =
+    overlay?.mode === pending.to && overlay.content
+      ? overlay.content
+      : orchestrationModeNoticeContent({ mode: pending.to, carried: true });
+  return { revision: pending.revision, content };
+}
+
+/** The notice of `revision` reached the model: nothing is due any more. */
+export function acknowledgePendingOrchestrationModeNotice(session, revision) {
+  if (!session?.orchestrationModeSwitch || session.orchestrationModeSwitch.revision !== Number(revision)) return false;
+  delete session.orchestrationModeSwitch;
+  return true;
+}

package/src/runtime/agent/orchestrator/session/manager/owner-route-fallbacks.mjs

@@ -0,0 +1,42 @@
+// The fallback models a Lead-class session starts with. Agents get theirs from
+// their spawn preset (agent-child.mjs); a Lead-class session gets its OWNER's:
+// - a coding Lead (new task, task a bot created): the Lead route, i.e. the
+//   preset of `config.default` (workflow-lead);
+// - an agent-mode Lead (a bot's home chat, a room turn, a routine run, or
+//   Mixy's own thread): that bot's own route in its folder (agent.json), so
+//   Mixy and the Lead keep separate chains.
+// The chain applies only while the session runs on the owner's configured
+// primary model. A session the user put on another model (composer picker,
+// New Task) is a deliberate choice and gets none. Route changes recompute it
+// (updateSessionRoute `routeFallbacks`); a fallback hop does not.
+import { loadConfig } from '../../config.mjs';
+import { findPreset } from '../../runtime-core/config-helpers.mjs';
+import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
+import { canonicalRouteProvider } from '../../../../shared/model-route-chain.mjs';
+import { storedBotRoute } from '../../../../shared/agent-store.mjs';
+import { configuredAgentRouteCandidates } from '../../../../shared/agent-route-config.mjs';
+import { CODING_MODE } from '../agent-mode.mjs';
+
+export function ownerRouteFallbacks({ sessionMode, agentId, provider, model, config = null }) {
+  if (!agentId) return [];
+  const cfg = () => config || loadConfig({ secrets: false });
+  let stored;
+  if (sessionMode === CODING_MODE) {
+    stored = findPreset(cfg(), cfg()?.default);
+  } else {
+    // Before the bot split a bot's route is still in the config (Mixy's never).
+    stored = storedBotRoute(agentId) || (agentId === 'lead' ? null : configuredAgentRouteCandidates(cfg(), agentId)[0]);
+  }
+  if (!stored?.fallbacks?.length) return [];
+  let route;
+  try {
+    route = normalizeWorkflowRoute(stored);
+  } catch {
+    return [];
+  }
+  const onPrimary =
+    route &&
+    canonicalRouteProvider(route.provider) === canonicalRouteProvider(provider) &&
+    String(route.model) === String(model);
+  return onPrimary ? route.fallbacks || [] : [];
+}

package/src/runtime/agent/orchestrator/session/manager/pending-messages.mjs

@@ -1,5 +1,5 @@
 // Steering / pending-message queue with sync buffering and atomic persistence.
-import { readFileSync } from 'node:fs';
+import { readJsonStateSync } from '../../../../shared/atomic-file.mjs';
 import { loadSession } from '../store.mjs';
 import {
   currentPendingLifecycleToken,
@@ -602,14 +602,8 @@ export function _getPendingMessagesForSession(sessionId) {
   const queued = [...(_sessionPendingMessages.get(sessionId) || []), ...(_pendingPersistBuffers.get(sessionId) || [])];
   // The not-yet-migrated global spool can still hold this session's rows.
   for (const path of [pendingMessagesPath(sessionId), legacyPendingMessagesPath()]) {
-    let raw;
-    try {
-      raw = readFileSync(path, 'utf8');
-    } catch (err) {
-      if (err?.code === 'ENOENT') continue;
-      throw err;
-    }
-    const persisted = normalizePendingStore(JSON.parse(raw)).sessions[sessionId];
+    // A damaged spool file is kept aside and reads as empty; it never throws.
+    const persisted = normalizePendingStore(readJsonStateSync(path, { fallback: null })).sessions[sessionId];
     if (Array.isArray(persisted)) queued.push(...persisted);
   }
   return queued;

package/src/runtime/agent/orchestrator/session/manager/pending-spool-file.mjs

@@ -17,7 +17,7 @@ export const _pendingPersistTails = new Map();
 export { pendingMessagesPath, touchPendingSessionEntry } from './pending-spool-path.mjs';
 
 // Single spool transaction shape: every mutation touches only `sessionId`'s
-// own shard file, locked, compact and non-fsync; `extra` only ever relaxes the
+// own shard file, locked, compact and durable; `extra` only ever relaxes the
 // lock timeout.
 export function updateSpool(sessionId, mutate, extra = null) {
   return updatePendingShard(sessionId, mutate, extra);

package/src/runtime/agent/orchestrator/session/manager/pending-spool-shard.mjs

@@ -21,7 +21,8 @@ function storeIsEmpty(store) {
   );
 }
 
-// One shard transaction: locked, compact, non-fsync. A shard emptied by the
+// One shard transaction: locked, compact, durable (queued user messages must
+// survive a crash; a damaged shard is kept aside by updateJsonAtomic). A shard emptied by the
 // mutation (or found empty) is deleted under the same lock, so the directory
 // holds only sessions that actually have queued rows.
 async function updateShardFile(key, mutate, extra = null) {
@@ -33,7 +34,6 @@ async function updateShardFile(key, mutate, extra = null) {
         compact: true,
         lock: true,
         mode: PENDING_MESSAGES_MODE,
-        fsync: false,
         ...extra,
       });
       if (storeIsEmpty(result)) {
@@ -50,7 +50,9 @@ async function updateShardFile(key, mutate, extra = null) {
 }
 
 function rowKey(row) {
-  return row && typeof row === 'object' && typeof row.id === 'string' && row.id ? `id:${row.id}` : `json:${JSON.stringify(row)}`;
+  return row && typeof row === 'object' && typeof row.id === 'string' && row.id
+    ? `id:${row.id}`
+    : `json:${JSON.stringify(row)}`;
 }
 
 // Idempotent merge of one legacy bucket into its shard: legacy rows (older)

package/src/runtime/agent/orchestrator/session/manager/provider-replay.mjs

@@ -0,0 +1,50 @@
+// Provider-native replay state on transcript messages: reasoning items,
+// thinking blocks with their signatures, ordered native blocks, Gemini thought
+// signatures on tool calls. It belongs to the provider (and the account) that
+// produced it — another provider rejects it or, worse, a gateway of the same
+// family validates it against its own key. A route change drops it; what the
+// next provider needs (text, tool calls and their results, in order) stays,
+// and each adapter rebuilds its own wire shape from that.
+
+// Every message field a provider adapter replays or re-reads as native state.
+const PROVIDER_REPLAY_FIELDS = [
+  'providerReplay',
+  'reasoning',
+  'thinkingBlocks',
+  'assistantBlocks',
+  'reasoningItems',
+  'reasoningContent',
+  'providerMetadata',
+];
+// Opaque provider tokens a tool call may carry (Gemini thought signatures).
+const TOOL_CALL_SIGNATURE_FIELDS = ['thoughtSignature', 'thought_signature'];
+
+const hasAny = (value, fields) => fields.some((field) => field in value);
+
+function plainToolCalls(toolCalls) {
+  if (!Array.isArray(toolCalls) || !toolCalls.some((call) => call && hasAny(call, TOOL_CALL_SIGNATURE_FIELDS))) {
+    return toolCalls;
+  }
+  return toolCalls.map((call) => {
+    if (!call || !hasAny(call, TOOL_CALL_SIGNATURE_FIELDS)) return call;
+    const plain = { ...call };
+    for (const field of TOOL_CALL_SIGNATURE_FIELDS) delete plain[field];
+    return plain;
+  });
+}
+
+/** `message` without provider-native replay state; the same object when it carries none. */
+export function stripProviderReplayMessage(message) {
+  if (!message || typeof message !== 'object') return message;
+  const toolCalls = plainToolCalls(message.toolCalls);
+  if (!hasAny(message, PROVIDER_REPLAY_FIELDS) && toolCalls === message.toolCalls) return message;
+  const plain = { ...message };
+  for (const field of PROVIDER_REPLAY_FIELDS) delete plain[field];
+  if (toolCalls !== message.toolCalls) plain.toolCalls = toolCalls;
+  return plain;
+}
+
+/** Replace, never mutate: delta saves see rewritten messages as changed. */
+export function stripProviderReplayMessages(messages) {
+  return Array.isArray(messages) ? messages.map(stripProviderReplayMessage) : messages;
+}

package/src/runtime/agent/orchestrator/session/manager/rules-cache.mjs

@@ -1,9 +1,15 @@
 // Prompt-layer rules builders. Source revision tracking lives separately so
 // every layer observes deletions, replacements and timestamp rollbacks alike.
+import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { resolvePluginData, mixdogRoot } from '../../../../shared/plugin-paths.mjs';
 import { createRulesSourceCache } from './rules-source-cache.mjs';
+import {
+  AGENT_MODE_DELEGATION,
+  MIXY_CONTACTS_INTRO,
+  orchestrationInstructions,
+} from '../../runtime-core/orchestration.mjs';
 
 // Phase B: Pool B Tier 2 content builder (common rules only).
 // Loaded once per process via createRequire so the CJS module reaches us.
@@ -129,7 +135,7 @@ export function _buildLeadRules({ includeLeadBrief = true, part = 'common' } = {
   );
 }
 
-// One agent-mode rule file (rules/agent-mode): 'conduct', 'mixy' or 'routine'.
+// One agent-mode rule file (rules/agent-mode): 'conduct' or 'mixy'.
 export function _buildAgentModeRules({ part = 'conduct' } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   return buildCachedRules(
@@ -141,6 +147,30 @@ export function _buildAgentModeRules({ part = 'conduct' } = {}) {
   );
 }
 
+// --- Rules revision ---
+// The shipped rule texts a bot thread's prompt embeds — the shared tool
+// policy (canonical variant), every LEAD.md part, the agent-mode files and
+// the orchestration/delegation texts — as one hash. A bot thread stamps it
+// at creation; another value (a release changed a rule) rebuilds its prompt
+// once (session-runtime/tool-policy-refresh.mjs). Built from the cached
+// builders, so a check costs a few stats.
+export function promptRulesRevision() {
+  const hash = createHash('sha256');
+  const texts = [
+    _buildSharedRules(),
+    ...['common', 'coding', 'agent', 'identity'].flatMap((part) =>
+      [true, false].map((includeLeadBrief) => _buildLeadRules({ includeLeadBrief, part }))
+    ),
+    _buildAgentModeRules({ part: 'conduct' }),
+    _buildAgentModeRules({ part: 'mixy' }),
+    AGENT_MODE_DELEGATION,
+    MIXY_CONTACTS_INTRO,
+    ...['none', 'focused', 'balanced', 'swarm'].map(orchestrationInstructions),
+  ];
+  for (const text of texts) hash.update(`${text}\0`);
+  return hash.digest('hex').slice(0, 24);
+}
+
 export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
@@ -162,6 +192,15 @@ export function _buildLeadMetaContext({ includeOutputStyle = true } = {}) {
 // Trailing BP3 block: the configured response language. Kept out of BP2 so
 // it is the last instruction before the conversation (see
 // rules-builder.cjs buildLeadLanguageContent).
+// The configured response language as {id, name}, or null (a rule's `language`
+// condition compares the id; its text's {language} is the name).
+export function _buildLeadLanguage() {
+  const DATA_DIR = resolvePluginData();
+  return buildCachedRules('buildLeadLanguage', 'lead language', [join(DATA_DIR, 'mixdog-config.json')], {
+    DATA_DIR,
+  });
+}
+
 export function _buildLeadLanguageContext() {
   const DATA_DIR = resolvePluginData();
   return buildCachedRules('buildLeadLanguageContent', 'lead language context', [join(DATA_DIR, 'mixdog-config.json')], {

package/src/runtime/agent/orchestrator/session/manager/runtime-liveness.mjs

@@ -298,6 +298,16 @@ export function markSessionToolOutputTail(id, tail) {
   entry.toolOutputTail = text ? text.slice(-4000) : null;
   entry.toolOutputTailAt = Date.now();
 }
+// An approval has no wait limit, and the progress watchdog treats a turn with
+// `awaitingUser` as waiting on the user, not stalled. The user's answer is
+// progress: a wait begins and ends with a fresh progress stamp, so the hours
+// spent waiting are never counted as silence once the turn runs again.
+function _stampApprovalProgress(entry) {
+  if (entry.closed || entry.controller?.signal?.aborted || TERMINAL_STAGES.has(entry.stage)) return;
+  const now = Date.now();
+  entry.lastProgressAt = now;
+  entry.updatedAt = now;
+}
 // A turn blocked on the user: a PreToolUse `ask` waiting for the tool
 // approval only the user can give. Published as `awaitingUser: 'approval'` so
 // status surfaces stop presenting the session as working. Counted, because one
@@ -309,6 +319,7 @@ export function beginSessionApprovalWait(id) {
   if (!entry) return () => {};
   entry.approvalWaits = (entry.approvalWaits || 0) + 1;
   entry.awaitingUser = 'approval';
+  _stampApprovalProgress(entry);
   // The waiting turn: the end transition carries the begin's turn even when
   // the turn has settled (askStartedAt cleared) by the time it releases.
   const meta = { turnAt: entry.askStartedAt || 0 };
@@ -321,6 +332,7 @@ export function beginSessionApprovalWait(id) {
     entry.approvalWaits = Math.max(0, (entry.approvalWaits || 0) - 1);
     if (entry.approvalWaits > 0) return;
     entry.awaitingUser = null;
+    _stampApprovalProgress(entry);
     emitSessionApprovalWaitChange(id, null, meta);
   };
 }

package/src/runtime/agent/orchestrator/session/manager/runtime-state.mjs

@@ -19,6 +19,25 @@ export function isTurnInFlight(entry) {
   return IN_FLIGHT_STAGES.has(entry.stage);
 }
 
+// Sessions whose turn was handed to the runtime but has not claimed its
+// controller yet (spawn dispatched, askSession still loading the session).
+// The row already declares work; without this the pool cannot tell that
+// first-turn gap from a worker it lost track of, and reads `unknown`.
+const dispatchedTurns = new Map();
+
+/** Runs `run` (the turn's dispatch) with `id` counted as working until it
+ *  settles, covering the gap before the turn's own runtime entry is in flight. */
+export async function whileTurnDispatched(id, run) {
+  dispatchedTurns.set(id, (dispatchedTurns.get(id) || 0) + 1);
+  try {
+    return await run();
+  } finally {
+    const left = dispatchedTurns.get(id) - 1;
+    if (left > 0) dispatchedTurns.set(id, left);
+    else dispatchedTurns.delete(id);
+  }
+}
+
 const cleanLower = (value) =>
   String(value || '')
     .trim()
@@ -32,6 +51,7 @@ const cleanLower = (value) =>
 export function inFlightSessionActivity() {
   const working = new Set();
   const agentWorking = new Set();
+  for (const id of dispatchedTurns.keys()) working.add(id);
   for (const [id, entry] of runtimeState) {
     if (!isTurnInFlight(entry)) continue;
     working.add(id);

package/src/runtime/agent/orchestrator/session/manager/session-lifecycle.mjs

@@ -15,10 +15,12 @@ import { loadConfig } from '../../config.mjs';
 import {
   buildProviderCacheOpts,
   cacheCapabilityForProvider,
+  isLeadCacheClass,
   roleProviderCacheOpts,
 } from '../../agent-runtime/cache-strategy.mjs';
 import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
-import { _buildBaseRules } from './rules-cache.mjs';
+import { _buildBaseRules, promptRulesRevision } from './rules-cache.mjs';
+import { stripProviderReplayMessages } from './provider-replay.mjs';
 import { composeSessionSystem, seedSessionMessages } from './session-prompt-composition.mjs';
 import { agentProfileRevision, leadRosterRevision } from '../../context/role-instructions.mjs';
 import {
@@ -40,6 +42,7 @@ import { ensureCodexWireSessionId, mintSessionId } from './session-id.mjs';
 import { providerCacheKey } from './provider-cache-key.mjs';
 import { buildSessionRecord, normalizeDesktopSessionMetadata, sessionOriginFields } from './session-record.mjs';
 import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
+import { ownerRouteFallbacks } from './owner-route-fallbacks.mjs';
 import { applyPendingWorkspaceReroot, refreshSessionBp3Environment } from './prompt-utils.mjs';
 import { isWorktreeBound } from '../../../../shared/worktrees/contract.mjs';
 import { applyAgentToolExposure } from '../loop/tool-exposure-migration.mjs';
@@ -52,17 +55,20 @@ export { recoverSessionAfterProcessRestart } from './turn-checkpoint-recovery.mj
 // re-exported so prior importers of this module stay unchanged.
 export { prefetchSession, prepareSessionProjection } from './prepared-resume-cache.mjs';
 
-function buildSessionProviderCacheOpts(providerName, sessionId, agent = null, config = null) {
+// `session` is the record or create options; it classifies agent-mode Leads
+// (bot home threads, routine runs) into the Lead cache class.
+function buildSessionProviderCacheOpts(providerName, sessionId, agent = null, config = null, session = null) {
   // Keep this in sync with createSession's provider-cache policy: only
-  // explicit-breakpoint providers get BP cache opts here; OpenAI/key-prefix
-  // providers use promptCacheKey and request-time strategy instead, plus the
-  // shared prompt-cache scope of a one-shot role.
+  // explicit-breakpoint providers get BP cache opts here; key-prefix
+  // providers use promptCacheKey and request-time strategy instead (plus the
+  // OpenAI API's Lead-class 12h prefix TTL and a one-shot role's shared
+  // prompt-cache scope).
   if (cacheCapabilityForProvider(providerName) !== 'explicit-breakpoint') {
-    return roleProviderCacheOpts(providerName, agent);
+    return roleProviderCacheOpts(providerName, agent, { session });
   }
   try {
     let autoClear = null;
-    if (!agent || agent === 'lead') {
+    if (isLeadCacheClass(agent, session)) {
       const loadedConfig = config || loadConfig({ secrets: false });
       const normalizedAutoClear = normalizeAutoClearConfig(loadedConfig?.autoClear);
       autoClear = {
@@ -70,20 +76,23 @@ function buildSessionProviderCacheOpts(providerName, sessionId, agent = null, co
         idleMs: resolveAutoClearIdleMs(loadedConfig, providerName),
       };
     }
-    return buildProviderCacheOpts(providerName, sessionId, agent, { autoClear });
+    return buildProviderCacheOpts(providerName, sessionId, agent, { autoClear, session });
   } catch {
     return null;
   }
 }
 
-// Re-derive a Lead session's builder-made cache policy (messages TTL follows
-// the auto-clear idle window). Explicit caller/profile policies, non-Lead
-// sessions and non-explicit-breakpoint providers are left untouched.
+// Re-derive a Lead-class session's builder-made cache policy (Anthropic
+// messages TTL follows the auto-clear idle window; the OpenAI API prefix TTL
+// follows the cache class). Explicit caller/profile policies, sub-agents and
+// other providers are left untouched.
 export function refreshSessionProviderCacheOpts(session, config = null) {
   if (!session || session.providerCacheOptsOverride === true) return false;
-  if (session.agent && session.agent !== 'lead') return false;
-  if (cacheCapabilityForProvider(session.provider) !== 'explicit-breakpoint') return false;
-  const next = buildSessionProviderCacheOpts(session.provider, session.id, session.agent, config);
+  if (!isLeadCacheClass(session.agent, session)) return false;
+  if (cacheCapabilityForProvider(session.provider) !== 'explicit-breakpoint' && session.provider !== 'openai') {
+    return false;
+  }
+  const next = buildSessionProviderCacheOpts(session.provider, session.id, session.agent, config, session);
   if (!next) return false;
   session.providerCacheOpts = next;
   return true;
@@ -224,24 +233,35 @@ export function createSession(createOpts) {
     sessionMode === AGENT_MODE && !createOpts.agent && actingAgent
       ? { ...createOpts, agent: actingAgent, sessionMode }
       : { ...createOpts, sessionMode };
-  const routeFallbacks = normalizeWorkflowRoute({
-    provider: providerName,
-    model: modelName,
-    fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.fallbacks,
-  })?.fallbacks;
+  // A Lead-class session (actingAgent set) takes its owner's chain while it
+  // runs on the owner's primary model; an agent keeps its preset's.
+  const routeFallbacks = actingAgent
+    ? Object.hasOwn(opts, 'routeFallbacks')
+      ? opts.routeFallbacks
+      : ownerRouteFallbacks({ sessionMode, agentId: actingAgent, provider: providerName, model: modelName })
+    : normalizeWorkflowRoute({
+        provider: providerName,
+        model: modelName,
+        fallbacks: Object.hasOwn(opts, 'routeFallbacks') ? opts.routeFallbacks : presetObj?.fallbacks,
+      })?.fallbacks;
   // Provider cache strategy — agentRuntime.resolveSync() above is a
   // best-effort injection point (setAgentRuntime() has no live caller
   // today, so that branch never fires); build it directly here so every
-  // session still gets a cache strategy. Lead sessions (opts.agent ===
-  // 'lead', or no agent at all — raw/CLI callers) get their BP4 message
-  // tail TTL linked to the user's autoClear idle-sweep config; hidden and
-  // public agents keep the flat 5m default (see cache-strategy.mjs docs).
-  // Scoped to explicit-breakpoint (Anthropic-family) providers only.
-  const providerCacheOpts = resolved.providerCacheOpts || buildSessionProviderCacheOpts(providerName, id, opts.agent);
+  // session still gets a cache strategy. Lead-class sessions (the Lead, raw
+  // callers, bot home threads and other agent-mode Leads) get their BP4
+  // message tail TTL linked to the user's autoClear idle-sweep config and,
+  // on the OpenAI API, the 12h stable-prefix TTL; sub-agents and hidden roles
+  // keep the agent defaults (see cache-strategy.mjs docs).
+  const providerCacheOpts =
+    resolved.providerCacheOpts || buildSessionProviderCacheOpts(providerName, id, opts.agent, null, { ...opts, id });
   const surface = resolveSessionToolSurface(opts, { profile, toolPreset, modelName });
   // The agent profile the prompt is composed from, read first: an edit landing
   // during composition leaves the stamp behind, never ahead (refreshAgentProfile).
-  const agentProfile = surface.ownerIsAgent ? '' : agentProfileRevision(surface.resolvedAgent);
+  const agentProfile = surface.ownerIsAgent
+    ? ''
+    : agentProfileRevision(surface.resolvedAgent, { mixy: sessionMode === AGENT_MODE });
+  // A bot thread lives on across releases: the rules it was built from.
+  const rulesRevision = agentProfile && sessionMode === AGENT_MODE ? promptRulesRevision() : '';
   const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode });
   const messages = seedSessionMessages(prompt, opts.files);
   logSessionSurface(surface);
@@ -265,6 +285,7 @@ export function createSession(createOpts) {
     session.agentProfileRevision = agentProfile;
     // The bot roster its prompt lists (a Lead's catalog slices).
     session.agentRosterRevision = leadRosterRevision(opts.leadWorkflowParts);
+    if (rulesRevision) session.rulesRevision = rulesRevision;
   }
   if (routeFallbacks?.length) session.routeFallbacks = routeFallbacks;
   // A non-native agent sends core + bridge, built from its filtered tools.
@@ -337,6 +358,13 @@ function applyRouteFields(session, route) {
     else delete session.autoEffort;
   }
   if (Object.hasOwn(route, 'effort')) session.effort = route.effort || null;
+  // A deliberate route choice restarts the chain (a fallback hop never passes this).
+  if (Object.hasOwn(route, 'routeFallbacks')) {
+    if (route.routeFallbacks?.length) session.routeFallbacks = route.routeFallbacks;
+    else delete session.routeFallbacks;
+    delete session.routeFallbackIndex;
+    delete session.routeFallbackFailures;
+  }
   ensureCodexWireSessionId(session);
   if (Object.hasOwn(route, 'modelParameters')) {
     session.modelParameters =
@@ -384,7 +412,8 @@ function applyRouteContextWindow(session, routeChanged, selectedContextWindowPro
 // surface: the previous route's readings and prepared tools no longer apply.
 function resetSessionForRouteChange(id, session, previousModel, previousProvider) {
   session.promptCacheKey = providerCacheKey(session.provider);
-  session.providerCacheOpts = buildSessionProviderCacheOpts(session.provider, session.id, session.agent) || null;
+  session.providerCacheOpts =
+    buildSessionProviderCacheOpts(session.provider, session.id, session.agent, null, session) || null;
   session.providerCacheOptsOverride = false;
   session.lastInputTokens = 0;
   session.lastOutputTokens = 0;
@@ -421,27 +450,11 @@ function resetSessionForRouteChange(id, session, previousModel, previousProvider
   _forgetPreparedResume(id);
 }
 
-// Every message field a provider adapter replays or re-reads as native state.
-const PROVIDER_REPLAY_FIELDS = [
-  'providerReplay',
-  'reasoning',
-  'thinkingBlocks',
-  'assistantBlocks',
-  'reasoningItems',
-  'reasoningContent',
-  'providerMetadata',
-];
-
-// Provider-native replay (reasoning items, thinking blocks) belongs to the
-// provider that produced it. Replace, never mutate, so delta saves rewrite.
+// Provider-native replay (reasoning items, thinking blocks, signatures)
+// belongs to the provider that produced it (see provider-replay.mjs).
 function stripProviderReplay(session) {
   if (!Array.isArray(session.messages)) return;
-  session.messages = session.messages.map((message) => {
-    if (!message || !PROVIDER_REPLAY_FIELDS.some((field) => field in message)) return message;
-    const plain = { ...message };
-    for (const field of PROVIDER_REPLAY_FIELDS) delete plain[field];
-    return plain;
-  });
+  session.messages = stripProviderReplayMessages(session.messages);
 }
 
 // `options.crossProvider` is the explicit in-place continuation of an
@@ -450,7 +463,9 @@ function stripProviderReplay(session) {
 // auto-compacts) against the new model's window.
 export function updateSessionRoute(id, route = {}, options = {}) {
   if (!id) return null;
-  const session = loadSession(id);
+  // options.session: the live object of a running turn, changed in place; the id's
+  // stored copy (a disk reload after another process took the generation) is not.
+  const session = options.session?.id === id ? options.session : loadSession(id);
   if (!session || session.closed === true) return null;
   const previousProvider = session.provider || null;
   const previousModel = session.model || null;

package/src/runtime/agent/orchestrator/session/manager/session-prompt-composition.mjs

@@ -5,7 +5,7 @@
 import { buildSkillManifest, composeSystemPrompt } from '../../context/collect.mjs';
 import { configuredInstructionFilesMode, loadInstructionFilesContext } from '../../context/instruction-files.mjs';
 import { agentModeIdentityLine } from '../../context/role-instructions.mjs';
-import { AGENT_MODE, isRoutineSource, sessionModeOf } from '../agent-mode.mjs';
+import { AGENT_MODE, sessionModeOf } from '../agent-mode.mjs';
 import { MIXY_AGENT_ID } from '../agent-home.mjs';
 import {
   _buildBaseRules,
@@ -98,12 +98,9 @@ export function buildWorkspacePromptContext(session, cwd) {
 // A Lead's BP3 rule slices, ordered for prefix sharing (composeSystemPrompt):
 // LEAD.md's common lines first; then the mode block (coding: LEAD.md's two
 // passages; agent mode: their conversational variants and AGENT_MODE.md);
-// then Mixy's MIXY.md; last the per-session tail — routine line, identity.
+// then Mixy's MIXY.md; last the per-session tail — identity.
 // Agent mode is a Lead created as an agent (agent-mode.mjs).
-export function sessionRolePromptFields(
-  identity,
-  { ownerIsAgent, toolFreeRole, delegationFree, sessionMode, routine = false }
-) {
+export function sessionRolePromptFields(identity, { ownerIsAgent, toolFreeRole, delegationFree, sessionMode }) {
   const skipRules = identity.skipAgentRules || toolFreeRole;
   const lead = !ownerIsAgent && !skipRules;
   const agentMode = lead && sessionMode === AGENT_MODE;
@@ -131,7 +128,6 @@ export function sessionRolePromptFields(
       ? {
           agentModeRules: _buildAgentModeRules({ part: 'conduct' }),
           ...(mixy ? { mixyRules: _buildAgentModeRules({ part: 'mixy' }) } : {}),
-          ...(routine ? { routineRules: _buildAgentModeRules({ part: 'routine' }) } : {}),
         }
       : {}),
     userPrompt: identity.systemPrompt,
@@ -139,6 +135,9 @@ export function sessionRolePromptFields(
     // session running as that agent) carries its own AGENT.md role, and Mixy
     // in agent mode its optional agents/lead/AGENT.md.
     skipRoleCatalog: !ownerIsAgent && (!identity.agent || identity.agent === 'lead') && !(agentMode && mixy),
+    // Mixy's persona (bots/mixy/PERSONA.md) is Mixy's alone: keyed on Mixy's
+    // own agent-mode thread, never on the `lead` role a coding Lead shares.
+    skipPersona: !ownerIsAgent && (!identity.agent || identity.agent === 'lead') && !(agentMode && mixy),
     agent: identity.agent,
     profile: { skip: identity.profileSkip },
   };
@@ -173,7 +172,6 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
     toolFreeRole,
     delegationFree,
     sessionMode,
-    routine: isRoutineSource(opts.sourceType),
   });
   const leadOnly = !skipAgentRules && !ownerIsAgent;
   const metaContext = leadOnly ? _buildLeadMetaContext({ includeOutputStyle: !agentMode }) : '';