mixdog 1.3.0 → 1.3.2

package/src/runtime/agent/orchestrator/session/store-summary-index.mjs

@@ -29,7 +29,15 @@ import {
 } from './store-summary-fields.mjs';
 import { isRealTurnMessage } from './compact/user-message-kind.mjs';
 import { isRoutineResultMessage, normalizeRoutineProvenance, routineProvenance } from './routine-result.mjs';
-import { LAST_MESSAGE_PREVIEW_MAX, cleanSummaryPreview, lastMessageRawText } from './store-summary-last-message.mjs';
+import {
+  INCOMING_TAIL_MAX,
+  LAST_MESSAGE_PREVIEW_MAX,
+  cleanSummaryPreview,
+  isIncomingKind,
+  normalizedIncomingTail,
+  lastMessageRawText,
+  wantsIncomingTail,
+} from './store-summary-last-message.mjs';
 
 export const SESSION_SUMMARY_INDEX_VERSION = 2;
 
@@ -111,6 +119,13 @@ function _sessionMessageProjection(session) {
   let real = 0;
   let preview = '';
   let previewMessage = null;
+  // Where the incoming messages with text sit among the counted ones (see
+  // incomingTailOf), kept only for the threads that show an unread count.
+  const wantsIncoming = wantsIncomingTail(session?.id);
+  let incoming = [];
+  // The totals ahead of the newest message, which a streamed reply fills in
+  // place after it was counted: an append redoes that message from here.
+  let ahead = null;
   const canAppend =
     cached &&
     messages.length >= cached.length &&
@@ -119,6 +134,12 @@ function _sessionMessageProjection(session) {
     start = cached.length;
     count = cached.count;
     real = cached.real;
+    incoming = cached.incoming.slice();
+    if (cached.ahead) {
+      start = cached.length - 1;
+      ({ count, real } = cached.ahead);
+      incoming = cached.ahead.incoming.slice();
+    }
     preview = cached.preview;
     previewMessage = cached.previewMessage;
     // The first real user message is stable in normal append-only session
@@ -131,6 +152,7 @@ function _sessionMessageProjection(session) {
         start = 0;
         count = 0;
         real = 0;
+        incoming = [];
         preview = '';
         previewMessage = null;
       }
@@ -138,7 +160,14 @@ function _sessionMessageProjection(session) {
   }
   for (let index = start; index < messages.length; index += 1) {
     const message = messages[index];
-    if (message && (message.role === 'user' || message.role === 'assistant')) count += 1;
+    if (index === messages.length - 1) ahead = { count, real, incoming: incoming.slice() };
+    if (message && (message.role === 'user' || message.role === 'assistant')) {
+      count += 1;
+      if (wantsIncoming && isIncomingKind(message) && _lastPreviewFromMessage(message)) {
+        incoming.push(count);
+        if (incoming.length > INCOMING_TAIL_MAX) incoming.shift();
+      }
+    }
     if (isRealTurnMessage(message)) real += 1;
     if (!preview) {
       const candidate = _previewFromMessage(message);
@@ -165,11 +194,13 @@ function _sessionMessageProjection(session) {
       lastMessage: messages[messages.length - 1] || null,
       count,
       real,
+      incoming,
+      ahead,
       preview,
       previewMessage,
     });
   }
-  return { count, real, preview, last, lastRoutine };
+  return { count, real, incoming: wantsIncoming ? incoming : null, preview, last, lastRoutine };
 }
 
 function _desktopSessionSummary(value, cwd = null) {
@@ -233,6 +264,7 @@ export function _sessionSummary(session) {
       : null,
     taskType: session.taskType || null,
     messageCount: messageProjection.count,
+    ...(messageProjection.incoming ? { incomingTail: messageProjection.incoming.slice() } : {}),
     realTurnCount: messageProjection.real,
     title: _cleanPreview(session.title || '', 100),
     preview: messageProjection.preview,
@@ -291,6 +323,7 @@ function _normalizeSummaryRow(row) {
       : null,
     taskType: row.taskType || null,
     messageCount: Math.max(0, Math.floor(Number(row.messageCount) || 0)),
+    ...(Array.isArray(row.incomingTail) ? { incomingTail: normalizedIncomingTail(row.incomingTail) } : {}),
     realTurnCount: realTurnCount(row),
     title: _cleanPreview(row.title || '', 100),
     preview: _cleanPreview(row.preview || ''),
@@ -561,12 +594,14 @@ export function summaryLockFailureStats() {
 
 // ── Stale temp sweep ────────────────────────────────────────────────────────
 // A crash between an atomic write's temp file and its rename orphans
-// `.session-summaries.json.<24 hex>.tmp` (multi-MB each). Only this store's
+// `session-summaries.json.mixdog-tmp-<16 hex>` (multi-MB each; before the
+// cloud-sync fix `.session-summaries.json.<24 hex>.tmp`). Only this store's
 // pattern is touched. Deleted only when older than SUMMARY_TMP_MIN_AGE_MS and
 // while holding the index lock: every writer of these temps (full rewrite,
 // compaction) holds that lock for the whole write, so no live writer can own a
 // temp file the sweep sees.
-const SUMMARY_TMP_PATTERN = /^\.session-summaries\.json\.[0-9a-f]{24}\.tmp$/;
+const SUMMARY_TMP_PATTERN =
+  /^(?:\.session-summaries\.json\.[0-9a-f]{24}\.tmp|session-summaries\.json\.mixdog-tmp-[0-9a-f]{16,24})$/;
 const SUMMARY_TMP_MIN_AGE_MS = 10 * 60 * 1000;
 let _sweptSummaryDir = '';
 

package/src/runtime/agent/orchestrator/session/store-summary-last-message.mjs

@@ -7,6 +7,8 @@
 import { cleanSessionPreview, isSessionPreviewNoise, sessionMessageText } from '../runtime-core/session-text.mjs';
 import { plainPreviewText } from '../../../shared/plain-preview.mjs';
 import { isRoutineResultMessage, routineProvenance, routineResultNotice } from './routine-result.mjs';
+import { agentIdOfHomeSession } from './agent-home.mjs';
+import { roomIdOfSession } from './agent-room.mjs';
 
 export const LAST_MESSAGE_PREVIEW_MAX = 160;
 
@@ -28,13 +30,56 @@ export function lastMessageRawText(message) {
   return isRoutineResultMessage(message) ? routineResultNotice(message).text : sessionMessageText(message.content);
 }
 
-/** The message's last-message line, '' when it has none (tool-only, synthetic). */
+/** The message's last-message line, '' when it has none (tool-only, synthetic,
+ *  or the runtime's own task-notification envelopes). */
 export function lastMessageLine(message) {
   const raw = lastMessageRawText(message);
-  if (raw === null || isSessionPreviewNoise(raw)) return '';
+  if (raw === null || isSessionPreviewNoise(raw) || raw.trimStart().startsWith('<task-notification>\n')) return '';
   return cleanSummaryPreview(plainPreviewText(raw), LAST_MESSAGE_PREVIEW_MAX);
 }
 
+/** Most unseen messages a row can report: one past the pill's 99, so a full
+ *  tail still reads as "99+". */
+export const INCOMING_TAIL_MAX = 100;
+
+/** Only a bot's home thread or a group room's log shows an unread count, so
+ *  only their summaries carry the incoming tail. */
+export function wantsIncomingTail(sessionId) {
+  return Boolean(agentIdOfHomeSession(sessionId) || roomIdOfSession(sessionId));
+}
+
+/** Whether `message` is of a kind that arrives as a chat message the user did
+ *  not write: an assistant turn that is not a tool call, or a posted result
+ *  (routine, task report, bot-to-bot). A user prompt, a tool-call turn and a
+ *  tool result are not. Text is checked separately (lastMessageLine). */
+export function isIncomingKind(message) {
+  if (isRoutineResultMessage(message)) return true;
+  if (message?.role !== 'assistant') return false;
+  const content = Array.isArray(message.content) ? message.content : [];
+  return !(message.toolCalls?.length > 0) && !content.some((part) => part?.type === 'tool_use');
+}
+
+/** The incoming messages with text among the last of a transcript, each as
+ *  its 1-based place among the user/assistant messages (the numbering of
+ *  `messageCount` and of the read cursor), oldest first, at most
+ *  INCOMING_TAIL_MAX of them. */
+export function incomingTailOf(messages) {
+  const tail = [];
+  let ordinal = 0;
+  for (const message of Array.isArray(messages) ? messages : []) {
+    if (message?.role !== 'user' && message?.role !== 'assistant') continue;
+    ordinal += 1;
+    if (isIncomingKind(message) && lastMessageLine(message)) tail.push(ordinal);
+  }
+  return tail.slice(-INCOMING_TAIL_MAX);
+}
+
+/** A stored incoming tail as a clean ascending list of whole places. */
+export function normalizedIncomingTail(value) {
+  const places = (Array.isArray(value) ? value : []).filter((place) => Number.isSafeInteger(place) && place > 0);
+  return places.slice(-INCOMING_TAIL_MAX);
+}
+
 /** `{ lastMessagePreview, lastMessageRoutine }` of a transcript. */
 export function lastMessageSummary(messages) {
   const list = Array.isArray(messages) ? messages : [];

package/src/runtime/agent/orchestrator/session/tail-reminder-rules.mjs

@@ -0,0 +1,125 @@
+// Tail reminders: short per-model/per-language nudges appended to the very end
+// of an outgoing request (after the last tool result), fresh on every request.
+// They are never stored in session history or transcripts, and the Anthropic
+// builders place their last cache breakpoint BEFORE them, so the cached prefix
+// stays byte-identical from one request to the next.
+//
+// HOW TO ADD A RULE (a new per-model/per-language fix needs nothing else):
+//   1. Append {id, when, text} to TAIL_REMINDER_RULES. `when` holds any of
+//      provider / model / language / role, each a list of accepted values; ALL
+//      given tags must match, an omitted tag matches anything.
+//   2. `text` may use `{language}` (the language block's name, e.g. "Korean").
+//   3. Add a positive and a negative case to tail-reminder-rules.test.mjs.
+// Values: provider = provider id or family ('anthropic'); model = normalized
+// family id ('claude-opus-5-5', route prefix/dots/date folded); language = id
+// ('ko'); role = 'lead' | 'bot' | 'worker'. Unknown tags throw at load.
+import { AGENT_MODE } from './agent-mode.mjs';
+import { _buildLeadLanguage } from './manager/rules-cache.mjs';
+import { TAIL_REMINDER_META } from '../providers/lib/tail-reminder-split.mjs';
+
+export const TAIL_REMINDER_TAGS = Object.freeze(['provider', 'model', 'language', 'role']);
+const ROLES = ['lead', 'bot', 'worker'];
+
+const PROVIDER_FAMILIES = Object.freeze({
+  'anthropic-oauth': 'anthropic',
+  anthropic: 'anthropic',
+});
+
+export const TAIL_REMINDER_RULES = Object.freeze([
+  // Claude Opus 5.5 keeps answering Korean users in English in long agentic
+  // turns, where many English tool results sit between the user message and
+  // the final answer.
+  {
+    id: 'opus-5-5-korean',
+    when: { model: ['claude-opus-5-5'], language: ['ko'], role: ['lead', 'bot'] },
+    text: 'Write all user-facing text in {language}.',
+  },
+]);
+
+export function validateTailReminderRules(rules) {
+  if (!Array.isArray(rules)) throw new Error('tail reminder rules must be an array');
+  const ids = new Set();
+  for (const rule of rules) {
+    if (!rule?.id || ids.has(rule.id)) throw new Error(`tail reminder rule: missing or duplicate id "${rule?.id}"`);
+    ids.add(rule.id);
+    for (const key of Object.keys(rule)) {
+      if (!['id', 'when', 'text'].includes(key))
+        throw new Error(`tail reminder rule ${rule.id}: unknown field "${key}"`);
+    }
+    if (typeof rule.text !== 'string' || !rule.text.trim())
+      throw new Error(`tail reminder rule ${rule.id}: text required`);
+    for (const [tag, values] of Object.entries(rule.when || {})) {
+      if (!TAIL_REMINDER_TAGS.includes(tag)) throw new Error(`tail reminder rule ${rule.id}: unknown tag "${tag}"`);
+      if (!Array.isArray(values) || !values.length || values.some((v) => typeof v !== 'string' || !v)) {
+        throw new Error(`tail reminder rule ${rule.id}: "${tag}" must be a non-empty string list`);
+      }
+    }
+    for (const role of rule.when?.role || []) {
+      if (!ROLES.includes(role)) throw new Error(`tail reminder rule ${rule.id}: unknown role "${role}"`);
+    }
+  }
+  return rules;
+}
+validateTailReminderRules(TAIL_REMINDER_RULES);
+
+/** `anthropic/claude-opus-5.5`, `claude-opus-5-5-20260101`, `us.anthropic.claude-opus-5-5-v1:0`,
+ *  `claude-opus-5-5-thinking` → `claude-opus-5-5`. */
+export function modelFamilyId(model) {
+  let id = String(model || '')
+    .trim()
+    .toLowerCase()
+    .replace(/\./g, '-');
+  const at = id.indexOf('claude-');
+  if (at >= 0) id = id.slice(at);
+  else id = id.slice(id.lastIndexOf('/') + 1);
+  // `@date`, Bedrock `-v1:0`, a gateway `:variant` (`:thinking`), `-v1`,
+  // `-YYYYMMDD`, and the `-thinking` alias of the same model.
+  return id
+    .replace(/@.*$/, '')
+    .replace(/-v\d+:\d+$/, '')
+    .replace(/:[^/]*$/, '')
+    .replace(/-v\d+$/, '')
+    .replace(/-\d{8}$/, '')
+    .replace(/-thinking$/, '');
+}
+
+/** The session's role: 'worker' (agent-owned), 'bot' (agent mode) or 'lead'. */
+export function tailReminderRole(session) {
+  if (session?.owner === 'agent') return 'worker';
+  return session?.sessionMode === AGENT_MODE ? 'bot' : 'lead';
+}
+
+// All given conditions must hold (AND); an omitted condition matches anything.
+function ruleMatches({ when = {} }, { provider, model, languageId, role }) {
+  const family = PROVIDER_FAMILIES[provider];
+  if (when.provider && !when.provider.some((p) => p === provider || (family && p === family))) return false;
+  if (when.model && !when.model.includes(modelFamilyId(model))) return false;
+  if (when.language && !when.language.includes(languageId)) return false;
+  if (when.role && !when.role.includes(role)) return false;
+  return true;
+}
+
+/**
+ * The joined text of every matching rule wrapped as one system-reminder, or ''.
+ * context = {provider, model, language: {id, name}|null, role}.
+ */
+export function matchTailReminder(context, rules = TAIL_REMINDER_RULES) {
+  const language = context.language || null;
+  const facts = { ...context, languageId: language?.id };
+  const texts = rules
+    .filter((rule) => ruleMatches(rule, facts))
+    .map((rule) => rule.text.replaceAll('{language}', language?.name || ''));
+  return texts.length ? `<system-reminder>${texts.join('\n')}</system-reminder>` : '';
+}
+
+/** `messages` plus the tail reminder for this request (a copy; the input is untouched). */
+export function withTailReminder(messages, { session, provider, model }, language = _buildLeadLanguage()) {
+  const text = matchTailReminder({
+    provider: session?.provider || provider?.name || '',
+    model,
+    language,
+    role: tailReminderRole(session),
+  });
+  if (!text) return messages;
+  return [...messages, { role: 'user', content: text, meta: { source: TAIL_REMINDER_META } }];
+}

package/src/runtime/agent/orchestrator/session/tool-batch/finalize.mjs

@@ -11,6 +11,7 @@ import {
 import { isOffloadedToolResultText, maybeOffloadToolResultBatch } from '../tool-result-offload.mjs';
 import { setReadCached, setScopedToolCached } from '../read-dedup.mjs';
 import { _stripMcpPrefix, _isReadTool, _isScopedCacheableTool, _isShellTool } from '../loop/tool-classify.mjs';
+import { takeAgentTaskStarts } from '../../../../shared/agent-task-starts.mjs';
 import { crossTurnSignature, isEditProgressTool } from '../loop/completion-guards.mjs';
 import { isEagerDispatchable, isToolCallDedupEligible, parseNativeToolSearchPayload } from '../loop/tool-helpers.mjs';
 import { restoreToolCallBodyForId } from '../loop/stored-tool-args.mjs';
@@ -307,6 +308,9 @@ function completedToolResult(completed, result, postprocessStartedAt) {
     ...(completed.readWindow ? { readWindow: completed.readWindow } : {}),
     ...(uiDiff !== null ? { uiDiff } : {}),
     ...toolMetaPatchFromMessage(completed.result),
+    // Every agent call's result names the jobs it started (none: []), so a
+    // task session's report follows exactly its own agents' results.
+    ...(_stripMcpPrefix(call.name) === 'agent' ? { agentTaskIds: takeAgentTaskStarts(call.id) } : {}),
   };
 }
 

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -10,11 +10,11 @@ import {
   readdirSync,
   rmdirSync,
   unlinkSync,
-  writeFileSync,
 } from 'node:fs';
-import { lstat, open, readdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
+import { lstat, open, readdir, readFile, stat, unlink } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
+import { holdsNoData, writeFileAtomicAsync, writeFileAtomicSync } from '../../../shared/atomic-file.mjs';
 import { getPluginData } from '../config.mjs';
 import { countSplitLines, normalizeOutputPath } from '../tools/builtin/path-utils.mjs';
 import { classifyResultKind } from './result-classification.mjs';
@@ -236,28 +236,76 @@ export function persistToolResultArtifactSync({ sessionId, toolCallId, channel =
   }
   if (!meta) return null;
   try {
-    writeFileSync(meta.path, content, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    const state = existingArtifactStateSync(meta);
+    if (state === ARTIFACT_INTACT) return meta;
+    if (state === ARTIFACT_FOREIGN) return null;
+    // Whole-file publication (fsynced temp, then link or rename): a crash never
+    // leaves a torn artifact. Data-free damage is replaced whole.
+    if (state === ARTIFACT_DAMAGED) {
+      writeFileAtomicSync(meta.path, content, { mode: 0o600 });
+      return meta;
+    }
+    if (writeFileAtomicSync(meta.path, content, { mode: 0o600, createOnly: true })) return meta;
+    // Lost the create race: the winner's file is whole; verify it like any other.
+    return existingArtifactStateSync(meta) === ARTIFACT_INTACT ? meta : null;
+  } catch {
+    return null;
+  }
+}
+
+// What sits at an artifact's content-addressed path: nothing, the verified
+// bytes, a file a crash left without data (empty or NUL — replaced whole), or
+// anything else (mismatched bytes, a link, a directory, an unreadable file),
+// which is evidence that is never touched or trusted.
+const ARTIFACT_ABSENT = 'absent';
+const ARTIFACT_INTACT = 'intact';
+const ARTIFACT_DAMAGED = 'damaged';
+const ARTIFACT_FOREIGN = 'foreign';
+
+function artifactVerdict(meta, info, readBytes) {
+  if (!info.isFile()) return ARTIFACT_FOREIGN;
+  if (!artifactShapeMatches(meta, info)) return info.size === 0 ? ARTIFACT_DAMAGED : ARTIFACT_FOREIGN;
+  const bytes = readBytes();
+  if (createHash('sha256').update(bytes).digest('hex') === meta.sha256) return ARTIFACT_INTACT;
+  return holdsNoData(bytes) ? ARTIFACT_DAMAGED : ARTIFACT_FOREIGN;
+}
+
+function existingArtifactStateSync(meta) {
+  let fd;
+  try {
+    lstatSync(meta.path);
+    fd = openSync(meta.path, ARTIFACT_READ_FLAGS);
+    const info = fstatSync(fd);
+    return artifactVerdict(meta, info, () => readFileSync(fd));
   } catch (error) {
-    if (error?.code !== 'EEXIST') return null;
-    let fd;
+    return error?.code === 'ENOENT' ? ARTIFACT_ABSENT : ARTIFACT_FOREIGN;
+  } finally {
     try {
-      if (!artifactShapeMatches(meta, lstatSync(meta.path))) return null;
-      fd = openSync(meta.path, ARTIFACT_READ_FLAGS);
-      if (!artifactShapeMatches(meta, fstatSync(fd))) return null;
-      if (createHash('sha256').update(readFileSync(fd)).digest('hex') !== meta.sha256) return null;
+      if (fd !== undefined) closeSync(fd);
     } catch {
-      return null;
-    } finally {
-      try {
-        if (fd !== undefined) closeSync(fd);
-      } catch {
-        // The artifact is already written and byte-verified above; a failed
-        // descriptor close is cleanup, not a failed persist, and must never
-        // replace the verified meta this function returns.
-      }
+      // A failed descriptor close is cleanup, not a failed persist.
+    }
+  }
+}
+
+async function existingArtifactState(meta) {
+  let handle;
+  try {
+    await lstat(meta.path);
+    handle = await open(meta.path, ARTIFACT_READ_FLAGS);
+    const info = await handle.stat();
+    // The verdict needs the bytes only when the size matches: read them first.
+    const bytes = info.isFile() && artifactShapeMatches(meta, info) ? await handle.readFile() : null;
+    return artifactVerdict(meta, info, () => bytes);
+  } catch (error) {
+    return error?.code === 'ENOENT' ? ARTIFACT_ABSENT : ARTIFACT_FOREIGN;
+  } finally {
+    try {
+      await handle?.close();
+    } catch {
+      // A failed handle close is cleanup, not a failed persist.
     }
   }
-  return meta;
 }
 
 async function persistToolResultArtifact({ sessionId, toolCallId, channel = 'result', content } = {}) {
@@ -269,32 +317,19 @@ async function persistToolResultArtifact({ sessionId, toolCallId, channel = 'res
   }
   if (!meta) return null;
   try {
-    await writeFile(meta.path, content, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
-  } catch (error) {
-    if (error?.code !== 'EEXIST') return null;
-    let handle;
-    try {
-      if (!artifactShapeMatches(meta, await lstat(meta.path))) return null;
-      handle = await open(meta.path, ARTIFACT_READ_FLAGS);
-      if (!artifactShapeMatches(meta, await handle.stat())) return null;
-      if (
-        createHash('sha256')
-          .update(await handle.readFile())
-          .digest('hex') !== meta.sha256
-      )
-        return null;
-    } catch {
-      return null;
-    } finally {
-      try {
-        await handle?.close();
-      } catch {
-        // See persistToolResultArtifactSync: the verified artifact stands even
-        // when releasing the handle fails, so cleanup never nulls the result.
-      }
+    const state = await existingArtifactState(meta);
+    if (state === ARTIFACT_INTACT) return meta;
+    if (state === ARTIFACT_FOREIGN) return null;
+    // See persistToolResultArtifactSync.
+    if (state === ARTIFACT_DAMAGED) {
+      await writeFileAtomicAsync(meta.path, content, { mode: 0o600 });
+      return meta;
     }
+    if (await writeFileAtomicAsync(meta.path, content, { mode: 0o600, createOnly: true })) return meta;
+    return (await existingArtifactState(meta)) === ARTIFACT_INTACT ? meta : null;
+  } catch {
+    return null;
   }
-  return meta;
 }
 
 export async function maybeOffloadToolResult(sessionId, toolCallId, toolName, result, options = {}) {

package/src/runtime/agent/orchestrator/session/transcript-restore/restore.mjs

@@ -6,7 +6,7 @@
  */
 import { contextMeasurementStats } from '../../../../shared/context-measurement.mjs';
 import { toolResultText } from './tool-result-text.mjs';
-import { restoredUserImageRefs, restoredUserText } from './user-text.mjs';
+import { createUserTextRestore } from './user-text.mjs';
 import {
   completionCardFromExecution,
   parseModelVisibleCompletionWrapper,
@@ -86,6 +86,7 @@ function restoredTranscriptMetadata(message) {
     ...transcriptRouteMetadataFields(value),
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
     ...(typeof value.device === 'string' && value.device ? { device: value.device } : {}),
+    ...(typeof value.fromAgent === 'string' && value.fromAgent ? { fromAgent: value.fromAgent } : {}),
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
     // The attachments this prompt carried, by content hash: a restored row
     // opens/downloads them by id from the attachment store.
@@ -112,8 +113,13 @@ function restoredTurnDoneItem(completion, metadata, nextId, finalAssistantId = '
   };
 }
 
+// A stored message's plain text: string content as is, block content flattened.
+function restoredContentText(message) {
+  return typeof message?.content === 'string' ? message.content : toolResultText(message?.content);
+}
+
 function restoredAssistantTranscriptItems(message, nextId) {
-  const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)).trim();
+  const text = restoredContentText(message).trim();
   if (!text) return [];
   const { completion, ...metadata } = restoredTranscriptMetadata(message);
   const items = [{ kind: 'assistant', id: nextId(), text, ...metadata }];
@@ -198,7 +204,7 @@ function attachRestoredToolResult(message, pendingByCallId) {
   const target = callId ? pendingByCallId.get(callId) : null;
   if (!target) return;
   pendingByCallId.delete(callId);
-  const text = (typeof message?.content === 'string' ? message.content : toolResultText(message?.content)) || '';
+  const text = restoredContentText(message) || '';
   target.result = text;
   assignUiDiffFromMessage(target, message);
   assignToolMetaFromMessage(target, message);
@@ -339,7 +345,8 @@ function restoredMessageItemUpperBound(message) {
   const boundaries =
     (Array.isArray(message?.meta?.sessionInheritances) ? message.meta.sessionInheritances.length : 0) +
     (Array.isArray(message?.meta?.modelSwitches) ? message.meta.modelSwitches.length : 0) +
-    (Array.isArray(message?.meta?.workflowSwitches) ? message.meta.workflowSwitches.length : 0);
+    (Array.isArray(message?.meta?.workflowSwitches) ? message.meta.workflowSwitches.length : 0) +
+    (Array.isArray(message?.meta?.orchestrationModeSwitches) ? message.meta.orchestrationModeSwitches.length : 0);
   const completionCount =
     Number(Boolean(message?.meta?.transcript?.completion)) +
     (Array.isArray(message?.meta?.transcript?.previousCompletions)
@@ -379,7 +386,7 @@ function restoredNotificationToolItem(parsed, text, message, nextId, errorLabel)
   };
 }
 
-function restoredUserTranscriptItems(message, nextId) {
+function restoredUserTranscriptItems(message, nextId, userText) {
   // Injected model-context payloads are model-visible but never user-authored:
   // skill bodies (meta:'skill'), hook/system reminders, and tag-wrapped context
   // blocks must not restore as user bubbles in any client.
@@ -400,10 +407,10 @@ function restoredUserTranscriptItems(message, nextId) {
   }
   // Imported prose renders verbatim: never a control row, card or display rewrite.
   if (isImportedMessage(message)) {
-    const text = (typeof message.content === 'string' ? message.content : toolResultText(message.content)).trim();
+    const text = restoredContentText(message).trim();
     return text ? [{ kind: 'user', id: nextId(), text, ...restoredTranscriptMetadata(message) }] : [];
   }
-  const text = restoredUserText(message?.content).trim();
+  const text = userText.text(message?.content).trim();
   // Persisted async-completion wrappers ("Async shell task ... finished. Result:
   // > ...") are the only durable record of a background completion — the live
   // Response card is an event-time push that does not survive a transcript
@@ -434,7 +441,7 @@ function restoredUserTranscriptItems(message, nextId) {
   }
   const synthetic = parseSyntheticAgentMessage(text);
   if (!synthetic) {
-    const imageRefs = restoredUserImageRefs(message?.content);
+    const imageRefs = userText.imageRefs(message?.content);
     return [
       {
         kind: 'user',
@@ -442,6 +449,8 @@ function restoredUserTranscriptItems(message, nextId) {
         text,
         ...restoredTranscriptMetadata(message),
         ...(imageRefs.length ? { imageRefs } : {}),
+        // Read by the model inside its running turn, as the live row says.
+        ...(message?.meta?.source === 'steering' ? { steered: true } : {}),
       },
     ];
   }
@@ -461,7 +470,9 @@ export function modelSwitchItem(id, boundary) {
   };
 }
 
-/** The transcript row of a mid-conversation workflow switch (live and restored). */
+/** The transcript row of a mid-conversation workflow switch (live and
+ *  restored); `unavailable`: the chosen workflow was gone when it was due and
+ *  the conversation kept `from`. */
 export function workflowSwitchItem(id, boundary) {
   return {
     kind: 'statusdone',
@@ -470,11 +481,26 @@ export function workflowSwitchItem(id, boundary) {
     label: 'Workflow switched',
     from: boundary.from,
     to: boundary.to,
+    ...(boundary.unavailable === true ? { unavailable: true } : {}),
     at: boundary.at,
   };
 }
 
-function restoreTranscriptRange(messages, start, sessionId) {
+/** The transcript row of a mid-conversation orchestration (delegation) mode
+ *  switch (live and restored); `from`/`to` are mode ids. */
+export function orchestrationModeSwitchItem(id, boundary) {
+  return {
+    kind: 'statusdone',
+    id,
+    status: 'orchestration-mode-switched',
+    label: 'Delegation mode switched',
+    from: boundary.from,
+    to: boundary.to,
+    at: boundary.at,
+  };
+}
+
+function restoreTranscriptRange(messages, start, sessionId, userText) {
   const items = [];
   const pendingToolCalls = new Map();
   for (let index = start; index < messages.length; index += 1) {
@@ -490,7 +516,7 @@ function restoreTranscriptRange(messages, start, sessionId) {
       continue;
     }
     if (message?.role === 'user') {
-      items.push(...restoredUserTranscriptItems(message, restoredId));
+      items.push(...restoredUserTranscriptItems(message, restoredId, userText));
     } else if (message?.role === 'assistant' && !isContextAckMessage(message, messages[index - 1])) {
       items.push(...restoredAssistantTranscriptItems(message, restoredId));
       items.push(...restoredToolCallItems(message, restoredId, pendingToolCalls));
@@ -520,6 +546,12 @@ function restoreTranscriptRange(messages, start, sessionId) {
       if (!boundary?.to) continue;
       items.push(workflowSwitchItem(restoredId(), boundary));
     }
+    for (const boundary of Array.isArray(message?.meta?.orchestrationModeSwitches)
+      ? message.meta.orchestrationModeSwitches
+      : []) {
+      if (!boundary?.to) continue;
+      items.push(orchestrationModeSwitchItem(restoredId(), boundary));
+    }
     if (message?.meta?.transcript?.previousCompletions?.length) {
       const events = items.slice(eventStart);
       if (events.every((item) => Number.isFinite(item.at))) {
@@ -533,9 +565,12 @@ function restoreTranscriptRange(messages, start, sessionId) {
 
 export function restoreTranscriptItems(messages, { sessionId = 'session', itemLimit = Number.POSITIVE_INFINITY } = {}) {
   const source = Array.isArray(messages) ? messages : [];
+  // One projection per load: a widened range reuses each prompt's parts and
+  // the paste-line reads share one budget.
+  const userText = createUserTextRestore();
   const numericLimit = Number(itemLimit);
   const limited = Number.isFinite(numericLimit) && numericLimit > 0;
-  if (!limited) return restoreTranscriptRange(source, 0, sessionId);
+  if (!limited) return restoreTranscriptRange(source, 0, sessionId, userText);
 
   const limit = Math.max(1, Math.floor(numericLimit));
   // Restore beyond the visible cap so a boundary tool run can merge exactly
@@ -549,7 +584,7 @@ export function restoreTranscriptItems(messages, { sessionId = 'session', itemLi
     upperBound += restoredMessageItemUpperBound(source[start]);
   }
 
-  let restored = restoreTranscriptRange(source, start, sessionId);
+  let restored = restoreTranscriptRange(source, start, sessionId, userText);
   // Hidden/context messages and aggregate tool runs can make the cheap upper
   // bound optimistic. Expand backward exponentially only when necessary.
   let expansionTarget = Math.max(64, limit - restored.length);
@@ -559,7 +594,7 @@ export function restoreTranscriptItems(messages, { sessionId = 'session', itemLi
       start -= 1;
       expansion += restoredMessageItemUpperBound(source[start]);
     }
-    restored = restoreTranscriptRange(source, start, sessionId);
+    restored = restoreTranscriptRange(source, start, sessionId, userText);
     expansionTarget *= 2;
   }
   return restored.length > limit ? restored.slice(-limit) : restored;