mixdog 1.4.0 → 1.4.1

package/src/runtime/agent/orchestrator/session/conversation-import/turns.mjs

@@ -9,6 +9,11 @@
 export const IMPORT_WARNING_IMAGE_OMITTED = 'imageOmitted';
 export const IMPORT_WARNING_MALFORMED = 'malformed';
 export const IMPORT_WARNING_CWD_MISSING = 'cwdMissing';
+/** The conversation continues a history stored in another file that was not followed. */
+export const IMPORT_WARNING_HISTORY_PARTIAL = 'historyPartial';
+
+/** Failure code of a record the source app writes for its own use (not a conversation). */
+export const IMPORT_ERROR_INTERNAL = 'internalRecord';
 
 /** Stands in for an image the importer does not carry over. */
 export const IMAGE_OMITTED_TEXT = '[image omitted]';
@@ -17,12 +22,49 @@ export const IMPORTED_USER_STUB_TEXT = '[Imported conversation continues from an
 
 const TITLE_MAX_CHARS = 100;
 
-/** Plain-text note for a tool call: its name only, never its arguments. */
+/** Note for a tool call: its name only, never its arguments. A run of notes
+ *  becomes one compact line in the text and one structured entry in `toolRuns`. */
 export function toolNote(name) {
-  const clean = String(name || '')
-    .replace(/\s+/g, ' ')
-    .trim();
-  return { text: `[ran tool: ${clean || 'unknown'}]`, note: true };
+  const clean =
+    String(name || '')
+      .replace(/\s+/g, ' ')
+      .trim() || 'unknown';
+  return { text: `[ran tool: ${clean}]`, note: true, tool: clean };
+}
+
+/** Longest model-facing run line, and the longest tool name shown in it. */
+export const TOOL_RUN_LINE_MAX_CHARS = 400;
+const TOOL_RUN_NAME_MAX_CHARS = 40;
+
+/**
+ * Model-facing line for one run of tool notes: `[ran tools: shell ×6, Read ×2]`.
+ * Bounded: names are clipped, and tools that do not fit are counted as
+ * `, +N more`. Deterministic in `tools`, so a stored line can be re-derived.
+ */
+export function toolRunLine(tools) {
+  const entries = tools.map(({ name, count }) => {
+    const chars = Array.from(String(name));
+    const shown =
+      chars.length > TOOL_RUN_NAME_MAX_CHARS ? `${chars.slice(0, TOOL_RUN_NAME_MAX_CHARS - 1).join('')}…` : name;
+    return `${shown} ×${count}`;
+  });
+  const omittedSuffix = (omitted) => (omitted > 0 ? `, +${omitted} more` : '');
+  let body = '';
+  let shownCount = 0;
+  for (const entry of entries) {
+    const next = shownCount ? `${body}, ${entry}` : entry;
+    const length = `[ran tools: ${next}${omittedSuffix(entries.length - shownCount - 1)}]`.length;
+    if (shownCount && length > TOOL_RUN_LINE_MAX_CHARS) break;
+    body = next;
+    shownCount += 1;
+  }
+  return `[ran tools: ${body}${omittedSuffix(entries.length - shownCount)}]`;
+}
+
+function toolRunCounts(notes) {
+  const counts = new Map();
+  for (const note of notes) counts.set(note.tool, (counts.get(note.tool) || 0) + 1);
+  return [...counts].map(([name, count]) => ({ name, count }));
 }
 
 export function textPart(text) {
@@ -42,18 +84,31 @@ export function timestampMs(value) {
   return Number.isFinite(ms) && ms > 0 ? ms : null;
 }
 
-// Consecutive tool notes stay one per line; every other boundary is a blank line.
+// Each run of consecutive tool notes collapses into one compact line; every
+// boundary is a blank line. `toolRuns` locates those lines in `text`.
 function joinParts(parts) {
-  let text = '';
-  let previous = null;
+  const blocks = [];
   for (const part of parts) {
     const piece = String(part.text || '').trim();
     if (!piece) continue;
-    if (previous) text += previous.note && part.note ? '\n' : '\n\n';
-    text += piece;
-    previous = part;
+    const last = blocks[blocks.length - 1];
+    if (part.note && last?.notes) last.notes.push(part);
+    else blocks.push(part.note ? { notes: [part] } : { text: piece });
+  }
+  let text = '';
+  const toolRuns = [];
+  for (const block of blocks) {
+    if (text) text += '\n\n';
+    if (block.notes) {
+      const tools = toolRunCounts(block.notes);
+      const line = toolRunLine(tools);
+      toolRuns.push({ start: text.length, end: text.length + line.length, tools });
+      text += line;
+    } else {
+      text += block.text;
+    }
   }
-  return { text, last: previous };
+  return { text, toolRuns };
 }
 
 /**
@@ -72,9 +127,15 @@ export function normalizeTurns(rawTurns) {
     else merged.push({ role: raw.role, parts: [...parts], at: timestampMs(raw.at) });
   }
   const turns = merged.map(({ role, parts, at }) => {
-    const turn = { role, text: joinParts(parts).text, at };
-    // A carried-over compaction summary never names the conversation.
-    if (parts.some((part) => part.summary)) turn.titleText = joinParts(parts.filter((part) => !part.summary)).text;
+    const joined = joinParts(parts);
+    const turn = { role, text: joined.text, at };
+    if (joined.toolRuns.length) turn.toolRuns = joined.toolRuns;
+    // A carried-over compaction summary never names the conversation; a slash
+    // command only when no typed prompt does.
+    if (parts.some((part) => part.summary || part.command)) {
+      turn.titleText = joinParts(parts.filter((part) => !part.summary && !part.command)).text;
+    }
+    if (parts.some((part) => part.command)) turn.commandText = joinParts(parts.filter((part) => part.command)).text;
     return turn;
   });
   if (turns[0]?.role === 'assistant') {
@@ -83,19 +144,26 @@ export function normalizeTurns(rawTurns) {
   return turns;
 }
 
-const titleLines = (turn) =>
-  (turn.titleText ?? turn.text)
+const textLines = (text) =>
+  String(text ?? '')
     .split('\n')
     .map((value) => value.replace(/\s+/g, ' ').trim())
     .filter(Boolean);
 
+const titleLines = (turn) => textLines(turn.titleText ?? turn.text);
+
+/** First non-empty line of a title text, whitespace-normalized, ≤100 chars. */
+export function titleFromText(text) {
+  const line = textLines(text)[0];
+  if (!line) return null;
+  return Array.from(line).slice(0, TITLE_MAX_CHARS).join('').trim() || null;
+}
+
 /** First line of the first genuine user turn, whitespace-normalized, ≤100 chars
- *  (an image marker only when the turn has no text line). */
+ *  (an image marker only when the turn has no text line), else the first slash command. */
 export function conversationTitle(turns) {
   const first = turns.find((turn) => turn.role === 'user' && !turn.stub && titleLines(turn).length);
-  if (!first) return null;
+  if (!first) return titleFromText(turns.find((turn) => turn.role === 'user' && turn.commandText)?.commandText);
   const lines = titleLines(first);
-  const line = lines.find((value) => value !== IMAGE_OMITTED_TEXT) || lines[0];
-  if (!line) return null;
-  return Array.from(line).slice(0, TITLE_MAX_CHARS).join('').trim() || null;
+  return titleFromText(lines.find((value) => value !== IMAGE_OMITTED_TEXT) || lines[0]);
 }

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -16,6 +16,9 @@ import { CONTEXT_SHARE_RATIO, COMPACT_TARGET_MIN_TOKENS, COMPACT_SAFETY_PERCENT
 import { HANDOFF_TIMEOUT_MAX_MS } from '../compact/constants.mjs';
 import { envFlag, envPositiveInt } from '../../../../shared/env.mjs';
 import { positiveInt } from '../../../../shared/numbers.mjs';
+import { cacheWarmUseFor, lastCacheWarmUseAt } from '../../../../shared/idle-auto-clear-gate.mjs';
+import { ACCOUNT_PROVIDERS } from '../../../../shared/provider-accounts.mjs';
+import { plannedAccountId } from '../../providers/account-pool.mjs';
 import { isAgentOwner } from '../../agent-owner.mjs';
 import { isAgentModeSession } from '../agent-mode.mjs';
 import { providerInputExcludesCache, providerNativePdf } from '../../providers/registry.mjs';
@@ -703,13 +706,40 @@ export function shouldCompactForRequestMedia(messages, provider = '') {
 // Anthropic's 5m message-tail TTL (agent-runtime/cache-strategy.mjs gives it
 // to agent sessions). A send this long after the previous one finds the tail
 // cache expired and would rewrite the whole accumulated transcript; compacting
-// first makes that cold write the compacted transcript instead.
+// first makes that cold write the compacted transcript instead. The tail was
+// last used by the session's own send or by a successful cache warm
+// (cache-warm.mjs), which reads and refreshes it without moving
+// lastProviderSendAt: a warmed tail has not expired — for a request on the
+// warm's provider, model and account only, since the entry lives there.
 const AGENT_MESSAGE_CACHE_TTL_MS = 5 * 60_000;
 
-export function shouldCompactForExpiredAgentCache(sessionRef, opts) {
+// The account the request would be served by: the roster's first pick for a
+// provider with accounts (account-pool.mjs), '' for one without a roster.
+function requestAccountId(provider, model, sessionRef, opts, messages) {
+  if (!ACCOUNT_PROVIDERS.includes(provider)) return '';
+  return plannedAccountId(provider, {
+    sessionId: opts?.sessionId || sessionRef?.id || null,
+    messages,
+    providerState: opts?.providerState,
+    model,
+  });
+}
+
+/** Whether the agent session's 5m message tail expired before this request
+ *  on `provider` / `model` (default: the session's route). */
+export function shouldCompactForExpiredAgentCache(sessionRef, opts, { provider, model, messages = [] } = {}) {
   if (!isAgentOwner(sessionRef) || opts?.cacheStrategy?.messages !== '5m') return false;
   const lastSendAt = Number(sessionRef.lastProviderSendAt);
-  return lastSendAt > 0 && Date.now() - lastSendAt > AGENT_MESSAGE_CACHE_TTL_MS;
+  if (!(lastSendAt > 0)) return false;
+  const now = Date.now();
+  if (now - lastSendAt <= AGENT_MESSAGE_CACHE_TTL_MS) return false;
+  // No warm since the last send: the tail expired.
+  if (!(lastCacheWarmUseAt(sessionRef.id) > lastSendAt)) return true;
+  const route = { provider: provider || sessionRef.provider || '', model: model || sessionRef.model || '' };
+  const accountId = requestAccountId(route.provider, route.model, sessionRef, opts, messages);
+  if (accountId === null) return true;
+  const warmAt = cacheWarmUseFor(sessionRef.id, { ...route, accountId });
+  return now - Math.max(lastSendAt, warmAt) > AGENT_MESSAGE_CACHE_TTL_MS;
 }
 
 export function shouldCompactForSession(

package/src/runtime/agent/orchestrator/session/loop/fresh-context.mjs

@@ -278,14 +278,19 @@ function currentSkillResolver(sessionRef, { preview = false } = {}) {
   return (name) => {
     const delivery = currentSkillDelivery(name, cwd, config, skills);
     if (!delivery) return null;
-    if (preview) return { body: delivery.body, native: undefined };
     const { resource } = delivery;
+    // The tools whose use counts as use of the skill: its tool dependencies,
+    // an MCP server as `mcp:<server>`.
+    const tools = (resource.toolDependencies || []).flatMap(({ type, value }) =>
+      type === 'tool' ? [value] : type === 'mcp' ? [`mcp:${value}`] : []
+    );
+    if (preview) return { body: delivery.body, native: undefined, tools };
     const envelope = loadSkillToolDependencies(
       buildSkillToolEnvelope(name, resource.content, resource.dir, resource),
       sessionRef
     );
     const native = parseNativeToolSearchPayload('Skill', envelope.result);
-    return { body: delivery.body, native, summary: native?.summary ?? envelope.result };
+    return { body: delivery.body, native, summary: native?.summary ?? envelope.result, tools };
   };
 }
 

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -19,7 +19,7 @@ import { providerToolExclusionReason } from './provider-tool-exclusions.mjs';
 import { workflowOverlayDenial } from '../manager/workflow-switch-notice.mjs';
 import { agentMcpToolPermission, connectorPolicyAgentOf, projectMcpToolDisabled } from '../../mcp/agent-connectors.mjs';
 
-const WORKER_DENIED_TOOLS = new Set(['agent', 'ask_user', 'session']);
+const WORKER_DENIED_TOOLS = new Set(['agent', 'ask_user', 'handoff_user', 'session']);
 const BRIDGE_DISCOVERY_TOOL_NAMES = new Set(['load_tool']);
 
 const IMAGE_PATH_RE = /\.(?:png|jpe?g|gif|webp)(?:$|[?#])/i;

package/src/runtime/agent/orchestrator/session/loop/provider-tool-exclusions.mjs

@@ -31,6 +31,13 @@ function exclusionsFor(sessionRef) {
 
 const isSessionRef = (value) => value !== null && typeof value === 'object';
 
+// A schema 400 drop holds for the schema rule that refused it: a route on
+// another wire family (a fallback hop, a model switch) sends the tool again.
+function droppedOnRoute(sessionRef, name) {
+  const entry = isSessionRef(sessionRef) ? sessions.get(sessionRef)?.dropped.get(String(name || '')) : null;
+  return entry && entry.family === routeSchemaFamily(sessionRef) ? entry : null;
+}
+
 /** A new provider request: exclusions describe the latest request only. */
 export function beginProviderToolExclusions(sessionRef) {
   if (isSessionRef(sessionRef)) sessions.get(sessionRef)?.current.clear();
@@ -64,15 +71,16 @@ export function providerToolExclusionReason(sessionRef, name) {
   if (!isSessionRef(sessionRef)) return null;
   const state = sessions.get(sessionRef);
   const key = String(name || '');
-  const exclusion = state?.current.get(key) || state?.dropped.get(key);
+  const exclusion = state?.current.get(key) || droppedOnRoute(sessionRef, key);
   return exclusion ? unavailableText(exclusion) : null;
 }
 
 /** The provider rejected `exclusion.name`'s schema with an HTTP 400: leave the
- *  tool out of every later request of the session and tell the user once. */
+ *  tool out of the session's later requests on this wire family and tell the
+ *  user once. */
 export function dropSessionTool(sessionRef, exclusion, onStageChange) {
   if (!isSessionRef(sessionRef)) return;
-  exclusionsFor(sessionRef).dropped.set(exclusion.name, exclusion);
+  exclusionsFor(sessionRef).dropped.set(exclusion.name, { ...exclusion, family: routeSchemaFamily(sessionRef) });
   recordProviderToolExclusion(sessionRef, exclusion, onStageChange);
 }
 
@@ -82,7 +90,7 @@ export function withoutDroppedTools(sessionRef, { sendTools, requestToolScope })
   const dropped = isSessionRef(sessionRef) ? sessions.get(sessionRef)?.dropped : null;
   if (!dropped?.size) return { sendTools, requestToolScope };
   const prefix = providerNativeToolPrefixCount(sendTools);
-  const kept = sendTools.filter((tool, index) => index < prefix || !dropped.has(tool?.name));
+  const kept = sendTools.filter((tool, index) => index < prefix || !droppedOnRoute(sessionRef, tool?.name));
   if (kept.length === sendTools.length) return { sendTools, requestToolScope };
   const next = finalizeProviderRequestTools(kept, prefix);
   return { sendTools: next, requestToolScope: { ...requestToolScope, requestTools: next } };
@@ -128,7 +136,7 @@ function schemaExclusion(session, family, tool) {
  *  tools are never excluded by the schema rule. */
 export function routeToolExclusionReason(session, tool) {
   if (!tool) return null;
-  const dropped = isSessionRef(session) ? sessions.get(session)?.dropped.get(String(tool.name || '')) : null;
+  const dropped = droppedOnRoute(session, tool.name);
   if (dropped) return unavailableText(dropped);
   const exclusion = schemaExclusion(session, routeSchemaFamily(session), tool);
   return exclusion ? unavailableText(exclusion) : null;

package/src/runtime/agent/orchestrator/session/loop/route-fallback.mjs

@@ -17,6 +17,8 @@ import { buildRequestSendOptions } from '../manager/ask-turn-loop-options.mjs';
 import { prepareTurnEffortConfiguration } from '../../providers/effort-configuration.mjs';
 import { resolveSessionContextMeta } from '../manager/context-meta.mjs';
 import { stripProviderReplayMessages } from '../manager/provider-replay.mjs';
+import { isAgentOwner } from '../../agent-owner.mjs';
+import { rebuildToolSurfaceForProviderWithMigration } from './tool-exposure-migration.mjs';
 
 // The short reason a notice gives for leaving a model, by provider kind.
 const HOP_REASONS = {
@@ -149,6 +151,11 @@ export async function advanceAgentRoute(state, error) {
   updated.routeFallbackFailures = [...(session.routeFallbackFailures || []), failed];
   await pinSessionWireRoute(updated, provider);
   state.throwIfAborted();
+  // The route change replaced the session's tools with its whole resolved list.
+  // A delegated agent's surface was already re-applied by updateSessionRoute
+  // (applyAgentToolExposure); a Lead-class session gets its deferred surface
+  // restored for the new provider, as a manual model switch does.
+  if (!isAgentOwner(updated)) rebuildToolSurfaceForProviderWithMigration(updated, next.provider, state.messages);
   // The live turn (prompt, assistant tool calls, tool results) carries on;
   // only the previous provider's native replay state is dropped from it.
   state.messages.splice(0, state.messages.length, ...stripProviderReplayMessages(state.messages));
@@ -164,6 +171,13 @@ export async function advanceAgentRoute(state, error) {
   state.cacheBreakTraceKeys.clear();
   state.transportRetriesUsed = 0;
   state.transportRetryMax = 0;
+  // The one-shot recoveries the left model spent belong to its requests; the
+  // next model's first request gets its own (its window, images and schemas).
+  state.contextOverflowRetryUsed = false;
+  state.imageStripUsed = false;
+  state.imageStrip = null;
+  state.thinkingReplayRepairUsed = false;
+  state.toolSchemaDropUsed = false;
   for (const key of Object.keys(oldOptions)) delete state.opts[key];
   Object.assign(
     state.opts,

package/src/runtime/agent/orchestrator/session/loop/send-phase.mjs

@@ -4,7 +4,12 @@
  * consume a retry verdict, and settle a completed send into the loop state.
  */
 import { traceCacheBreak } from '../../cache-break-trace.mjs';
-import { anthropicPrefixChanges } from '../../providers/lib/anthropic-prefix-trace.mjs';
+import {
+  anthropicPrefixChanges,
+  latestAnthropicPrefix,
+  persistableAnthropicPrefix,
+  seedAnthropicPrefix,
+} from '../../providers/lib/anthropic-prefix-trace.mjs';
 import { resolveLiveToolCwd } from './tool-exec.mjs';
 import { notifySkillsApplied, prepareExplicitSkills, recordAppliedSkills } from '../explicit-skills.mjs';
 import { addUsage, usageDeltaEvent } from './usage.mjs';
@@ -179,6 +184,9 @@ export async function sendProviderRequest(state, round) {
   } catch {
     // the send-started observer is advisory
   }
+  // Diagnostic only: a restarted process compares its first request with the
+  // last prefix fingerprint the session record kept (anthropic-prefix-trace.mjs).
+  seedAnthropicPrefix(sessionId, sessionRef?.providerPrefixBaseline);
   // The request a /btw side question forks: kept while it is in flight, with
   // its reply once it proceeds, and dropped again if it fails.
   const sideQuestion = captureSideQuestionRequest({
@@ -374,6 +382,10 @@ function traceActualCacheMiss(state, sent, response, { previousGuardState, previ
     );
   }
   sessionRef.lastProviderCachedPrefixTokens = cachePrefixTokens;
+  // The fingerprint of this request survives a restart on the record, so the
+  // next process's first miss can still name what moved.
+  const fingerprint = persistableAnthropicPrefix(latestAnthropicPrefix(sessionId));
+  if (fingerprint) sessionRef.providerPrefixBaseline = fingerprint;
 }
 
 /** Fold a completed send into the state: prefix guard, image-strip

package/src/runtime/agent/orchestrator/session/loop/tool-exec/before-hook.mjs

@@ -132,8 +132,8 @@ export async function applyBeforeToolHook({
   mcpScopeId = null,
 }) {
   const call = { name, args, cwd };
-  // ask_user is itself the user prompt; it never goes through the ordinary approval gate.
-  if (name === 'ask_user') return call;
+  // ask_user and handoff_user are themselves the user prompt; they never go through the ordinary approval gate.
+  if (name === 'ask_user' || name === 'handoff_user') return call;
   try {
     const hookDecision = beforeToolHook
       ? await runAbortable(executeOpts.signal, () =>

package/src/runtime/agent/orchestrator/session/loop/tool-exposure-migration.mjs

@@ -46,12 +46,44 @@ export function markToolSurfaceMigrated(session, intent = TOOL_SURFACE_MIGRATION
   session.pendingCacheBreakIntent = intent;
 }
 
-/** Provider switch: rebuild the surface for `provider`, migrating bridge ↔ native. */
-export function rebuildToolSurfaceForProviderWithMigration(session, provider) {
+/**
+ * Run `apply` with `messages` (the transcript a running turn works on) as the
+ * session's messages, so a fixed-guidance rewrite lands there; the canonical
+ * transcript takes the rewritten system prefix. Without `messages`, `apply`
+ * runs on the session's own. `apply` runs synchronously.
+ */
+function applyOnWorkingMessages(session, messages, apply) {
+  const stored = session.messages;
+  const working = Array.isArray(messages) ? messages : stored;
+  if (Array.isArray(working)) session.messages = working;
+  try {
+    apply();
+  } finally {
+    if (Array.isArray(working) && session.messages !== working) {
+      // The rewrite may drop an emptied system message: keep the array
+      // identity the request loop holds.
+      working.splice(0, working.length, ...session.messages);
+    }
+    session.messages = stored;
+  }
+  // The rewritten prompt messages are fresh objects; the canonical transcript
+  // the save path persists takes them too, so the next save writes the new
+  // prompt together with the new exposure.
+  if (Array.isArray(stored) && Array.isArray(working) && stored !== working) syncSystemPrefix(stored, working);
+}
+
+/**
+ * Provider switch: rebuild the surface for `provider`, migrating bridge ↔
+ * native. `messages`: the running turn's transcript, when a switch happens
+ * mid-turn (a route fallback hop).
+ */
+export function rebuildToolSurfaceForProviderWithMigration(session, provider, messages) {
   if (!session) return false;
   const migrating = toolExposureMigrationNeeded(session, provider);
-  rebuildDeferredToolSurfaceForProvider(session, provider);
-  if (migrating) markToolSurfaceMigrated(session);
+  applyOnWorkingMessages(session, messages, () => {
+    rebuildDeferredToolSurfaceForProvider(session, provider);
+    if (migrating) markToolSurfaceMigrated(session);
+  });
   return migrating;
 }
 
@@ -75,26 +107,12 @@ function hasUnansweredToolCalls(messages) {
  */
 export function migrateToolExposureAtBoundary(session, messages) {
   if (!session || !toolExposureMigrationNeeded(session) || hasUnansweredToolCalls(messages)) return false;
-  const stored = session.messages;
-  const working = Array.isArray(messages) ? messages : stored;
-  if (Array.isArray(working)) session.messages = working;
-  try {
+  applyOnWorkingMessages(session, messages, () =>
     applyDeferredToolSurface(session, session.deferredSurfaceMode || 'lead', [], {
       provider: session.provider,
       model: session.model,
-    });
-  } finally {
-    if (Array.isArray(working) && session.messages !== working) {
-      // The rewrite may drop an emptied system message: keep the request
-      // transcript array identity the loop holds.
-      working.splice(0, working.length, ...session.messages);
-    }
-    session.messages = stored;
-  }
-  // The rewritten prompt messages are fresh objects; the canonical transcript
-  // the save path persists takes them too, so the next save writes the new
-  // prompt together with the new exposure.
-  if (Array.isArray(stored) && Array.isArray(working) && stored !== working) syncSystemPrefix(stored, working);
+    })
+  );
   invalidateForToolSurfaceMigration(session);
   return true;
 }

package/src/runtime/agent/orchestrator/session/manager/ask-turn-loop-options.mjs

@@ -231,9 +231,9 @@ export function buildAgentLoopOptions({
     },
     onStreamDelta: (kind = 'semantic') => {
       markSessionStreamDelta(sessionId, kind).catch(() => {});
-      // Raw transport is an internal health signal, not model progress.
-      // Preserve the public callback's historical semantic-only contract.
-      if (kind !== 'transport') relay(askOpts?.onStreamDelta, kind);
+      // Raw transport and keepalives are internal health signals, not model
+      // progress. Preserve the public callback's historical semantic-only contract.
+      if (kind !== 'transport' && kind !== 'keepalive') relay(askOpts?.onStreamDelta, kind);
     },
   };
 }

package/src/runtime/agent/orchestrator/session/manager/ask-turn-settle.mjs

@@ -225,7 +225,9 @@ export function publishAskTurn({ sessionId, opened, terminalResultPreview, askOp
   // (which inspects entry.emptyFinal first) classifies the
   // terminal state correctly even if it ticks during unwind.
   const isEmptyFinal =
-    !terminalResultPreview.content && !terminalResultPreview.reasoningContent && !terminalResultPreview.reactionCompleted;
+    !terminalResultPreview.content &&
+    !terminalResultPreview.reasoningContent &&
+    !terminalResultPreview.reactionCompleted;
   if (isEmptyFinal) {
     markSessionEmptyFinal(sessionId);
   }

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

@@ -13,7 +13,7 @@
 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 { canonicalRouteProvider, executionFallbacks } 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';
@@ -48,5 +48,5 @@ export function ownerConfiguredRoute({ sessionMode, agentId, config = null }) {
 export function ownerRouteFallbacks({ sessionMode, agentId, provider, model, config = null }) {
   const route = ownerConfiguredRoute({ sessionMode, agentId, config });
   if (!route?.fallbacks?.length) return [];
-  return sameRouteModel(route, { provider, model }) ? route.fallbacks : [];
+  return sameRouteModel(route, { provider, model }) ? executionFallbacks(route) : [];
 }

package/src/runtime/agent/orchestrator/session/manager/route-fallback-chain.mjs

@@ -12,6 +12,7 @@
 import { findPreset } from '../../runtime-core/config-helpers.mjs';
 import { normalizeWorkflowRoute } from '../../runtime-core/workflow.mjs';
 import { configuredAgentRouteCandidates } from '../../../../shared/agent-route-config.mjs';
+import { executionFallbacks } from '../../../../shared/model-route-chain.mjs';
 import { CODING_MODE, resolveSessionMode } from '../agent-mode.mjs';
 import { _liveSessions } from '../store/live-state.mjs';
 import { ownerConfiguredRoute, sameRouteModel } from './owner-route-fallbacks.mjs';
@@ -64,7 +65,7 @@ export function liveRouteFallbacks(session, config) {
   if (!source)
     return { chain: Array.isArray(session?.routeFallbacks) ? session.routeFallbacks : [], fromSettings: false };
   const onSourcePrimary = sameRouteModel(source, sessionRoutePrimary(session));
-  return { chain: onSourcePrimary ? source.fallbacks || [] : [], fromSettings: true };
+  return { chain: onSourcePrimary ? executionFallbacks(source) : [], fromSettings: true };
 }
 
 /** Index in `chain` of the next route to try: the first after the session's

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

@@ -59,15 +59,19 @@ function omitToolsKey(omitTools) {
     .join(',');
 }
 
-export function _buildSharedRules({ omitTools = [], allowTools = null } = {}) {
+export function _buildSharedRules({ omitTools = [], allowTools = null, ownerIsAgent = false } = {}) {
   const PLUGIN_ROOT = mixdogRoot();
   const RULES_DIR = join(PLUGIN_ROOT, 'rules');
   return buildCachedRules(
     'buildSharedToolContent',
     'shared tool rules',
     [join(RULES_DIR, 'shared')],
-    { PLUGIN_ROOT, DATA_DIR: resolvePluginData(), omitTools, allowTools },
-    JSON.stringify([omitToolsKey(omitTools), Array.isArray(allowTools) ? omitToolsKey(allowTools) : null])
+    { PLUGIN_ROOT, DATA_DIR: resolvePluginData(), omitTools, allowTools, ownerIsAgent },
+    JSON.stringify([
+      omitToolsKey(omitTools),
+      Array.isArray(allowTools) ? omitToolsKey(allowTools) : null,
+      ownerIsAgent === true,
+    ])
   );
 }
 
@@ -98,8 +102,17 @@ export function _buildRouteRules({ provider = null, model = null, omitTools = []
 
 // BP1 = shared tool policy followed by this route's rules. Every site that
 // renders or re-identifies the BP1 block must use this one composition.
-export function _buildBaseRules({ provider = null, model = null, omitTools = [], allowTools = null } = {}) {
-  return [_buildSharedRules({ omitTools, allowTools }), _buildRouteRules({ provider, model, omitTools, allowTools })]
+export function _buildBaseRules({
+  provider = null,
+  model = null,
+  omitTools = [],
+  allowTools = null,
+  ownerIsAgent = false,
+} = {}) {
+  return [
+    _buildSharedRules({ omitTools, allowTools, ownerIsAgent }),
+    _buildRouteRules({ provider, model, omitTools, allowTools }),
+  ]
     .filter(Boolean)
     .join('\n\n---\n\n');
 }
@@ -201,9 +214,14 @@ export function _buildLeadLanguage() {
   });
 }
 
-export function _buildLeadLanguageContext() {
+export function _buildLeadLanguageContext({ includeOutputStyle = true } = {}) {
+  const PLUGIN_ROOT = mixdogRoot();
   const DATA_DIR = resolvePluginData();
-  return buildCachedRules('buildLeadLanguageContent', 'lead language context', [join(DATA_DIR, 'mixdog-config.json')], {
-    DATA_DIR,
-  });
+  return buildCachedRules(
+    'buildLeadLanguageContent',
+    'lead language context',
+    [join(DATA_DIR, 'mixdog-config.json'), join(PLUGIN_ROOT, 'output-styles'), join(DATA_DIR, 'output-styles')],
+    { PLUGIN_ROOT, DATA_DIR, includeOutputStyle },
+    includeOutputStyle ? 'style' : 'no-style'
+  );
 }