mixdog 1.3.0 → 1.3.1

package/src/runtime/agent/orchestrator/session/loop/usage.mjs

@@ -41,7 +41,7 @@ export function usageDeltaEvent({
   usage,
   sendTools,
   toolCalls = 0,
-  generationMs = 0,
+  requestMs = 0,
 }) {
   return {
     sessionId,
@@ -57,9 +57,10 @@ export function usageDeltaEvent({
     deltaToolCalls: toolCalls,
     ...reasoningUsage(usage),
     deltaPrompt: usage.promptTokens || 0,
-    // First visible token → end of this response; 0 when the call was not
-    // timed (nothing visible streamed). Only timed output enters speed figures.
-    generationMs,
+    // Request start → end of this response (first-token wait included, as the
+    // ledger's duration_ms); 0 when the call was not timed. Only timed output
+    // enters speed figures.
+    requestMs,
     // A provider that cannot measure the prompt or its cache split says so;
     // its zeros are unknowns, not readings (no cache hit can be derived).
     promptKnown: usage.inputTokensKnown !== false && usage.cacheTokensKnown !== false,
@@ -79,6 +80,47 @@ export function usageDeltaEvent({
   };
 }
 
+const SUMMED_USAGE_FIELDS = [
+  'inputTokens',
+  'outputTokens',
+  'cachedTokens',
+  'cacheWriteTokens',
+  'cacheWrite1hTokens',
+  'promptTokens',
+];
+
+/** What `total` added after the running total `earlier` (both from addUsage); null when nothing. */
+export function usageSince(total, earlier) {
+  if (!total) return null;
+  if (!earlier) return { ...total };
+  const delta = {};
+  for (const field of SUMMED_USAGE_FIELDS) delta[field] = Math.max(0, (total[field] || 0) - (earlier[field] || 0));
+  if (total.reasoningTokens != null) {
+    delta.reasoningTokens = Math.max(0, total.reasoningTokens - (earlier.reasoningTokens ?? 0));
+    delta.reasoningTokensComplete = total.reasoningTokensComplete === true;
+  }
+  if (total.costUsd != null) delta.costUsd = Math.max(0, total.costUsd - (earlier.costUsd || 0));
+  if (total.contextTokens) delta.contextTokens = total.contextTokens;
+  return Object.values(delta).some((value) => typeof value === 'number' && value > 0) ? delta : null;
+}
+
+/**
+ * The turn's usage split per model when the route switched mid-turn:
+ * `hops` holds, per left model, the running total when it was left. Each
+ * segment carries only its own tokens so it is priced at its own rates.
+ */
+export function routeUsageSegments(hops, total, current) {
+  if (!Array.isArray(hops) || !hops.length) return null;
+  const boundaries = [...hops, { ...current, usage: total }];
+  return boundaries
+    .map((segment, index) => ({
+      provider: segment.provider,
+      model: segment.model,
+      usage: usageSince(segment.usage, index ? boundaries[index - 1].usage : null),
+    }))
+    .filter((segment) => segment.usage);
+}
+
 export function addUsage(total, usage) {
   const delta = normalizeUsage(usage);
   if (!delta) return total;

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

@@ -120,14 +120,24 @@ function recordAgentRuntimeCall(session, result) {
 export async function recordAskUsage({ session, result, askStartedAt, turnSignal }) {
   const prefixHashForLog = recordAgentRuntimeCall(session, result);
   if (!result.usage) return;
-  await logSessionLlmUsage({
-    session,
-    usage: result.usage,
-    startedAt: askStartedAt,
-    signal: turnSignal,
-    prefixHash: prefixHashForLog,
-    transportTiming: result.transportTiming || null,
-  });
+  // A turn that switched models mid-way books one row per model, each priced
+  // at that model's rates; otherwise one row for the whole turn.
+  const segments = result.usageSegments?.length
+    ? result.usageSegments
+    : [{ provider: session.provider, model: session.model, usage: result.usage }];
+  for (const segment of segments) {
+    await logSessionLlmUsage({
+      session:
+        segment.provider === session.provider && segment.model === session.model
+          ? session
+          : { ...session, provider: segment.provider, model: segment.model },
+      usage: segment.usage,
+      startedAt: askStartedAt,
+      signal: turnSignal,
+      prefixHash: prefixHashForLog,
+      transportTiming: result.transportTiming || null,
+    });
+  }
   recordStandaloneStatusTelemetry(session, result, Date.now() - askStartedAt);
 }
 

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/session-lifecycle.mjs

@@ -19,6 +19,7 @@ import {
 } from '../../agent-runtime/cache-strategy.mjs';
 import { normalizeAutoClearConfig, resolveAutoClearIdleMs } from '../../runtime-core/config-helpers.mjs';
 import { _buildBaseRules } 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 {
@@ -241,7 +242,9 @@ export function createSession(createOpts) {
   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 });
   const prompt = composeSessionSystem(opts, { profile, providerName, modelName, surface, sessionMode });
   const messages = seedSessionMessages(prompt, opts.files);
   logSessionSurface(surface);
@@ -421,27 +424,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

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

@@ -139,6 +139,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 },
   };

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

@@ -18,6 +18,7 @@ import {
   writeCheckpointHeader,
 } from './turn-checkpoint-journal.mjs';
 import { captureTurnCheckpointContextState, restoreTurnCheckpointContextState } from './turn-checkpoint-context.mjs';
+import { stripProviderReplayMessages } from './provider-replay.mjs';
 
 export { turnCheckpointPath, turnMessagesForCheckpoint };
 export { captureTurnCheckpointContextState, restoreTurnCheckpointContextState };
@@ -198,7 +199,12 @@ export function recoverTurnCheckpoint(session) {
   const current = Array.isArray(session.messages) ? session.messages : [];
   const start = findTurnStart(current, checkpoint.currentUserContent);
   const kept = start >= 0 ? current.slice(0, start) : current;
-  session.messages = checkpoint.fullTranscript === true ? finalized.messages : [...kept, ...finalized.messages];
+  // The route switched models mid-turn (the marker says so) and the journal
+  // may predate the switch: its turn still carries the previous provider's
+  // native replay state, which the saved route's provider must not receive.
+  const turnMessages =
+    marker?.routeChanged === true ? stripProviderReplayMessages(finalized.messages) : finalized.messages;
+  session.messages = checkpoint.fullTranscript === true ? turnMessages : [...kept, ...turnMessages];
   // Re-anchor provider usage / post-compact replacement state to the exact
   // canonical checkpoint representation. If a legacy or corrupted checkpoint
   // cannot prove alignment, retain the last provider reading for display but

package/src/runtime/agent/orchestrator/session/manager/usage-metrics.mjs

@@ -558,7 +558,7 @@ export async function persistIterationMetrics(delta) {
     // per model call of this session (every tool-loop iteration), replaced
     // immutably so a consumer can tell by identity that it changed. Sessions
     // saved before this field began at their first call after it.
-    session.usageReadout = foldUsageReadout(session.usageReadout, delta, delta.generationMs);
+    session.usageReadout = foldUsageReadout(session.usageReadout, delta, delta.requestMs);
     recordLastContextTokens(session, iterationContext(delta));
   }
   session.lastIterationIndex = iterationIndex;

package/src/runtime/agent/orchestrator/session/mixy-name.mjs

@@ -4,8 +4,9 @@
 // use so a rename applies at once. Text shared across agents (tool schemas,
 // other agents' shared prompt block) says "the representative agent" instead,
 // so a rename never changes cached bytes.
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { mixdogGlobalDir, readSafe } from '../context/skill-catalog.mjs';
+import { mixyIdentityDir } from '../../../shared/agent-store.mjs';
 
 export const DEFAULT_MIXY_NAME = 'Mixy';
 
@@ -17,7 +18,9 @@ export function mixyNameOf(manifest) {
 
 export function mixyDisplayName() {
   try {
-    return mixyNameOf(JSON.parse(readSafe(join(mixdogGlobalDir('agents'), 'lead', 'agent.json')) || '{}'));
+    // bots/mixy once Mixy is its own bot, agents/lead before (agent-store.mjs).
+    const dir = mixyIdentityDir(dirname(mixdogGlobalDir('agents')));
+    return mixyNameOf(JSON.parse(readSafe(join(dir, 'agent.json')) || '{}'));
   } catch {
     return DEFAULT_MIXY_NAME;
   }

package/src/runtime/agent/orchestrator/session/routine-result.d.mts

@@ -9,7 +9,7 @@ export interface RoutineProvenance {
 export interface RoutineMessageMeta {
   source: string;
   routine: Record<string, unknown>;
-  transcript: { at: number; messageId?: string };
+  transcript: { at: number; messageId?: string; attachments?: unknown[] };
 }
 export interface RoutineMessage {
   role: 'user';
@@ -22,6 +22,15 @@ export interface RoutineNotice {
   routine: Record<string, unknown>;
   /** Live run notices only (routineRunNotice). */
   messageId?: string;
+  /** A task report's stored files (handoff-artifacts.mjs). */
+  attachments?: Array<{
+    id: string;
+    attachmentRef: string;
+    kind: string;
+    name: string;
+    mimeType: string;
+    size: number;
+  }>;
 }
 
 export const ROUTINE_RESULT_SOURCE: 'schedule-result';
@@ -45,7 +54,14 @@ export function agentTaskMessage(options: {
   status: string;
   text?: unknown;
   taskSessionId: string;
+  /** 'session': any session other than a task session the agent created. */
+  target?: 'task' | 'session';
   round?: number;
+  /** false: the report was posted without waking the agent (round-trip cap). */
+  woken?: boolean;
+  /** The files the turn produced (handoff-artifacts.mjs). */
+  files?: ReadonlyArray<{ name: string; path: string; mimeType?: string; size?: number; kind?: string; id?: string }>;
+  omitted?: number;
   at?: number;
   messageId?: string;
 }): RoutineMessage;

package/src/runtime/agent/orchestrator/session/routine-result.mjs

@@ -9,6 +9,8 @@
 // close the boundary or forge a reminder. Every transcript renders the row as
 // a notice: a routine result, never a user bubble or an assistant turn.
 import { escapeHarnessTags } from '../../../shared/shell-output-summary.mjs';
+import { artifactLines, artifactRecords, normalizeHandoffFiles } from '../../../shared/handoff-artifacts.mjs';
+import { transcriptAttachmentFields } from '../../../shared/transcript-metadata.mjs';
 
 export const ROUTINE_RESULT_SOURCE = 'schedule-result';
 const SUMMARY_LIMIT = 600;
@@ -135,10 +137,28 @@ export const TASK_LOOP_CAP = 3;
  *  turn that ended `completed` / `failed` / `cancelled`. `round` counts the
  *  agent-initiated round trips; from TASK_LOOP_CAP on, the report asks the
  *  agent to check with the user before continuing. */
-export function agentTaskMessage({ title, status, text = '', taskSessionId, round = 0, at = Date.now(), messageId }) {
+export function agentTaskMessage({
+  title,
+  status,
+  text = '',
+  taskSessionId,
+  target = 'task',
+  round = 0,
+  woken = true,
+  files = [],
+  omitted = 0,
+  at = Date.now(),
+  messageId,
+}) {
   const summary = routineSummary(text);
+  // The files the turn produced: listed for the agent, stored ones carried as
+  // the row's attachments (shown with the report, forwardable by id).
+  const produced = normalizeHandoffFiles(files);
+  const attachments = artifactRecords(produced);
   const label = escapeHarnessTags(String(title).replace(/["\r\n]/g, ''));
-  const head = `[mixdog-runtime] Coding task session "${label}" (${taskSessionId})`;
+  // `target` 'session': any session other than a task session the agent created.
+  const session = target === 'session';
+  const head = `[mixdog-runtime] ${session ? 'Session' : 'Agent task session'} "${label}" (${taskSessionId})`;
   let content;
   if (status === 'started') content = `${head} started; its result is reported here when its turn ends.`;
   else if (status === 'blocked') {
@@ -149,9 +169,13 @@ export function agentTaskMessage({ title, status, text = '', taskSessionId, roun
       `<task-output session="${taskSessionId}" status="${status}">`,
       escapeHarnessTags(summary),
       '</task-output>',
+      ...artifactLines(produced, omitted),
       ...(round >= TASK_LOOP_CAP
-        ? [`This was round trip ${round} with this task session: check with the user before sending it more work.`]
+        ? [
+            `This was round trip ${round} with this ${session ? 'session' : 'agent task session'}: check with the user before sending it more work.`,
+          ]
         : []),
+      ...(woken ? [] : ['This report did not wake you: the round-trip cap with that agent thread is reached.']),
     ].join('\n');
   }
   return {
@@ -159,17 +183,33 @@ export function agentTaskMessage({ title, status, text = '', taskSessionId, roun
     content,
     meta: {
       source: ROUTINE_RESULT_SOURCE,
-      routine: { kind: 'task', name: title, status, summary, sessionId: taskSessionId },
-      transcript: { at, ...(messageId ? { messageId } : {}) },
+      routine: {
+        kind: 'task',
+        name: title,
+        status,
+        summary,
+        sessionId: taskSessionId,
+        ...(session ? { target: 'session' } : {}),
+        ...(produced.length ? { files: produced } : {}),
+      },
+      transcript: { at, ...(messageId ? { messageId } : {}), ...(attachments.length ? { attachments } : {}) },
     },
   };
 }
 
-/** The hidden prompt that wakes the agent once its task results are posted. */
-export function agentTaskWakePrompt(messages) {
+/** The hidden prompt that wakes the agent once its task results are posted;
+ *  `more` counts posted reports it carries only as rows in the thread. */
+export function agentTaskWakePrompt(messages, { more = 0 } = {}) {
+  const files = messages.some((message) => message?.meta?.routine?.files?.length);
   return [
     ...messages.map((message) => message.content),
+    ...(more > 0 ? [`${more} more report${more === 1 ? '' : 's'} arrived; read the rows above.`] : []),
     'Relay the task result above to the user now, briefly and in your own words.',
+    ...(files
+      ? [
+          'Its files are already shown to the user with the report; name the ones that matter, link a path as a markdown link only when you refer to it, and pass them on to another session or agent with attachments.',
+        ]
+      : []),
   ].join('\n\n');
 }
 
@@ -218,11 +258,23 @@ export function routineResultNotice(message) {
   }
   if (routine.kind === 'task') {
     const { name, status, summary, sessionId } = routine;
+    const session = routine.target === 'session';
     const what = { started: 'started', blocked: 'waiting for confirmation' }[status] || status;
+    const files = normalizeHandoffFiles(routine.files);
     return {
-      text: `🛠 Task ${what} · ${name}${summary ? ` — ${summary}` : ''}`,
+      text: `🛠 ${session ? 'Session' : 'Agent task'} ${what} · ${name}${summary ? ` — ${summary}` : ''}`,
       tone: status === 'failed' ? 'warn' : 'info',
-      routine: { kind: 'task', name, status, summary, sessionId },
+      routine: {
+        kind: 'task',
+        name,
+        status,
+        summary,
+        sessionId,
+        ...(session ? { target: 'session' } : {}),
+        ...(files.length ? { files } : {}),
+      },
+      // The stored files, in the field a prompt row draws its attachments from.
+      ...transcriptAttachmentFields(message.meta.transcript),
     };
   }
   const webhook = routine.kind === 'webhook';

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,
@@ -379,7 +379,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.
@@ -403,7 +403,7 @@ function restoredUserTranscriptItems(message, nextId) {
     const text = (typeof message.content === 'string' ? message.content : toolResultText(message.content)).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 +434,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 +442,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 } : {}),
       },
     ];
   }
@@ -474,7 +476,7 @@ export function workflowSwitchItem(id, boundary) {
   };
 }
 
-function restoreTranscriptRange(messages, start, sessionId) {
+function restoreTranscriptRange(messages, start, sessionId, userText) {
   const items = [];
   const pendingToolCalls = new Map();
   for (let index = start; index < messages.length; index += 1) {
@@ -490,7 +492,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));
@@ -533,9 +535,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 +554,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 +564,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;

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

@@ -116,14 +116,64 @@ function referencedFeedbackText(part) {
   }
 }
 
+const PASTED_LINES = /· (\d+) lines?$/;
+const PASTED_TEXT_MAX_BYTES = 1024 * 1024;
+/** Blob bytes one transcript load may read to count the lines of pastes
+ *  whose stored name does not carry the count (pastes stored before it did). */
+export const PASTED_LINE_READ_BUDGET_BYTES = 4 * 1024 * 1024;
+
+/** Visible lines of a stored paste (as `pastedTextLineCount` counts them), or
+ *  null when the count would take a read past the load's budget. */
+function storedPasteLines(part, budget) {
+  const named = PASTED_LINES.exec(String(part.filename || ''));
+  if (named) return Number(named[1]);
+  const allowance = Math.min(PASTED_TEXT_MAX_BYTES, budget.remaining);
+  if (allowance <= 0) return null;
+  try {
+    const read = readAttachmentTextWithin(part, allowance);
+    if (read == null) return null;
+    budget.remaining -= Buffer.byteLength(read, 'utf8');
+    const value = read.replace(/\r\n?/g, '\n').replace(/\n+$/, '');
+    return value ? value.split('\n').length : 0;
+  } catch (error) {
+    // A blob that failed its integrity check was read before it failed: the
+    // read counts against the cap (at most the allowance). A missing blob
+    // read nothing.
+    if (error?.code !== 'ENOENT') budget.remaining -= allowance;
+    return null;
+  }
+}
+
+/** The chip token a stored pasted / attached text stood for in the live
+ *  bubble (intake moved its body into the store and dropped the token). A
+ *  paste whose line count is unknown shows as the plain `[Pasted text #n]`. */
+function storedTextToken(part, number, budget) {
+  if (part?.type !== 'text') return '';
+  if (part.textKind === 'paste') {
+    const lines = storedPasteLines(part, budget);
+    return lines == null ? `[Pasted text #${number}]` : `[Pasted text #${number} +${lines} lines]`;
+  }
+  if (part.textKind === 'file') return `[File #${number}: ${part.filename || 'attachment.txt'}]`;
+  return '';
+}
+
 /** The display lines of a stored prompt's parts, and for each image part the
  *  line that draws it: the composer's metadata line right before it, else a
- *  bare line of its own (a bare line never stands for the next image). */
-function restoredUserParts(content) {
+ *  bare line of its own (a bare line never stands for the next image). A
+ *  stored pasted or attached text shows as its chip token. */
+function restoredUserParts(content, budget) {
   const texts = [];
   const images = [];
   let pendingMetadata = '';
+  let storedTexts = 0;
   for (const part of content) {
+    const token = isAttachmentReference(part) ? storedTextToken(part, storedTexts + 1, budget) : '';
+    if (token) {
+      storedTexts += 1;
+      texts.push(token);
+      pendingMetadata = '';
+      continue;
+    }
     if (part?.type === 'image' || part?.type === 'input_image') {
       let line = pendingMetadata;
       if (!line) {
@@ -141,21 +191,48 @@ function restoredUserParts(content) {
   return { texts, images };
 }
 
+/**
+ * The user-bubble projection of one transcript load: each stored prompt's
+ * parts are worked out once (its text and its image refs share them, and a
+ * load that widens its range sees the same messages again), and the blob
+ * reads that count paste lines share one byte budget.
+ */
+export function createUserTextRestore({ readBudgetBytes = PASTED_LINE_READ_BUDGET_BYTES } = {}) {
+  const budget = { remaining: readBudgetBytes };
+  const parts = new WeakMap();
+  const partsOf = (content) => {
+    let found = parts.get(content);
+    if (!found) {
+      found = restoredUserParts(content, budget);
+      parts.set(content, found);
+    }
+    return found;
+  };
+  return {
+    text(content) {
+      if (!Array.isArray(content)) {
+        return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
+      }
+      return withVisualizeFeedbackDisplay(partsOf(content).texts.join('\n'));
+    },
+    /** The stored original of each image the restored bubble draws, by the
+     *  `[Image: …]` line that draws it. Every image keeps its slot (one
+     *  without a stored original has no `ref`) so later images do not shift
+     *  onto it; empty when no image has a stored original. */
+    imageRefs(content) {
+      if (!Array.isArray(content)) return [];
+      const slots = partsOf(content).images.map(({ part, line }) =>
+        isAttachmentReference(part) ? { line, ref: part.attachmentRef } : { line }
+      );
+      return slots.some((slot) => slot.ref) ? slots : [];
+    },
+  };
+}
+
 export function restoredUserText(content) {
-  if (!Array.isArray(content)) {
-    return withVisualizeFeedbackDisplay(typeof content === 'string' ? content : toolResultText(content));
-  }
-  return withVisualizeFeedbackDisplay(restoredUserParts(content).texts.join('\n'));
+  return createUserTextRestore().text(content);
 }
 
-/** The stored original of each image the restored bubble draws, by the
- *  `[Image: …]` line that draws it. Every image keeps its slot (one without a
- *  stored original has no `ref`) so later images do not shift onto it; empty
- *  when no image has a stored original. */
 export function restoredUserImageRefs(content) {
-  if (!Array.isArray(content)) return [];
-  const slots = restoredUserParts(content).images.map(({ part, line }) =>
-    isAttachmentReference(part) ? { line, ref: part.attachmentRef } : { line }
-  );
-  return slots.some((slot) => slot.ref) ? slots : [];
+  return createUserTextRestore().imageRefs(content);
 }