elanous 0.2.28 → 0.2.31

package/src/dashboard/input/chat-main-entry-runtime.ts

@@ -14,6 +14,7 @@ export interface RunDashboardChatMainEntryDeps {
   promptFrame: PromptFrame;
   getPromptFrame?: () => PromptFrame;
   inputCols: number;
+  getInputCols: () => number;
   surfaceRegistry: SurfaceRegistry;
   invalidateRenderCacheRow: (row0: number) => void;
   buildPromptFrameDividerRows: (promptFrame: PromptFrame, divider: string) => Array<{ row: number; text: string }>;
@@ -61,6 +62,7 @@ export async function runDashboardChatMainEntry(
     promptFrame: deps.promptFrame,
     getPromptFrame,
     inputCols: deps.inputCols,
+    getInputCols: deps.getInputCols,
     surfaceRegistry: deps.surfaceRegistry,
     invalidateRenderCacheRow: deps.invalidateRenderCacheRow,
     buildPromptFrameDividerRows: deps.buildPromptFrameDividerRows,

package/src/dashboard/input/chat-main-log-actions.ts

@@ -12,6 +12,8 @@ export function dashboardLogHelpLines(): string[] {
     '  /log freeze                 Show scroll-freeze status + queued-line count.',
     '  /log turn <off|rule|time|both|now>  Insert/toggle between-turn separator (rule + optional clock).',
     '  /log fold <line|task-unit|kind-unit>  Set fold mode: line (budget), task-unit (tool headers), kind-unit (same-kind ops).',
+    '  /log unfold [all]           Expand every folded block now (same as /log fold off).',
+    '  /log fold all               Collapse every folded block back.',
     '  /log filter <query>         Filter visible log rows by substring.',
     '  /log filter clear           Clear the active visible-row filter.',
     '  /log search [query]         Open search modal (no query) or jump to first match.',
@@ -30,6 +32,8 @@ export function dashboardLogHelpLines(): string[] {
     '  s        Open in-pane search modal',
     '  n / Shift+N  Next / previous match (after a search)',
     '  Esc      Clear active search highlight',
+    '  f / F    Toggle the latest folded block / every folded block',
+    '  Ctrl+X f (anywhere, incl. input) toggles every folded block.',
     '  Ctrl+L   Clear log',
     '  Ctrl+\u2191/\u2193 (anywhere) also resizes; Ctrl+0 resets.',
   ];

package/src/dashboard/input/chat-main-log-command.ts

@@ -8,6 +8,7 @@ export type DashboardChatMainLogCommand =
   | { kind: 'solo' }
   | { kind: 'turn'; arg: string }
   | { kind: 'fold'; mode: string }
+  | { kind: 'fold-all'; expanded: boolean }
   | { kind: 'copy-all' }
   | { kind: 'return-to-input' }
   | { kind: 'unknown'; subcommand: string };
@@ -24,7 +25,17 @@ export function resolveDashboardChatMainLogCommand(
   if (sub === 'freeze') return { kind: 'freeze' };
   if (sub === 'solo' || sub === 'maximize' || sub === 'zoom') return { kind: 'solo' };
   if (sub === 'turn') return { kind: 'turn', arg: (args[1] ?? '').toLowerCase().trim() };
-  if (sub === 'fold') return { kind: 'fold', mode: (args[1] ?? '').toLowerCase().trim() };
+  if (sub === 'fold') {
+    const mode = (args[1] ?? '').toLowerCase().trim();
+    // #19 — bulk state, not a fold mode: `fold all` collapses every static fold, `fold off` opens them.
+    if (mode === 'all') return { kind: 'fold-all', expanded: false };
+    if (mode === 'off') return { kind: 'fold-all', expanded: true };
+    return { kind: 'fold', mode };
+  }
+  if (sub === 'unfold') {
+    const target = (args[1] ?? 'all').toLowerCase().trim();
+    return target === 'all' ? { kind: 'fold-all', expanded: true } : { kind: 'unknown', subcommand: `unfold ${target}` };
+  }
   if (sub === 'copy' || sub === 'all') return { kind: 'copy-all' };
   if (sub === 'input' || sub === 'return') return { kind: 'return-to-input' };
   return { kind: 'unknown', subcommand: sub };

package/src/dashboard/input/chat-main-plain-turn-runtime.ts

@@ -1,5 +1,6 @@
 import type { ThinkingHandle } from '../../thinking-line.js';
 import { debug, redactSecretText } from '../../debug/log.js';
+import { logTurnThrew } from '../turn-busy-teardown.js';
 import type { SubmitTurnIntent } from '../../input/input-intent.js';
 import type { InputSourceRef } from '../../input/input-source-kind.js';
 import { findRecentQuickPassSignal } from '../../input/turn-submit-revision.js';
@@ -8,6 +9,12 @@ import type { DashboardTurnBlockAttachLike } from '../turn-message-runtime.js';
 import type { DashboardAssistantRenderState } from '../turn-tail-runtime.js';
 import type { SearchPlannerState } from '../../session-runtime/index.js';
 import { runDashboardPlainTurnStream } from './dashboard-plain-turn-stream.js';
+import {
+  formatFailureNotice, matchFailureText, recordFailureSignatureMatch,
+} from '../../self-health/signatures.js';
+import { isUnknownCodex400, repairCodexToolPairs, restoreRepairedHistory } from './compact-prepass-recovery.js';
+import type { LLMMessage } from '../../llm.js';
+import { isTuiRouteLine } from '../../core-turn/short-question.js';
 
 export interface DashboardChatMainPlainTurnRuntimeDeps {
   userText: string;
@@ -75,11 +82,14 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
     preamble: unknown[];
     chatHistory: unknown[];
     userMsg: unknown;
+    onPrePassApplied: () => void;
   }) => Promise<void>;
+  /** Null means the server-side dispatch boundary cannot be observed. */
+  readToolDispatchCount?: () => number | null;
 
   attachChatStreamingKeys: (abortCtrl: AbortController) => () => void;
   /** ⭐ 관측 심 — 형제 `chat-main-entry-runtime` 과 «같은 형태»다(재발명 0 · `OBS-T124`). */
-  debugLog?: (category: string, event: string, payload: Record<string, unknown>) => void;
+  debugLog?: (category: string, event: string, payload: Record<string, unknown>, opts?: { level?: 'warn' }) => void;
   createOptionalSpecs: () => Promise<unknown[]>;
   createTurnStreamRuntime: (initialAssistantStart: number) => {
     onText(chunk: string, accumulated: string): void;
@@ -141,6 +151,8 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
   runActionEffects: (outcome: unknown) => Promise<void>;
   warningLine: (message: string) => string;
   pushErrorLine: (message: string) => void;
+  /** 실패 지문이 맞은 오류: 화면엔 한국어 처방 한 줄, 원문은 여기(`/detail`)로. 없으면 원문을 그대로 낸다. */
+  pushFailureNotice?: (notice: string, raw: string) => void;
   finalizeTurn: (status: 'completed' | 'interrupted' | 'failed', error?: string) => void;
 }
 
@@ -172,6 +184,7 @@ export async function runDashboardChatMainPlainTurn(
   const userText = deps.intent?.text ?? deps.userText;
 
   let cleanupEsc = () => {};
+  let stage = 'streaming-keys-attached';
 
   try {
     const abortCtrl = new AbortController();
@@ -202,7 +215,6 @@ export async function runDashboardChatMainPlainTurn(
         turnStartedAtIso,
       });
     } catch { /* fail-soft — 관측이 턴을 막지 않는다 */ }
-    let stage = 'streaming-keys-attached';
     const finishIfAborted = (): boolean => {
       if (!abortCtrl.signal.aborted) return false;
       finalStatus = 'interrupted';
@@ -237,6 +249,9 @@ export async function runDashboardChatMainPlainTurn(
       pushChatLine: deps.pushChatLine,
     });
     deps.chat.history.push(userMsg);
+    // Detect whether the pre-pass actually replaced history before considering
+    // a bounded pair repair. The copy is never replayed to the provider.
+    const beforeCompact = deps.chat.history.slice();
 
     await deps.beginCodeEditTurn(
       typeof userMsg.content === 'string' ? userMsg.content : '',
@@ -251,11 +266,15 @@ export async function runDashboardChatMainPlainTurn(
       userConfig,
     });
 
+    let prePassApplied = false;
     await deps.runAutoCompact({
       preamble,
       chatHistory: deps.chat.history,
       userMsg,
+      onPrePassApplied: () => { prePassApplied = true; },
     });
+    const compactChanged = prePassApplied && (deps.chat.history.length !== beforeCompact.length
+      || deps.chat.history.some((message, index) => message !== beforeCompact[index]));
     stage = 'runAutoCompact';
     if (finishIfAborted()) return;
 
@@ -316,10 +335,139 @@ export async function runDashboardChatMainPlainTurn(
         });
       } catch { /* fail-soft — 관측이 턴을 막지 않는다 */ }
     };
+    const recoverySend: typeof deps.acpSession = {
+      send: async (opts) => {
+        let lastError: unknown;
+        let pairReport: ReturnType<typeof repairCodexToolPairs> | null = null;
+        let inspectedHistory: string | null = null;
+        let initialAttemptEmitted = false;
+        let warned = false;
+        const manualRecovery = (reason: string): void => {
+          if (warned) return;
+          warned = true;
+          deps.debugLog?.('chat.compact-400-recovery', 'manual-recovery-required', {
+            reason, historyMessages: deps.chat.history.length,
+          });
+          deps.pushChatLine(deps.warningLine(
+            'Codex 400으로 자동 복구를 멈췄습니다. 대화 이력을 확인한 뒤 /session new 로 새 세션을 시작하세요.',
+          ));
+        };
+        const dispatchCountBeforeSend = deps.readToolDispatchCount?.() ?? null;
+        const attempt = async (stage: string): Promise<boolean> => {
+          let emitted = false;
+          try {
+            await deps.acpSession.send({
+              ...opts,
+              // 라우팅 줄은 브리지가 모델 호출 «전»에 보낸다 — 모델 출력이 아니므로 재시도를 막지 않는다.
+              onText: (chunk) => {
+                if (!isTuiRouteLine(chunk)) { emitted = true; if (stage === 'initial') initialAttemptEmitted = true; }
+                opts.onText(chunk);
+              },
+              onToolCall: (call) => { emitted = true; if (stage === 'initial') initialAttemptEmitted = true; opts.onToolCall(call); },
+              onToolResult: (call) => { emitted = true; if (stage === 'initial') initialAttemptEmitted = true; opts.onToolResult(call); },
+            });
+            deps.debugLog?.('chat.compact-400-recovery', 'recovered', { stage });
+            return true;
+          } catch (err) {
+            const dispatchCountNow = deps.readToolDispatchCount?.() ?? null;
+            const dispatchUnknown = dispatchCountBeforeSend === null || dispatchCountNow === null;
+            const toolDispatched = dispatchCountNow !== dispatchCountBeforeSend;
+            const unknown400 = isUnknownCodex400(selectDashboardChatErrorDetail(err), err);
+            if (unknown400 && compactChanged) {
+              if (!pairReport) {
+                pairReport = repairCodexToolPairs(deps.chat.history as LLMMessage[]);
+                try { inspectedHistory = JSON.stringify(deps.chat.history); } catch { /* unsafe to retry */ }
+                deps.debugLog?.('chat.compact-400-recovery', 'pair-check', {
+                  removedCalls: pairReport.removedCalls,
+                  removedResults: pairReport.removedResults,
+                  ambiguousCount: pairReport.ambiguousIds.length,
+                  readOnly: true,
+                });
+              }
+              deps.debugLog?.('chat.compact-400-recovery', 'codex-400-unknown', {
+                stage, historyMessages: deps.chat.history.length,
+                emitted, dispatchUnknown, toolDispatched,
+              });
+            }
+            if (emitted || dispatchUnknown || toolDispatched || abortCtrl.signal.aborted || !compactChanged
+              || !unknown400) {
+              if (stage === 'pair-repair') manualRecovery('pair-repair-failed');
+              else if (unknown400 && compactChanged) manualRecovery('unsafe-retry');
+              throw err;
+            }
+            lastError = err;
+            return false;
+          }
+        };
+        if (await attempt('initial')) return;
+
+        const repaired = pairReport!;
+        let historyUnchanged = false;
+        try {
+          historyUnchanged = inspectedHistory !== null
+            && JSON.stringify(deps.chat.history) === inspectedHistory;
+        } catch { /* unsafe to retry */ }
+        if (!historyUnchanged) {
+          deps.debugLog?.('chat.compact-400-recovery', 'history-changed-after-pair-check', {
+            historyMessages: deps.chat.history.length,
+          });
+          manualRecovery('history-changed-after-pair-check');
+          throw lastError;
+        }
+        if (repaired.ambiguousIds.length === 0 && repaired.removedCalls + repaired.removedResults > 0) {
+          let beforeRepairValues: typeof deps.chat.history;
+          let expectedRepairedValues: typeof repaired.messages;
+          try {
+            beforeRepairValues = structuredClone(deps.chat.history);
+            expectedRepairedValues = structuredClone(repaired.messages);
+          } catch {
+            manualRecovery('history-snapshot-unavailable');
+            throw lastError;
+          }
+          const dispatchCountBeforeRepair = deps.readToolDispatchCount?.() ?? null;
+          let historyStillInspected = false;
+          try {
+            historyStillInspected = inspectedHistory !== null
+              && JSON.stringify(deps.chat.history) === inspectedHistory;
+          } catch { /* unsafe to retry */ }
+          if (dispatchCountBeforeSend === null || dispatchCountBeforeRepair === null
+            || dispatchCountBeforeRepair !== dispatchCountBeforeSend
+            || initialAttemptEmitted || abortCtrl.signal.aborted || !historyStillInspected) {
+            deps.debugLog?.('chat.compact-400-recovery', 'retry-gate-changed', {
+              dispatchUnknown: dispatchCountBeforeSend === null || dispatchCountBeforeRepair === null,
+              toolDispatched: dispatchCountBeforeRepair !== dispatchCountBeforeSend,
+              emitted: initialAttemptEmitted,
+              aborted: abortCtrl.signal.aborted,
+              historyChanged: !historyStillInspected,
+            });
+            manualRecovery('retry-gate-changed');
+            throw lastError;
+          }
+          deps.chat.history.splice(0, deps.chat.history.length, ...repaired.messages);
+          let recovered = false;
+          try {
+            recovered = await attempt('pair-repair');
+            if (recovered) return;
+          } finally {
+            if (!recovered) {
+              const restoration = restoreRepairedHistory(
+                deps.chat.history, beforeRepairValues, repaired.messages, expectedRepairedValues,
+              );
+              deps.debugLog?.('chat.compact-400-recovery', restoration.restored
+                ? 'history-restored' : 'history-restore-skipped', restoration);
+            }
+          }
+        }
+
+        manualRecovery(repaired.ambiguousIds.length > 0 ? 'ambiguous-tool-pairing'
+          : repaired.removedCalls + repaired.removedResults > 0 ? 'pair-repair-failed' : 'no-orphan-pairs');
+        throw lastError;
+      },
+    };
     const streamResult = await runDashboardPlainTurnStream({
       userText,
       abortCtrl,
-      acpSession: deps.acpSession,
+      acpSession: recoverySend,
       onText: (chunk, accumulated) => {
         logFirstToken(chunk);
         turnStreamRuntime.onText(chunk, accumulated);
@@ -398,11 +546,35 @@ export async function runDashboardChatMainPlainTurn(
   } catch (err: any) {
     finalStatus = 'failed';
     const detail = selectDashboardChatErrorDetail(err);
+    const stackHead = typeof err?.stack === 'string'
+      ? err.stack.split('\n').slice(0, 4).join('\n')
+      : undefined;
+    deps.debugLog?.('chat-main.plain-turn', 'turn-failed', {
+      stage,
+      message: redactSecretText(detail),
+      stackHead: stackHead === undefined ? undefined : redactSecretText(stackHead),
+    });
+    // TUI-STALE-BUSY-MARKER(#58) — 턴 본문 실패도 tui 범주 한 곳(`tui.turn turn-threw`)에서 보인다.
+    logTurnThrew(`turn:${stage}`, err, deps.debugLog);
     const firstLine = detail.split(/\r?\n/, 1)[0]?.trim() ?? '';
     finalError = detail === ''
       ? err?.message || String(err)
       : firstLine.length > 80 ? `${firstLine.slice(0, 80)}…` : firstLine;
-    deps.pushErrorLine(detail);
+    const failure = deps.pushFailureNotice ? matchFailureText(detail) : null;
+    if (failure && deps.pushFailureNotice) {
+      recordFailureSignatureMatch(failure, 'turn-error');
+      finalError = failure.cause;
+      deps.pushFailureNotice(formatFailureNotice(failure, { rawHint: '/detail open' }), detail);
+    } else {
+      deps.pushErrorLine(detail);
+    }
+    // ⛔ #27452 400 복구 판정은 «원문» detail 로 — 지문 번역(finalError)으로 판정하면 복구가 안 걸린다.
+    if (isUnknownCodex400(detail)) {
+      // The normal finalizer also stops it, but freezing here closes the
+      // failure path even if an outer render callback throws afterward.
+      deps.thinking.stop({ status: 'failed', errorText: finalError });
+      deps.debugLog?.('chat.compact-400-recovery', 'thinking-stopped', { status: 'failed' });
+    }
   } finally {
     try {
       cleanupEsc();

package/src/dashboard/input/chat-main-session.ts

@@ -1,11 +1,12 @@
 import type { PromptFrame } from '../../display/prompt-frame.js';
-import { hLine, ansi } from '../../tui.js';
+import { hLine, ansi, renderCacheRowIs } from '../../tui.js';
 import type { SurfaceRegistry } from '../../surface/index.js';
 
 export interface ChatMainInputSession {
   inputRow: number;
   getInputRow: () => number;
   inputWidth: number;
+  getInputWidth: () => number;
   paintChrome: () => void;
   shouldPaint: () => boolean;
   register: () => void;
@@ -16,8 +17,11 @@ export interface CreateChatMainInputSessionDeps {
   promptFrame: PromptFrame;
   getPromptFrame?: () => PromptFrame;
   inputCols: number;
+  getInputCols?: () => number;
   surfaceRegistry: SurfaceRegistry;
   invalidateRenderCacheRow: (row0: number) => void;
+  /** Frame-cache probe (0-based row). Defaults to the live render cache. */
+  renderCacheRowIs?: (row0: number, text: string) => boolean;
   buildPromptFrameDividerRows: (promptFrame: PromptFrame, divider: string) => Array<{ row: number; text: string }>;
   shouldPaint: () => boolean;
   debugLog?: (event: string, label: string, payload: Record<string, unknown>) => void;
@@ -36,10 +40,16 @@ export function createChatMainInputSession(
   // of the full-width divider, which reads like the border width
   // flickered when slash/search pickers appear.
   const inputWidth = deps.inputCols;
+  const getInputWidth = (): number => deps.getInputCols?.() ?? inputWidth;
 
+  const cacheRowIs = deps.renderCacheRowIs ?? renderCacheRowIs;
   const paintChrome = () => {
-    const divider = hLine(deps.inputCols);
+    const divider = hLine(getInputWidth());
     for (const row of deps.buildPromptFrameDividerRows(getPromptFrame(), divider)) {
+      // The frame renderer already painted this exact divider — rewriting
+      // it (and dirtying the cache) only re-erases a settled row every
+      // repaint (RESEARCH-tui-bottom-flicker-2026-10-14 §3).
+      if (cacheRowIs(row.row - 1, row.text)) continue;
       deps.invalidateRenderCacheRow(row.row - 1);
       process.stdout.write(ansi.moveTo(row.row, 1) + '\x1b[2K' + row.text);
     }
@@ -57,7 +67,7 @@ export function createChatMainInputSession(
     deps.debugLog?.('input.surface.register', 'chat-main', {
       inputId: 'chat-main',
       row: getInputRow(),
-      width: inputWidth,
+      width: getInputWidth(),
     });
   };
 
@@ -70,6 +80,7 @@ export function createChatMainInputSession(
     inputRow,
     getInputRow,
     inputWidth,
+    getInputWidth,
     paintChrome,
     shouldPaint,
     register,

package/src/dashboard/input/chat-main-slash-command.ts

@@ -10,6 +10,13 @@ export function resolveDashboardChatMainSlashCommand(
   let cmdLower = cmd?.toLowerCase() ?? '';
   let args: string[] = rawArgs.filter(Boolean);
 
+  // A terminal command is shell text: splitting and joining its words would
+  // collapse whitespace inside quotes (for example `sh -c 'echo a  b'`).
+  if ((cmdLower === 'term' || cmdLower === 'terminal') && args[0]?.toLowerCase() === 'new') {
+    const command = /^\S+\s+\S+(?:\s+([\s\S]*))?$/.exec(commandText.slice(1))?.[1];
+    args = command === undefined ? ['new'] : ['new', command];
+  }
+
   // Top-level alias: `/resume <id>` → `/session load <id>`.
   // Reuses the existing /session subcommand handler so the resume
   // flow stays in one place.

package/src/dashboard/input/chat-main-turn.ts

@@ -1,10 +1,10 @@
 import { textInput, type InputResult } from '../../chat/index.js';
-import { ansi, resetRenderCache } from '../../tui.js';
+import { ansi, invalidateRenderCacheRow } from '../../tui.js';
 import type { ChatMainInputSession } from './chat-main-session.js';
 
 export type ChatMainTextInputBaseOpts = Omit<
   Parameters<typeof textInput>[0],
-  'row' | 'getRow' | 'col' | 'width' | 'prompt' | 'maxLines' | 'initialText' | 'history' | 'onPaintChrome' | 'shouldPaint' | 'placeholder' | 'preferHistoryArrowKeys'
+  'row' | 'getRow' | 'col' | 'width' | 'getWidth' | 'prompt' | 'maxLines' | 'initialText' | 'history' | 'onPaintChrome' | 'shouldPaint' | 'placeholder' | 'preferHistoryArrowKeys'
 >;
 
 export interface RunChatMainInputTurnDeps {
@@ -24,6 +24,7 @@ export function buildChatMainTextInputRequest(
     getRow: deps.session.getInputRow,
     col: 1,
     width: deps.session.inputWidth,
+    getWidth: deps.session.getInputWidth,
     prompt: '\u276f ',
     maxLines: 8,
     onPaintChrome: deps.session.paintChrome,
@@ -36,11 +37,20 @@ export function buildChatMainTextInputRequest(
   };
 }
 
+/** Turn-entry prompt erase. Only the prompt row is erased, so only it
+ *  leaves the frame cache. A full resetRenderCache() here made the draw
+ *  already queued for this turn boundary take the force path — a
+ *  whole-screen `\x1b[J` outside synchronized output
+ *  (RESEARCH-tui-bottom-flicker-2026-10-14 §4(f)). */
+export function beginChatMainInputTurnPaint(inputRow: number): string {
+  invalidateRenderCacheRow(inputRow - 1);
+  return ansi.moveTo(inputRow, 1) + '\x1b[2K';
+}
+
 export async function runChatMainInputTurn(
   deps: RunChatMainInputTurnDeps,
 ): Promise<InputResult> {
-  resetRenderCache();
-  process.stdout.write(ansi.moveTo(deps.session.getInputRow(), 1) + '\x1b[2K');
+  process.stdout.write(beginChatMainInputTurnPaint(deps.session.getInputRow()));
   deps.session.register();
   try {
     return await textInput(buildChatMainTextInputRequest(deps));

package/src/dashboard/input/compact-prepass-recovery.ts

@@ -0,0 +1,130 @@
+import type { ContentBlock, LLMMessage } from '../../llm.js';
+import { isDeepStrictEqual } from 'node:util';
+
+export function isUnknownCodex400(detail: string, error?: unknown): boolean {
+  if (error && typeof error === 'object' && 'status' in error && 'provider' in error
+    && error.status === 400 && error.provider === 'codex') return true;
+  return /\bCodex\s+API\s+400\b/i.test(detail.replace(/\s+/g, ' '));
+}
+
+/** The three recovery axes — persistent active session ID, ACP session ID, and in-memory history. */
+export interface PrepassRecoverySnapshotInput {
+  persistentActiveId: string;
+  acpId: string;
+  messages: readonly LLMMessage[];
+}
+
+export interface PrepassRecoverySnapshot {
+  persistentActiveId: string;
+  acpId: string;
+  messages: LLMMessage[];
+}
+
+/** Capture all three recovery axes into one immutable-by-convention deep snapshot. */
+export function capturePrepassRecoverySnapshot(input: PrepassRecoverySnapshotInput): PrepassRecoverySnapshot {
+  return {
+    persistentActiveId: input.persistentActiveId,
+    acpId: input.acpId,
+    messages: structuredClone([...input.messages]),
+  };
+}
+
+/** Restore a fresh, independently-mutable copy of all three axes; repeatable without aliasing. */
+export function restorePrepassRecoverySnapshot(
+  snapshot: PrepassRecoverySnapshot,
+): PrepassRecoverySnapshot {
+  return {
+    persistentActiveId: snapshot.persistentActiveId,
+    acpId: snapshot.acpId,
+    messages: structuredClone([...snapshot.messages]),
+  };
+}
+
+/** Restore only the repaired prefix, retaining messages appended during the retry. */
+export function restoreRepairedHistory<T>(
+  history: T[], originalValues: readonly T[], repaired: readonly T[], expectedRepairedValues: readonly T[],
+): { restored: boolean; preservedTail: number } {
+  if (history.length < repaired.length || repaired.some((message, index) => history[index] !== message)
+    || !isDeepStrictEqual(history.slice(0, repaired.length), expectedRepairedValues)) {
+    return { restored: false, preservedTail: Math.max(0, history.length - repaired.length) };
+  }
+  const preservedTail = history.length - repaired.length;
+  history.splice(0, repaired.length, ...originalValues);
+  return { restored: true, preservedTail };
+}
+
+/** Remove only protocol orphans; preserve every matched call/result and their order. */
+export function repairCodexToolPairs(messages: readonly LLMMessage[]): {
+  messages: LLMMessage[];
+  removedCalls: number;
+  removedResults: number;
+  ambiguousIds: string[];
+} {
+  const seenCalls = new Set<string>();
+  const seenResults = new Set<string>();
+  const ambiguousIds = new Set<string>();
+  for (const message of messages) {
+    if (!Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (block.type === 'tool_use' && block.id) {
+        if (seenCalls.has(block.id)) ambiguousIds.add(block.id);
+        seenCalls.add(block.id);
+      } else if (block.type === 'tool_result' && block.tool_use_id) {
+        if (seenResults.has(block.tool_use_id)) ambiguousIds.add(block.tool_use_id);
+        seenResults.add(block.tool_use_id);
+      }
+    }
+  }
+  // A repeated ID cannot be assigned to a unique call/result pair. Leave history intact.
+  if (ambiguousIds.size > 0) {
+    return { messages: [...messages], removedCalls: 0, removedResults: 0,
+      ambiguousIds: [...ambiguousIds] };
+  }
+  const pending = new Map<string, string>();
+  const completed = new Set<string>();
+  const dropped = new Set<string>();
+  let removedCalls = 0;
+  let removedResults = 0;
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const content = messages[messageIndex]!.content;
+    if (!Array.isArray(content)) continue;
+    for (let blockIndex = 0; blockIndex < content.length; blockIndex++) {
+      const block = content[blockIndex]!;
+      const key = `${messageIndex}:${blockIndex}`;
+      if (block.type === 'tool_use') {
+        if (!block.id || pending.has(block.id) || completed.has(block.id)) {
+          dropped.add(key);
+          removedCalls++;
+        } else {
+          pending.set(block.id, key);
+        }
+      } else if (block.type === 'tool_result') {
+        if (!pending.has(block.tool_use_id)) {
+          dropped.add(key);
+          removedResults++;
+        } else {
+          pending.delete(block.tool_use_id);
+          completed.add(block.tool_use_id);
+        }
+      }
+    }
+  }
+  for (const key of pending.values()) {
+    dropped.add(key);
+    removedCalls++;
+  }
+  if (dropped.size === 0) return { messages: [...messages], removedCalls, removedResults, ambiguousIds: [] };
+  const repaired: LLMMessage[] = [];
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex]!;
+    if (!Array.isArray(message.content)) {
+      repaired.push(message);
+      continue;
+    }
+    const blocks = message.content.filter((_block: ContentBlock, blockIndex: number) =>
+      !dropped.has(`${messageIndex}:${blockIndex}`));
+    if (blocks.length > 0) repaired.push({ ...message, content: blocks });
+    else if (message.content.length === 0) repaired.push(message);
+  }
+  return { messages: repaired, removedCalls, removedResults, ambiguousIds: [] };
+}

package/src/dashboard/input/dashboard-chord-actions.ts

@@ -12,7 +12,8 @@ export type DashboardChordAction =
   | { kind: 'open-pane-modal' }
   | { kind: 'toggle-log-zoom' }
   | { kind: 'open-preview-terminal' }
-  | { kind: 'toggle-preview-terminal-expand' };
+  | { kind: 'toggle-preview-terminal-expand' }
+  | { kind: 'toggle-all-folds' };
 
 export function matchDashboardChordAction(key: Key): DashboardChordAction | null {
   if (key.ctrl && (key.name === 'w' || key.name === 'ㅈ')) {
@@ -54,6 +55,10 @@ export function matchDashboardChordAction(key: Key): DashboardChordAction | null
   if (key.name === 'e' || key.name === 'ㄷ') {
     return { kind: 'toggle-preview-terminal-expand' };
   }
+  // #19 — the log-pane `F` bulk fold toggle, reachable from the input (plain `F` types a letter there).
+  if (!key.ctrl && (key.name === 'f' || key.name === 'ㄹ')) {
+    return { kind: 'toggle-all-folds' };
+  }
   return null;
 }
 
@@ -70,6 +75,7 @@ export interface DashboardChordActionRunnerDeps<Pane> {
   toggleLogZoom: () => void | Promise<void>;
   openPreviewTerminal: () => void;
   togglePreviewTerminalExpand: () => void;
+  toggleAllFolds?: () => void;
 }
 
 export function createDashboardChordActionRunner<Pane>(
@@ -113,6 +119,9 @@ export function createDashboardChordActionRunner<Pane>(
       case 'toggle-preview-terminal-expand':
         deps.togglePreviewTerminalExpand();
         return;
+      case 'toggle-all-folds':
+        deps.toggleAllFolds?.();
+        return;
     }
   };
 }

package/src/dashboard/input/dashboard-chord-runtime.ts

@@ -31,6 +31,7 @@ export interface DashboardChordRuntimeDeps<Pane> {
   focusPreviewAfterTerminalExpand: () => void;
   onPreviewTerminalExpandChanged: (expanded: boolean) => void;
   onMissingPreviewTerminal: () => void;
+  toggleAllFolds?: () => void;
 }
 
 export function createDashboardChordRuntime<Pane>(
@@ -80,6 +81,7 @@ export function createDashboardChordRuntime<Pane>(
     },
     toggleLogZoom: deps.toggleLogZoom,
     openPreviewTerminal: deps.openPreviewTerminal,
+    toggleAllFolds: deps.toggleAllFolds,
     togglePreviewTerminalExpand: () => {
       const term = deps.getPreviewTerminal();
       if (term !== null && term.isAlive) {