mixdog 1.4.1 → 1.4.3

package/src/tui/markdown/render-ansi.mjs

@@ -33,7 +33,7 @@ const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|(?:^|\n)\d+[.)] |(?:^|\n)\+ |(?:^|\n)={2
 
 // GFM strikethrough, pair-only. marked's default `del` also accepts a SINGLE
 // tilde, which turns approximation prose ("~100", "1~2개") into struck text —
-// the reason this tokenizer used to be disabled outright. Requiring `~~` keeps
+// so the default tokenizer cannot be used as is. Requiring `~~` keeps
 // real strikethrough working and lockstep with the desktop pipeline
 // (remark-gfm singleTilde:false).
 const DEL_RE = /^~~(?=[^\s~])([\s\S]*?[^\s~])~~(?!~)/;

package/src/tui/session/agent-job-feed/notification-router.mjs

@@ -2,6 +2,10 @@ import { parseAgentJob } from '../agent-envelope.mjs';
 import { notificationQueueKey, resolveTuiRuntimeNotificationDelivery } from '../notification-plan.mjs';
 import { isTerminalExecutionStatus } from './agent-status-refresh.mjs';
 
+// The runtime's setup-changed action after an empty session's settings
+// reconcile (session-runtime/boot/tools.mjs CONTEXT_STATUS_REFRESHED_ACTION).
+const CONTEXT_STATUS_REFRESHED = 'context_status_refreshed';
+
 // Routes one runtime notification by its delivery plan: UI-only kinds patch
 // the store or raise a notice, execution envelopes go through the execution
 // delivery, everything else becomes a model-visible task notification.
@@ -13,6 +17,7 @@ export function createNotificationRouter({
   statusRefresh,
   executionDelivery,
   modelNotification,
+  refreshContextStats = null,
   getAdmission = () => 'open',
 }) {
   let uiOpenSeq = 0;
@@ -20,6 +25,11 @@ export function createNotificationRouter({
   const uiActions = {
     'setup-ui': (delivery) => set({ setupUiRequest: { id: delivery.id, at: Date.now() } }),
     'setup-changed': (delivery) => {
+      // An empty session took moved settings: the context gauge re-reads.
+      if (delivery.setupAction === CONTEXT_STATUS_REFRESHED) {
+        refreshContextStats?.();
+        return;
+      }
       // Monotonic like ui-open: consecutive changes by the same action must
       // each refresh the attached surfaces.
       setupChangeSeq += 1;

package/src/tui/session/agent-job-feed.mjs

@@ -37,6 +37,7 @@ export function createAgentJobFeed({
   displayedExecutionNotificationKeys,
   itemIndexById,
   pushNotice,
+  refreshContextStats = null,
   now = () => Date.now(),
   executionResumeTombstoneTtlMs = 30_000,
   executionResumeTombstoneLimit = 128,
@@ -79,6 +80,7 @@ export function createAgentJobFeed({
     statusRefresh,
     executionDelivery,
     modelNotification,
+    refreshContextStats,
     getAdmission,
   });
 

package/src/tui/session/context-state.mjs

@@ -7,6 +7,7 @@
  */
 import { contextMeasurementStats } from '../../runtime/shared/context-measurement.mjs';
 import { goalStateSnapshot } from '../../runtime/agent/orchestrator/runtime-core/goal-state.mjs';
+import { todoSnapshot } from '../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 
 export function createContextState({
   runtime,
@@ -92,6 +93,8 @@ export function createContextState({
     // The daemon-queued quota resume of this session id (identity-stable while
     // unchanged), so a resume or session switch republishes it with the route.
     quotaResume: typeof getQuotaResume === 'function' ? getQuotaResume() : null,
+    // The session's own step list (identity-stable while unchanged); null when empty.
+    todo: todoSnapshot(runtime.session),
   });
 
   const routeState = () => {

package/src/tui/session/goal-turn-state.mjs

@@ -1,11 +1,15 @@
 // A steering handoff cancels a turn, not its durable Goal. Record the explicit
 // abort path against its turn epoch instead of guessing intent from error text.
-export function abortGoalTurn(runtime, flags, hasPendingSteering, reason = 'user-cancel') {
+export function abortGoalTurn(runtime, flags, hasPendingSteering, reason = 'user-cancel', { timeout = false } = {}) {
   const previous = flags.goalSteeringAbortEpoch;
   const epoch = flags.leadTurnEpoch;
   flags.goalSteeringAbortEpoch = hasPendingSteering ? epoch : null;
   try {
-    const result = runtime.abort(hasPendingSteering ? 'interrupt' : reason);
+    // A steering interrupt outranks a timeout: the turn was redirected, not abandoned.
+    const result =
+      timeout && !hasPendingSteering
+        ? runtime.abort(reason, { timeout: true })
+        : runtime.abort(hasPendingSteering ? 'interrupt' : reason);
     if (result === false) flags.goalSteeringAbortEpoch = previous;
     return result;
   } catch (error) {

package/src/tui/session/quota-resume.mjs

@@ -57,7 +57,7 @@ export function latestQuotaFailure(items) {
 
 /** The turn key of the failed turndone that ends the transcript, when no
  *  later turn has begun; '' otherwise. */
-export function latestFailedTurnKey(items) {
+function latestFailedTurnKey(items) {
   const transcript = Array.isArray(items) ? items : [];
   for (let index = transcript.length - 1; index >= 0; index -= 1) {
     const item = transcript[index];

package/src/tui/session/session-api/controls.mjs

@@ -67,6 +67,10 @@ export function createSessionControlsApi(bag) {
     stopShellJob: async (taskId) => {
       return (await runtime.stopShellJob?.(taskId)) ?? { stopped: false, error: 'shell job control is unavailable' };
     },
+    // `/stop`: this session's background shells, and stopping all of them:
+    // { jobs } and { stopped, stopping }.
+    listStoppableShellJobs: async () => (await runtime.listStoppableShellJobs?.()) ?? { jobs: [] },
+    stopShellJobs: async () => (await runtime.stopShellJobs?.()) ?? { stopped: 0, stopping: 0 },
     // Explicit force-release of a shell whose termination is unconfirmed:
     // { released, error? }. Surfaces confirm with the user before calling.
     releaseShellJob: async (taskId) => {

package/src/tui/session/session-api/extensions.mjs

@@ -54,6 +54,14 @@ export function createSessionExtensionsApi(bag) {
       (input) => runtime.addMcpServer?.(input),
       (result, input) => [`mcp added: ${result?.name || input?.name || 'server'}`]
     ),
+    // No command lock: the runtime serializes adds per connector
+    // (oneAddAtATime), so concurrent adds each succeed with their own key.
+    addConnectorAccount: async (input) => {
+      const result = await runtime.addConnectorAccount?.(input);
+      refreshRouteStats();
+      pushNotice(`mcp account added: ${result?.account || input?.connector || 'connector'}`);
+      return result;
+    },
     saveMcpServer: lockedChange(
       (input) => runtime.saveMcpServer?.(input),
       (result, input) => [`mcp saved: ${result?.name || input?.name || 'server'}`]

package/src/tui/session/session-api/intake/abort.mjs

@@ -172,7 +172,8 @@ export function createAbortAction(bag) {
       runtime,
       flags,
       hasPendingSteering,
-      keepsPrompt ? USER_CANCEL_KEEP_PROMPT_REASON : reason
+      keepsPrompt ? USER_CANCEL_KEEP_PROMPT_REASON : reason,
+      { timeout: options?.timeout === true }
     );
     if (restoreState) {
       // A user Stop consumes this input even when no draft is requested.

package/src/tui/session/session-api/intake.mjs

@@ -20,6 +20,7 @@ export function createSessionIntakeApi(bag) {
     patchItem,
     restoreOlderTranscript,
     restoreNewerTranscript,
+    readSpilledTranscript,
     routeState,
     restoreQueued,
     prioritizeQueued,
@@ -32,6 +33,7 @@ export function createSessionIntakeApi(bag) {
     patchItem,
     restoreOlderTranscript,
     restoreNewerTranscript,
+    ...(typeof readSpilledTranscript === 'function' ? { readSpilledTranscript } : {}),
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);

package/src/tui/session/session-api/integrations.mjs

@@ -129,8 +129,8 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
     getOAuthProviderLoginStatus: (flowId) => oauthFlows.status(flowId),
     completeOAuthProviderLogin: async (flowId, code) => oauthFlows.complete(flowId, code),
     cancelOAuthProviderLogin: async (flowId) => oauthFlows.cancel(flowId),
-    saveProviderApiKey: async (provider, secret) => {
-      const result = await runtime.saveProviderApiKey(provider, secret);
+    saveProviderApiKey: async (provider, secret, options) => {
+      const result = await runtime.saveProviderApiKey(provider, secret, options);
       pushNotice(`provider api key saved: ${result.provider}`, 'info');
       return true;
     },

package/src/tui/session/session-api/lifecycle/dispose.mjs

@@ -34,6 +34,7 @@ export function createDisposeAction(bag, { oauthFlows }) {
         'unsubscribeCompletionWakeGate',
         'unsubscribeGitHeadWatch',
         'unsubscribeWorktreeSetup',
+        'unsubscribeTodo',
       ]) {
         try {
           lifecycle[key]?.();

package/src/tui/session/session-api/lifecycle/session-reset.mjs

@@ -122,6 +122,13 @@ export function createSessionResetActions(bag) {
           throw error;
         }
       }),
+    // The desktop's auto-delete (session-delete.mjs deleteSessionIfIdle): never
+    // the current session, so no reset of this one's view.
+    deleteSessionIfIdle: async (id, expected, guards) => {
+      const result = await runtime.deleteSessionIfIdle(id, expected, guards);
+      if (result?.deleted === true) bag.supersedeQuotaResume?.(id);
+      return result;
+    },
     switchContext: (options) =>
       withResetLock(async () => {
         const rollbackSnapshot = beginTuiReset();

package/src/tui/session/session-api/routes-agent-definitions.mjs

@@ -27,6 +27,11 @@ export function createAgentDefinitionApi(runtime) {
     createWorkflow: async (payload) => runtime.createWorkflow?.(payload) ?? null,
     deleteWorkflow: async (workflowId) => runtime.deleteWorkflow?.(workflowId) ?? null,
     getAgentDefinition: (agentId) => runtime.getAgentDefinition?.(agentId) ?? null,
+    listInstructionFiles: () => runtime.listInstructionFiles?.() ?? [],
+    getInstructionFile: (group, id) => runtime.getInstructionFile?.(group, id) ?? null,
+    saveInstructionFile: async (payload) => runtime.saveInstructionFile?.(payload) ?? null,
+    resetInstructionFile: async (group, id, expectedRevision) =>
+      runtime.resetInstructionFile?.(group, id, expectedRevision) ?? null,
     getAgentAvatarImage: (agentId) => runtime.getAgentAvatarImage?.(agentId) ?? null,
     getAgentConnectors: (agentId) => runtime.getAgentConnectors?.(agentId) ?? [],
     listConnectors: () => runtime.listConnectors?.() ?? [],
@@ -43,6 +48,7 @@ export function createAgentDefinitionApi(runtime) {
     setAgentConnectorToolPermission: async (agentId, connectorId, toolName, permission, options) =>
       runtime.setAgentConnectorToolPermission?.(agentId, connectorId, toolName, permission, options) ?? null,
     getAgentAlwaysAllowedTools: (agentId) => runtime.getAgentAlwaysAllowedTools?.(agentId) ?? [],
+    getAgentConnectorTools: (agentId) => runtime.getAgentConnectorTools?.(agentId) ?? [],
     // Per-agent action-kind permissions (ask / allow / block) for the profile.
     getAgentPermissions: async (agentId) =>
       (await import('../../../runtime/agent/orchestrator/session/human-gate/store.mjs')).agentPermissions(agentId),

package/src/tui/session/session-api/settings.mjs

@@ -113,13 +113,13 @@ export function createSessionSettingsApi(bag) {
       return await runtime.setAiSessionTitles?.(enabled);
     }),
     getCacheWarmingSettings: () => {
-      return runtime.getCacheWarmingSettings?.() || { enabled: true };
+      return runtime.getCacheWarmingSettings?.() || { enabled: false };
     },
     setCacheWarmingEnabled: withCommandLock(async (enabled) => {
       return await runtime.setCacheWarmingEnabled?.(enabled);
     }),
     getHeartbeatSettings: () => {
-      return runtime.getHeartbeatSettings?.() || { heartbeat: true, intervalMinutes: 60 };
+      return runtime.getHeartbeatSettings?.() || { heartbeat: false, intervalMinutes: 60 };
     },
     setHeartbeatEnabled: withCommandLock(async (enabled) => {
       return await runtime.setHeartbeatEnabled?.(enabled);

package/src/tui/session/session-api/worktree.mjs

@@ -23,7 +23,15 @@
  *     (expectedRevision: WORKTREE_REVISION_CONFLICT when the session moved on)
  *     (WORKTREE_REMOVAL_INCOMPLETE: partly removed; call again to finish)
  *   listWorktrees()                                → every managed worktree with its retention
- *   pruneWorktrees()                               → reconcile report (never a retained worktree) */
+ *   pruneWorktrees()                               → reconcile report (with autoCleanup on, also the
+ *     count/age limits and archive rules of the automatic cleanup)
+ *   previewWorktreeCleanup({ repoCommonDir? })     → { hasCandidates } (whether pruneWorktrees could act on
+ *     anything; read-only, no git verification)
+ *   deleteWorktree({ entryId, force? })          → { removed, entryId, path } (Settings → Worktrees;
+ *     refuses one in use, dirty or unmerged work unless `force`)
+ *   getSessionWorktreeWork({ sessionIds })          → { sessionIds } owning a worktree removal would refuse
+ *   setArchivedSessionWorktrees({ sessionIds, archived }) → { changed } (autoCleanup on: archived
+ *     sessions' worktrees become disposable for the startup reconcile / prune; a restore unmarks) */
 import { worktreeError } from '../../../runtime/shared/worktrees/contract.mjs';
 
 /** Session actions of the Lead worktree feature (settings live in settings.mjs). */
@@ -40,6 +48,10 @@ export const SESSION_WORKTREE_ACTIONS = Object.freeze([
   'removeWorktree',
   'listWorktrees',
   'pruneWorktrees',
+  'previewWorktreeCleanup',
+  'deleteWorktree',
+  'getSessionWorktreeWork',
+  'setArchivedSessionWorktrees',
 ]);
 
 export function createSessionWorktreeApi({ runtime, set, routeState } = {}) {

package/src/tui/session/session-flow/drain.mjs

@@ -29,16 +29,13 @@ function earliestSubmittedAt(batch) {
 
 function renderBatchItems(batch, pushUserOrSyntheticItem) {
   for (const entry of batch) {
-    // Async-completion twins (queued model-visible wrapper) used to be
-    // display-skipped here on the assumption the live notification push
-    // already rendered a card. That push is event-ephemeral and can be
-    // missed (listener race, dedupe state from another surface, daemon
-    // restart), which left completions with NO transcript card at all
-    // (2026-08-17 field report: bench shell output never appeared).
-    // Render the wrapper through the synthetic path instead — the
-    // task_id upsert in upsertSyntheticToolItem patches an
-    // already-rendered card, so the double-delivery case stays
-    // duplicate-free. Non-wrapper entries keep the old skip.
+    // Async-completion twins (queued model-visible wrapper) are rendered
+    // through the synthetic path rather than display-skipped: the live
+    // notification push is event-ephemeral and can be missed (listener race,
+    // dedupe state from another surface, daemon restart), which would leave
+    // the completion with NO transcript card at all. The task_id upsert in
+    // upsertSyntheticToolItem patches an already-rendered card, so the
+    // double-delivery case stays duplicate-free. Non-wrapper entries are skipped.
     if (entry.mode === 'pending-resume' || entry.suppressDisplay) {
       const twin = typeof entry.content === 'string' ? entry.content : String(entry.text || '');
       if (parseModelVisibleCompletionWrapper(twin)) {
@@ -145,10 +142,10 @@ export function turnOptionsForBatch(batch, steering) {
       Array.isArray(entry?.resumeCompletionKeys) ? entry.resumeCompletionKeys : []
     ),
     transcriptMeta: completionWakeTranscriptMeta(batch),
-    // Only a routine turn names its selection text (never its payload).
-    ...(batch[0]?.mode === 'routine' && typeof batch[0].skillSelection === 'string'
-      ? { skillSelection: batch[0].skillSelection }
-      : {}),
+    // Only host code names a selection text (queue/entry-shape.mjs): a
+    // routine turn, or a routine's executor sub-agent turn — its trusted
+    // instructions, never a payload.
+    ...(typeof batch[0]?.skillSelection === 'string' ? { skillSelection: batch[0].skillSelection } : {}),
     context:
       batch
         .map((entry) => String(entry.context || '').trim())

package/src/tui/session/tool-card-results/grouped-result.mjs

@@ -49,8 +49,8 @@ function applyAgentJobFields(ctx, patch, { itemId, group, text, rawText, isError
   const body = String(text || rawText || '').trim();
   if (body) patch.rawResult = text || rawText;
   if (parseAgentJob(rawText)) ctx.set(ctx.agentStatusState({ force: true }));
-  // The two calls previously wrote the same card back-to-back with different
-  // result/text strings, producing the visible L1/L2 flash. The agent fields
+  // Writing the same card back-to-back with different result/text strings
+  // produces a visible L1/L2 flash, so a single patch is written. The agent fields
   // win (final display) while patch keeps the completion metadata
   // (count/completedCount/completedAt/rawResult) for expand.
   Object.assign(patch, ctx.buildAgentJobCardPatch(itemId, rawText, isError));

package/src/tui/session/transcript-spill/spill-writer.mjs

@@ -10,6 +10,8 @@
 // Pages are self-contained files named by the owner, so a restart continues
 // the same spill directory with nothing to hand over.
 import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 const MAX_ATTEMPTS = 2;
 const SPILL_WRITER_IDLE_MS = 10_000;
@@ -67,6 +69,11 @@ export function createSpillWriter({ workerFactory, writeTimeoutMs = 5000, idleMs
     if (record.cancelled) return;
     record.attempts += 1;
     if (record.attempts <= MAX_ATTEMPTS) {
+      // The spill folder vanished (TEMP cleaned): the retry recreates it. Only
+      // the parent does this, synchronously right before it posts the retry
+      // and only for a live record, so a reset or cleanup (which cancels the
+      // record first) can never have its folder resurrected by a late write.
+      record.recreateDir = /ENOENT/.test(String(error));
       queue.unshift(record);
       return;
     }
@@ -159,6 +166,14 @@ export function createSpillWriter({ workerFactory, writeTimeoutMs = 5000, idleMs
       queueMicrotask(pump);
       return;
     }
+    if (active.recreateDir) {
+      active.recreateDir = false;
+      try {
+        mkdirSync(dirname(active.path), { recursive: true });
+      } catch {
+        /* the retry reports the failure */
+      }
+    }
     // Pages are capped at chunkSize, so the structured-clone post cost is
     // bounded; the retry payload is identical to the first attempt.
     const tempPath = `${active.path}.attempt-${active.attempts}-${randomUUID()}.tmp`;

package/src/tui/session/transcript-spill.mjs

@@ -20,6 +20,13 @@ export const tuiDebug = (msg) => {
   } catch {}
 };
 
+/** Normal-level spill warning for the daemon: its stderr is daemon.log. */
+export const spillWarningToStderr = (message) => {
+  try {
+    process.stderr.write(`[transcript-spill] ${message}\n`);
+  } catch {}
+};
+
 // Item ids outlive the process (queued-input mirror, turn change records), so
 // a restarted process never issues an id again.
 const ID_PREFIX = `it_${randomBytes(4).toString('hex')}_`;
@@ -41,6 +48,48 @@ export function sweepStaleTranscriptSpillDirsOnce() {
   cleanupStaleTranscriptSpillDirs();
 }
 
+const decodePage = (record) => record.pendingItems || JSON.parse(readFileSync(record.path, 'utf8'));
+
+/** Spilled rows `[stop - limit, stop)` of `pages` (`spilledRows` rows in all),
+ *  `stop` being `end` clamped to the spilled rows, read newest page first;
+ *  `broken` when a page cannot be read whole. */
+function readSpilledRows(pages, spilledRows, end, limit) {
+  const stop = Math.max(0, Math.min(Number(end) || 0, spilledRows));
+  const begin = Math.max(0, stop - Math.max(0, Number(limit) || 0));
+  const parts = [];
+  const result = (broken) => {
+    const items = parts.reverse().flat();
+    return { items, start: stop - items.length, broken };
+  };
+  // The page holding row `stop - 1`, by binary search over the pages' first
+  // rows: a read touches only the pages it returns rows from, at any depth.
+  let low = 0;
+  let high = pages.length - 1;
+  let last = -1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    if (pages[middle].start < stop) {
+      last = middle;
+      low = middle + 1;
+    } else high = middle - 1;
+  }
+  for (let index = last; index >= 0; index -= 1) {
+    const record = pages[index];
+    const pageStart = record.start;
+    const pageEnd = pageStart + record.count;
+    if (pageEnd <= begin) break;
+    let items = null;
+    try {
+      items = decodePage(record);
+    } catch {
+      items = null;
+    }
+    if (!Array.isArray(items) || items.length !== record.count) return result(true);
+    parts.push(items.slice(Math.max(begin, pageStart) - pageStart, Math.min(stop, pageEnd) - pageStart));
+  }
+  return result(false);
+}
+
 // Serialized pages deliberately release the old item object graph while
 // keeping every byte restorable. Only `items` is render-live and walkable.
 // This buffer owns the page list, the reading cursor and snapshots; the spill
@@ -65,6 +114,21 @@ export function createTranscriptSpillBuffer({
   let cursor = null;
   let spillDir = null;
   let pageSequence = 0;
+  // Spilled rows in this page list, and its epoch: it moves whenever the list
+  // is replaced (reset, restored snapshot, dispose), so an absolute row index
+  // names one row only within an epoch. Cursor-independent.
+  let spilledRows = 0;
+  let epoch = 0;
+  let spilledInfo = { rows: 0, epoch: 0 };
+  // Each page's first absolute row (`start`) within the current page list.
+  const replaced = () => {
+    spilledRows = 0;
+    for (const record of pages) {
+      record.start = spilledRows;
+      spilledRows += record.count;
+    }
+    epoch += 1;
+  };
   let warningEmitted = false;
   let spillDisabled = false;
   const snapshots = new Set();
@@ -96,6 +160,7 @@ export function createTranscriptSpillBuffer({
     const record = {
       id: pageSequence,
       path: page,
+      count: items.length,
       pendingItems: items,
       cancelled: false,
       attempts: 0,
@@ -104,11 +169,10 @@ export function createTranscriptSpillBuffer({
     writer.enqueue(record);
     return record;
   };
-  const decode = (record) => record.pendingItems || JSON.parse(readFileSync(record.path, 'utf8'));
   const restoredWithOverlap = (liveItems) => {
-    const restored = decode(pages[cursor]);
+    const restored = decodePage(pages[cursor]);
     let following = Array.isArray(liveItems) ? liveItems : [];
-    if (cursor + 1 < pages.length) following = decode(pages[cursor + 1]);
+    if (cursor + 1 < pages.length) following = decodePage(pages[cursor + 1]);
     return [...restored, ...following.slice(0, TRANSCRIPT_RESTORE_OVERLAP_ITEMS)];
   };
   return {
@@ -118,6 +182,14 @@ export function createTranscriptSpillBuffer({
     get hasNewer() {
       return cursor != null;
     },
+    /** `{ rows, epoch }`: how many rows were spilled above the live ones, in
+     *  which page list. The same object while neither changes. */
+    get spilled() {
+      if (spilledInfo.rows !== spilledRows || spilledInfo.epoch !== epoch) {
+        spilledInfo = { rows: spilledRows, epoch };
+      }
+      return spilledInfo;
+    },
     reset() {
       const retained = [...snapshots].some((snapshot) => snapshot.spillDir === spillDir);
       const oldPages = pages.splice(0);
@@ -127,6 +199,7 @@ export function createTranscriptSpillBuffer({
       pageSequence = 0;
       spillDisabled = false;
       warningEmitted = false;
+      replaced();
       if (!retained) cleanupRecords(oldPages, oldDir);
     },
     snapshot() {
@@ -155,6 +228,7 @@ export function createTranscriptSpillBuffer({
       pageSequence = snapshot.pageSequence;
       spillDisabled = snapshot.spillDisabled === true;
       warningEmitted = snapshot.warningEmitted === true;
+      replaced();
       snapshots.delete(snapshot);
       return true;
     },
@@ -169,6 +243,7 @@ export function createTranscriptSpillBuffer({
         if (snapshot.spillDir !== spillDir) cleanupRecords(snapshot.pages, snapshot.spillDir);
       }
       pages.length = 0;
+      replaced();
       snapshots.clear();
       cursor = null;
       spillDir = null;
@@ -191,11 +266,24 @@ export function createTranscriptSpillBuffer({
       let live = Array.isArray(items) ? items : [];
       if (spillDisabled) return live;
       while (live.length > cap) {
-        pages.push(encode(live.slice(0, chunkSize)));
+        const record = encode(live.slice(0, chunkSize));
+        record.start = spilledRows;
+        pages.push(record);
+        spilledRows += chunkSize;
         live = live.slice(chunkSize);
       }
       return live;
     },
+    /** Spilled rows `[start, end)` by absolute index (0 = the first row ever
+     *  spilled in this `epoch`), at most `limit` ending at `end`, exactly as
+     *  they were spilled. Reads pages in order without moving the reading
+     *  cursor. Null for another epoch. A page that cannot be read whole (gone,
+     *  not JSON, not an array of its recorded length) ends the spilled
+     *  history there: `broken`, with only the rows below it. */
+    readSpilled({ epoch: wanted, end = spilledRows, limit = 0 } = {}) {
+      if (wanted !== epoch) return null;
+      return readSpilledRows(pages, spilledRows, end, limit);
+    },
     restoreOlder(liveItems) {
       const nextCursor = cursor == null ? pages.length - 1 : cursor - 1;
       if (nextCursor < 0) return null;

package/src/tui/session/transcript-store.mjs

@@ -21,6 +21,8 @@ export function createTranscriptStore({ draft, store, flags, transcriptSpill, it
   const transcriptHistoryFlags = () => ({
     transcriptHistoryBefore: transcriptSpill.hasOlder,
     transcriptHistoryAfter: transcriptSpill.hasNewer,
+    // Paged views read spilled rows by this, never by the TUI reading cursor.
+    transcriptSpilled: transcriptSpill.spilled,
   });
   const restoreOlderTranscript = () => {
     const transcriptViewItems = transcriptSpill.restoreOlder(draft.state.items);

package/src/tui/session/turn-quiet.mjs

@@ -9,7 +9,7 @@ import { resolveAgentStallThresholds } from '../../runtime/agent/orchestrator/st
 const QUIET_POLL_MS = 1_000;
 
 /** The lead's stall-watchdog warn point, in ms. */
-export function leadStallWarnMs() {
+function leadStallWarnMs() {
   return resolveAgentStallThresholds('lead').warn * 1000;
 }
 

package/src/tui/session/turn.mjs

@@ -549,6 +549,8 @@ export function failTurn(ctx, error) {
   if (record.quota) turn.quota = record.quota;
   turn.failureDetail = record.detail;
   turn.failureDiagnostic = record.errorDetails;
+  // Answers the turn went on past before it failed (turn-report.mjs).
+  if (typeof error?.carriedReport === 'string') turn.carriedReport = error.carriedReport;
   pushNotice(turn.failureDetail, 'error', { owner: 'transcript' });
 }
 
@@ -661,6 +663,7 @@ async function settleTurn(ctx) {
     session: runtime.session || null,
     error: turn.failureDetail || null,
     errorKind: turn.failed ? turn.errorKind || null : null,
+    ...(turn.failed && turn.carriedReport ? { carriedReport: turn.carriedReport } : {}),
   };
   // Publish termination before optional Goal work can delay the caller.
   bag.settleSteeredSubmissions?.(turn.epoch, detail);

package/src/tui/session/worktree-setup-notice.mjs

@@ -12,7 +12,7 @@ const ENDINGS = {
 const INCOMPLETE = 'Some worktree dependencies were not installed; the agent has the details.';
 
 /** Notice text and tone for one install progress event. */
-export function worktreeSetupNotice(event) {
+function worktreeSetupNotice(event) {
   if (event.final) {
     const text = ENDINGS[event.status] ?? INCOMPLETE;
     return { text, tone: event.status === 'completed' ? 'info' : 'warn' };

package/src/tui/spinner-meta.mjs

@@ -17,7 +17,7 @@ const compactNumberFormatter = new Intl.NumberFormat('en-US', {
   minimumFractionDigits: 0,
 });
 
-export function formatSpinnerTokens(value) {
+function formatSpinnerTokens(value) {
   const tokens = Math.max(0, Number(value || 0));
   if (tokens >= 1000) return compactNumberFormatter.format(tokens).toLowerCase();
   return String(Math.round(tokens));
@@ -84,8 +84,8 @@ export function buildSpinnerMeta({
     thinkingParts,
     tokensText: tokens > 0 ? `${formatSpinnerTokens(tokens)} tokens` : '',
     // The count appears with the FIRST token (user: 30초가 아니라 바로).
-    // Elapsed was never gated, so the byline used to grow a second field
-    // mid-turn for no reason the reader could see; now both arrive together.
+    // Elapsed is never gated, so showing tokens with the first token keeps the
+    // byline from growing a second field mid-turn; both arrive together.
     showTokens: tokens > 0,
     thinkingText,
     thinkingActive: Boolean(thinking || Number(thinkingSince) > 0),

package/src/tui/spinner-verbs.mjs

@@ -199,13 +199,13 @@ export const SPINNER_VERBS = [
 ];
 
 /** How long one phrase holds before the pool advances. */
-export const SPINNER_VERB_ROTATE_MS = 30_000;
+const SPINNER_VERB_ROTATE_MS = 30_000;
 
 /** Odds that a 30s boundary actually swaps the phrase (user: 바꿀지 말지만
  *  랜덤 돌리면 되잖아). Below 1 the window stretches: ~half the boundaries
  *  hold, so a phrase lives 30s, 60s, 90s… and the rhythm stops being a
  *  metronome. */
-export const SPINNER_VERB_CHANGE_ODDS = 0.5;
+const SPINNER_VERB_CHANGE_ODDS = 0.5;
 
 /**
  * Deterministic coin for ONE (turn, boundary) pair.