parallel-codex-tui 0.1.3 → 0.1.4

package/dist/tui/WorkerOutputView.js

@@ -1,60 +1,152 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from "react";
 import { basename, dirname, join } from "node:path";
-import { readdir } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import { Box, Text } from "ink";
 import { pathExists, readTextIfExists } from "../core/file-store.js";
 import { compactEndByDisplayWidth, displayWidth, wrapByDisplayWidth } from "./display-width.js";
+import { decodeHtmlEntities } from "./markdown-text.js";
+import { createIncrementalTextFileReader } from "./incremental-text-file.js";
 import { selectViewportLines } from "./scrolling.js";
-const WORKER_PANEL_BACKGROUND = "ansi256(235)";
-const WORKER_PANEL_TITLE_BACKGROUND = "ansi256(24)";
-export function WorkerOutputView({ title, role, logPath, scrollOffset = 0, height = 24, terminalWidth = Number(process.stdout.columns) || 120, onViewportChange }) {
+import { TUI_THEME } from "./theme.js";
+const EMPTY_WORKER_OUTPUT_TEXT = "waiting for output";
+const LOADING_WORKER_OUTPUT_TEXT = "loading output";
+const NO_WORKER_OUTPUT_TEXT = "No workers yet · start a complex task";
+export function workerOutputNavigationTargets(lines, height, query = "") {
+    const viewportHeight = Math.max(1, Math.trunc(height));
+    const maxOffset = Math.max(0, lines.length - viewportHeight);
+    const normalizedQuery = query.trim().toLocaleLowerCase();
+    const searchOffsets = [];
+    const searchLineIndexes = [];
+    const errorOffsets = [];
+    const diffOffsets = [];
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (!line) {
+            continue;
+        }
+        const offset = Math.min(maxOffset, Math.max(0, lines.length - 1 - index));
+        if (normalizedQuery && line.text.toLocaleLowerCase().includes(normalizedQuery)) {
+            searchOffsets.push(offset);
+            searchLineIndexes.push(index);
+        }
+        if (line.kind === "error") {
+            errorOffsets.push(offset);
+        }
+        if (line.kind === "diff-file" || line.kind === "diff-hunk") {
+            diffOffsets.push(offset);
+        }
+    }
+    return { searchOffsets, searchLineIndexes, errorOffsets, diffOffsets };
+}
+export function WorkerOutputView({ title, role, featureId, logPath, scrollOffset = 0, height = 24, terminalWidth = Number(process.stdout.columns) || 120, searchQuery = "", searchMatchIndex = 0, onViewportChange, onNavigationChange }) {
     const nanoOutput = isNanoWorkerOutputWidth(terminalWidth);
-    const contentKey = workerOutputContentKey(role, logPath, nanoOutput);
+    const contentKey = workerOutputContentKey(role, featureId, logPath, nanoOutput);
     const [contentState, setContentState] = useState({ key: "", lines: [] });
     useEffect(() => {
         let active = true;
+        let refreshing = false;
+        let refreshQueued = false;
+        let rendered = false;
+        let artifactSignature = null;
         const loadKey = contentKey;
+        const outputReader = logPath ? createIncrementalTextFileReader(logPath) : null;
         async function load() {
-            if (!logPath) {
-                setContentState({
-                    key: loadKey,
-                    lines: [{ kind: "content", text: "No worker log selected." }]
-                });
-                return;
-            }
-            if (nanoOutput) {
-                const lines = await loadNanoWorkerOutputLines(logPath, height);
+            try {
+                if (!logPath || !outputReader) {
+                    if (rendered) {
+                        return;
+                    }
+                    rendered = true;
+                    setContentState({
+                        key: loadKey,
+                        lines: [{ kind: "placeholder", text: NO_WORKER_OUTPUT_TEXT }]
+                    });
+                    return;
+                }
+                const snapshot = await outputReader.read();
+                const nextArtifactSignature = nanoOutput
+                    ? ""
+                    : await workerArtifactSignature(role, dirname(logPath), featureId);
+                if (rendered && !snapshot.changed && nextArtifactSignature === artifactSignature) {
+                    return;
+                }
+                rendered = true;
+                artifactSignature = nextArtifactSignature;
+                const output = snapshot.text;
+                if (nanoOutput) {
+                    const lines = await loadNanoWorkerOutputLines(logPath, height, output);
+                    if (active) {
+                        setContentState({
+                            key: loadKey,
+                            lines
+                        });
+                    }
+                    return;
+                }
+                const sections = await loadWorkerOutputSections(role, logPath, output, featureId);
                 if (active) {
                     setContentState({
                         key: loadKey,
-                        lines
+                        lines: renderLinesFromSections(sections, { nanoProcess: nanoOutput, height })
                     });
                 }
-                return;
             }
-            const sections = await loadWorkerOutputSections(role, logPath);
-            if (active) {
-                setContentState({
-                    key: loadKey,
-                    lines: renderLinesFromSections(sections, { nanoProcess: nanoOutput, height })
-                });
+            catch (error) {
+                if (active) {
+                    const detail = error instanceof Error ? error.message : String(error);
+                    setContentState({
+                        key: loadKey,
+                        lines: [{ kind: "error", text: `output read failed · ${detail}` }]
+                    });
+                }
             }
         }
-        void load();
+        const refresh = () => {
+            if (refreshing) {
+                refreshQueued = true;
+                return;
+            }
+            refreshing = true;
+            void (async () => {
+                do {
+                    refreshQueued = false;
+                    await load();
+                } while (active && refreshQueued);
+            })().finally(() => {
+                refreshing = false;
+                if (active && refreshQueued) {
+                    refresh();
+                }
+            });
+        };
+        refresh();
         const interval = setInterval(() => {
-            void load();
+            refresh();
         }, 1000);
         return () => {
             active = false;
             clearInterval(interval);
         };
-    }, [contentKey, height, logPath, nanoOutput, role]);
-    const content = contentState.key === contentKey
+    }, [contentKey, featureId, height, logPath, nanoOutput, role]);
+    const contentReady = contentState.key === contentKey;
+    const content = contentReady
         ? contentState.lines
-        : [{ kind: "content", text: "Loading worker log..." }];
+        : [{ kind: "placeholder", text: LOADING_WORKER_OUTPUT_TEXT }];
     const sourceLines = isNanoWorkerOutputWidth(terminalWidth) ? tinyWorkerOutputSourceLines(content, height) : content;
-    const displayLines = renderDisplayLines(sourceLines, terminalWidth);
+    const panelWidth = workerOutputPanelRailWidth(terminalWidth);
+    const nanoRender = isNanoWorkerOutputWidth(terminalWidth);
+    const displayLines = renderDisplayLines(sourceLines, terminalWidth, {
+        contentWidth: nanoRender ? undefined : Math.max(1, panelWidth - 2),
+        nano: nanoRender
+    });
+    const navigationTargets = workerOutputNavigationTargets(displayLines, height, searchQuery);
+    const selectedSearchIndex = navigationTargets.searchLineIndexes.length > 0
+        ? Math.min(navigationTargets.searchLineIndexes.length - 1, Math.max(0, Math.trunc(searchMatchIndex)))
+        : -1;
+    const selectedSearchLineIndex = selectedSearchIndex >= 0
+        ? navigationTargets.searchLineIndexes[selectedSearchIndex] ?? -1
+        : -1;
     const selection = selectViewportLines(displayLines.map((line) => line.text).join("\n"), height, scrollOffset);
     const end = displayLines.length - selection.clampedOffset;
     const rawStart = Math.max(0, end - Math.max(1, height));
@@ -67,30 +159,58 @@ export function WorkerOutputView({ title, role, logPath, scrollOffset = 0, heigh
         ? 0
         : workerOutputTailTopPaddingLines(selection.clampedOffset, selection.maxOffset, visibleLines.length, height);
     useEffect(() => {
+        if (!contentReady) {
+            return;
+        }
         onViewportChange?.({
             offset: selection.clampedOffset,
             maxOffset: selection.maxOffset
         });
-    }, [onViewportChange, selection.clampedOffset, selection.maxOffset]);
-    const panelWidth = workerOutputPanelRailWidth(terminalWidth);
+    }, [contentReady, onViewportChange, selection.clampedOffset, selection.maxOffset]);
+    useEffect(() => {
+        onNavigationChange?.(navigationTargets);
+    }, [
+        navigationTargets.diffOffsets.join(","),
+        navigationTargets.errorOffsets.join(","),
+        navigationTargets.searchLineIndexes.join(","),
+        navigationTargets.searchOffsets.join(","),
+        onNavigationChange
+    ]);
     const scrollLabel = workerOutputScrollDisplay(selection.clampedOffset, selection.maxOffset, terminalWidth);
-    const displayTitle = workerOutputHeaderDisplay(title, selection.maxOffset > 0 ? scrollLabel : null, Math.max(1, panelWidth - 2));
-    const nanoRender = isNanoWorkerOutputWidth(terminalWidth);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(WorkerOutputTitleRail, { title: displayTitle, width: panelWidth }), Array.from({ length: topPaddingLines }, (_, index) => _jsx(Text, { children: " " }, `tail-pad-${index}`)), visibleLines.length > 0
+    const normalizedSearchQuery = searchQuery.trim();
+    const navigationLabel = normalizedSearchQuery
+        ? `find ${selectedSearchIndex >= 0 ? selectedSearchIndex + 1 : 0}/${navigationTargets.searchOffsets.length}`
+        : selection.maxOffset > 0 ? scrollLabel : null;
+    const displayTitle = workerOutputHeaderDisplay(title, navigationLabel, Math.max(1, panelWidth - 2));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(WorkerOutputTitleRail, { title: displayTitle, width: panelWidth }), Array.from({ length: topPaddingLines }, (_, index) => _jsx(WorkerOutputBlankLine, { width: panelWidth }, `tail-pad-${index}`)), visibleLines.length > 0
                 ? visibleLines.map((line, index) => nanoRender
-                    ? _jsx(WorkerOutputNanoLine, { line: line, width: terminalWidth }, index)
-                    : _jsx(WorkerOutputLine, { line: line }, index))
-                : _jsx(Text, { children: "(empty log)" })] }));
+                    ? _jsx(WorkerOutputNanoLine, { fillWidth: panelWidth, line: line, selected: start + index === selectedSearchLineIndex, width: terminalWidth }, index)
+                    : _jsx(WorkerOutputLine, { line: line, selected: start + index === selectedSearchLineIndex, width: panelWidth }, index))
+                : _jsx(Text, { ...workerOutputEmptyFallbackTheme(), children: EMPTY_WORKER_OUTPUT_TEXT })] }));
 }
 function WorkerOutputTitleRail({ title, width }) {
     const titleText = ` ${title} `;
+    const segments = workerOutputTitleSegments(title);
     const renderWidth = typeof process.stdout.columns === "number"
         ? width
         : null;
     const trailingWidth = renderWidth === null
         ? 0
         : Math.max(0, renderWidth - displayWidth(titleText));
-    return (_jsxs(Box, { children: [_jsx(Text, { backgroundColor: WORKER_PANEL_TITLE_BACKGROUND, color: "white", bold: true, children: titleText }), trailingWidth > 0 ? _jsx(Text, { backgroundColor: WORKER_PANEL_BACKGROUND, children: " ".repeat(trailingWidth) }) : null] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " " }), _jsx(Text, { backgroundColor: TUI_THEME.chrome, color: TUI_THEME.accent, bold: true, children: segments.identity }), segments.metadata ? (_jsx(Text, { backgroundColor: TUI_THEME.chrome, color: TUI_THEME.muted, children: segments.metadata })) : null, _jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " " }), trailingWidth > 0 ? _jsx(Text, { backgroundColor: TUI_THEME.chrome, children: " ".repeat(trailingWidth) }) : null] }));
+}
+function workerOutputTitleSegments(title) {
+    const separatorIndex = title.indexOf(" · ");
+    if (separatorIndex >= 0) {
+        return {
+            identity: title.slice(0, separatorIndex),
+            metadata: title.slice(separatorIndex)
+        };
+    }
+    const spaceIndex = title.indexOf(" ");
+    return spaceIndex > 0
+        ? { identity: title.slice(0, spaceIndex), metadata: title.slice(spaceIndex) }
+        : { identity: title, metadata: "" };
 }
 function workerOutputPanelRailWidth(terminalWidth) {
     const renderWidth = typeof process.stdout.columns === "number"
@@ -128,17 +248,33 @@ function lastIndexWhere(values, predicate) {
     }
     return -1;
 }
-function workerOutputContentKey(role, logPath, nanoOutput = false) {
-    return `${role ?? ""}:${logPath ?? ""}:${nanoOutput ? "nano" : "full"}`;
+function workerOutputContentKey(role, featureId, logPath, nanoOutput = false) {
+    return `${role ?? ""}:${featureId ?? ""}:${logPath ?? ""}:${nanoOutput ? "nano" : "full"}`;
 }
 export function workerOutputTitleDisplay(title, width) {
-    const match = title.match(/^(.+?)\s+\(([^)]+)\)\s+output(?:\s+\((\d+\/\d+)\))?$/i);
+    const match = title.match(/^(.+?)\s+\(([^)]+)\)(?:\s+·\s+(.+?))?\s+output(?:\s+\((\d+\/\d+)\))?$/i);
     if (!match) {
-        return title.replace(/\s+output\b/i, "");
+        return compactEndByDisplayWidth(title.replace(/\s+output\b/i, "").trim(), width);
     }
     const role = (match[1] ?? "").trim().toLowerCase();
     const provider = (match[2] ?? "").trim().toLowerCase();
-    const page = match[3] ?? "";
+    const detail = (match[3] ?? "").trim();
+    const page = match[4] ?? "";
+    const detailed = joinWorkerOutputChromeParts([`${role}/${provider}`, detail, page]);
+    if (detail && displayWidth(detailed) <= width) {
+        return detailed;
+    }
+    if (detail) {
+        const fixed = joinWorkerOutputChromeParts([`${role}/${provider}`, page]);
+        const detailBudget = width - displayWidth(fixed) - displayWidth(" · ");
+        if (detailBudget >= 8) {
+            return joinWorkerOutputChromeParts([
+                `${role}/${provider}`,
+                compactEndByDisplayWidth(detail, detailBudget),
+                page
+            ]);
+        }
+    }
     const compact = joinWorkerOutputChromeParts([`${role}/${provider}`, page]);
     if (displayWidth(compact) <= width) {
         return compact;
@@ -361,7 +497,7 @@ function latestSectionBoundaryWithinTail(lines, start, end) {
     }
     return latestSectionStart !== null && end - latestSectionStart >= 3 ? latestSectionStart : null;
 }
-async function loadWorkerOutputSections(role, logPath) {
+async function loadWorkerOutputSections(role, logPath, processOutput, featureId) {
     const workerDir = dirname(logPath);
     const sections = [];
     const artifactFiles = roleArtifactFiles(role);
@@ -372,28 +508,28 @@ async function loadWorkerOutputSections(role, logPath) {
         }
         sections.push({ group: "role", title: file, text });
     }
-    for (const artifact of await featureArtifactSections(role, workerDir)) {
+    for (const artifact of await featureArtifactSections(role, workerDir, featureId)) {
         const text = artifact.text.trim();
         if (!text) {
             continue;
         }
         sections.push({ group: "feature", title: artifact.label, text });
     }
-    const rawOutput = (await readTextIfExists(logPath)).trimEnd();
+    const rawOutput = (processOutput ?? await readTextIfExists(logPath)).trimEnd();
     if (rawOutput) {
         sections.push({ group: "process", title: "output.log", text: rawOutput });
     }
     return sections;
 }
-async function loadNanoWorkerOutputLines(logPath, height) {
-    const rawOutput = (await readTextIfExists(logPath)).trimEnd();
+async function loadNanoWorkerOutputLines(logPath, height, processOutput) {
+    const rawOutput = (processOutput ?? await readTextIfExists(logPath)).trimEnd();
     if (!rawOutput) {
-        return [{ kind: "content", text: "No worker output." }];
+        return [{ kind: "placeholder", text: EMPTY_WORKER_OUTPUT_TEXT }];
     }
     const lines = renderNanoProcessContent(compactNanoProcessText(rawOutput, height));
     return lines.length > 0
         ? [{ kind: "group", text: "process" }, ...lines]
-        : [{ kind: "content", text: "No worker output." }];
+        : [{ kind: "placeholder", text: EMPTY_WORKER_OUTPUT_TEXT }];
 }
 function renderNanoProcessContent(text) {
     const lines = [];
@@ -438,7 +574,7 @@ function roleArtifactFiles(role) {
     }
     return [];
 }
-async function featureArtifactSections(role, workerDir) {
+async function featureArtifactSections(role, workerDir, featureId) {
     const files = featureArtifactFiles(role);
     if (files.length === 0) {
         return [];
@@ -448,11 +584,7 @@ async function featureArtifactSections(role, workerDir) {
     if (!(await pathExists(featuresDir))) {
         return [];
     }
-    const entries = await readdir(featuresDir, { withFileTypes: true });
-    const featureDirs = entries
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name)
-        .sort();
+    const featureDirs = await scopedFeatureDirectoryNames(featuresDir, workerDir, featureId);
     const sections = [];
     for (const featureDir of featureDirs) {
         for (const file of files) {
@@ -468,6 +600,57 @@ async function featureArtifactSections(role, workerDir) {
     }
     return sections;
 }
+async function workerArtifactSignature(role, workerDir, featureId) {
+    const paths = roleArtifactFiles(role).map((file) => join(workerDir, file));
+    const featureFiles = featureArtifactFiles(role);
+    if (featureFiles.length > 0) {
+        const featuresDir = join(dirname(workerDir), "features");
+        if (await pathExists(featuresDir)) {
+            const featureDirs = await scopedFeatureDirectoryNames(featuresDir, workerDir, featureId);
+            for (const featureDir of featureDirs) {
+                for (const file of featureFiles) {
+                    paths.push(join(featuresDir, featureDir, file));
+                }
+            }
+        }
+    }
+    const signatures = await Promise.all(paths.map(async (path) => {
+        try {
+            const metadata = await stat(path);
+            return `${path}\0${metadata.dev}:${metadata.ino}:${metadata.size}:${metadata.mtimeMs}:${metadata.ctimeMs}`;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return `${path}\0missing`;
+            }
+            throw error;
+        }
+    }));
+    return signatures.join("\u0001");
+}
+async function scopedFeatureDirectoryNames(featuresDir, workerDir, featureId) {
+    if (featureId) {
+        return [featureId];
+    }
+    const turnId = workerTurnIdFromDirectory(workerDir);
+    const entries = await readdir(featuresDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory() && (!turnId || entry.name === turnId || entry.name.startsWith(`${turnId}-`)))
+        .map((entry) => entry.name)
+        .sort();
+}
+function workerTurnIdFromDirectory(workerDir) {
+    const workerId = basename(workerDir);
+    const waveTurn = workerId.match(/-wave-(\d{4,})-/)?.[1];
+    if (waveTurn) {
+        return waveTurn;
+    }
+    const scopedTurn = workerId.match(/-(\d{4,})(?:-|$)/)?.[1];
+    if (scopedTurn) {
+        return scopedTurn;
+    }
+    return /^(?:judge|actor|critic)-/.test(workerId) ? "0001" : null;
+}
 function featureArtifactFiles(role) {
     if (role === "actor") {
         return ["actor-worklog.md", "actor-replies.jsonl"];
@@ -655,7 +838,7 @@ function renderLinesFromSections(sections, options = {}) {
             renderedArtifactFiles.add(basename(section.title));
         }
     }
-    return lines;
+    return lines.length > 0 ? lines : [{ kind: "placeholder", text: EMPTY_WORKER_OUTPUT_TEXT }];
 }
 function compactNanoProcessText(text, height) {
     const rawLines = text.split(/\r?\n/);
@@ -773,8 +956,16 @@ function renderSectionContent(section, renderedArtifactFiles = new Set()) {
             index = collapseDiff ? skipProcessDiffTailContext(rawLines, diffBlock.nextIndex) : diffBlock.nextIndex;
             continue;
         }
-        if (section.group === "process" && hiddenProcessDiffFiles.size > 0 && isDiffHunkLine(line.trimStart())) {
-            index = collectBareDiffHunkBlock(rawLines, index).nextIndex;
+        if (section.group === "process" && parseHunkStart(line.trimStart())) {
+            const bareHunk = collectBareDiffHunkBlock(rawLines, index);
+            const bareDiffFile = inferBareDiffFile(rawLines, index);
+            if (!bareDiffTargetsRenderedArtifact(bareHunk.lines, bareDiffFile, hiddenProcessDiffFiles)) {
+                if (lines.length > 0 && lines[lines.length - 1]?.kind !== "blank") {
+                    lines.push({ kind: "blank", text: "" });
+                }
+                lines.push(...renderBareDiffHunkContent(bareHunk.lines, bareDiffFile));
+            }
+            index = skipBareDiffTailContext(rawLines, bareHunk.nextIndex);
             continue;
         }
         if (section.group === "process" &&
@@ -797,13 +988,10 @@ function renderSectionContent(section, renderedArtifactFiles = new Set()) {
                 continue;
             }
         }
-        if (isMarkdownTableSeparator(trimmed)) {
-            index += 1;
-            continue;
-        }
-        if (isMarkdownTableRow(trimmed)) {
-            lines.push({ kind: "table", text: renderMarkdownTableRow(trimmed) });
-            index += 1;
+        const tableBlock = collectMarkdownTableBlock(rawLines, index);
+        if (tableBlock) {
+            lines.push(...tableBlock.lines);
+            index = tableBlock.nextIndex;
             continue;
         }
         lines.push(classifyRenderedLine(section, line));
@@ -820,6 +1008,25 @@ function processDiffBlockTargetsArtifacts(diffLines, artifactFiles) {
         return artifactFiles.has(diffTitlePath(title));
     });
 }
+function bareDiffTargetsRenderedArtifact(diffLines, diffFile, artifactFiles) {
+    if (artifactFiles.size === 0) {
+        return false;
+    }
+    if (artifactFiles.has("patch.diff")) {
+        return true;
+    }
+    if (diffFile) {
+        return artifactFiles.has(basename(diffFile));
+    }
+    const additions = diffLines
+        .filter((line) => line.startsWith("+") && !line.startsWith("+++"))
+        .map((line) => line.slice(1).trim())
+        .filter(Boolean);
+    return (artifactFiles.has("review.md")
+        && additions.some((line) => /^(?:#{1,6}\s+)?(?:Critic Review|APPROVED|REVISION_REQUIRED)\b/i.test(line))) || ((artifactFiles.has("worklog.md") || artifactFiles.has("actor-worklog.md"))
+        && additions.some((line) => /^(?:#{1,6}\s+)?(?:Actor )?Worklog\b/i.test(line))) || (artifactFiles.has("decisions.md")
+        && additions.some((line) => /^(?:#{1,6}\s+)?Decisions\b/i.test(line)));
+}
 function compactRenderedBlankLines(lines) {
     const compacted = [];
     let blankPending = false;
@@ -1052,7 +1259,137 @@ function isSingleFilePathListItem(trimmed) {
         /^[A-Za-z0-9._@+-]+\/[A-Za-z0-9._@+*?/-]+$/.test(trimmed));
 }
 function cleanProcessRenderLines(lines) {
-    return removePatchDiffReadbackNoise(removeDiffAdjacentCodeSummaries(mergeSmokeStatusSuccessLines(lines)));
+    return dedupeSupersededChecklistSnapshots(dedupeBareDiffHunks(dedupeCollapsedDiffSummaries(removePatchDiffReadbackNoise(removeDiffAdjacentCodeSummaries(mergeSmokeStatusSuccessLines(lines))))));
+}
+function dedupeBareDiffHunks(lines) {
+    const blocks = [];
+    let currentDiffFile = null;
+    for (let index = 0; index < lines.length;) {
+        const line = lines[index];
+        if (!line) {
+            index += 1;
+            continue;
+        }
+        if (line.kind === "diff-file") {
+            currentDiffFile = line.text.trim();
+            index += 1;
+            continue;
+        }
+        if (line.kind !== "diff-hunk") {
+            if (line.kind !== "blank" && !isAnyDiffLine(line)) {
+                currentDiffFile = null;
+            }
+            index += 1;
+            continue;
+        }
+        const startIndex = index;
+        index += 1;
+        while (index < lines.length && isDiffHunkBodyLine(lines[index])) {
+            index += 1;
+        }
+        const blockLines = lines.slice(startIndex, index);
+        const diffFile = line.diffFile ?? currentDiffFile;
+        blocks.push({
+            startIndex,
+            endIndex: index,
+            key: [
+                `file\0${diffFile ?? ""}`,
+                ...blockLines.map((line) => `${line.kind}\0${line.text}`)
+            ].join("\n")
+        });
+    }
+    const lastBlockByKey = new Map();
+    for (const block of blocks) {
+        lastBlockByKey.set(block.key, block);
+    }
+    const hiddenIndexes = new Set();
+    for (const block of blocks) {
+        if (lastBlockByKey.get(block.key) === block) {
+            continue;
+        }
+        for (let index = block.startIndex; index < block.endIndex; index += 1) {
+            hiddenIndexes.add(index);
+        }
+    }
+    return hiddenIndexes.size > 0
+        ? lines.filter((_line, index) => !hiddenIndexes.has(index))
+        : lines;
+}
+function isDiffHunkBodyLine(line) {
+    return line?.kind === "diff-context" ||
+        line?.kind === "diff-meta" ||
+        line?.kind === "diff-add" ||
+        line?.kind === "diff-remove";
+}
+function isAnyDiffLine(line) {
+    return line.kind === "diff-file" ||
+        line.kind === "diff-summary" ||
+        line.kind === "diff-hunk" ||
+        line.kind === "diff-context" ||
+        line.kind === "diff-meta" ||
+        line.kind === "diff-add" ||
+        line.kind === "diff-remove";
+}
+function dedupeSupersededChecklistSnapshots(lines) {
+    const snapshots = [];
+    for (let index = 0; index < lines.length;) {
+        const firstItem = checklistSnapshotItem(lines[index]);
+        if (!firstItem) {
+            index += 1;
+            continue;
+        }
+        const items = [];
+        const startIndex = index;
+        while (index < lines.length) {
+            const item = checklistSnapshotItem(lines[index]);
+            if (!item) {
+                break;
+            }
+            items.push(item);
+            index += 1;
+        }
+        if (items.length >= 2) {
+            snapshots.push({ startIndex, endIndex: index, key: items.join("\n") });
+        }
+    }
+    const lastSnapshotByKey = new Map();
+    for (const snapshot of snapshots) {
+        lastSnapshotByKey.set(snapshot.key, snapshot);
+    }
+    const hidden = new Set();
+    for (const snapshot of snapshots) {
+        if (lastSnapshotByKey.get(snapshot.key) === snapshot) {
+            continue;
+        }
+        for (let index = snapshot.startIndex; index < snapshot.endIndex; index += 1) {
+            hidden.add(index);
+        }
+    }
+    return hidden.size > 0 ? lines.filter((_line, index) => !hidden.has(index)) : lines;
+}
+function checklistSnapshotItem(line) {
+    if (!line || (line.kind !== "content" && line.kind !== "success")) {
+        return null;
+    }
+    return line.text.trim().match(/^(?:✓|✔|→|•)\s+(.+)$/)?.[1]?.trim() ?? null;
+}
+function dedupeCollapsedDiffSummaries(lines) {
+    const deduped = [];
+    const seen = new Set();
+    for (const line of lines) {
+        if (isCollapsedDiffSummaryLine(line)) {
+            const key = line.text.trim();
+            if (seen.has(key)) {
+                while (deduped[deduped.length - 1]?.kind === "blank") {
+                    deduped.pop();
+                }
+                continue;
+            }
+            seen.add(key);
+        }
+        deduped.push(line);
+    }
+    return deduped;
 }
 function mergeSmokeStatusSuccessLines(lines) {
     const merged = [];
@@ -1197,13 +1534,13 @@ function diffTitlePath(title) {
 }
 const SOURCE_OUTPUT_COLLAPSE_MIN_LINES = 8;
 const CODE_OUTPUT_COLLAPSE_MIN_LINES = 4;
-const FILE_LIST_OUTPUT_COLLAPSE_MIN_LINES = 12;
+const FILE_LIST_OUTPUT_COLLAPSE_MIN_LINES = 4;
 const READ_SUMMARY_RUN_COLLAPSE_MIN_ITEMS = 3;
 const NODE_TEST_OUTPUT_COLLAPSE_MIN_PASSES = 3;
 const PROCESS_DIFF_COLLAPSE_MIN_BODY_LINES = 1;
 const PROCESS_DIFF_COLLAPSE_MIN_FILES = 4;
 function sanitizeProcessOutput(text, options = {}) {
-    const rawLines = text.split("\n");
+    const rawLines = dedupeRepeatedAssistantNarrativeBlocks(text.split("\n"));
     const kept = [];
     const hideAssistantNarration = options.hideAssistantNarration ?? false;
     const renderedArtifactFiles = options.renderedArtifactFiles ?? new Set();
@@ -1222,8 +1559,8 @@ function sanitizeProcessOutput(text, options = {}) {
             index = skipCodexStartupPreamble(rawLines, index);
             continue;
         }
-        if (hideAssistantNarration && isAssistantNarrativeMarker(trimmed)) {
-            index = skipAssistantNarrativeBlock(rawLines, index);
+        if (isAssistantNarrativeMarker(trimmed)) {
+            index = hideAssistantNarration ? skipAssistantNarrativeBlock(rawLines, index) : index + 1;
             continue;
         }
         if (hideAssistantNarration && isUnmarkedAssistantNarrativeStart(trimmed)) {
@@ -1240,16 +1577,30 @@ function sanitizeProcessOutput(text, options = {}) {
             index = skipRolePromptTranscript(rawLines, index);
             continue;
         }
+        const hiddenCommandBatch = collectParallelHiddenCommandBatch(rawLines, index, renderedArtifactFiles);
+        if (hiddenCommandBatch) {
+            kept.push(...hiddenCommandBatch.lines);
+            index = hiddenCommandBatch.nextIndex;
+            continue;
+        }
+        const parallelRead = collectParallelReadCommandBatch(rawLines, index, renderedArtifactFiles);
+        if (parallelRead) {
+            kept.push(parallelRead.summary);
+            index = parallelRead.nextIndex;
+            continue;
+        }
         const execCommand = collectProcessExecCommand(rawLines, index);
         if (execCommand) {
-            if (processCommandReadsRenderedArtifact(execCommand.command, renderedArtifactFiles) ||
-                processCommandReadsParallelCodexTaskFile(execCommand.command) ||
-                processCommandInspectsSessionMetadata(execCommand.command) ||
-                processCommandReadsSessionSystemFile(execCommand.command) ||
-                processCommandReadsSkillDocument(execCommand.command)) {
+            if (shouldHideProcessCommand(execCommand, renderedArtifactFiles)) {
                 index = skipProcessCommandOutputBlock(rawLines, execCommand.nextIndex);
                 continue;
             }
+            const chainedRead = collectChainedReadCommandBlock(rawLines, execCommand.command, execCommand.nextIndex);
+            if (chainedRead) {
+                kept.push(chainedRead.summary);
+                index = chainedRead.nextIndex;
+                continue;
+            }
             kept.push(execCommand.commandLine);
             index = execCommand.nextIndex;
             continue;
@@ -1257,7 +1608,151 @@ function sanitizeProcessOutput(text, options = {}) {
         kept.push(rawLines[index] ?? "");
         index += 1;
     }
-    return collapseProcessOutputLines(compactReadSummaryRuns(compactNoMatchSearchCommandBlocks(compactAnnotatedStatusCommandPairs(compactNodeTestOutputBlocks(compactBuildOutputBlocks(compactDevServerFallbackBlocks(compactCollapsedCommandBlocks(dropSuccessfulInternalLaunchCommands(collapseVerboseProcessOutput(kept)))))))))).join("\n").trimEnd();
+    const compactedNetworkOutput = compactRecoveredNetworkEvents(kept);
+    const shieldedDiff = shieldProcessDiffBlocks(compactedNetworkOutput);
+    const sanitized = collapseProcessOutputLines(compactReadSummaryRuns(compactNoMatchSearchCommandBlocks(compactAnnotatedStatusCommandPairs(compactNodeTestOutputBlocks(compactBuildOutputBlocks(compactDevServerFallbackBlocks(compactCollapsedCommandBlocks(dropSuccessfulInternalLaunchCommands(collapseVerboseProcessOutput(shieldedDiff.lines))))))))));
+    return sanitized
+        .map((line) => shieldedDiff.originals.get(line) ?? line)
+        .join("\n")
+        .trimEnd();
+}
+function shieldProcessDiffBlocks(lines) {
+    const shielded = [];
+    const originals = new Map();
+    const occupied = new Set(lines.map((line) => normalizedProcessLine(line)));
+    let namespace = 0;
+    let tokenPrefix = "pct protected diff line";
+    while (Array.from(occupied).some((line) => line.startsWith(`${tokenPrefix} `))) {
+        namespace += 1;
+        tokenPrefix = `pct protected diff line namespace ${namespace}`;
+    }
+    let tokenIndex = 0;
+    const appendBlock = (blockLines) => {
+        for (const line of blockLines) {
+            const token = `${tokenPrefix} ${String(tokenIndex).padStart(8, "0")}`;
+            tokenIndex += 1;
+            originals.set(token, line);
+            shielded.push(token);
+        }
+    };
+    for (let index = 0; index < lines.length;) {
+        const line = normalizedProcessLine(lines[index] ?? "");
+        const trimmedStart = line.trimStart();
+        if (isDiffStartLine(trimmedStart)) {
+            const block = collectEmbeddedDiffBlock(lines, index);
+            appendBlock(block.lines);
+            index = block.nextIndex;
+            continue;
+        }
+        if (parseHunkStart(trimmedStart)) {
+            const block = collectBareDiffHunkBlock(lines, index);
+            appendBlock(block.lines);
+            index = block.nextIndex;
+            continue;
+        }
+        shielded.push(lines[index] ?? "");
+        index += 1;
+    }
+    return { lines: shielded, originals };
+}
+function compactRecoveredNetworkEvents(lines) {
+    const compacted = [];
+    const reconnectAttempts = [];
+    let httpsFallbacks = 0;
+    let summaryIndex = null;
+    for (let index = 0; index < lines.length;) {
+        const event = collectRecoveredNetworkEvent(lines, index);
+        if (!event) {
+            compacted.push(lines[index] ?? "");
+            index += 1;
+            continue;
+        }
+        summaryIndex ??= compacted.length;
+        reconnectAttempts.push(...event.reconnectAttempts);
+        httpsFallbacks += event.httpsFallbacks;
+        index = event.nextIndex;
+    }
+    if (summaryIndex !== null) {
+        compacted.splice(summaryIndex, 0, formatRecoveredNetworkSummary(reconnectAttempts, httpsFallbacks));
+    }
+    return compacted;
+}
+function collectRecoveredNetworkEvent(lines, startIndex) {
+    const first = normalizedProcessLine(lines[startIndex] ?? "").trim();
+    if (!isNetworkRetryDiagnostic(first) && !reconnectAttempt(first)) {
+        return null;
+    }
+    const reconnectAttempts = [];
+    let httpsFallbacks = 0;
+    let index = startIndex;
+    let sawNetworkLine = false;
+    while (index < lines.length) {
+        const trimmed = normalizedProcessLine(lines[index] ?? "").trim();
+        const attempt = reconnectAttempt(trimmed);
+        if (isNetworkRetryDiagnostic(trimmed)) {
+            sawNetworkLine = true;
+            index += 1;
+            continue;
+        }
+        if (attempt) {
+            sawNetworkLine = true;
+            reconnectAttempts.push(attempt);
+            index += 1;
+            continue;
+        }
+        if (isHttpsFallbackLine(trimmed)) {
+            sawNetworkLine = true;
+            httpsFallbacks += 1;
+            index += 1;
+            continue;
+        }
+        if (sawNetworkLine && (!trimmed || /^context compacted$/i.test(trimmed))) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    if (reconnectAttempts.length === 0) {
+        return null;
+    }
+    const nextLine = nextSignificantProcessText(lines, index);
+    if (!nextLine || isTerminalNetworkFailureLine(nextLine)) {
+        return null;
+    }
+    return { reconnectAttempts, httpsFallbacks, nextIndex: index };
+}
+function nextSignificantProcessText(lines, startIndex) {
+    for (let index = startIndex; index < lines.length; index += 1) {
+        const trimmed = normalizedProcessLine(lines[index] ?? "").trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return null;
+}
+function isNetworkRetryDiagnostic(line) {
+    return /codex_core::responses_retry:.*retrying sampling request/i.test(line);
+}
+function reconnectAttempt(line) {
+    return line.match(/^(?:ERROR:\s*)?Reconnecting\.\.\.\s+(\d+\/\d+)/i)?.[1] ?? null;
+}
+function isHttpsFallbackLine(line) {
+    return /Falling back from WebSockets to HTTPS transport/i.test(line);
+}
+function isTerminalNetworkFailureLine(line) {
+    return (/^(?:ERROR|FATAL)\b/i.test(line) ||
+        /\b(?:request|process|router|worker)\b.*\b(?:timed out|timeout|failed)\b/i.test(line));
+}
+function formatRecoveredNetworkSummary(reconnectAttempts, httpsFallbacks) {
+    const reconnect = reconnectAttempts.length === 1
+        ? `reconnect ${reconnectAttempts[0] ?? ""}`.trim()
+        : `${reconnectAttempts.length} reconnects`;
+    const fallback = httpsFallbacks === 1
+        ? " via HTTPS fallback"
+        : httpsFallbacks > 1
+            ? ` with ${httpsFallbacks} HTTPS fallbacks`
+            : "";
+    return `Network recovered after ${reconnect}${fallback}`;
 }
 function collectProcessExecCommand(rawLines, startIndex) {
     const line = normalizedProcessLine(rawLines[startIndex] ?? "");
@@ -1269,20 +1764,227 @@ function collectProcessExecCommand(rawLines, startIndex) {
             return {
                 command,
                 commandLine: `$ ${command}`,
+                cwd: parseShellExecCwd(nextLine),
                 nextIndex: startIndex + 2
             };
         }
-        return null;
+        return null;
+    }
+    const command = parseShellExecCommand(trimmed);
+    if (!command) {
+        return null;
+    }
+    return {
+        command,
+        commandLine: `$ ${command}`,
+        cwd: parseShellExecCwd(trimmed),
+        nextIndex: startIndex + 1
+    };
+}
+function collectParallelReadCommandBatch(rawLines, startIndex, renderedArtifactFiles) {
+    const commands = [];
+    let index = startIndex;
+    while (index < rawLines.length) {
+        const command = collectProcessExecCommand(rawLines, index);
+        if (!command) {
+            break;
+        }
+        commands.push(command);
+        index = command.nextIndex;
+    }
+    if (commands.length < 2 || commands.some((command) => shouldHideProcessCommand(command, renderedArtifactFiles))) {
+        return null;
+    }
+    const targets = [];
+    for (const command of commands) {
+        const readTargets = sedReadTargets(command.command);
+        if (!readTargets) {
+            return null;
+        }
+        targets.push(...readTargets);
+    }
+    let totalLines = 0;
+    let contentLines = 0;
+    for (let commandIndex = 0; commandIndex < commands.length; commandIndex += 1) {
+        const status = normalizedProcessLine(rawLines[index] ?? "").trim();
+        if (!/^succeeded\s+in\s+\d+(?:ms|s|m)?:?$/i.test(status)) {
+            return null;
+        }
+        const outputStart = index + 1;
+        const outputEnd = parallelReadOutputEnd(rawLines, outputStart, commandIndex < commands.length - 1);
+        if (outputEnd === null) {
+            return null;
+        }
+        const outputLines = compactableReadOutputLines(rawLines, outputStart, outputEnd);
+        totalLines += outputLines.length;
+        contentLines += outputLines.filter((line) => normalizedProcessLine(line).trim()).length;
+        index = outputEnd;
+    }
+    if (contentLines < CODE_OUTPUT_COLLAPSE_MIN_LINES) {
+        return null;
+    }
+    return {
+        summary: `Collapsed read summaries: ${targets.length} chunks, ${totalLines} lines (${compactReadSummaryTargets(targets.map(formatReadTarget))})`,
+        nextIndex: index
+    };
+}
+function collectParallelHiddenCommandBatch(rawLines, startIndex, renderedArtifactFiles) {
+    const commands = [];
+    let index = startIndex;
+    while (index < rawLines.length) {
+        const command = collectProcessExecCommand(rawLines, index);
+        if (!command) {
+            break;
+        }
+        commands.push(command);
+        index = command.nextIndex;
+    }
+    if (commands.length < 2 || commands.some((command) => !shouldHideProcessCommand(command, renderedArtifactFiles))) {
+        return null;
+    }
+    const output = [];
+    let allSucceeded = true;
+    const includesWorkerLogReadback = commands.some((command) => processCommandReadsWorkerOutputLog(command.command));
+    for (let commandIndex = 0; commandIndex < commands.length; commandIndex += 1) {
+        const status = normalizedProcessLine(rawLines[index] ?? "").trim();
+        if (!isProcessStatusLine(status)) {
+            return null;
+        }
+        allSucceeded &&= /^succeeded\s+in\s+/i.test(status);
+        const outputStart = index + 1;
+        const isLastOutput = commandIndex === commands.length - 1;
+        const outputEnd = includesWorkerLogReadback && isLastOutput
+            ? nestedWorkerLogReadbackEnd(rawLines, outputStart)
+            : parallelReadOutputEnd(rawLines, outputStart, !isLastOutput);
+        if (outputEnd === null) {
+            return null;
+        }
+        output.push(status, ...rawLines.slice(outputStart, outputEnd));
+        index = outputEnd;
+    }
+    return {
+        lines: allSucceeded ? [] : [...commands.map((command) => command.commandLine), ...output],
+        nextIndex: index
+    };
+}
+function processCommandReadsWorkerOutputLog(command) {
+    const trimmed = command.trim();
+    return (/^(?:cat|sed|nl|head|tail|bat|less|more)\b/.test(trimmed) &&
+        trimmed.includes(".parallel-codex/sessions/") &&
+        /\/output\.log\b/.test(trimmed));
+}
+function nestedWorkerLogReadbackEnd(rawLines, startIndex) {
+    for (let index = startIndex; index < rawLines.length - 1; index += 1) {
+        const marker = normalizedProcessLine(rawLines[index] ?? "").trim();
+        const command = normalizedProcessLine(rawLines[index + 1] ?? "").trim();
+        if (marker === "exec" && parseShellExecCommand(command) !== null) {
+            return index;
+        }
+    }
+    return null;
+}
+function parallelReadOutputEnd(rawLines, startIndex, expectsStatus) {
+    for (let index = startIndex; index < rawLines.length; index += 1) {
+        const trimmed = normalizedProcessLine(rawLines[index] ?? "").trim();
+        if (expectsStatus && isProcessStatusLine(trimmed)) {
+            return index;
+        }
+        if (isChainedReadOutputBoundary(trimmed)) {
+            return expectsStatus ? null : index;
+        }
+    }
+    return null;
+}
+function collectChainedReadCommandBlock(rawLines, command, statusIndex) {
+    const targets = sedReadTargets(command);
+    if (!targets || targets.length < 2) {
+        return null;
+    }
+    const status = normalizedProcessLine(rawLines[statusIndex] ?? "").trim();
+    if (!/^succeeded\s+in\s+\d+(?:ms|s|m)?:?$/i.test(status)) {
+        return null;
+    }
+    const outputStart = statusIndex + 1;
+    let nextIndex = outputStart;
+    while (nextIndex < rawLines.length) {
+        const trimmed = normalizedProcessLine(rawLines[nextIndex] ?? "").trim();
+        if (isChainedReadOutputBoundary(trimmed)) {
+            break;
+        }
+        nextIndex += 1;
+    }
+    const outputLines = compactableReadOutputLines(rawLines, outputStart, nextIndex);
+    const contentLineCount = outputLines.filter((line) => normalizedProcessLine(line).trim()).length;
+    if (contentLineCount < CODE_OUTPUT_COLLAPSE_MIN_LINES) {
+        return null;
+    }
+    const displayTargets = compactReadSummaryTargets(targets.map(formatReadTarget));
+    return {
+        summary: `Collapsed read summaries: ${targets.length} chunks, ${outputLines.length} lines (${displayTargets})`,
+        nextIndex
+    };
+}
+function compactableReadOutputLines(rawLines, startIndex, endIndex) {
+    const outputLines = rawLines
+        .slice(startIndex, endIndex)
+        .filter((line) => {
+        const normalized = normalizedProcessLine(line);
+        return !shouldDropNoisyProcessLine(normalized.trim(), normalized);
+    });
+    while (outputLines.length > 0 && !normalizedProcessLine(outputLines[0] ?? "").trim()) {
+        outputLines.shift();
+    }
+    while (outputLines.length > 0 && !normalizedProcessLine(outputLines[outputLines.length - 1] ?? "").trim()) {
+        outputLines.pop();
+    }
+    return outputLines;
+}
+function sedReadTargets(command) {
+    const segments = command.split(/\s+&&\s+/);
+    const targets = [];
+    for (const segment of segments) {
+        const match = segment.trim().match(/^sed\s+-n\s+(\S+)\s+(.+)$/);
+        const range = match ? singleShellTokenValue(match[1] ?? "") : null;
+        const target = match ? singleShellTokenValue(match[2] ?? "") : null;
+        if (!range || !/^\d+,\d+p$/.test(range) || !target) {
+            return null;
+        }
+        targets.push(target);
     }
-    const command = parseShellExecCommand(trimmed);
-    if (!command) {
+    return targets;
+}
+function shouldHideProcessCommand(command, artifactFiles) {
+    return (processCommandReadsRenderedArtifact(command.command, artifactFiles) ||
+        processCommandReadsParallelCodexTaskFile(command.command) ||
+        processCommandInspectsSessionMetadata(command.command) ||
+        processCommandInspectsSessionCwd(command.command, command.cwd) ||
+        processCommandReadsSessionSystemFile(command.command) ||
+        processCommandReadsSkillDocument(command.command));
+}
+function singleShellTokenValue(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
         return null;
     }
-    return {
-        command,
-        commandLine: `$ ${command}`,
-        nextIndex: startIndex + 1
-    };
+    if (trimmed[0] === "\"" || trimmed[0] === "'") {
+        const segment = readQuotedShellSegment(trimmed, 0);
+        return segment?.endIndex === trimmed.length ? segment.value : null;
+    }
+    return /^[^\s;&|]+$/.test(trimmed) ? trimmed : null;
+}
+function isChainedReadOutputBoundary(trimmed) {
+    return (trimmed === "exec" ||
+        trimmed.startsWith("$ ") ||
+        parseShellExecCommand(trimmed) !== null ||
+        isAssistantNarrativeMarker(trimmed) ||
+        /^tokens used$/i.test(trimmed) ||
+        isRolePromptTranscriptStart(trimmed) ||
+        isDiffStartLine(trimmed) ||
+        /^apply patch$/i.test(trimmed) ||
+        /^patch:\s+(?:completed|failed)\b/i.test(trimmed));
+}
+function parseShellExecCwd(line) {
+    return line.match(/\s+in\s+(\/.+)$/)?.[1]?.trim() ?? null;
 }
 function processCommandReadsRenderedArtifact(command, artifactFiles) {
     if (artifactFiles.size === 0) {
@@ -1301,19 +2003,47 @@ function processCommandReadsRenderedArtifact(command, artifactFiles) {
 }
 function processCommandReadsParallelCodexTaskFile(command) {
     const trimmed = command.trim();
+    const conditionalTarget = readOnlySessionFileProbeTarget(trimmed);
+    if (conditionalTarget) {
+        return (conditionalTarget.includes(".parallel-codex/sessions/") &&
+            /\.(?:md|json|jsonl|diff|log|toml|txt)$/.test(conditionalTarget));
+    }
     if (!/^(?:cat|sed|nl|head|tail|bat|less|more)\b/.test(trimmed)) {
         return false;
     }
     if (!trimmed.includes(".parallel-codex/sessions/")) {
         return false;
     }
-    return /\.(?:md|json|jsonl|diff|toml|txt)\b/.test(trimmed);
+    return /\.(?:md|json|jsonl|diff|log|toml|txt)\b/.test(trimmed);
+}
+function readOnlySessionFileProbeTarget(command) {
+    const parts = command.split(/\s*;\s*/);
+    if (parts.length !== 5 || parts[3] !== "else echo MISSING" || parts[4] !== "fi") {
+        return null;
+    }
+    const existsMatch = parts[0]?.match(/^if\s+\[\s+-f\s+(.+)\s+\]$/);
+    const countMatch = parts[1]?.match(/^then\s+wc\s+-c\s+(.+)$/);
+    const existsTarget = existsMatch ? singleShellTokenValue(existsMatch[1] ?? "") : null;
+    const countTarget = countMatch ? singleShellTokenValue(countMatch[1] ?? "") : null;
+    const readTargets = sedReadTargets(parts[2] ?? "");
+    if (!existsTarget || countTarget !== existsTarget || readTargets?.length !== 1 || readTargets[0] !== existsTarget) {
+        return null;
+    }
+    return existsTarget;
 }
 function processCommandInspectsSessionMetadata(command) {
     const trimmed = command.trim();
     return (/^(?:find|ls|wc|stat|du)\b/.test(trimmed) &&
         trimmed.includes(".parallel-codex/sessions/"));
 }
+function processCommandInspectsSessionCwd(command, cwd) {
+    if (!cwd || !/[\\/]\.parallel-codex[\\/]sessions[\\/]/.test(cwd)) {
+        return false;
+    }
+    const trimmed = command.trim();
+    return (/^(?:rg\s+--files|ls|find|fd|tree|stat|du|wc)\b/.test(trimmed) ||
+        /^pwd\s*&&\s*(?:rg\s+--files|ls|find|fd|tree)\b/.test(trimmed));
+}
 function processCommandReadsSessionSystemFile(command) {
     const trimmed = command.trim();
     if (!/^(?:cat|sed|nl|head|tail|bat|less|more)\b/.test(trimmed)) {
@@ -1339,6 +2069,7 @@ function skipProcessCommandOutputBlock(rawLines, startIndex) {
             trimmed.startsWith("$ ") ||
             parseShellExecCommand(trimmed) !== null ||
             isAssistantNarrativeMarker(trimmed) ||
+            /^tokens used$/i.test(trimmed) ||
             isDiffStartLine(trimmed)) {
             return index;
         }
@@ -1412,6 +2143,61 @@ function readQuotedShellSegment(text, startIndex) {
 function isAssistantNarrativeMarker(trimmed) {
     return trimmed === "codex" || trimmed === "assistant";
 }
+function dedupeRepeatedAssistantNarrativeBlocks(rawLines) {
+    const blocks = collectAssistantNarrativeBlocks(rawLines);
+    const lastBlockByKey = new Map();
+    for (const block of blocks) {
+        lastBlockByKey.set(block.key, block);
+    }
+    const removed = new Set();
+    for (const block of blocks) {
+        if (lastBlockByKey.get(block.key) === block) {
+            continue;
+        }
+        for (let index = block.startIndex; index < block.endIndex; index += 1) {
+            removed.add(index);
+        }
+    }
+    return removed.size > 0
+        ? rawLines.filter((_line, index) => !removed.has(index))
+        : rawLines;
+}
+function collectAssistantNarrativeBlocks(rawLines) {
+    const blocks = [];
+    for (let index = 0; index < rawLines.length;) {
+        const trimmed = normalizedProcessLine(rawLines[index] ?? "").trim();
+        const marked = isAssistantNarrativeMarker(trimmed);
+        const tokenTrailer = /^tokens used$/i.test(trimmed);
+        if (!marked && !tokenTrailer) {
+            index += 1;
+            continue;
+        }
+        const contentStart = marked ? index + 1 : skipNoisyProcessLine(rawLines, index);
+        const endIndex = skipAssistantNarrativeTextBlock(rawLines, contentStart);
+        const key = assistantNarrativeBlockKey(rawLines, contentStart, endIndex);
+        if (key) {
+            blocks.push({
+                startIndex: marked ? index : contentStart,
+                endIndex,
+                key
+            });
+        }
+        index = Math.max(index + 1, endIndex);
+    }
+    return blocks;
+}
+function assistantNarrativeBlockKey(rawLines, startIndex, endIndex) {
+    const lines = rawLines
+        .slice(startIndex, endIndex)
+        .map((line) => normalizedProcessLine(line).trimEnd());
+    while (lines.length > 0 && !lines[0]?.trim()) {
+        lines.shift();
+    }
+    while (lines.length > 0 && !lines[lines.length - 1]?.trim()) {
+        lines.pop();
+    }
+    return lines.join("\n");
+}
 function skipAssistantNarrativeBlock(rawLines, startIndex) {
     return skipAssistantNarrativeTextBlock(rawLines, startIndex + 1);
 }
@@ -1893,6 +2679,19 @@ function isBuildOutputSummaryLine(line) {
 function isNoMatchesSummaryLine(line) {
     return /^No matches in \d+(?:ms|s|m)?(?:\s+\(\$ .+\))?$/i.test(line);
 }
+function isNetworkRecoverySummaryLine(line) {
+    return networkRecoverySummaryParts(line) !== null;
+}
+function networkRecoverySummaryParts(line) {
+    const match = line.match(/^Network recovered after (reconnect \d+\/\d+|\d+ reconnects?)(?: (via HTTPS fallback|with \d+ HTTPS fallbacks))?$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        reconnect: match[1] ?? "",
+        fallback: match[2]?.replace(/^via\s+/i, "").replace(/^with\s+/i, "") ?? ""
+    };
+}
 function isCollapsedOutputSummaryLine(line) {
     return /^Collapsed (?:code|file list|source) output: \d+ (?:lines|paths)$/i.test(line);
 }
@@ -1945,7 +2744,7 @@ function isFileListOutputLine(line) {
     if (pathPattern.test(line)) {
         return true;
     }
-    return /^[A-Za-z0-9._@+-]+\.(?:cjs|css|diff|html|js|json|jsonl|lock|md|mjs|toml|ts|tsx|txt|yml|yaml)$/.test(line);
+    return /^[A-Za-z0-9._@+-]+\.(?:cjs|css|diff|html|js|json|jsonl|lock|log|md|mjs|toml|ts|tsx|txt|yml|yaml)$/.test(line);
 }
 function collectSourceOutputRun(lines, startIndex) {
     let index = startIndex;
@@ -2026,7 +2825,7 @@ function isCssLikeProcessLine(line) {
         /^[A-Za-z][A-Za-z0-9-]*;$/.test(line));
 }
 function isJavaScriptLikeProcessLine(line) {
-    return (/^(?:const|let|var|import|export|await|return|if|else|for|while|switch|try|catch|finally|function|class|new)\b/.test(line) ||
+    return (/^(?:const|let|var|import|export|await|return|delete|throw|yield|break|continue|if|else|for|while|switch|try|catch|finally|function|class|new)\b/.test(line) ||
         /^\}\s*else\b/.test(line) ||
         /^\.[A-Za-z_$][\w$]*(?:\s*\(|\.)/.test(line) ||
         /^[A-Za-z_$][\w$.[\]'"]*\s*(?:[+\-*/%]?=|\(|\.)/.test(line) ||
@@ -2054,6 +2853,18 @@ function skipNoisyProcessLine(rawLines, startIndex) {
         }
         return index;
     }
+    if (isCodexPluginManifestNoise(trimmed)) {
+        const next = normalizedProcessLine(rawLines[startIndex + 1] ?? "").trim();
+        return /^supported path=.*(?:\.codex-plugin\/plugin\.json|\/plugin\.json)$/i.test(next)
+            ? startIndex + 2
+            : startIndex + 1;
+    }
+    if (isCodexTelemetryNoise(trimmed)) {
+        const next = normalizedProcessLine(rawLines[startIndex + 1] ?? "").trim();
+        return /^failed:\s+tag value contains invalid characters:/i.test(next)
+            ? startIndex + 2
+            : startIndex + 1;
+    }
     return startIndex + 1;
 }
 function shouldDropNoisyProcessLine(trimmed, line) {
@@ -2061,6 +2872,10 @@ function shouldDropNoisyProcessLine(trimmed, line) {
         return false;
     }
     return (/^tokens used$/i.test(trimmed) ||
+        /^apply patch$/i.test(trimmed) ||
+        /^patch:\s+completed$/i.test(trimmed) ||
+        isCodexPluginManifestNoise(trimmed) ||
+        isCodexTelemetryNoise(trimmed) ||
         trimmed.includes("codex_models_manager::manager: failed to refresh available models") ||
         (trimmed.includes("failed to decode models response") && trimmed.includes("body: {\"data\"")) ||
         trimmed.startsWith("body: {\"data\"") ||
@@ -2070,6 +2885,12 @@ function shouldDropNoisyProcessLine(trimmed, line) {
         /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]$/.test(trimmed) ||
         line === "--------");
 }
+function isCodexPluginManifestNoise(trimmed) {
+    return /codex_?core_?plugins::manifest: ignoring interface\.defaultPrompt/.test(trimmed);
+}
+function isCodexTelemetryNoise(trimmed) {
+    return trimmed.includes("codex_otel::events::session_telemetry: metrics counter");
+}
 function isNpmLifecycleEchoStart(trimmed) {
     return /^>\s+(?:@[^/\s]+\/)?[^@\s]+@\S+\s+\S+/.test(trimmed);
 }
@@ -2240,6 +3061,7 @@ function collectEmbeddedDiffBlock(rawLines, startIndex) {
     return { lines, nextIndex: index };
 }
 function collectBareDiffHunkBlock(rawLines, startIndex) {
+    const lines = [];
     let index = startIndex;
     let insideHunk = false;
     let hunkCounts = null;
@@ -2249,6 +3071,7 @@ function collectBareDiffHunkBlock(rawLines, startIndex) {
         if (isDiffHunkLine(trimmedStart)) {
             insideHunk = true;
             hunkCounts = parseHunkCounts(trimmedStart);
+            lines.push(trimmedStart);
             index += 1;
             continue;
         }
@@ -2256,17 +3079,63 @@ function collectBareDiffHunkBlock(rawLines, startIndex) {
             if (hunkCounts && hunkCounts.oldRemaining <= 0 && hunkCounts.newRemaining <= 0) {
                 break;
             }
+            lines.push(line);
             hunkCounts = consumeHunkLine(line, hunkCounts);
             index += 1;
             continue;
         }
         if (insideHunk && isDiffMetaLine(trimmedStart)) {
+            lines.push(trimmedStart);
             index += 1;
             continue;
         }
         break;
     }
-    return { nextIndex: index };
+    return { lines, nextIndex: index };
+}
+function inferBareDiffFile(rawLines, startIndex) {
+    let newPath = null;
+    let oldPath = null;
+    let inspected = 0;
+    for (let index = startIndex - 1; index >= 0 && inspected < 8; index -= 1) {
+        const trimmed = normalizedProcessLine(rawLines[index] ?? "").trim();
+        if (!trimmed) {
+            continue;
+        }
+        inspected += 1;
+        const nextFile = unifiedDiffHeaderPath(trimmed, "+++");
+        if (nextFile !== null) {
+            newPath = nextFile;
+            continue;
+        }
+        const previousFile = unifiedDiffHeaderPath(trimmed, "---");
+        if (previousFile !== null) {
+            oldPath = previousFile;
+            const selected = newPath && newPath !== "/dev/null" ? newPath : oldPath;
+            return selected && selected !== "/dev/null" ? formatDiffDisplayPath(selected) : null;
+        }
+        if (!newPath && looksLikeStandaloneDiffPath(trimmed)) {
+            return formatDiffDisplayPath(trimmed);
+        }
+        if (parseHunkStart(trimmed) || isDiffStartLine(trimmed) || isHardProcessBoundary(trimmed)) {
+            break;
+        }
+    }
+    const selected = newPath && newPath !== "/dev/null" ? newPath : oldPath;
+    return selected && selected !== "/dev/null" ? formatDiffDisplayPath(selected) : null;
+}
+function unifiedDiffHeaderPath(line, marker) {
+    if (!line.startsWith(`${marker} `) && !line.startsWith(`${marker}\t`)) {
+        return null;
+    }
+    const value = line.slice(marker.length).trimStart().split("\t", 1)[0]?.trim() ?? "";
+    return value.replace(/^[ab]\//, "");
+}
+function looksLikeStandaloneDiffPath(line) {
+    return !/\s/.test(line)
+        && /(?:^|\/)[A-Za-z0-9._@+-]+\.[A-Za-z0-9._@+-]+$/.test(line)
+        && !line.startsWith("+")
+        && !line.startsWith("-");
 }
 function collectBareProcessDiffBodyRun(rawLines, startIndex) {
     let index = startIndex;
@@ -2314,7 +3183,7 @@ function nextSignificantProcessLineStartsDiff(rawLines, startIndex) {
             isCollapsedOutputSummaryLine(trimmed)) {
             continue;
         }
-        return isDiffStartLine(trimmed);
+        return isDiffStartLine(trimmed) || parseHunkStart(trimmed) !== null;
     }
     return false;
 }
@@ -2426,6 +3295,58 @@ function skipProcessDiffTailContext(rawLines, startIndex) {
     }
     return index;
 }
+function skipBareDiffTailContext(rawLines, startIndex) {
+    let index = startIndex;
+    let skippedTail = false;
+    while (index < rawLines.length) {
+        const line = normalizedProcessLine(rawLines[index] ?? "");
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (skippedTail || nextLineLooksLikeBareDiffTail(rawLines, index + 1)) {
+                index += 1;
+                continue;
+            }
+            return index;
+        }
+        if (isHardProcessBoundary(trimmed)
+            || isDiffStartLine(trimmed)
+            || parseHunkStart(trimmed)
+            || isAssistantNarrativeMarker(trimmed)
+            || isRolePromptTranscriptStart(trimmed)) {
+            return index;
+        }
+        if (isCollapsedOutputSummaryLine(trimmed)
+            || isProcessCodeOutputLine(trimmed)
+            || isBareProcessDiffBodyLine(line)
+            || isIndentedBareDiffTailLine(line)) {
+            skippedTail = true;
+            index += 1;
+            continue;
+        }
+        return index;
+    }
+    return index;
+}
+function nextLineLooksLikeBareDiffTail(rawLines, startIndex) {
+    for (let index = startIndex; index < rawLines.length; index += 1) {
+        const line = normalizedProcessLine(rawLines[index] ?? "");
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        return (isCollapsedOutputSummaryLine(trimmed)
+            || isProcessCodeOutputLine(trimmed)
+            || isBareProcessDiffBodyLine(line)
+            || isIndentedBareDiffTailLine(line));
+    }
+    return false;
+}
+function isIndentedBareDiffTailLine(line) {
+    const trimmedStart = line.trimStart();
+    return !trimmedStart.startsWith("+++")
+        && !trimmedStart.startsWith("---")
+        && /^[+-]\s{2,}\S/.test(trimmedStart);
+}
 function nextLineLooksLikeProcessDiffTail(rawLines, startIndex) {
     for (let index = startIndex; index < rawLines.length; index += 1) {
         const line = normalizedProcessLine(rawLines[index] ?? "");
@@ -2470,7 +3391,7 @@ function renderDiffContent(text) {
         const fileTitle = renderDiffFileTitle(trimmedStart);
         if (fileTitle) {
             flushCurrentFile();
-            currentFile = { title: fileTitle, added: 0, removed: 0, lines: [] };
+            currentFile = { title: fileTitle, added: 0, removed: 0, hunks: 0, lines: [] };
             oldLineNumber = 0;
             newLineNumber = 0;
             insideHunk = false;
@@ -2478,6 +3399,12 @@ function renderDiffContent(text) {
         }
         const hunkStart = parseHunkStart(trimmedStart);
         if (hunkStart) {
+            if (currentFile) {
+                if (currentFile.hunks > 0) {
+                    currentFile.lines.push({ kind: "diff-hunk", text: trimmedStart });
+                }
+                currentFile.hunks += 1;
+            }
             oldLineNumber = hunkStart.oldStart;
             newLineNumber = hunkStart.newStart;
             insideHunk = true;
@@ -2522,6 +3449,65 @@ function renderDiffContent(text) {
     flushCurrentFile();
     return rendered;
 }
+function renderBareDiffHunkContent(lines, diffFile = null) {
+    const hunks = [];
+    let currentHunk = [];
+    let oldLineNumber = 0;
+    let newLineNumber = 0;
+    let insideHunk = false;
+    const flushHunk = () => {
+        if (currentHunk.some((line) => line.kind === "diff-add" || line.kind === "diff-remove")) {
+            hunks.push(currentHunk);
+        }
+        currentHunk = [];
+    };
+    for (const rawLine of lines) {
+        const line = stripAnsiForDiff(rawLine);
+        const trimmedStart = line.trimStart();
+        const hunkStart = parseHunkStart(trimmedStart);
+        if (hunkStart) {
+            flushHunk();
+            currentHunk.push({
+                kind: "diff-hunk",
+                text: trimmedStart,
+                ...(diffFile ? { diffFile } : {})
+            });
+            oldLineNumber = hunkStart.oldStart;
+            newLineNumber = hunkStart.newStart;
+            insideHunk = true;
+            continue;
+        }
+        if (!insideHunk) {
+            continue;
+        }
+        if (line.startsWith("+")) {
+            currentHunk.push({
+                kind: "diff-add",
+                text: formatDiffCodeLine(newLineNumber, "+", line.slice(1))
+            });
+            newLineNumber += 1;
+            continue;
+        }
+        if (line.startsWith("-")) {
+            currentHunk.push({
+                kind: "diff-remove",
+                text: formatDiffCodeLine(oldLineNumber, "-", line.slice(1))
+            });
+            oldLineNumber += 1;
+            continue;
+        }
+        if (line.startsWith(" ")) {
+            currentHunk.push({
+                kind: "diff-context",
+                text: formatDiffCodeLine(newLineNumber, " ", line.slice(1))
+            });
+            oldLineNumber += 1;
+            newLineNumber += 1;
+        }
+    }
+    flushHunk();
+    return hunks.flat();
+}
 function renderDiffFileLine(line) {
     const title = renderDiffFileTitle(line);
     if (!title) {
@@ -2678,6 +3664,9 @@ function classifyRenderedLine(section, line) {
     if (isNoMatchesSummaryLine(trimmed)) {
         return { kind: "summary", text: trimmed };
     }
+    if (isNetworkRecoverySummaryLine(trimmed)) {
+        return { kind: "summary", text: trimmed };
+    }
     if ((isProcessSection || isExplicitErrorLine(trimmed)) &&
         isErrorProcessLine(trimmed) &&
         !isMarkdownListLikeLine(trimmed)) {
@@ -2833,16 +3822,70 @@ function isMarkdownTableSeparator(line) {
 function isMarkdownTableRow(line) {
     return line.startsWith("|") && line.endsWith("|") && line.split("|").length > 2;
 }
-function renderMarkdownTableRow(line) {
+function collectMarkdownTableBlock(rawLines, startIndex) {
+    const rows = [];
+    let index = startIndex;
+    let consumed = false;
+    while (index < rawLines.length) {
+        const line = stripAnsi(rawLines[index] ?? "").replace(/\r/g, "").trim();
+        if (!line) {
+            break;
+        }
+        if (isMarkdownTableSeparator(line)) {
+            consumed = true;
+            index += 1;
+            continue;
+        }
+        if (!isMarkdownTableRow(line)) {
+            break;
+        }
+        const row = parseMarkdownTableRow(line);
+        if (row.length > 0) {
+            rows.push(row);
+        }
+        consumed = true;
+        index += 1;
+    }
+    if (!consumed) {
+        return null;
+    }
+    return {
+        lines: renderMarkdownTableRows(rows),
+        nextIndex: index
+    };
+}
+function parseMarkdownTableRow(line) {
     return line
         .split("|")
         .map((cell) => stripInlineMarkdown(cell.trim()))
-        .filter(Boolean)
-        .join("  ");
+        .filter(Boolean);
+}
+function renderMarkdownTableRows(rows) {
+    if (rows.length === 0) {
+        return [];
+    }
+    const columnWidths = markdownTableColumnWidths(rows);
+    return rows.map((row) => ({
+        kind: "table",
+        text: row
+            .map((cell, index) => index === row.length - 1
+            ? cell
+            : `${cell}${" ".repeat(Math.max(0, (columnWidths[index] ?? 0) - displayWidth(cell)))}`)
+            .join("  ")
+    }));
+}
+function markdownTableColumnWidths(rows) {
+    const widths = [];
+    for (const row of rows) {
+        row.forEach((cell, index) => {
+            widths[index] = Math.max(widths[index] ?? 0, displayWidth(cell));
+        });
+    }
+    return widths;
 }
 function stripInlineMarkdown(text) {
     return text
-        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 <$2>")
+        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, label, target) => formatMarkdownLink(label, target))
         .replace(/`([^`]+)`/g, "$1")
         .replace(/\*\*([^*]+)\*\*/g, "$1")
         .replace(/__([^_]+)__/g, "$1")
@@ -2850,19 +3893,25 @@ function stripInlineMarkdown(text) {
         .replace(/_([^_]+)_/g, "$1")
         .trim();
 }
-function decodeHtmlEntities(text) {
+function formatMarkdownLink(label, target) {
+    const text = stripInlineMarkdownLinkText(label);
+    const href = target.trim();
+    if (!href) {
+        return text;
+    }
+    return isExternalMarkdownLinkTarget(href) ? `${text} <${href}>` : text;
+}
+function stripInlineMarkdownLinkText(text) {
     return text
-        .replace(/&larr;/g, "←")
-        .replace(/&rarr;/g, "→")
-        .replace(/&uarr;/g, "↑")
-        .replace(/&darr;/g, "↓")
-        .replace(/&middot;/g, "·")
-        .replace(/&nbsp;/g, " ")
-        .replace(/&amp;/g, "&")
-        .replace(/&lt;/g, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&quot;/g, "\"")
-        .replace(/&#39;/g, "'");
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/__([^_]+)__/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/_([^_]+)_/g, "$1")
+        .trim();
+}
+function isExternalMarkdownLinkTarget(target) {
+    return /^(?:https?:|mailto:)/i.test(target);
 }
 function renderJsonLine(line) {
     try {
@@ -2873,7 +3922,7 @@ function renderJsonLine(line) {
                 kind: "json",
                 text: summary.meta
             },
-            ...(summary.message ? [{ kind: "json-message", text: summary.message }] : [])
+            ...summary.messages.map((message) => ({ kind: "json-message", text: message }))
         ];
     }
     catch {
@@ -2881,26 +3930,86 @@ function renderJsonLine(line) {
     }
 }
 function summarizeJsonRecord(value) {
-    const severity = stringField(value, "severity");
-    const id = stringField(value, "id");
-    const target = stringField(value, "to") || stringField(value, "from");
+    const state = stringField(value, "status") || stringField(value, "severity");
+    const id = stringField(value, "id") || stringField(value, "finding_id") || stringField(value, "findingId");
+    const to = stringField(value, "to");
+    const from = stringField(value, "from");
+    const direction = from && to ? `${from} -> ${to}` : to ? `to ${to}` : from ? `from ${from}` : "";
     const file = stringField(value, "file") || stringField(value, "path");
-    const message = stringField(value, "message") || stringField(value, "summary") || JSON.stringify(value);
-    const meta = [
-        severity ? `[${severity}]` : "",
-        id,
-        target ? `to ${target}` : "",
-        file
-    ].filter(Boolean).join(" ");
+    const line = numberLikeField(value, "line");
+    const column = numberLikeField(value, "column") || numberLikeField(value, "col");
+    const location = formatJsonRecordLocation(file, line, column);
+    const messages = jsonRecordMessages(value);
+    const marker = state ? `[${state}]` : "";
+    const lead = [marker, id].filter(Boolean).join(" ");
+    const details = [direction, location].filter(Boolean);
+    const meta = id
+        ? [lead, ...details].filter(Boolean).join(" · ")
+        : [lead, ...details].filter(Boolean).join(" ");
     return {
         meta: meta || "json",
-        message
+        messages: messages.length > 0 ? messages : [JSON.stringify(value)]
     };
 }
 function stringField(value, key) {
     const field = value[key];
     return typeof field === "string" ? field.trim() : "";
 }
+function jsonRecordMessages(value) {
+    const primary = stringField(value, "message") || stringField(value, "summary");
+    if (primary) {
+        return [primary];
+    }
+    return [
+        ...textFragmentsField(value, "title"),
+        ...textFragmentsField(value, "detail").map((text) => `detail · ${text}`),
+        ...textFragmentsField(value, "details").map((text) => `detail · ${text}`),
+        ...textFragmentsField(value, "recommendation").map((text) => `fix · ${text}`)
+    ].filter(uniqueTextFragmentFilter());
+}
+function textFragmentsField(value, key) {
+    return textFragmentsValue(value[key]);
+}
+function textFragmentsValue(value) {
+    if (typeof value === "string") {
+        return value.trim() ? [value.trim()] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => textFragmentsValue(item));
+    }
+    return [];
+}
+function uniqueTextFragmentFilter() {
+    const seen = new Set();
+    return (value) => {
+        const normalized = value.toLowerCase();
+        if (!value || seen.has(normalized)) {
+            return false;
+        }
+        seen.add(normalized);
+        return true;
+    };
+}
+function numberLikeField(value, key) {
+    const field = value[key];
+    if (typeof field === "number" && Number.isFinite(field)) {
+        return String(field);
+    }
+    if (typeof field !== "string") {
+        return "";
+    }
+    const trimmed = field.trim();
+    return /^\d+$/.test(trimmed) ? trimmed : "";
+}
+function formatJsonRecordLocation(file, line, column) {
+    if (!file) {
+        return "";
+    }
+    if (!line) {
+        return file;
+    }
+    return column ? `${file}:${line}:${column}` : `${file}:${line}`;
+}
 function stripAnsi(value) {
     return value.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "");
 }
@@ -2918,72 +4027,91 @@ function groupTitle(group) {
 }
 export function workerOutputLineTheme(kind) {
     if (kind === "group") {
-        return { backgroundColor: "ansi256(24)", bold: true, color: "white" };
+        return { backgroundColor: TUI_THEME.chrome, bold: true, color: TUI_THEME.text };
     }
     if (kind === "section") {
-        return { backgroundColor: "ansi256(236)", color: "yellow" };
+        return { backgroundColor: TUI_THEME.rail, color: TUI_THEME.warning };
+    }
+    if (kind === "content" || kind === "list" || kind === "list-detail" || kind === "ordered-list" || kind === "task") {
+        return { backgroundColor: TUI_THEME.surface, color: TUI_THEME.text };
+    }
+    if (kind === "placeholder") {
+        return workerOutputEmptyFallbackTheme();
     }
     if (kind === "heading") {
-        return { backgroundColor: "ansi256(235)", bold: true, color: "white" };
+        return { backgroundColor: TUI_THEME.surface, bold: true, color: TUI_THEME.text };
     }
     if (kind === "quote") {
-        return { backgroundColor: "ansi256(235)", color: "gray" };
+        return { backgroundColor: TUI_THEME.surface, color: TUI_THEME.muted };
     }
     if (kind === "table") {
-        return { backgroundColor: "ansi256(236)", color: "white" };
+        return { backgroundColor: TUI_THEME.rail, color: TUI_THEME.text };
     }
     if (kind === "rule") {
-        return { color: "gray", dimColor: true };
+        return { backgroundColor: TUI_THEME.surface, color: TUI_THEME.muted };
+    }
+    if (kind === "blank") {
+        return { backgroundColor: TUI_THEME.surface };
     }
     if (kind === "code") {
-        return { backgroundColor: "ansi256(236)", color: "gray" };
+        return { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted };
     }
     if (kind === "source-line") {
-        return { backgroundColor: "ansi256(235)", color: "white" };
+        return { backgroundColor: TUI_THEME.surface, color: TUI_THEME.text };
     }
     if (kind === "summary") {
-        return { backgroundColor: "ansi256(236)", color: "gray" };
+        return { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted };
     }
     if (kind === "json") {
-        return { backgroundColor: "ansi256(53)", color: "magenta" };
+        return { backgroundColor: TUI_THEME.rail, color: TUI_THEME.accent };
     }
     if (kind === "json-message") {
-        return { backgroundColor: "ansi256(235)" };
+        return { backgroundColor: TUI_THEME.surface };
     }
     if (kind === "command") {
-        return { backgroundColor: "ansi256(17)", color: "cyan" };
+        return { backgroundColor: TUI_THEME.chrome, color: TUI_THEME.accent };
     }
     if (kind === "success") {
-        return { backgroundColor: "ansi256(22)", color: "green" };
+        return { backgroundColor: TUI_THEME.successSurface, color: TUI_THEME.success };
     }
     if (kind === "error") {
-        return { backgroundColor: "ansi256(52)", color: "red" };
+        return { backgroundColor: TUI_THEME.dangerSurface, color: TUI_THEME.danger };
     }
     if (kind === "diff-file") {
-        return { bold: true, color: "cyan" };
+        return { backgroundColor: TUI_THEME.surface, bold: true, color: TUI_THEME.accent };
     }
     if (kind === "diff-summary") {
-        return { color: "white" };
+        return { backgroundColor: TUI_THEME.surface, color: TUI_THEME.text };
     }
     if (kind === "diff-hunk" || kind === "diff-meta") {
-        return { backgroundColor: "ansi256(236)", color: "gray" };
+        return { backgroundColor: TUI_THEME.rail, color: TUI_THEME.muted };
     }
     if (kind === "diff-add") {
-        return { backgroundColor: "ansi256(22)", color: "green" };
+        return { backgroundColor: TUI_THEME.successSurface, color: TUI_THEME.success };
     }
     if (kind === "diff-remove") {
-        return { backgroundColor: "ansi256(52)", color: "red" };
+        return { backgroundColor: TUI_THEME.dangerSurface, color: TUI_THEME.danger };
     }
     if (kind === "diff-context") {
-        return { color: "gray" };
+        return { backgroundColor: TUI_THEME.surface, color: TUI_THEME.muted };
     }
     return {};
 }
+export function workerOutputEmptyFallbackTheme() {
+    return {
+        backgroundColor: TUI_THEME.surface,
+        color: TUI_THEME.muted
+    };
+}
+export function workerOutputLineFillTheme(kind) {
+    const backgroundColor = workerOutputLineTheme(kind).backgroundColor;
+    return backgroundColor ?? null;
+}
 export function workerOutputLineLayout(kind, text) {
     if (kind === "section") {
-        return { gutter: "", body: `file · ${formatWorkerSectionTitle(text)}` };
+        return { gutter: "", body: joinWorkerOutputChromeParts([workerSectionLabel(text), formatWorkerSectionTitle(text)]) };
     }
-    if (kind === "content") {
+    if (kind === "content" || kind === "placeholder") {
         return { gutter: "", body: formatPlainDisplayText(text) };
     }
     if (kind === "heading") {
@@ -2999,7 +4127,7 @@ export function workerOutputLineLayout(kind, text) {
         return { gutter: "", body: text };
     }
     if (kind === "quote") {
-        return { gutter: "", body: `> ${text}` };
+        return { gutter: "", body: `│ ${text}` };
     }
     if (kind === "table" || kind === "rule") {
         return { gutter: "", body: text };
@@ -3035,7 +4163,7 @@ export function workerOutputLineLayout(kind, text) {
         return { gutter: "", body: `└ ${text}` };
     }
     if (kind === "diff-hunk") {
-        return { gutter: "", body: `hunk ${text}` };
+        return { gutter: "", body: text };
     }
     if (kind === "diff-context") {
         return { gutter: "", body: text };
@@ -3052,9 +4180,66 @@ export function workerOutputLineLayout(kind, text) {
     return { gutter: "", body: text };
 }
 function formatWorkerSectionTitle(title) {
+    const featureMatch = title.match(/^features\/([^/]+)\/([^/]+)$/);
+    const turn = featureMatch?.[1] ?? "";
+    const file = (featureMatch?.[2] ?? basename(title)).toLowerCase();
+    if (turn && isTurnScopedWorkerArtifact(file)) {
+        return turn;
+    }
+    if (file === "requirements.md" || file === "plan.md" || file === "acceptance.md" || file === "worklog.md") {
+        return "";
+    }
+    if (file === "patch.diff") {
+        return "patch";
+    }
     return title.replace(/^features\//, "");
 }
+function workerSectionLabel(title) {
+    const file = basename(title).toLowerCase();
+    if (file === "requirements.md") {
+        return "requirements";
+    }
+    if (file === "plan.md") {
+        return "plan";
+    }
+    if (file === "acceptance.md") {
+        return "acceptance";
+    }
+    if (file === "actor-worklog.md" || file === "worklog.md") {
+        return "worklog";
+    }
+    if (file === "decisions.md") {
+        return "decision";
+    }
+    if (file.endsWith(".diff")) {
+        return "diff";
+    }
+    if (file === "actor-replies.jsonl") {
+        return "mail";
+    }
+    if (file === "critic-findings.jsonl") {
+        return "findings";
+    }
+    if (file.endsWith(".jsonl")) {
+        return "jsonl";
+    }
+    return "file";
+}
+function isTurnScopedWorkerArtifact(file) {
+    return file === "actor-worklog.md" ||
+        file === "decisions.md" ||
+        file === "actor-replies.jsonl" ||
+        file === "critic-findings.jsonl";
+}
 function formatSummaryDisplayText(text) {
+    const networkRecovery = networkRecoverySummaryParts(text);
+    if (networkRecovery) {
+        return [
+            "network recovered",
+            networkRecovery.reconnect,
+            networkRecovery.fallback
+        ].filter(Boolean).join(" · ");
+    }
     const readRun = text.match(/^Collapsed read summaries: (\d+) chunks, (\d+) lines(?: \((.+)\))?$/i);
     if (readRun) {
         return [
@@ -3275,41 +4460,76 @@ function formatFileUrlDisplay(url) {
     const segments = path.split("/").filter(Boolean);
     return segments.slice(-2).join("/") || url;
 }
-function WorkerOutputLine({ line }) {
+function WorkerOutputLine({ line, selected, width }) {
     const theme = workerOutputLineTheme(line.kind);
+    const fillBackground = workerOutputLineFillTheme(line.kind);
     if (line.kind === "blank") {
-        return _jsx(Text, { children: " " });
+        return _jsx(WorkerOutputBlankLine, { width: width });
     }
     if (line.kind === "group") {
-        return (_jsx(Box, { children: _jsxs(Text, { ...theme, children: [" ", line.text, " "] }) }));
+        const body = `${selected ? ">" : " "}${line.text} `;
+        return (_jsxs(Box, { children: [_jsx(Text, { ...theme, children: body }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: displayWidth(body) })] }));
     }
     if (line.preformatted) {
-        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { ...theme, wrap: "truncate-end", children: line.text || " " })] }));
+        const body = line.text || " ";
+        return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), _jsx(Text, { ...theme, wrap: "truncate-end", children: body }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: 2 + displayWidth(body) })] }));
     }
     const layout = workerOutputLineLayout(line.kind, line.text);
     if (line.kind === "code") {
-        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { ...theme, wrap: "wrap", children: line.text || " " })] }));
+        return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), _jsx(Text, { ...theme, wrap: "wrap", children: line.text || " " }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: 2 + displayWidth(line.text || " ") })] }));
     }
     if (line.kind === "source-line") {
         const sourceParts = sourceDisplayLineParts(line.text);
         if (sourceParts) {
-            return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { backgroundColor: WORKER_PANEL_BACKGROUND, color: "gray", children: sourceParts.gutter }), _jsx(Text, { backgroundColor: WORKER_PANEL_BACKGROUND, color: "white", wrap: "truncate-end", children: sourceParts.code })] }));
+            const usedWidth = 2 + displayWidth(sourceParts.gutter) + displayWidth(sourceParts.code || " ");
+            return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), _jsx(Text, { backgroundColor: TUI_THEME.surface, color: TUI_THEME.muted, children: sourceParts.gutter }), _jsx(Text, { backgroundColor: TUI_THEME.surface, color: TUI_THEME.text, wrap: "truncate-end", children: sourceParts.code }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: usedWidth })] }));
         }
-        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { ...theme, children: line.text || " " })] }));
+        const body = line.text || " ";
+        return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), _jsx(Text, { ...theme, children: body }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: 2 + displayWidth(body) })] }));
     }
     if (line.continuation && isDiffCodeKind(line.kind)) {
-        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { ...theme, wrap: "truncate-end", children: line.text || " " })] }));
+        const body = line.text || " ";
+        return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), _jsx(Text, { ...theme, wrap: "truncate-end", children: body }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: 2 + displayWidth(body) })] }));
     }
     const diffCodeLine = diffCodeLineParts(line);
     if (diffCodeLine) {
-        return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), _jsx(Text, { ...theme, children: `${diffCodeLine.lineNumber} ${diffCodeLine.sign} ` }), _jsx(Text, { ...theme, wrap: "wrap", children: diffCodeLine.code || " " })] }));
+        const prefix = `${diffCodeLine.lineNumber} ${diffCodeLine.sign} `;
+        const code = diffCodeLine.code || " ";
+        return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), _jsx(Text, { ...theme, children: prefix }), _jsx(Text, { ...theme, wrap: "wrap", children: code }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: 2 + displayWidth(prefix) + displayWidth(code) })] }));
+    }
+    const gutter = layout.gutter ? formatGutter(layout.gutter) : "";
+    const body = layout.body || " ";
+    return (_jsxs(Box, { children: [_jsx(WorkerOutputIndent, { backgroundColor: fillBackground, selected: selected }), gutter ? _jsx(Text, { ...theme, children: gutter }) : null, _jsx(Text, { ...theme, wrap: "truncate-end", children: body }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: width, usedWidth: 2 + displayWidth(gutter) + displayWidth(body) })] }));
+}
+function WorkerOutputIndent({ backgroundColor, selected }) {
+    if (selected) {
+        return _jsx(Text, { backgroundColor: backgroundColor ?? TUI_THEME.surface, color: TUI_THEME.accent, bold: true, children: "> " });
+    }
+    return backgroundColor
+        ? _jsx(Text, { backgroundColor: backgroundColor, children: "  " })
+        : _jsx(Text, { color: TUI_THEME.muted, children: "  " });
+}
+function WorkerOutputBlankLine({ width }) {
+    const theme = workerOutputLineTheme("blank");
+    const fillWidth = shouldRenderWorkerOutputRailFill() ? Math.max(1, width) : 1;
+    return _jsx(Text, { ...theme, children: " ".repeat(fillWidth) });
+}
+function WorkerOutputTrailingFill({ backgroundColor, usedWidth, width }) {
+    if (!backgroundColor || !shouldRenderWorkerOutputRailFill()) {
+        return null;
     }
-    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  " }), layout.gutter ? _jsx(Text, { ...theme, children: formatGutter(layout.gutter) }) : null, _jsx(Text, { ...theme, wrap: "truncate-end", children: layout.body || " " })] }));
+    const fillWidth = Math.max(0, width - usedWidth);
+    return fillWidth > 0 ? _jsx(Text, { backgroundColor: backgroundColor, children: " ".repeat(fillWidth) }) : null;
+}
+function shouldRenderWorkerOutputRailFill() {
+    return process.stdout.isTTY === true && typeof process.stdout.columns === "number";
 }
-function WorkerOutputNanoLine({ line, width }) {
+function WorkerOutputNanoLine({ fillWidth, line, selected, width }) {
     const theme = workerOutputLineTheme(line.kind);
-    const text = compactEndByDisplayWidth(workerOutputNanoLineText(line), Math.max(1, width));
-    return _jsx(Text, { ...theme, wrap: "truncate-end", children: text || " " });
+    const fillBackground = workerOutputLineFillTheme(line.kind);
+    const text = compactEndByDisplayWidth(`${selected ? "> " : ""}${workerOutputNanoLineText(line)}`, Math.max(1, width));
+    const body = text || " ";
+    return (_jsxs(Box, { children: [_jsx(Text, { ...theme, wrap: "truncate-end", children: body }), _jsx(WorkerOutputTrailingFill, { backgroundColor: fillBackground, width: fillWidth, usedWidth: displayWidth(body) })] }));
 }
 function workerOutputNanoLineText(line) {
     if (line.kind === "blank") {
@@ -3367,9 +4587,9 @@ export function workerOutputDiffColumns(text) {
         code: match[3] ?? ""
     };
 }
-function renderDisplayLines(lines, width = Number(process.stdout.columns) || 120) {
-    const contentWidth = Math.max(1, width - 4);
-    if (isNanoWorkerOutputWidth(width)) {
+function renderDisplayLines(lines, width = Number(process.stdout.columns) || 120, options = {}) {
+    const contentWidth = options.contentWidth ?? Math.max(1, width - 4);
+    if (options.nano ?? isNanoWorkerOutputWidth(width)) {
         return renderNanoDisplayLines(lines, contentWidth);
     }
     return lines.flatMap((line) => {
@@ -3442,6 +4662,9 @@ export function workerOutputBodyDisplayLines(kind, text, width) {
     return wrapBodyWithContinuation(body, Math.max(1, width), continuationPrefix);
 }
 function compactWorkerBodyForWidth(kind, body, width) {
+    if (kind === "diff-hunk") {
+        return compactDiffHunkBodyForWidth(body, width);
+    }
     if (kind === "summary") {
         return compactSummaryBodyForWidth(body, width);
     }
@@ -3480,6 +4703,25 @@ function compactWorkerBodyForWidth(kind, body, width) {
     }
     return body;
 }
+function compactDiffHunkBodyForWidth(body, width) {
+    if (displayWidth(body) <= width) {
+        return body;
+    }
+    const match = body.match(/^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@(?:\s+.*)?$/);
+    if (!match) {
+        return compactEndByDisplayWidth(body, width);
+    }
+    const oldStart = match[1] ?? "0";
+    const newStart = match[2] ?? "0";
+    const candidates = [
+        `@@ -${oldStart} +${newStart} @@`,
+        `-${oldStart} +${newStart}`,
+        `${oldStart}>${newStart}`,
+        `+${newStart}`
+    ];
+    return candidates.find((candidate) => displayWidth(candidate) <= width)
+        ?? compactEndByDisplayWidth(body, width);
+}
 function compactContextWindowErrorForWidth(body, width) {
     if (width < 7) {
         return "ctx";
@@ -3558,9 +4800,9 @@ function compactNarrowWorkerBody(body, width) {
     if (/^Findings:\s*none$/i.test(body)) {
         return width < 24 ? compactFindingsNoneForWidth(width) : body;
     }
-    const findingsLabel = width < 24 ? "findings" : "findings.jsonl";
-    const repliesLabel = width < 24 ? "replies" : "replies.jsonl";
-    const worklogLabel = width < 24 ? "worklog" : "worklog.md";
+    const findingsLabel = width < 24 ? "findings" : width < 32 ? "findings.jsonl" : "critic-findings.jsonl";
+    const repliesLabel = width < 24 ? "replies" : width < 32 ? "replies.jsonl" : "actor-replies.jsonl";
+    const worklogLabel = width < 24 ? "worklog" : width < 32 ? "worklog.md" : "actor-worklog.md";
     return body
         .replace(/^(•\s+)?npm run dev could not bind\b.*$/i, (_match, marker) => `${marker ?? ""}dev fallback.`)
         .replace(/\bcritic-findings\.jsonl\b/g, findingsLabel)