mixdog 0.9.174 → 1.0.0

package/src/tui/components/prompt-input/key-handler.mjs

@@ -0,0 +1,364 @@
+/*
+ * components/prompt-input/key-handler.mjs — the PromptInput useInput handler.
+ *
+ * createPromptKeyHandler(ctx) closes over the component's per-render draft
+ * helpers and callbacks and returns the (input, key) handler; PromptInput
+ * passes it straight to ink's useInput. Escape policy lives in escape-key.mjs
+ * and the edit chords shared with TextEntryPanel in edit-chords.mjs.
+ */
+import {
+  clearSelection,
+  lineEnd,
+  lineStart,
+  moveCursor,
+  nextWordOffset,
+  previousWordOffset,
+  replaceSelection,
+} from '../../input-editing.mjs';
+import { applyEditChord } from './edit-chords.mjs';
+import {
+  insertText,
+  isModifiedEnterSequence,
+  isAnyModifiedEnterSequence,
+  leftArrowOffset,
+  rightArrowOffset,
+  singleTrailingLineBreakPrefix,
+} from './edit-helpers.mjs';
+import { handleEscapeKey } from './escape-key.mjs';
+import {
+  decodeArrowSignals,
+  isCsiPrivateReply,
+  isDiscardedControlInput,
+  isMouseReportSequence,
+  printableFromInput,
+} from './key-signals.mjs';
+import { paletteOwnsPromptVerticalArrow } from './restore-policy.mjs';
+
+// `suppressShiftNav` may be a predicate, a ref holding a predicate, or a ref
+// holding a flag; resolve it at event time.
+function gridSelectionActive(suppressShiftNavRef) {
+  if (typeof suppressShiftNavRef === 'function') return suppressShiftNavRef();
+  if (typeof suppressShiftNavRef?.current === 'function') return suppressShiftNavRef.current();
+  return Boolean(suppressShiftNavRef?.current);
+}
+
+export function createPromptKeyHandler(ctx) {
+  const {
+    disabled,
+    escapeClearAtRef,
+    suppressShiftNavRef,
+    draftRef,
+    commitDraft,
+    updateDraft,
+    handleExternalPaste,
+    submitEnterChunk,
+    submitDraft,
+    commandPaletteActive,
+    commandPaletteOptionCount,
+    onCommandPaletteNavigate,
+    onCommandPaletteAccept,
+    onCommandPaletteComplete,
+    onTab,
+    hasQueuedMessages,
+    moveDraftVertically,
+    restoreQueuedToDraft,
+    applyHistoryNavigation,
+    undoStack,
+  } = ctx;
+
+  return (input, key) => {
+    if (disabled) return;
+
+    const rawInput = String(input ?? '');
+    const inputKey = rawInput.toLowerCase();
+    if (!key.escape) escapeClearAtRef.current = 0;
+    // Arrow / shift / ctrl+shift decode: prompt-input/key-signals.mjs.
+    const {
+      ctrlShiftHeld,
+      rawCtrlShiftDown,
+      rawCtrlShiftLeft,
+      rawCtrlShiftRight,
+      rawCtrlShiftUp,
+      rawDownArrow,
+      rawShiftArrowForGrid,
+      rawShiftDown,
+      rawShiftLeft,
+      rawShiftRight,
+      rawShiftUp,
+      rawUpArrow,
+      shiftHeld,
+    } = decodeArrowSignals(rawInput, key);
+
+    // App owns Shift+Arrow when a transcript/status ink-grid selection is live.
+    // Because the parent (App) useInput handler fires AFTER this child handler
+    // for the same event, a flag SET in App's handler is always one event stale.
+    // Instead call a synchronous predicate derived from dragRef at event time.
+    if (gridSelectionActive(suppressShiftNavRef)) {
+      const isShiftArrow =
+        key.shift && (key.leftArrow || key.rightArrow || key.upArrow || key.downArrow || key.home || key.end);
+      if (isShiftArrow || rawShiftArrowForGrid) return;
+    }
+
+    // Terminal reports are not text: drop SGR mouse sequences and CSI-private
+    // replies before anything can type them into the prompt
+    // (prompt-input/key-signals.mjs).
+    if (isMouseReportSequence(rawInput)) {
+      return;
+    }
+    if (isCsiPrivateReply(rawInput)) {
+      return;
+    }
+
+    const lineBreakIndex = rawInput.search(/[\r\n]/);
+    const rawEnter = rawInput === '\r' || rawInput === '\n' || rawInput === '\r\n';
+    const trailingEnterPrefix = singleTrailingLineBreakPrefix(rawInput);
+    const rawModifiedEnter = isModifiedEnterSequence(rawInput);
+    const modifiedLineBreak = key.shift || key.meta || key.ctrl || rawModifiedEnter;
+
+    // Ctrl+J is the protocol-INDEPENDENT newline that works on every terminal.
+    //  • Legacy / modifyOtherKeys terminals: Ctrl+J is a lone '\n' (0x0A). A real
+    //    Enter is CR, which ink marks key.return (name 'return'); a lone '\n'
+    //    arrives as name 'enter' with key.return false. A multi-char paste that
+    //    contains '\n' is length > 1 (handled by the paste paths below).
+    //  • Kitty protocol active: Ctrl+J arrives as \x1b[106;5u, which ink decodes
+    //    to input 'j' with key.ctrl set.
+    // Either way → insert a newline. This MUST run before the trailing-newline/
+    // submit paths, since singleTrailingLineBreakPrefix('\n') returns '' (not
+    // null) and would otherwise route a bare Ctrl+J to submit.
+    if ((rawInput === '\n' && !key.return) || (key.ctrl && inputKey === 'j')) {
+      updateDraft((d) => replaceSelection(d, '\n'));
+      return;
+    }
+
+    // Consume uncommon modified-Enter combinations outside the normal
+    // Shift/Alt/Ctrl newline set so raw CSI bytes never enter the prompt.
+    if (!rawModifiedEnter && isAnyModifiedEnterSequence(rawInput)) {
+      return;
+    }
+
+    // Legacy guard only. Bracketed paste is now buffered by the termio parser
+    // and routed on the 'paste' channel (handleExternalPaste via usePaste), so
+    // multi-line paste never reaches useInput here. This newline-sniffing branch
+    // remains a defensive fallback for terminals/paths that somehow deliver a
+    // multi-char newline chunk through 'input'; under normal bracketed paste it
+    // does not trigger (paste never reaches useInput).
+    const pasteFallback =
+      lineBreakIndex !== -1 && trailingEnterPrefix === null && !rawEnter && (rawInput.length > 1 || !key.return);
+    if (pasteFallback) {
+      handleExternalPaste(rawInput, { source: 'paste-fallback' });
+      return;
+    }
+
+    if (trailingEnterPrefix !== null) {
+      if (modifiedLineBreak) {
+        updateDraft((d) => insertText(d, `${trailingEnterPrefix}\n`));
+        return;
+      }
+      submitEnterChunk(trailingEnterPrefix);
+      return;
+    }
+
+    if (rawModifiedEnter) {
+      updateDraft((d) => replaceSelection(d, '\n'));
+      return;
+    }
+
+    if (!commandPaletteActive && (key.ctrl || key.meta) && inputKey === 'v') {
+      // Ctrl+V / Meta+V: read OS clipboard (text first, image fallback) — the
+      // empty text arg tags the shortcut path in handlePromptPaste.
+      handleExternalPaste('', { source: 'clipboard-shortcut' });
+      return;
+    }
+
+    if (key.return) {
+      if (modifiedLineBreak) {
+        updateDraft((d) => replaceSelection(d, '\n'));
+        return;
+      }
+
+      if (commandPaletteActive) {
+        const accepted = onCommandPaletteAccept?.(draftRef.current.value);
+        if (accepted !== false) {
+          commitDraft({ value: '', cursor: 0, selectionAnchor: null });
+        }
+        return;
+      }
+
+      const current = draftRef.current;
+      if (current.value[current.cursor - 1] === '\\') {
+        updateDraft((d) => ({
+          value: `${d.value.slice(0, d.cursor - 1)}\n${d.value.slice(d.cursor)}`,
+          cursor: d.cursor,
+          selectionAnchor: null,
+        }));
+        return;
+      }
+
+      submitDraft(current);
+      return;
+    }
+
+    // Ctrl+Shift+Left/Right → extend selection whole-word. Kept before the plain
+    // shift-arrow branches so the ctrl+shift chord never falls through to a
+    // char-wise extend. (Up/Down ctrl+shift extend to line-relative vertical
+    // move with extend — same as shift alone; handled in the vertical branch.)
+    if (ctrlShiftHeld && (rawCtrlShiftLeft || (key.ctrl && key.shift && key.leftArrow))) {
+      if (!commandPaletteActive) {
+        updateDraft((d) => moveCursor(d, previousWordOffset(d.value, d.cursor), { extend: true }));
+      }
+      return;
+    }
+    if (ctrlShiftHeld && (rawCtrlShiftRight || (key.ctrl && key.shift && key.rightArrow))) {
+      if (!commandPaletteActive) {
+        updateDraft((d) => moveCursor(d, nextWordOffset(d.value, d.cursor), { extend: true }));
+      }
+      return;
+    }
+
+    if (key.upArrow || rawUpArrow || rawShiftUp || rawCtrlShiftUp) {
+      if (commandPaletteActive && paletteOwnsPromptVerticalArrow(commandPaletteOptionCount)) {
+        onCommandPaletteNavigate?.(-1);
+      } else {
+        // A Shift-held Up is a SELECTION gesture, never history navigation:
+        // extend the selection up one visual line, and if already on the first
+        // line extend all the way to document start (offset 0). History
+        // navigation (restoreQueued / applyHistoryNavigation) MUST NOT fire.
+        if (shiftHeld) {
+          if (!moveDraftVertically(-1, { extend: true })) {
+            updateDraft((d) => moveCursor(d, 0, { extend: true }));
+          }
+        } else if (!moveDraftVertically(-1, { extend: false })) {
+          const emptyDraft = String(draftRef.current.value || '').length === 0;
+          if (!hasQueuedMessages || !restoreQueuedToDraft()) {
+            applyHistoryNavigation('up', { emptyDraft });
+          }
+        }
+      }
+      return;
+    }
+
+    if (key.downArrow || rawDownArrow || rawShiftDown || rawCtrlShiftDown) {
+      if (commandPaletteActive && paletteOwnsPromptVerticalArrow(commandPaletteOptionCount)) {
+        onCommandPaletteNavigate?.(1);
+      } else {
+        // Shift-held Down: extend selection down one line, or to document end
+        // (value.length) when already on the last line. Never history nav.
+        if (shiftHeld) {
+          if (!moveDraftVertically(1, { extend: true })) {
+            updateDraft((d) => moveCursor(d, d.value.length, { extend: true }));
+          }
+        } else if (!moveDraftVertically(1, { extend: false })) {
+          applyHistoryNavigation('down', { emptyDraft: String(draftRef.current.value || '').length === 0 });
+        }
+      }
+      return;
+    }
+
+    if (commandPaletteActive && key.pageUp) {
+      onCommandPaletteNavigate?.(-8);
+      return;
+    }
+
+    if (commandPaletteActive && key.pageDown) {
+      onCommandPaletteNavigate?.(8);
+      return;
+    }
+
+    if (commandPaletteActive && key.home) {
+      onCommandPaletteNavigate?.('home');
+      return;
+    }
+
+    if (commandPaletteActive && key.end) {
+      onCommandPaletteNavigate?.('end');
+      return;
+    }
+
+    if (key.tab) {
+      if (commandPaletteActive) {
+        const completed = onCommandPaletteComplete?.(draftRef.current.value);
+        if (typeof completed === 'string') {
+          commitDraft({ value: completed, cursor: completed.length, selectionAnchor: null });
+        }
+        return;
+      }
+      if (onTab?.(draftRef.current.value) === true) return;
+    }
+
+    if (key.escape) {
+      handleEscapeKey(ctx);
+      return;
+    }
+
+    if (key.leftArrow || rawShiftLeft) {
+      if (commandPaletteActive) {
+        onCommandPaletteNavigate?.('left');
+        return;
+      }
+      updateDraft((d) =>
+        moveCursor(d, leftArrowOffset(d, { word: key.ctrl || key.meta, extend: shiftHeld }), { extend: shiftHeld })
+      );
+      return;
+    }
+    if (key.rightArrow || rawShiftRight) {
+      if (commandPaletteActive) {
+        onCommandPaletteNavigate?.('right');
+        return;
+      }
+      updateDraft((d) =>
+        moveCursor(d, rightArrowOffset(d, { word: key.ctrl || key.meta, extend: shiftHeld }), { extend: shiftHeld })
+      );
+      return;
+    }
+    if (key.home) {
+      updateDraft((d) => moveCursor(d, lineStart(d.value, d.cursor), { extend: shiftHeld }));
+      return;
+    }
+    if (key.end) {
+      updateDraft((d) => moveCursor(d, lineEnd(d.value, d.cursor), { extend: shiftHeld }));
+      return;
+    }
+
+    // Undo / redo. Covered encodings:
+    //  • kitty protocol: ctrl+z → input 'z' + key.ctrl; ctrl+y → 'y' + key.ctrl;
+    //    ctrl+shift+z → 'z' + key.ctrl + key.shift (redo).
+    //  • legacy control bytes: Ctrl+Z is \x1a (SUB, 0x1A), Ctrl+Y is \x19 (EM,
+    //    0x19). ink may deliver these as raw input without key.ctrl on some
+    //    terminals, so match the byte directly too.
+    const isCtrlZ = (key.ctrl && inputKey === 'z') || rawInput === '\x1a';
+    const isCtrlY = (key.ctrl && inputKey === 'y') || rawInput === '\x19';
+    if (isCtrlZ && (key.shift || shiftHeld)) {
+      undoStack.redo();
+      return;
+    }
+    if (isCtrlZ) {
+      undoStack.undo();
+      return;
+    }
+    if (isCtrlY) {
+      undoStack.redo();
+      return;
+    }
+
+    // ctrl+a selects all like a normal text box; ctrl+e keeps readline line-end.
+    if (key.ctrl && inputKey === 'a') {
+      updateDraft((d) => (d.value ? { ...d, cursor: d.value.length, selectionAnchor: 0 } : clearSelection(d)));
+      return;
+    }
+    if (key.ctrl && inputKey === 'e') {
+      updateDraft((d) => moveCursor(d, lineEnd(d.value, d.cursor), { extend: key.shift }));
+      return;
+    }
+    if (applyEditChord(key, inputKey, updateDraft)) return;
+
+    // Printable input (ignore other control keys). The discarded Ctrl+Space
+    // encodings and the printable filter live in prompt-input/key-signals.mjs.
+    if (isDiscardedControlInput(rawInput)) {
+      return;
+    }
+    const printable = printableFromInput(rawInput);
+    if (printable && !key.ctrl && !key.meta) {
+      updateDraft((d) => insertText(d, printable));
+    }
+  };
+}

package/src/tui/components/status-line/boot-schedule.mjs

@@ -0,0 +1,83 @@
+/*
+ * components/status-line/boot-schedule.mjs — lazy statusline module loading, boot
+ * full-render timing/backoff and active-work detection for StatusLine.
+ */
+import { loadStatuslineModule, resetStatuslineModuleLoad } from '../statusline-module-loader.mjs';
+
+export { loadStatuslineModule, resetStatuslineModuleLoad };
+
+export const STATUSLINE_RENDER_DEBOUNCE_MS = 150;
+/** Background import of statusline.mjs before the +1000ms full-render tick. */
+const STATUSLINE_MODULE_PREWARM_DELAY_MS = 300;
+
+let statuslineModulePrewarmScheduled = false;
+
+export function scheduleStatuslineModulePrewarm() {
+  if (statuslineModulePrewarmScheduled) return;
+  statuslineModulePrewarmScheduled = true;
+  const timer = setTimeout(() => {
+    loadStatuslineModule().catch(() => {});
+  }, STATUSLINE_MODULE_PREWARM_DELAY_MS);
+  timer.unref?.();
+}
+
+const STATUSLINE_BOOT_FULL_DELAY_MS = 1000;
+const STATUSLINE_BOOT_FULL_DELAY_ACTIVE_MS = 2200;
+export const STATUSLINE_BOOT_FULL_RETRY_MS = 2000;
+const STATUSLINE_BOOT_FULL_RETRY_MAX_MS = 30000;
+export const STATUSLINE_REFRESH_MS = 2000;
+export const STATUSLINE_ACTIVE_REFRESH_MS = 500;
+
+export function isTerminalStatus(statusText) {
+  return /idle|done|complete|success|closed|error|fail|cancel|killed|timeout/.test(
+    String(statusText || '').toLowerCase()
+  );
+}
+
+function hasRunningStatuslineWorkers(agentWorkers = [], agentJobs = []) {
+  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
+    const tag = String(worker?.tag || worker?.agent || worker?.name || '').trim();
+    if (tag && !isTerminalStatus(worker?.stage || worker?.status)) return true;
+  }
+  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
+    if (/running/i.test(String(job?.status || job?.stage || ''))) return true;
+  }
+  return false;
+}
+
+function stripAnsi(text) {
+  return String(text || '').replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function hasActiveStatuslineTools(activeTools = null) {
+  if (!activeTools || typeof activeTools !== 'object') return false;
+  return Number(activeTools.web_search?.count) > 0;
+}
+
+export function hasActiveStatuslineWork(line, agentWorkers = [], agentJobs = [], activeTools = null) {
+  if (hasRunningStatuslineWorkers(agentWorkers, agentJobs) || hasActiveStatuslineTools(activeTools)) return true;
+  const plain = stripAnsi(line);
+  return /\bRunning \d+ (?:Agents?|Shells?)\b/.test(plain) || /\b(?:Exploring|Searching|Memory)\b/.test(plain);
+}
+
+// Milliseconds left before the boot full render may run (<= 0 once eligible);
+// the delay is longer while agents/shells/tools are active.
+export function bootFullRenderDelayRemainingMs(mountAtMs, line, agentWorkers = [], agentJobs = [], activeTools = null) {
+  const active = hasActiveStatuslineWork(line, agentWorkers, agentJobs, activeTools);
+  const delay = active ? STATUSLINE_BOOT_FULL_DELAY_ACTIVE_MS : STATUSLINE_BOOT_FULL_DELAY_MS;
+  return delay - (Date.now() - mountAtMs);
+}
+
+export function canAttemptBootFullRender(nextAttemptAtMs = 0) {
+  return Date.now() >= nextAttemptAtMs;
+}
+
+export function scheduleBootFullRetry(backoffMsRef, nextAttemptAtRef) {
+  resetStatuslineModuleLoad();
+  const nextBackoff = Math.min(
+    STATUSLINE_BOOT_FULL_RETRY_MAX_MS,
+    Math.max(STATUSLINE_BOOT_FULL_RETRY_MS, backoffMsRef.current * 2)
+  );
+  backoffMsRef.current = nextBackoff;
+  nextAttemptAtRef.current = Date.now() + nextBackoff;
+}

package/src/tui/components/status-line/local-line.mjs

@@ -0,0 +1,213 @@
+/*
+ * components/status-line/local-line.mjs — the instant-local statusline (L1/L2)
+ * built from store state, plus palette normalization for the full async line.
+ */
+import { rgbSgr } from '../../../runtime/shared/statusline/ansi.mjs';
+import { measuredContextUsage, contextMeasurementLabel } from '../../../runtime/shared/context-measurement.mjs';
+import { displayModelName, shortenModelName } from '../../../runtime/shared/model-display.mjs';
+import { theme } from '../../theme.mjs';
+import { normalizeStatuslineAnsi } from '../../statusline-ansi-bridge.mjs';
+// Cache-only synchronous read (never touches fs on the render path), so the
+// instant-local L2 can render the Shell segment itself instead of grafting it
+// out of the previous full line.
+import { shellJobsStatus } from '../../../runtime/shared/statusline/statusline-segments.mjs';
+import { formatElapsed, num, terminalColumns, timeMs } from '../../../runtime/shared/statusline/statusline-format.mjs';
+import { isTerminalStatus } from './boot-schedule.mjs';
+
+const RESET = '\x1b[0m';
+
+function ansiRgb(value, fallback) {
+  const match = /^rgb\((\d+),(\d+),(\d+)\)$/.exec(String(value || '').replace(/\s+/g, ''));
+  if (!match) return fallback;
+  return rgbSgr(match[1], match[2], match[3]);
+}
+
+// SGR escapes derived from the active theme. Resolved per call (not captured at
+// module load) so a live `/theme` switch re-tones the statusline on the next
+// render. `theme` is mutated in-place on switch.
+function statusColors() {
+  return {
+    STATUS: ansiRgb(theme.statusText, rgbSgr(198, 198, 198)),
+    SUBTLE: ansiRgb(theme.statusSubtle, rgbSgr(136, 136, 136)),
+    SUCCESS: ansiRgb(theme.success, rgbSgr(0, 170, 75)),
+    WARNING: ansiRgb(theme.warning, rgbSgr(255, 193, 7)),
+    ERROR: ansiRgb(theme.error, rgbSgr(220, 70, 88)),
+  };
+}
+
+function localContextPctDisplayLabel(ctxPct) {
+  const pct = Number(ctxPct);
+  if (!Number.isFinite(pct) || pct <= 0) return '0';
+  return String(Math.round(Math.min(100, pct) * 10) / 10);
+}
+
+function localContextSegmentFromPct(ctxPct, source = 'pending') {
+  const { SUBTLE, SUCCESS, WARNING, ERROR } = statusColors();
+  if (ctxPct == null) return `${SUBTLE}${contextMeasurementLabel(source)}${RESET}`;
+  const cols = terminalColumns();
+  const cells = cols >= 80 ? 14 : 0;
+  const raw = Number(ctxPct);
+  const pct = Number.isFinite(raw) ? Math.max(0, raw) : 0;
+  const barPct = Math.max(0, Math.min(100, pct));
+  let fill = SUCCESS;
+  if (pct >= 90) fill = ERROR;
+  else if (pct >= 70) fill = WARNING;
+  const label = localContextPctDisplayLabel(pct);
+  if (!cells) return `${fill}${label}%${RESET}`;
+  let filled = Math.floor((barPct * cells) / 100);
+  if (barPct >= 1 && filled === 0) filled = 1;
+  filled = Math.max(0, Math.min(cells, filled));
+  const bar = '▓'.repeat(filled) + '░'.repeat(cells - filled);
+  const filledBar = bar.replace(/░/g, '');
+  const emptyBar = bar.replace(/▓/g, '');
+  return `${fill}${filledBar}${RESET}${SUBTLE}${emptyBar}${RESET} ${label}%`;
+}
+
+const LOCAL_WORKER_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+// L2 segment spinner reuses the original worker dot glyphs (no separate glyph
+// list) but spins them at 120ms instead of the worker spinner's 160ms. Mirrors
+// statusline.mjs l2SpinnerFrame()/L2_SPINNER_FRAME_MS so instant-local and full
+// render stay in sync (no flicker).
+const LOCAL_L2_SPINNER_FRAME_MS = 120;
+
+function localL2SpinnerFrame(now = Date.now()) {
+  const index = Math.floor(now / LOCAL_L2_SPINNER_FRAME_MS) % LOCAL_WORKER_SPINNER_FRAMES.length;
+  return LOCAL_WORKER_SPINNER_FRAMES[index] || LOCAL_WORKER_SPINNER_FRAMES[0];
+}
+
+function localRunningWorkerCount(agentWorkers = [], agentJobs = []) {
+  const seen = new Set();
+  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
+    const tag = String(worker?.tag || worker?.agent || worker?.name || '').trim();
+    if (!tag || isTerminalStatus(worker?.stage || worker?.status)) continue;
+    seen.add(tag);
+  }
+  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
+    if (!/running/i.test(String(job?.status || job?.stage || ''))) continue;
+    const tag = String(job?.tag || job?.agent || job?.type || job?.task_id || job?.taskId || '').trim();
+    if (!tag) continue;
+    seen.add(tag);
+  }
+  return seen.size;
+}
+
+// Oldest running worker/job start time, for the Agents segment elapsed. Mirrors
+// the async path which derives elapsed from the oldest running worker.
+function localOldestWorkerStartMs(agentWorkers = [], agentJobs = []) {
+  let oldest = Infinity;
+  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
+    if (isTerminalStatus(worker?.stage || worker?.status)) continue;
+    const t = timeMs(worker?.startedAt || worker?.startTime || worker?.createdAt);
+    if (t > 0 && t < oldest) oldest = t;
+  }
+  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
+    if (!/running/i.test(String(job?.status || job?.stage || ''))) continue;
+    const t = timeMs(job?.startedAt);
+    if (t > 0 && t < oldest) oldest = t;
+  }
+  return Number.isFinite(oldest) ? oldest : 0;
+}
+
+// L2 assembly only — themed SGR (statusColors SUCCESS/STATUS/SUBTLE), already in
+// the active palette, so this must NOT be passed through normalizeStatusLine.
+// Returns the joined L2 string or '' when no active segment. Order:
+// Agents → Shells → Web Searching. shellJobsStatus() is a cache-only
+// synchronous read (its refresh runs in the background, never on the render
+// path), so the shell count is computed here directly instead of being grafted
+// out of the previously cached full line.
+export function localStatusLineL2(
+  { agentWorkers = [], agentJobs = [], activeTools = null, sessionId = '', clientHostPid = 0 } = {},
+  now = Date.now()
+) {
+  const { STATUS, SUBTLE, SUCCESS } = statusColors();
+  const spin = `${SUCCESS}${localL2SpinnerFrame(now)}${RESET}`;
+  const segSep = ` ${SUBTLE}│${RESET} `;
+  const elapsedSuffix = (label) => (label ? ` ${SUBTLE}·${RESET} ${label}` : '');
+  const l2Parts = [];
+  const runningCount = localRunningWorkerCount(agentWorkers, agentJobs);
+  if (runningCount > 0) {
+    const label = `Running ${runningCount} Agent${runningCount === 1 ? '' : 's'}`;
+    const oldestStart = localOldestWorkerStartMs(agentWorkers, agentJobs);
+    const elapsed = oldestStart > 0 ? formatElapsed(now - oldestStart) : '';
+    l2Parts.push(`${spin} ${STATUS}${label}${RESET}${elapsedSuffix(elapsed)}`);
+  }
+  // Session-scoped like the full path: one host process owns many sessions'
+  // jobs, so an owner-wide aggregate would light up every other pane.
+  const shellScope = String(sessionId ?? '').trim();
+  const shellStatus = shellScope
+    ? shellJobsStatus({ clientHostPid, sessionId: shellScope })
+    : shellJobsStatus({ clientHostPid });
+  const shellCount = Number(shellStatus?.count) || 0;
+  if (shellCount > 0) {
+    const label = `Running ${shellCount} Shell${shellCount === 1 ? '' : 's'}`;
+    l2Parts.push(`${spin} ${STATUS}${label}${RESET}${elapsedSuffix(shellStatus.elapsedLabel || '')}`);
+  }
+  // `web_search` is the key the producers publish (session/active-tool-summary
+  // and app/use-transcript-activity); the async full render reads the same key,
+  // so both paths light the segment on the same snapshot.
+  const tools = activeTools && typeof activeTools === 'object' ? activeTools : {};
+  const searchInfo = tools.web_search || null;
+  if (searchInfo && num(searchInfo.count) > 0) {
+    const elapsed = num(searchInfo.startedAt) > 0 ? formatElapsed(now - num(searchInfo.startedAt)) : '';
+    l2Parts.push(`${spin} ${STATUS}Web Searching${RESET}${elapsedSuffix(elapsed)}`);
+  }
+  return l2Parts.length ? l2Parts.join(segSep) : '';
+}
+
+export function localBootStatusLine(args = {}) {
+  const {
+    provider = '',
+    model = '',
+    effort = '',
+    fast = false,
+    stats = null,
+    contextWindow = 0,
+    displayContextWindow = 0,
+    rawContextWindow = 0,
+  } = args;
+  const raw = String(model || '').trim();
+  const { STATUS, SUBTLE } = statusColors();
+  const display = shortenModelName(displayModelName(raw, provider, ''), terminalColumns());
+  const flags = [effort ? String(effort).toUpperCase() : '', fast === true ? 'FAST' : ''].filter(Boolean);
+  const modelBits = [display, ...flags].join(` ${SUBTLE}·${RESET} `);
+  const ctxPct = measuredContextUsage({
+    stats,
+    contextWindow,
+    displayContextWindow,
+    rawContextWindow,
+  }).percent;
+  const l1 = `${STATUS}${modelBits}${RESET} ${SUBTLE}│${RESET} ${localContextSegmentFromPct(ctxPct, stats?.currentContextSource)}`;
+  const l2 = localStatusLineL2(args);
+  return l2 ? `${l1}\n${l2}` : l1;
+}
+
+export function normalizeStatusLine(text) {
+  return normalizeStatuslineAnsi(text, statusColors(), { reset: RESET });
+}
+
+export function workflowModeLabel(workflow = {}) {
+  const name = String(workflow?.name || workflow?.id || 'Default').trim() || 'Default';
+  return `${name} Mode`;
+}
+
+// Local line shown while the async full render is not yet applicable. Keeps the
+// cached full line's L1 (usage segment preserved, re-toned via normalize) and
+// grafts a FRESH L2 from the CURRENT args so agent count/elapsed/web search are
+// never stale. The cached line is canonical-truecolor, so normalizeStatusLine
+// re-tones it; the fresh L2 is built with statusColors() (already themed) and
+// MUST NOT be double-normalized. Falls back to localBootStatusLine when there is
+// no cached line or it normalizes to empty (never emit a blank).
+export function buildLocalSnapLine(args, cachedRawLine) {
+  if (cachedRawLine) {
+    const cachedNormalized = normalizeStatusLine(cachedRawLine);
+    if (cachedNormalized) {
+      const [cachedL1] = cachedNormalized.split('\n');
+      // One shared `now` so every L2 spinner shows the SAME frame even across a
+      // 120ms frame boundary. The local L2 renders every segment itself (Agents
+      // → Shells → Web Search), so the cached L2 is discarded outright.
+      const freshL2 = localStatusLineL2(args, Date.now());
+      return freshL2 ? `${cachedL1}\n${freshL2}` : cachedL1;
+    }
+  }
+  return normalizeStatusLine(localBootStatusLine(args));
+}