mixdog 1.2.3 → 1.2.4

package/src/runtime/shared/model-route-fallback.mjs

@@ -0,0 +1,22 @@
+import { providerErrorKind } from '../agent/orchestrator/providers/provider-error-kind.mjs';
+import { readStreamOutcome } from '../agent/orchestrator/providers/lib/stream-outcome.mjs';
+
+const ELIGIBLE = new Set(['rate_limited', 'quota_exhausted', 'overloaded', 'transient']);
+
+export function canFallbackRoute(error, { signal, outcome = readStreamOutcome(error), committed = false } = {}) {
+  if (signal?.aborted || committed || outcome.userAbort || outcome.stallObserved) return false;
+  if (
+    !outcome.replaySafe ||
+    outcome.observedOutput ||
+    outcome.toolCallsStarted ||
+    outcome.pendingToolInput ||
+    outcome.continuation ||
+    outcome.terminalObserved
+  )
+    return false;
+  const { kind, status } = providerErrorKind(error);
+  if (!ELIGIBLE.has(kind)) return false;
+  // A rejected HTTP request or a provider account-pool refusal proves no
+  // generation started. A transport disconnect alone does not.
+  return status === 429 || status === 503 || (kind === 'quota_exhausted' && error?.quotaExhausted != null);
+}

package/src/runtime/shared/pid-liveness.mjs

@@ -25,3 +25,15 @@ export function isPidAlive(value) {
     return error?.code === 'EPERM';
   }
 }
+
+/** Destructive operations require proof of death, not merely a failed probe. */
+export function isPidAliveOrUnknown(value) {
+  const pid = parsePid(value);
+  if (!pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== 'ESRCH';
+  }
+}

package/src/runtime/shared/provider-api-key.mjs

@@ -76,6 +76,12 @@ export function resolveProviderApiKey(provider, config) {
   return config?.apiKey || getAgentApiKey(provider) || '';
 }
 
+/** Presence twin of resolveProviderApiKey, same precedence, no key value read. */
+export function hasProviderApiKey(provider, config) {
+  if (config?.apiKeyEnv) return Boolean(process.env[config.apiKeyEnv]);
+  return Boolean(config?.apiKey) || hasAgentApiKey(provider);
+}
+
 /** Auth-error reload: the stored/environment key is re-read first so a
  *  rotated key beats the stale one captured in config. */
 export function reloadProviderApiKey(provider, config) {

package/src/runtime/shared/provider-timeout-phase.mjs

@@ -0,0 +1,17 @@
+// The phase a provider timeout names on its `timeoutPhase` field. A provider
+// stamps it where the timer that fired is known; retry policy and error
+// presentation read it instead of matching the timeout's message text.
+export const TIMEOUT_PHASE = Object.freeze({
+  // The response headers did not arrive in the first-byte window.
+  HEADERS: 'headers',
+  // The headers arrived, the first chunk did not.
+  FIRST_CHUNK: 'first-chunk',
+  // A stream that already produced output went silent.
+  IDLE: 'idle',
+});
+
+/** A timeout before the model produced anything: headers or first chunk. */
+export function isFirstByteTimeout(err) {
+  const phase = err?.timeoutPhase;
+  return phase === TIMEOUT_PHASE.HEADERS || phase === TIMEOUT_PHASE.FIRST_CHUNK;
+}

package/src/runtime/shared/quiet-progress.d.mts

@@ -0,0 +1,35 @@
+export type QuietWaitKind = 'provider' | 'thinking' | 'model' | 'tool' | 'slot' | 'cancel' | '';
+
+export const MODEL_THINKING_STAGE: 'model_thinking';
+export function awaitingModelResponse(liveness: unknown): boolean;
+export function displayProgressStage(liveness: unknown): string | null;
+
+export interface QuietProgress {
+  since: number;
+  wait: QuietWaitKind;
+  tool?: string;
+}
+
+export interface QuietProgressParts {
+  quietMs: number;
+  minutes: number;
+  wait: QuietWaitKind;
+  tool: string;
+  escalated: boolean;
+}
+
+export const QUIET_PROGRESS_CUE_MS: number;
+export function lastProgressAt(liveness: unknown): number;
+export function quietWaitKind(stage: unknown): QuietWaitKind;
+export function quietProgress(options: {
+  progressAt: unknown;
+  stage: unknown;
+  tool?: unknown;
+  now?: number;
+}): QuietProgress | null;
+export function quietProgressParts(
+  quiet: { since?: unknown; wait?: unknown; tool?: unknown } | null | undefined,
+  now: number,
+  warnMs?: unknown
+): QuietProgressParts | null;
+export function quietProgressLabel(parts: QuietProgressParts | null): string;

package/src/runtime/shared/quiet-progress.mjs

@@ -0,0 +1,101 @@
+// Quiet-time cue for a running turn: how long it has gone without progress
+// the stall watchdog counts, and what it is waiting on. Display only — the
+// watchdog's abort policy lives in stall-policy.mjs and is never read or
+// changed here. Shared by the TUI spinner, the desktop live status line and
+// the desktop agent rows, so every surface says the same thing.
+
+/** A running turn with no counted progress for this long reads "quiet".
+ *  Lenient on purpose: effort-mode models can think for minutes without a
+ *  single semantic delta (stall-policy.mjs, the semantic-idle notes), so the
+ *  cue stays neutral text; only the watchdog's own warn point escalates it. */
+export const QUIET_PROGRESS_CUE_MS = 120_000;
+
+/** The newest progress stamp of a runtime liveness entry or progress
+ *  snapshot: the same signals the stall watchdog counts (stage changes,
+ *  semantic stream deltas, tool starts and tool heartbeats, the turn start). */
+export function lastProgressAt(liveness) {
+  if (!liveness || typeof liveness !== 'object') return 0;
+  return Math.max(
+    Number(liveness.lastProgressAt) || 0,
+    Number(liveness.lastStreamDeltaAt) || 0,
+    Number(liveness.toolStartedAt) || 0,
+    Number(liveness.askStartedAt) || 0
+  );
+}
+
+/** The stage a provider reports once its request is on the wire and the
+ *  response headers are still pending. The runtime keeps the turn in
+ *  `requesting` and records the send time (`requestSentAt`); the display stage
+ *  below reads "model thinking" from that record. */
+export const MODEL_THINKING_STAGE = 'model_thinking';
+
+/** Request sent, response headers (transport) not yet received — read from
+ *  a runtime liveness entry or progress snapshot. */
+export function awaitingModelResponse(liveness) {
+  if (!liveness || typeof liveness !== 'object' || liveness.stage !== 'requesting') return false;
+  const sentAt = Number(liveness.requestSentAt) || 0;
+  return sentAt > 0 && !((Number(liveness.lastTransportAt) || 0) >= sentAt);
+}
+
+/** The stage a surface shows: `model_thinking` while the request waits for
+ *  its headers, otherwise the runtime stage. */
+export function displayProgressStage(liveness) {
+  if (awaitingModelResponse(liveness)) return MODEL_THINKING_STAGE;
+  return typeof liveness?.stage === 'string' ? liveness.stage : null;
+}
+
+const WAIT_BY_STAGE = {
+  connecting: 'provider',
+  requesting: 'provider',
+  [MODEL_THINKING_STAGE]: 'thinking',
+  streaming: 'model',
+  tool_running: 'tool',
+  resource_wait: 'slot',
+  cancelling: 'cancel',
+};
+
+/** What a quiet turn waits on, from its runtime stage ('' when unknown). */
+export function quietWaitKind(stage) {
+  return WAIT_BY_STAGE[String(stage || '')] || '';
+}
+
+/** The quiet state of a running turn at `now`, or null while it is not
+ *  quiet. `since` is the frozen progress stamp, so the value stays identical
+ *  for the whole silence and publishing it costs one update per silence. */
+export function quietProgress({ progressAt, stage, tool = null, now = Date.now() }) {
+  const since = Number(progressAt) || 0;
+  if (!since || now - since < QUIET_PROGRESS_CUE_MS) return null;
+  const wait = quietWaitKind(stage);
+  return { since, wait, ...(wait === 'tool' && tool ? { tool: String(tool) } : {}) };
+}
+
+/** Display parts of a quiet state at `now`: whole quiet minutes, and whether
+ *  the silence reached the watchdog's warn point (`warnMs`, 0 = none). */
+export function quietProgressParts(quiet, now, warnMs = 0) {
+  const since = Number(quiet?.since) || 0;
+  if (!since) return null;
+  const quietMs = Math.max(0, now - since);
+  if (quietMs < QUIET_PROGRESS_CUE_MS) return null;
+  return {
+    quietMs,
+    minutes: Math.floor(quietMs / 60_000),
+    wait: String(quiet.wait || ''),
+    tool: typeof quiet.tool === 'string' ? quiet.tool : '',
+    escalated: Number(warnMs) > 0 && quietMs >= Number(warnMs),
+  };
+}
+
+const WAIT_TEXT = {
+  provider: 'waiting on provider',
+  thinking: 'model thinking',
+  model: 'waiting on model',
+  slot: 'waiting for a slot',
+  cancel: 'stopping',
+};
+
+/** The TUI's lowercase English cue: `quiet for 2m · waiting on provider`. */
+export function quietProgressLabel(parts) {
+  if (!parts) return '';
+  const wait = parts.wait === 'tool' ? `running ${parts.tool || 'a tool'}` : WAIT_TEXT[parts.wait] || '';
+  return [`quiet for ${parts.minutes}m`, wait].filter(Boolean).join(' · ');
+}

package/src/runtime/shared/quota-resume-store.mjs

@@ -131,6 +131,32 @@ export function listQuotaResumeEntries() {
   return [...load().entries.values()];
 }
 
+/** Rekey a proven legacy execution and its Goal together; invalidate old fires. */
+export function rekeyQuotaResumeTurn(sessionId, fromTurnKey, toTurnKey) {
+  const current = load();
+  const id = text(sessionId);
+  const from = text(fromTurnKey);
+  const to = text(toTurnKey);
+  if (!id || !from || !to || from === to) return false;
+  const entry = current.entries.get(id);
+  const suspension = current.suspensions.get(id);
+  const moveEntry = entry?.turnKey === from;
+  const moveGoal = suspension?.turnKey === from;
+  if (!moveEntry && !moveGoal) return false;
+  const next = {
+    ...current,
+    generation: current.generation + Number(moveEntry),
+    entries: new Map(current.entries),
+    suspensions: new Map(current.suspensions),
+  };
+  if (moveEntry) next.entries.set(id, normalizeEntry({ ...entry, turnKey: to, generation: next.generation }));
+  if (moveGoal) next.suspensions.set(id, normalizeSuspension({ ...suspension, turnKey: to }));
+  persist(next);
+  state = next;
+  notify(id);
+  return true;
+}
+
 /** The session snapshot's `quotaResume` value for an entry (or null). */
 export function publicQuotaResume(entry) {
   if (!entry) return null;
@@ -244,7 +270,12 @@ export function isAgentOnlySession(session) {
   const lower = (value) => text(value).toLowerCase();
   if (lower(session.visibility) === 'agent-only') return true;
   const parentId = text(session.parentSessionId || session.ownerSessionId);
-  return lower(session.owner) === 'agent' && lower(session.agent) !== 'lead' && parentId !== '' && parentId !== text(session.id);
+  return (
+    lower(session.owner) === 'agent' &&
+    lower(session.agent) !== 'lead' &&
+    parentId !== '' &&
+    parentId !== text(session.id)
+  );
 }
 
 /** Global setting, default on. */

package/src/runtime/shared/read-row-numbers.mjs

@@ -61,3 +61,47 @@ export function readRowsForDisplay(text) {
   }
   return out.join('\n');
 }
+
+/** Decode one contiguous model-facing read window, never display metadata.
+ * Unknown or disjoint views are not safe substitutes for file text. Per-line
+ * clipping is not visible in the text: the read executor reports it
+ * structurally, never inferred from row content.
+ * The display format does not preserve original byte size or final newline.
+ */
+export function readSourceWindow(text) {
+  if (typeof text !== 'string') return null;
+  if (/^<system-reminder>File exists but has empty contents: [^\n]*<\/system-reminder>$/.test(text))
+    return { content: '', totalLines: 0, startLine: 1, endLine: 0, truncated: false };
+  const emptyRange = /^\(no lines in range; file has (\d+) lines\)$/.exec(text);
+  if (emptyRange)
+    return { content: '', totalLines: Number(emptyRange[1]), startLine: null, endLine: null, truncated: false };
+  if (!RUN_MARKER_RE.test(text.split('\n', 1)[0])) return null;
+  const rows = [];
+  let totalLines;
+  let footer = null;
+  for (const line of readRowsForDisplay(text).split('\n')) {
+    const row = /^(\d+)→([\s\S]*)$/.exec(line);
+    if (row) {
+      if (footer) return null;
+      const number = Number(row[1]);
+      if (rows.length && number !== rows.at(-1).number + 1) return null;
+      rows.push({ number, content: row[2] });
+      continue;
+    }
+    const metadata = /^\[lines (\d+)-(\d+) of (\d+)(?:; pass offset:\d+ to continue)?\]$/.exec(line);
+    if (!metadata || footer) return null;
+    footer = metadata;
+    totalLines = Number(metadata[3]);
+  }
+  if (!rows.length) return null;
+  const startLine = rows[0].number;
+  const endLine = rows.at(-1).number;
+  if (footer && (Number(footer[1]) !== startLine || Number(footer[2]) !== endLine || totalLines < endLine)) return null;
+  return {
+    content: rows.map((row) => row.content).join('\n'),
+    ...(totalLines === undefined ? {} : { totalLines }),
+    startLine,
+    endLine,
+    truncated: totalLines === undefined || endLine < totalLines,
+  };
+}

package/src/runtime/shared/remote-intent.mjs

@@ -1,47 +1,7 @@
-// Durable channel-link record (channel-remote-intent.json), read-side.
-//
-// The daemon's channel transport OWNS this file (writes/clears it); everything
-// else only asks one question: "which session is pinned to the channel?".
-// That session reclaims its link on boot
-// instead of waiting for a manual toggle — the reconnect path that used to
-// look like the channel had silently unlinked itself.
-import { readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+// Path of the durable channel-link record (channel-remote-intent.json).
+import { join } from 'node:path';
 import { resolveRuntimeRoot } from './runtime-root.mjs';
 
 export function remoteIntentPath(root = resolveRuntimeRoot()) {
   return join(root, 'channel-remote-intent.json');
 }
-
-export function readRemoteIntent(path = remoteIntentPath()) {
-  try {
-    const value = JSON.parse(readFileSync(path, 'utf8'));
-    const sessionId = String(value?.sessionId || '').trim();
-    const transcriptPath = String(value?.transcriptPath || '').trim();
-    if (!/^[A-Za-z0-9_-]+$/.test(sessionId) || !transcriptPath) return null;
-    return {
-      sessionId,
-      transcriptPath,
-      cwd: value?.cwd == null ? null : String(value.cwd),
-    };
-  } catch {
-    return null;
-  }
-}
-
-// cwd is compared only when the record carries one: the intent is session
-// pinned, and a resumed session keeps its id across restarts.
-export function remoteIntentMatchesSession(sessionId, cwd = null, path = undefined) {
-  const id = String(sessionId || '').trim();
-  if (!id) return false;
-  const intent = readRemoteIntent(path);
-  if (!intent || intent.sessionId !== id) return false;
-  if (intent.cwd && cwd) {
-    try {
-      if (resolve(intent.cwd) !== resolve(cwd)) return false;
-    } catch {
-      return false;
-    }
-  }
-  return true;
-}

package/src/runtime/shared/slow-span.mjs

@@ -64,7 +64,14 @@ export function createSlowSpans({
     span.end = now();
     span.ms = span.end - span.start;
     if (span.ms >= minMs) {
-      ring.push({ label: span.label, start: span.start, end: span.end, ms: span.ms, phases: span.phases, size: span.size });
+      ring.push({
+        label: span.label,
+        start: span.start,
+        end: span.end,
+        ms: span.ms,
+        phases: span.phases,
+        size: span.size,
+      });
       if (ring.length > capacity) ring.shift();
     }
     if (span.ms >= slowMs) {

package/src/runtime/shared/statusline/statusline-segments.mjs

@@ -15,6 +15,11 @@ import { join } from 'node:path';
 import { formatElapsed } from './statusline-format.mjs';
 import { positiveInt } from '../numbers.mjs';
 import { isPidAlive } from '../pid-liveness.mjs';
+import { workspaceSees } from '../worktrees/workspace-visibility.mjs';
+
+/** Whether an orphaned held shell (`status.orphaned`) belongs in the list of a
+ *  session working in `sessionCwd`. */
+export const shellJobVisibleFrom = (job, sessionCwd) => workspaceSees(job?.cwd, sessionCwd);
 
 const DEFAULT_MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
 const DEFAULT_STANDALONE_DATA_DIR = join(DEFAULT_MIXDOG_HOME, 'data');
@@ -87,6 +92,12 @@ export function shellJobsStatus({ clientHostPid, sessionId } = {}) {
   return (scope && sessions?.[scope]) || EMPTY_SHELL_JOBS_SESSION;
 }
 
+/** Listed jobs held only because their termination is unconfirmed. */
+export function unconfirmedShellCount(status) {
+  const jobs = Array.isArray(status?.jobs) ? status.jobs : [];
+  return jobs.filter((job) => job?.terminationUnconfirmed === true).length;
+}
+
 // Awaited fresh scan for pollers that own their cadence (desktop): the result
 // reflects the disk at call time instead of the previous poll. The CLI render
 // path keeps using the cache-only shellJobsStatus.
@@ -171,6 +182,7 @@ async function refreshShellJobsStatus(ownerPid) {
     let count = 0;
     let oldestMs = Infinity;
     const jobs = [];
+    const orphaned = [];
     // sessionId -> { count, oldestMs, jobs }. Jobs with no session stamp (legacy
     // records, plain CLI runs) still count toward the owner total but belong to
     // no pane, so they never light up a session's indicator.
@@ -183,11 +195,16 @@ async function refreshShellJobsStatus(ownerPid) {
       } catch {
         continue;
       }
-      if (!(await isShellJobAlive(detail, p, dir, id))) continue;
+      // A killed command whose processes are not confirmed gone has already
+      // reported its result, so its tool card is closed: it is listed until
+      // its owner retires the record. Its root pid may be gone while a
+      // descendant lives, so the owner's liveness decides, not the root's.
+      const unconfirmed = detail?.terminationUnconfirmed === true;
+      if (unconfirmed ? !isPidAlive(ownerByJob.get(id) || 0) : !(await isShellJobAlive(detail, p, dir, id))) continue;
       // A foreground command is awaited in its own tool card; listing it here
       // made every short command flash in and out of the shell list. Only
       // backgrounded jobs (including promoted ones) are background work.
-      if (detail?.foreground === true) continue;
+      if (detail?.foreground === true && !unconfirmed) continue;
       // Owner-wide totals stay this process's own; session buckets take every
       // live job regardless of which host published it.
       const ownedByThisHost = ownerByJob.get(id) === ownerPid;
@@ -204,8 +221,12 @@ async function refreshShellJobsStatus(ownerPid) {
         command: String(detail?.command || '').trim(),
         cwd: String(detail?.cwd || '').trim(),
         startedAt: detail?.startedAt || (Number.isFinite(jobMs) ? jobMs : null),
+        ...(unconfirmed ? { terminationUnconfirmed: true } : {}),
       };
       if (ownedByThisHost) jobs.push(job);
+      // Held by a session that has closed: every session that sees its
+      // folder lists it (shellJobVisibleFrom), not only the closed owner.
+      if (unconfirmed && detail?.ownerSessionClosed === true) orphaned.push(job);
       if (!owner) continue;
       const bucket = bySession.get(owner) || { count: 0, oldestMs: Infinity, jobs: [], finished: [] };
       bucket.count += 1;
@@ -244,6 +265,7 @@ async function refreshShellJobsStatus(ownerPid) {
     // count stays 0 (its publisher is a shard, not this host), so an empty
     // aggregate must NOT discard the session buckets.
     if (count || bySession.size) value = summarizeShellJobs({ count, oldestMs, jobs, bySession });
+    if (orphaned.length) value = { ...value, orphaned };
   } catch {
     value = EMPTY_SHELL_JOBS;
   }

package/src/runtime/shared/tool-card-model/card-header.mjs

@@ -24,7 +24,8 @@ function headerLabel(base, surface, display, status, detail) {
   // Bridge load_tool describes definitions; it never loads a tool.
   const described =
     normalizedName === 'load_tool' && !headerPending ? bridgeDescribedToolNames(display.displayedResultText) : null;
-  if (described) return described.length ? `Described ${described.map(displayToolSearchTarget).join(', ')}` : 'Described';
+  if (described)
+    return described.length ? `Described ${described.map(displayToolSearchTarget).join(', ')}` : 'Described';
   return (
     (isAgentTool(normalizedName) ? agentActionTitle(parsedArgs, display.displayedResultText) : '') ||
     formatToolActionHeader(name, args, {

package/src/runtime/shared/tool-output-budget.mjs

@@ -0,0 +1,2 @@
+export const TOOL_OUTPUT_PAGE_BYTES = 8 * 1024;
+export const TOOL_OUTPUT_TAIL_BYTES = 12 * 1024;

package/src/runtime/shared/tool-result-summary.mjs

@@ -640,8 +640,22 @@ function summarizeAgentResult({ text, trimmed, translate }) {
 
 const summarizeGeneric = ({ text, translate }) => summarizeGenericResult(text, translate);
 
-const summarizeAskUserResult = ({ text }) => {
-  const answers = /^User has answered your questions:\s*(.*?)(?:\s*You can now continue with these answers in mind\.)?$/s.exec(String(text ?? '').trim());
+const summarizeAskUserResult = ({ text, translate }) => {
+  // A composer message answered: `User replied in chat: "<json>". ` then the
+  // picks sentence or only the closing one. Summarized as the reply itself.
+  const replied = /^User replied in chat: ("(?:[^"\\]|\\.)*")\. /s.exec(String(text ?? '').trim());
+  if (replied) {
+    let reply = '';
+    try {
+      reply = String(JSON.parse(replied[1]));
+    } catch {}
+    const label = translate('Answered in chat', 'Answered in chat', {});
+    return truncateSingleLine(reply ? `${label}: ${reply}` : label, AGENT_SURFACE_BRIEF_MAX);
+  }
+  const answers =
+    /^User has answered your questions:\s*(.*?)(?:\s*You can now continue with these answers in mind\.)?$/s.exec(
+      String(text ?? '').trim()
+    );
   return truncateSingleLine(answers ? answers[1] : String(text ?? '').trim(), AGENT_SURFACE_BRIEF_MAX) || null;
 };
 

package/src/runtime/shared/tool-status.mjs

@@ -49,9 +49,10 @@ export function isUserControlCancellation(text) {
 }
 
 // A non-zero exit the tool itself marked as a signal (search no-match, a
-// `git diff --exit-code` difference) rather than a command failure.
+// `git diff --exit-code` difference, a `git merge-tree` conflict report) rather
+// than a command failure.
 export function hasBenignExitOutcome(text) {
-  return /^\[outcome:\s*(?:no-match|no-change)\]\s*$/im.test(String(text || ''));
+  return /^\[outcome:\s*(?:no-match|no-change|conflicts)\]\s*$/im.test(String(text || ''));
 }
 
 // The status a task/bridge envelope reports in its leading block. A `<status>`

package/src/runtime/shared/tool-surface.mjs

@@ -452,9 +452,8 @@ function summarizeGithub(a, max) {
   const id = a.number ?? a.id;
   const hasId = id != null && String(id).trim() !== '';
   const title = truncateToolText(firstText(a.title, a.workflow, a.tag), Math.min(max, 60));
-  return hasId
-    ? compactParts([`${phrase} ${String(id).trim()}`, repo, title])
-    : compactParts([repo ? `${phrase} ${repo}` : phrase, title]);
+  if (hasId) return compactParts([`${phrase} ${String(id).trim()}`, repo, title]);
+  return compactParts([repo ? `${phrase} ${repo}` : phrase, title]);
 }
 
 export function formatToolSurface(name, args, opts = {}) {

package/src/runtime/shared/tool-work-units.mjs

@@ -344,12 +344,18 @@ function officeUnit(a) {
 
 function visualizeUnit(a) {
   const action = String(a.action || '').toLowerCase();
-  if (action === 'capture') return unitDescriptor('Visualize', { count: 1, active: 'Capturing', done: 'Captured', noun: 'screenshot' });
-  if (action === 'export') return unitDescriptor('Visualize', { count: 1, active: 'Exporting', done: 'Exported', noun: 'file' });
-  if (action === 'annotate') return unitDescriptor('Visualize', { count: 1, active: 'Marking', done: 'Marked', noun: 'annotation' });
-  if (action === 'check') return unitDescriptor('Visualize', { count: 1, active: 'Checking', done: 'Checked', noun: 'page' });
-  if (action === 'inspect') return unitDescriptor('Visualize', { count: 1, active: 'Inspecting', done: 'Inspected', noun: 'page' });
-  if (action === 'close') return unitDescriptor('Visualize', { count: 1, active: 'Closing', done: 'Closed', noun: 'tab' });
+  if (action === 'capture')
+    return unitDescriptor('Visualize', { count: 1, active: 'Capturing', done: 'Captured', noun: 'screenshot' });
+  if (action === 'export')
+    return unitDescriptor('Visualize', { count: 1, active: 'Exporting', done: 'Exported', noun: 'file' });
+  if (action === 'annotate')
+    return unitDescriptor('Visualize', { count: 1, active: 'Marking', done: 'Marked', noun: 'annotation' });
+  if (action === 'check')
+    return unitDescriptor('Visualize', { count: 1, active: 'Checking', done: 'Checked', noun: 'page' });
+  if (action === 'inspect')
+    return unitDescriptor('Visualize', { count: 1, active: 'Inspecting', done: 'Inspected', noun: 'page' });
+  if (action === 'close')
+    return unitDescriptor('Visualize', { count: 1, active: 'Closing', done: 'Closed', noun: 'tab' });
   return unitDescriptor('Visualize', { count: 1, active: 'Showing', done: 'Showed', noun: 'artifact' });
 }
 
@@ -592,14 +598,10 @@ function cwdUnit(a) {
   }
   if (action === 'favorite' || action === 'archive') {
     const off = a.value === false;
-    const [active, done] =
-      action === 'favorite'
-        ? off
-          ? ['Unfavoriting', 'Unfavorited']
-          : ['Favoriting', 'Favorited']
-        : off
-          ? ['Unarchiving', 'Unarchived']
-          : ['Archiving', 'Archived'];
+    let words;
+    if (action === 'favorite') words = off ? ['Unfavoriting', 'Unfavorited'] : ['Favoriting', 'Favorited'];
+    else words = off ? ['Unarchiving', 'Unarchived'] : ['Archiving', 'Archived'];
+    const [active, done] = words;
     return unitDescriptor('Setup', { active, done, noun: 'session', effect: true });
   }
   if (action.endsWith('-worktree') || action.endsWith('-worktrees')) {
@@ -613,7 +615,12 @@ function cwdUnit(a) {
   if (action === 'status') {
     return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'session' });
   }
-  return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'working directory', pluralNoun: 'working directories' });
+  return unitDescriptor('Setup', {
+    active: 'Checking',
+    done: 'Checked',
+    noun: 'working directory',
+    pluralNoun: 'working directories',
+  });
 }
 
 const TOOL_UNITS = new Map([

package/src/runtime/shared/transcript-metadata.mjs

@@ -21,6 +21,37 @@ export function createTranscriptRouteMetadata(session, route = {}, at = Date.now
   return { at, ...transcriptRouteMetadataFields({ modelId, model, provider, agent }) };
 }
 
+const ATTACHMENT_ID = /^[a-f0-9]{64}$/;
+const ATTACHMENT_KINDS = new Set(['image', 'file', 'text']);
+
+/**
+ * The attachments a user message carries (`meta.transcript.attachments`):
+ * `[{ id, attachmentRef, kind, name, mimeType, size }]`, the id being the
+ * content hash under which the attachment store keeps the bytes. Anything that
+ * is not a well-formed record is dropped, so a row never names an id the store
+ * could not hold. Each record repeats the hash under `attachmentRef` — the
+ * key the store's census marks as referenced.
+ */
+export function normalizeMessageAttachments(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const raw of value) {
+    const id = typeof raw?.id === 'string' ? raw.id : '';
+    if (!ATTACHMENT_ID.test(id) || seen.has(id) || out.length >= 64) continue;
+    seen.add(id);
+    out.push({
+      id,
+      attachmentRef: id,
+      kind: ATTACHMENT_KINDS.has(raw.kind) ? raw.kind : 'file',
+      name: String(raw.name || 'attachment').slice(0, 200),
+      mimeType: String(raw.mimeType || 'application/octet-stream').slice(0, 100),
+      size: Number.isFinite(Number(raw.size)) && Number(raw.size) >= 0 ? Number(raw.size) : 0,
+    });
+  }
+  return out;
+}
+
 /** A new stable message id (`meta.transcript.messageId`). */
 export function newTranscriptMessageId() {
   return `msg_${globalThis.crypto.randomUUID().replaceAll('-', '')}`;
@@ -36,6 +67,7 @@ export function persistedUserTranscriptMetadata(value) {
   if (!value || typeof value !== 'object') return null;
   return {
     messageId: stableMessageId(value.messageId),
+    ...(typeof value.attemptId === 'string' && value.attemptId ? { attemptId: value.attemptId } : {}),
     ...(Number.isFinite(Number(value.at)) ? { at: Number(value.at) } : {}),
     ...transcriptRouteMetadataFields(value),
     ...(typeof value.sender === 'string' && value.sender ? { sender: value.sender } : {}),
@@ -44,14 +76,30 @@ export function persistedUserTranscriptMetadata(value) {
     // The turn's change-record key (the outer prompt id), so a restored user
     // row still addresses its turn's Undo/Reapply.
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    ...attachmentsField(value.attachments),
   };
 }
 
+function attachmentsField(value) {
+  const attachments = normalizeMessageAttachments(value);
+  return attachments.length ? { attachments } : {};
+}
+
+/** The `attachments` field of a transcript row (absent when there are none). */
+export function transcriptAttachmentFields(value) {
+  return attachmentsField(value?.attachments);
+}
+
 export function persistedAssistantTranscriptMetadata(value, fallbackAt = Date.now()) {
   if (!value || typeof value !== 'object') return null;
   const candidateAt = Number(value.assistantAt);
   const assistantAt = Number.isFinite(candidateAt) && candidateAt > 0 ? candidateAt : fallbackAt;
   value.assistantAt = assistantAt;
   value.assistantMessageId = stableMessageId(value.assistantMessageId);
-  return { messageId: value.assistantMessageId, at: assistantAt, ...transcriptRouteMetadataFields(value) };
+  return {
+    messageId: value.assistantMessageId,
+    at: assistantAt,
+    ...(typeof value.attemptId === 'string' && value.attemptId ? { attemptId: value.attemptId } : {}),
+    ...transcriptRouteMetadataFields(value),
+  };
 }