pi-agent-flow 2.0.0 → 2.0.2

package/dist/snapshot/snapshot.js

@@ -2,8 +2,7 @@
  * Two JSONL protocols are used in this codebase:
  *
  * 1. Fork Snapshot Protocol (snapshot.ts):
- *    Types: session, model_change, thinking_level_change, system, message,
- *           compression-stats
+ *    Types: session, model_change, thinking_level_change, message
  *    Purpose: Serialized session state passed to child flows via --session.
  *              Emitted by buildForkSessionSnapshotJsonl() and consumed by
  *              sanitizeForkSnapshot() before forking.
@@ -18,7 +17,8 @@
 import { stripReasoningFromAssistantMessage } from "./reasoning-strip.js";
 import { stripSteeringHintFromContent, contentContainsSteeringHintTag, isJsonEqual, } from "../steering/sliding-prompt.js";
 import { stripStrategicHintsFromContent } from "../steering/tool-utils.js";
-import { logError } from "../config/log.js";
+import { logWarn, logError } from "../config/log.js";
+import * as path from "node:path";
 // ---------------------------------------------------------------------------
 // Session snapshot serialization
 // ---------------------------------------------------------------------------
@@ -26,6 +26,27 @@ export function buildForkSessionSnapshotJsonl(sessionManager) {
     const header = sessionManager.getHeader();
     if (!header || typeof header !== "object")
         return null;
+    // Compress cwd in session header: relative to repo root if under it,
+    // otherwise basename only. Saves ~50-100 bytes per snapshot.
+    const repoRoot = process.cwd();
+    let compressedHeader = header;
+    if (typeof compressedHeader.cwd === "string") {
+        const cwd = compressedHeader.cwd;
+        let compressedCwd;
+        if (cwd === repoRoot) {
+            compressedCwd = ".";
+        }
+        else if (cwd.startsWith(repoRoot + "/") || cwd.startsWith(repoRoot + "\\")) {
+            compressedCwd = cwd.slice(repoRoot.length + 1);
+        }
+        else {
+            const lastSep = Math.max(cwd.lastIndexOf("/"), cwd.lastIndexOf("\\"));
+            compressedCwd = lastSep >= 0 ? cwd.slice(lastSep + 1) : cwd;
+        }
+        if (compressedCwd !== cwd) {
+            compressedHeader = { ...compressedHeader, cwd: compressedCwd };
+        }
+    }
     const branchEntries = sessionManager.getBranch();
     const lines = [];
     // Emit session header once, unless getBranch() already includes it as the
@@ -38,13 +59,7 @@ export function buildForkSessionSnapshotJsonl(sessionManager) {
         typeof firstBranch !== "object" ||
         (firstType !== "session" && firstType !== "header") ||
         firstId !== headerId) {
-        lines.push(JSON.stringify(header));
-    }
-    // Emit system event so the JSONL is self-contained — parsers can reconstruct
-    // full context without needing the markdown section.
-    const systemPrompt = header.systemPrompt;
-    if (typeof systemPrompt === "string" && systemPrompt) {
-        lines.push(JSON.stringify({ type: "system", content: systemPrompt }));
+        lines.push(JSON.stringify(compressedHeader));
     }
     for (const entry of branchEntries)
         lines.push(JSON.stringify(entry));
@@ -111,50 +126,18 @@ export function renderCompressedFlowResult(r) {
     }
     if (r.error)
         parts.push(`Error: ${r.error}`);
-    const text = parts.join("\n");
-    if (text.includes("undefined"))
+    // Safety net: reject malformed runtime data where required fields are missing.
+    // This is more precise than a substring search that would false-positive on
+    // legitimate content containing the word "undefined".
+    if (!r.type || !r.status)
         return undefined;
-    return text;
-}
-// ---------------------------------------------------------------------------
-// batch_read result compression
-// ---------------------------------------------------------------------------
-/**
- * Extract file paths from a batch_read tool call's arguments.
- * Handles both { o: [...] } and bare array argument formats.
- */
-function extractBatchReadPaths(args) {
-    if (!args || typeof args !== "object")
-        return [];
-    let ops;
-    if (Array.isArray(args)) {
-        ops = args;
-    }
-    else if (Array.isArray(args.o)) {
-        ops = args.o;
-    }
-    else {
-        return [];
-    }
-    const paths = [];
-    for (const op of ops) {
-        if (!op || typeof op !== "object")
-            continue;
-        const p = op.p;
-        if (typeof p === "string" && p)
-            paths.push(p);
-    }
-    return paths;
-}
-/**
- * Render a compressed batch_read result as compact metadata for child context.
- * Format: [batch_read] N ops → paths: file1.ts, file2.ts, …
- */
-function renderCompressedBatchReadResult(paths) {
-    const MAX_PATHS_DISPLAY = 10;
-    const display = paths.slice(0, MAX_PATHS_DISPLAY);
-    const suffix = paths.length > MAX_PATHS_DISPLAY ? `, … +${paths.length - MAX_PATHS_DISPLAY} more` : "";
-    return `[batch_read] ${paths.length} ops → paths: ${display.join(", ")}${suffix}`;
+    if (r.actions?.some((a) => !a.type || !a.description))
+        return undefined;
+    if (r.commands?.some((c) => !c.command))
+        return undefined;
+    if (r.notDone?.some((n) => !n.item))
+        return undefined;
+    return parts.join("\n");
 }
 // ---------------------------------------------------------------------------
 // Additional tool result compressors
@@ -170,29 +153,444 @@ const KNOWN_SECTION_HEADERS = [
     /^--- (.+) \((\d+) lines\) ---$/,
     /^--- (.+) (context map|file summary) ---$/,
     /^--- bash \[.+\] exit (\d+) ---$/,
+    /^--- bash \[.+\] pending ---$/,
+    /^--- bash \[.+\] error ---$/,
     /^--- edit: .+ ---$/,
     /^--- write: .+ ---$/,
     /^--- delete: .+ ---$/,
     /^--- read: .+ ---$/,
-    /^--- (?!bash \[|edit:|write:|delete:|read:)(.+) ---$/,
+    /^--- rg: .+ ---$/,
+    /^--- (?!bash \[|edit:|write:|delete:|read:|rg:)(.+) ---$/,
 ];
 function isKnownSectionHeader(line) {
     return KNOWN_SECTION_HEADERS.some((re) => re.test(line));
 }
-/** Compress batch tool result: keep bash sections verbatim, truncate read content. */
-function compressBatchResult(text) {
+/** Compress a single bash block into the X1 compact format. */
+/** Convert legacy depth number to DepthPolicy. */
+export function depthToPolicy(depth) {
+    const isDepth1 = depth < 2;
+    return { showPreviews: isDepth1, showBytes: isDepth1, showSupersededBreadcrumbs: isDepth1, showEditBlocks: isDepth1 };
+}
+function compressBashSection(bashId, status, exitCode, timingTier, stdoutLines, stderrLines, policy) {
+    const isDepth1 = policy.showPreviews;
+    const tier = timingTier ? ` · ${timingTier}` : "";
+    // Trim trailing empty lines inserted by multi-bash formatting
+    while (stdoutLines.length > 0 && stdoutLines[stdoutLines.length - 1] === "")
+        stdoutLines.pop();
+    while (stderrLines.length > 0 && stderrLines[stderrLines.length - 1] === "")
+        stderrLines.pop();
+    if (status === "ok") {
+        const lineCount = stdoutLines.length;
+        const linesLabel = lineCount === 1 ? "1 line" : `${lineCount} lines`;
+        if (isDepth1) {
+            if (lineCount === 0) {
+                return `[bash:ok] ${bashId} · exit ${exitCode}${tier} · 0 lines`;
+            }
+            const head = stdoutLines.slice(0, 3).join("\n");
+            return `[bash:ok] ${bashId} · exit ${exitCode}${tier} · ${linesLabel}\n> head:\n${head}`;
+        }
+        return `[bash:ok] ${bashId} · exit ${exitCode}`;
+    }
+    if (status === "pending") {
+        const lineCount = stdoutLines.length;
+        const linesLabel = lineCount === 1 ? "1 line partial" : `${lineCount} lines partial`;
+        if (isDepth1) {
+            if (lineCount === 0) {
+                return `[bash:pending] ${bashId} · still running · 0 lines partial`;
+            }
+            const head = stdoutLines.slice(0, 3).join("\n");
+            return `[bash:pending] ${bashId} · still running · ${linesLabel}\n> head:\n${head}`;
+        }
+        return `[bash:pending] ${bashId} · still running`;
+    }
+    if (status === "error") {
+        const lineCount = stderrLines.length;
+        const linesLabel = lineCount === 1 ? "1 line stderr" : `${lineCount} lines stderr`;
+        const exit = exitCode !== undefined ? ` · exit ${exitCode}` : "";
+        if (isDepth1) {
+            if (lineCount === 0) {
+                return `[bash:err] ${bashId}${exit}${tier} · 0 lines`;
+            }
+            const head = stderrLines.slice(0, 3).join("\n");
+            return `[bash:err] ${bashId}${exit}${tier} · ${linesLabel}\n> stderr:\n${head}`;
+        }
+        return `[bash:err] ${bashId}${exit}`;
+    }
+    return `[bash] ${bashId} · status unknown`;
+}
+/**
+ * Normalize a bash command string for use as a dedup key.
+ */
+function normalizeBashCommand(cmd) {
+    return cmd.trim().replace(/\s+/g, " ");
+}
+/**
+ * Normalize a file path for use as a dedup key.
+ */
+function normalizeDedupPath(rawPath, cwd) {
+    let p = rawPath.replace(/\\/g, "/");
+    if (p.startsWith("./")) {
+        p = p.slice(2);
+    }
+    p = path.resolve(cwd, p);
+    p = path.normalize(p);
+    return p;
+}
+/**
+ * Scan all batch tool results in the snapshot and build a DedupIndex.
+ * Only successful writes/edits/deletes are tracked; error operations are exempt.
+ */
+function buildDedupIndex(lines, toolCallIdToName, toolCallIdToArgs, sessionCwd) {
+    const cwd = sessionCwd ?? process.cwd();
+    const latestWrite = new Map();
+    const latestEdit = new Map();
+    const latestDelete = new Map();
+    const latestWebSearch = new Map();
+    const latestWebFetch = new Map();
+    const latestAskUser = new Map();
+    const bashIdToCommand = new Map();
+    const latestBash = new Map();
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry?.type !== "message" || (entry.message?.role !== "tool" && entry.message?.role !== "toolResult"))
+            continue;
+        const toolCallId = entry.message?.toolCallId;
+        if (typeof toolCallId !== "string")
+            continue;
+        const toolName = toolCallIdToName.get(toolCallId);
+        if (toolName === "batch") {
+            const text = extractToolResultText(entry) ?? "";
+            const textLines = text.replace(/\r\n/g, "\n").split("\n");
+            for (let i = 0; i < textLines.length; i++) {
+                const l = textLines[i];
+                // Successful write
+                const writeMatch = l.match(/^--- write: (.+) \((\d+) bytes\) ---$/);
+                if (writeMatch) {
+                    const normPath = normalizeDedupPath(writeMatch[1].trim(), cwd);
+                    latestWrite.set(normPath, toolCallId);
+                    latestEdit.delete(normPath); // write supersedes earlier edits
+                    continue;
+                }
+                // Error write — exempt from dedup
+                const errorWriteMatch = l.match(/^--- write: (.+) ---$/);
+                if (errorWriteMatch) {
+                    continue;
+                }
+                // Successful edit
+                const editMatch = l.match(/^--- edit: (.+) \(([^)]*)\) ---$/);
+                if (editMatch) {
+                    const normPath = normalizeDedupPath(editMatch[1].trim(), cwd);
+                    latestEdit.set(normPath, toolCallId);
+                    continue;
+                }
+                // Error edit — exempt from dedup
+                const errorEditMatch = l.match(/^--- edit: (.+) ---$/);
+                if (errorEditMatch) {
+                    continue;
+                }
+                // Delete
+                const deleteMatch = l.match(/^--- delete: (.+) ---$/);
+                if (deleteMatch) {
+                    const normPath = normalizeDedupPath(deleteMatch[1].trim(), cwd);
+                    latestDelete.set(normPath, toolCallId);
+                    latestWrite.delete(normPath); // delete supersedes earlier writes
+                    latestEdit.delete(normPath); // delete supersedes earlier edits
+                }
+            }
+            // B1: Extract bash commands from batch args for cross-turn dedup
+            const args = toolCallIdToArgs.get(toolCallId);
+            if (args && typeof args === "object") {
+                const a = args;
+                const ops = Array.isArray(a.o) ? a.o : Array.isArray(a.op) ? a.op : undefined;
+                if (ops) {
+                    for (const op of ops) {
+                        if (op && typeof op === "object") {
+                            const opObj = op;
+                            if (opObj.o === "bash" || opObj.op === "bash") {
+                                const cmd = typeof opObj.c === "string" ? opObj.c : "";
+                                const id = typeof opObj.i === "string" ? opObj.i : "";
+                                if (cmd && id) {
+                                    const normCmd = normalizeBashCommand(cmd);
+                                    bashIdToCommand.set(id, normCmd);
+                                    latestBash.set(normCmd, id);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Ask_user tool results — build A1 dedup index
+        if (toolName === "ask_user") {
+            const args = toolCallIdToArgs.get(toolCallId);
+            if (args && typeof args === "object") {
+                const question = args.question;
+                if (typeof question === "string") {
+                    const norm = question.trim().toLowerCase().slice(0, 120);
+                    if (norm) {
+                        latestAskUser.set(norm, toolCallId);
+                    }
+                }
+            }
+        }
+        // Web tool results — build Q1 dedup index
+        if (toolName === "web") {
+            const args = toolCallIdToArgs.get(toolCallId);
+            if (args && typeof args === "object") {
+                const a = args;
+                const ops = Array.isArray(a.o) ? a.o : Array.isArray(a.op) ? a.op : undefined;
+                if (ops && ops.length > 0) {
+                    const firstOp = ops[0];
+                    if (firstOp && typeof firstOp === "object") {
+                        const query = typeof firstOp.q === "string" ? firstOp.q.trim().toLowerCase() : undefined;
+                        const url = typeof firstOp.u === "string" ? firstOp.u.trim().replace(/\/$/, "") : undefined;
+                        if (query)
+                            latestWebSearch.set(query, toolCallId);
+                        if (url)
+                            latestWebFetch.set(url, toolCallId);
+                    }
+                }
+            }
+        }
+    }
+    return { latestWrite, latestEdit, latestDelete, latestWebSearch, latestWebFetch, latestAskUser, bashIdToCommand, latestBash };
+}
+/** Check if a web tool result is superseded by a later result with the same query or URL. */
+function checkWebDedup(args, toolCallId, dedupIndex) {
+    if (!args || typeof args !== "object")
+        return { isSuperseded: false };
+    const a = args;
+    const ops = Array.isArray(a.o) ? a.o : Array.isArray(a.op) ? a.op : undefined;
+    if (!ops || ops.length === 0)
+        return { isSuperseded: false };
+    const firstOp = ops[0];
+    if (!firstOp || typeof firstOp !== "object")
+        return { isSuperseded: false };
+    if (typeof firstOp.q === "string") {
+        const normQuery = firstOp.q.trim().toLowerCase();
+        if (normQuery) {
+            const latestTc = dedupIndex.latestWebSearch.get(normQuery);
+            if (latestTc !== toolCallId) {
+                return {
+                    isSuperseded: true,
+                    marker: `[web:search] "${firstOp.q}" (superseded by later search)`,
+                };
+            }
+        }
+    }
+    if (typeof firstOp.u === "string") {
+        const normUrl = firstOp.u.trim().replace(/\/$/, "");
+        if (normUrl) {
+            const latestTc = dedupIndex.latestWebFetch.get(normUrl);
+            if (latestTc !== toolCallId) {
+                return {
+                    isSuperseded: true,
+                    marker: `[web:fetch] ${firstOp.u} (superseded by later fetch)`,
+                };
+            }
+        }
+    }
+    return { isSuperseded: false };
+}
+/** Compress batch tool result: compress bash sections, truncate read content, dedup writes/edits/deletes (W1 + E1). */
+function compressBatchResult(text, options = {}) {
+    const policy = options.depthPolicy ?? depthToPolicy(1);
+    const { toolCallId, latestWrite, latestEdit, latestDelete, bashIdToCommand, latestBash } = options;
+    const cwd = options.cwd ?? process.cwd();
     const lines = text.replace(/\r\n/g, "\n").split("\n");
+    // Pre-scan to find the last occurrence of each operation within this result.
+    // This handles the edge case where a single batch result contains multiple
+    // writes/edits/deletes to the same path.
+    const lastWriteIndex = new Map();
+    const lastEditIndex = new Map();
+    const lastDeleteIndex = new Map();
+    for (let j = 0; j < lines.length; j++) {
+        const w = lines[j].match(/^--- write: (.+) \((\d+) bytes\) ---$/);
+        if (w)
+            lastWriteIndex.set(normalizeDedupPath(w[1].trim(), cwd), j);
+        const e = lines[j].match(/^--- edit: (.+) \(([^)]*)\) ---$/);
+        if (e)
+            lastEditIndex.set(normalizeDedupPath(e[1].trim(), cwd), j);
+        const d = lines[j].match(/^--- delete: (.+) ---$/);
+        if (d)
+            lastDeleteIndex.set(normalizeDedupPath(d[1].trim(), cwd), j);
+    }
     const out = [];
     let i = 0;
+    const isSupersededWrite = (normPath, index) => {
+        if (!toolCallId)
+            return false;
+        const latestTc = latestWrite?.get(normPath);
+        if (latestTc !== toolCallId)
+            return true;
+        return lastWriteIndex.get(normPath) !== index;
+    };
+    const isSupersededEdit = (normPath, index) => {
+        if (!toolCallId)
+            return false;
+        const latestTc = latestEdit?.get(normPath);
+        if (latestTc !== toolCallId)
+            return true;
+        return lastEditIndex.get(normPath) !== index;
+    };
+    const isSupersededDelete = (normPath, index) => {
+        if (!toolCallId)
+            return false;
+        const latestTc = latestDelete?.get(normPath);
+        if (latestTc !== toolCallId)
+            return true;
+        return lastDeleteIndex.get(normPath) !== index;
+    };
     while (i < lines.length) {
         const line = lines[i];
-        // File read section with content — truncate
-        const readMatch = line.match(/^--- (.+) \((\d+) lines\) ---$/);
-        if (readMatch) {
-            out.push(`--- ${readMatch[1]} (${readMatch[2]} lines, content truncated) ---`);
+        // Bash section — compress with X1 protocol
+        const bashMatch = line.match(/^--- bash \[([^\]]+)\] (exit (\d+)|pending|error) ---$/);
+        if (bashMatch) {
+            const bashId = bashMatch[1];
+            const rawStatus = bashMatch[2];
+            const status = rawStatus.startsWith("exit") ? "ok" : rawStatus;
+            const exitCode = bashMatch[3] !== undefined ? Number(bashMatch[3]) : undefined;
+            // Stricter section-end check for bash content: don't treat generic
+            // `--- text ---` lines as section headers (they could be bash output).
+            const isBashSectionEnd = (l) => /^--- bash \[.+\]/.test(l) ||
+                /^--- (.+) \((\d+) lines\) ---$/.test(l) ||
+                /^--- (.+) (context map|file summary) ---$/.test(l) ||
+                /^--- edit: .+ ---$/.test(l) ||
+                /^--- write: .+ ---$/.test(l) ||
+                /^--- delete: .+ ---$/.test(l) ||
+                /^--- read: .+ ---$/.test(l) ||
+                /^--- rg: .+ ---$/.test(l);
+            // B1 cross-turn bash dedup
+            const normCmd = bashIdToCommand?.get(bashId);
+            const isSupersededBash = normCmd ? latestBash?.get(normCmd) !== bashId : false;
+            if (isSupersededBash) {
+                if (policy.showSupersededBreadcrumbs) {
+                    const statusTag = status === "ok" ? "ok" : status === "pending" ? "pending" : "err";
+                    out.push(`[bash:${statusTag}] ${bashId} (superseded)`);
+                }
+                i++;
+                while (i < lines.length && !isBashSectionEnd(lines[i])) {
+                    i++;
+                }
+                continue;
+            }
             i++;
+            let timingTier;
+            const stdoutLines = [];
+            let stderrLines = [];
+            let inStderr = false;
+            while (i < lines.length && !isBashSectionEnd(lines[i])) {
+                const contentLine = lines[i];
+                const timingMatch = contentLine.match(/^\[Execution time: (.+)\]$/);
+                if (timingMatch) {
+                    timingTier = timingMatch[1];
+                }
+                else if (contentLine === "[stderr]") {
+                    inStderr = true;
+                }
+                else if (contentLine === "[partial output]") {
+                    // pending partial output marker — stdout follows
+                    inStderr = false;
+                }
+                else if (contentLine.startsWith("[Use batch_bash_poll")) {
+                    // skip poll hint lines
+                }
+                else {
+                    if (inStderr) {
+                        stderrLines.push(contentLine);
+                    }
+                    else {
+                        stdoutLines.push(contentLine);
+                    }
+                }
+                i++;
+            }
+            // If error bash has no stderr but produced stdout, preserve the stdout
+            // as the error output so it isn't silently lost.
+            if (status === "error" && stderrLines.length === 0 && stdoutLines.length > 0) {
+                stderrLines = stdoutLines;
+            }
+            out.push(compressBashSection(bashId, status, exitCode, timingTier, stdoutLines, stderrLines, policy));
+            continue;
+        }
+        // R1: rg output compression
+        const rgMatch = line.match(/^--- rg: (.+) ---$/);
+        if (rgMatch) {
+            const rgPath = rgMatch[1].trim();
+            i++;
+            const rgLines = [];
             while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                rgLines.push(lines[i]);
+                i++;
+            }
+            // Trim trailing empty lines
+            while (rgLines.length > 0 && rgLines[rgLines.length - 1] === "")
+                rgLines.pop();
+            const matchCount = rgLines.length;
+            // Detect error: batch tool outputs "Error: <msg>" for failed rg ops
+            const firstNonEmpty = rgLines.find((l) => l.trim() !== "");
+            const isError = firstNonEmpty?.startsWith("Error:") ?? false;
+            if (isError) {
+                const lineCount = rgLines.filter((l) => l.trim() !== "").length;
+                const linesLabel = lineCount === 1 ? "1 line" : `${lineCount} lines`;
+                out.push(`[rg:err] ${rgPath} · ${linesLabel}`);
+            }
+            else if (matchCount === 0) {
+                out.push(`[rg:ok] ${rgPath} · 0 matches`);
+            }
+            else {
+                // Extract unique file paths from rg output (format: path:line:content)
+                const fileSet = new Set(rgLines
+                    .map((l) => {
+                    const colonIdx = l.indexOf(":");
+                    return colonIdx > 0 ? l.slice(0, colonIdx) : "";
+                })
+                    .filter(Boolean));
+                const fileCount = fileSet.size;
+                if (policy.showPreviews) {
+                    const head = rgLines.slice(0, 3).join("\n");
+                    out.push(`[rg:ok] ${rgPath} · ${matchCount} matches · ${fileCount} files\n> head:\n${head}`);
+                }
+                else {
+                    out.push(`[rg:ok] ${rgPath} · ${matchCount} matches · ${fileCount} files`);
+                }
+            }
+            i--; // will be incremented by loop
+            continue;
+        }
+        // File read section with content — preview or truncate
+        const readMatch = line.match(/^--- (.+) \((\d+) lines\) ---$/);
+        if (readMatch) {
+            if (policy.showPreviews) {
+                i++;
+                const contentLines = [];
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    contentLines.push(lines[i]);
+                    i++;
+                }
+                const head = contentLines.slice(0, 2).join("\n");
+                const tail = contentLines.slice(-2).join("\n");
+                let previewText;
+                if (contentLines.length > 4) {
+                    previewText = `${head}\n[...${contentLines.length - 4} lines truncated...]\n${tail}`;
+                }
+                else {
+                    previewText = contentLines.join("\n");
+                }
+                out.push(`--- ${readMatch[1]} (${readMatch[2]} lines, preview) ---\n${previewText}`);
+            }
+            else {
+                out.push(`--- ${readMatch[1]} (${readMatch[2]} lines, content truncated) ---`);
                 i++;
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    i++;
+                }
             }
             continue;
         }
@@ -206,21 +604,160 @@ function compressBatchResult(text) {
             }
             continue;
         }
-        // File read without line count — truncate
+        // File read without line count — preview or truncate
         // Negative lookahead excludes bash/edit/write/delete/read-error sections that should be kept verbatim
         const fallbackReadMatch = line.match(/^--- (?!bash \[|edit:|write:|delete:|read:)(.+) ---$/);
         if (fallbackReadMatch) {
-            out.push(`--- ${fallbackReadMatch[1]} (content truncated) ---`);
+            if (policy.showPreviews) {
+                i++;
+                const contentLines = [];
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    contentLines.push(lines[i]);
+                    i++;
+                }
+                const head = contentLines.slice(0, 2).join("\n");
+                const tail = contentLines.slice(-2).join("\n");
+                let previewText;
+                if (contentLines.length > 4) {
+                    previewText = `${head}\n[...${contentLines.length - 4} lines truncated...]\n${tail}`;
+                }
+                else {
+                    previewText = contentLines.join("\n");
+                }
+                out.push(`--- ${fallbackReadMatch[1]} (preview) ---\n${previewText}`);
+            }
+            else {
+                out.push(`--- ${fallbackReadMatch[1]} (content truncated) ---`);
+                i++;
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    i++;
+                }
+            }
+            continue;
+        }
+        // Write section — W1 dedup and compression
+        const writeMatch = line.match(/^--- write: (.+) \((\d+) bytes\) ---$/);
+        if (writeMatch) {
+            const rawPath = writeMatch[1].trim();
+            const normPath = normalizeDedupPath(rawPath, cwd);
+            const bytes = writeMatch[2];
+            if (isSupersededWrite(normPath, i)) {
+                if (policy.showSupersededBreadcrumbs) {
+                    out.push(`[batch:write] ${rawPath} (superseded)`);
+                }
+                i++;
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    i++;
+                }
+                continue;
+            }
+            if (policy.showBytes) {
+                out.push(`[batch:write] ${rawPath} (${bytes} bytes)`);
+            }
+            else {
+                out.push(`[batch:write] ${rawPath}`);
+            }
+            i++;
+            while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                i++;
+            }
+            continue;
+        }
+        // Error write — exempt from dedup, keep verbatim
+        const errorWriteMatch = line.match(/^--- write: (.+) ---$/);
+        if (errorWriteMatch) {
+            out.push(line);
+            i++;
+            while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                out.push(lines[i]);
+                i++;
+            }
+            continue;
+        }
+        // Edit section — E1 dedup and compression
+        const editMatch = line.match(/^--- edit: (.+) \(([^)]*)\) ---$/);
+        if (editMatch) {
+            const rawPath = editMatch[1].trim();
+            const normPath = normalizeDedupPath(rawPath, cwd);
+            const blockInfo = editMatch[2];
+            if (isSupersededEdit(normPath, i)) {
+                if (policy.showSupersededBreadcrumbs) {
+                    out.push(`[batch:edit] ${rawPath} (superseded)`);
+                }
+                i++;
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    i++;
+                }
+                continue;
+            }
+            if (policy.showEditBlocks) {
+                const blocksLabel = blockInfo ? ` (${blockInfo})` : "";
+                out.push(`[batch:edit] ${rawPath}${blocksLabel}`);
+            }
+            else {
+                out.push(`[batch:edit] ${rawPath}`);
+            }
+            i++;
+            while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                i++;
+            }
+            continue;
+        }
+        // Error edit — exempt from dedup, keep verbatim
+        const errorEditMatch = line.match(/^--- edit: (.+) ---$/);
+        if (errorEditMatch) {
+            out.push(line);
+            i++;
+            while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                out.push(lines[i]);
+                i++;
+            }
+            continue;
+        }
+        // Delete section — keep existing format for non-superseded, skip superseded
+        const deleteMatch = line.match(/^--- delete: (.+) ---$/);
+        if (deleteMatch) {
+            const rawPath = deleteMatch[1].trim();
+            const normPath = normalizeDedupPath(rawPath, cwd);
+            if (isSupersededDelete(normPath, i)) {
+                if (policy.showSupersededBreadcrumbs) {
+                    out.push(`[batch:delete] ${rawPath} (superseded)`);
+                }
+                i++;
+                while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                    i++;
+                }
+                continue;
+            }
+            out.push(line);
             i++;
             while (i < lines.length && !isKnownSectionHeader(lines[i])) {
+                out.push(lines[i]);
                 i++;
             }
             continue;
         }
-        // Everything else (bash, edit, write, delete, error, summary) — keep as-is
+        // Everything else (summary, error generic, etc.) — keep as-is
         out.push(line);
         i++;
     }
+    // B1: If every line in out is superseded or truncated noise, collapse to single summary
+    const meaningfulOut = out.filter((l) => l.trim() !== "");
+    // Single-pass rollup check: matches superseded breadcrumbs, truncated reads,
+    // and compact bash/rg lines. Equivalent to the previous multi-check logic.
+    const SUPERSEDED_OR_TRUNCATED_RE = /\(superseded\)|\(content truncated\)|\(context map, truncated\)|^\[bash:(ok|pending|err)\] |^\[bash:poll\] |^\[rg:(ok|err)\] /;
+    const isAllSupersededOrTruncated = meaningfulOut.length > 0 && meaningfulOut.every((l) => SUPERSEDED_OR_TRUNCATED_RE.test(l));
+    // At depth 2+, superseded writes/edits are dropped entirely (no breadcrumbs),
+    // leaving out empty. If the original text had only section headers and no
+    // summary or other kept content, rollup to a single line.
+    const meaningfulLines = lines.filter((l) => l.trim() !== "");
+    const allLinesWereSectionHeaders = meaningfulLines.length > 0 && meaningfulLines.every((l) => isKnownSectionHeader(l));
+    if (isAllSupersededOrTruncated || (allLinesWereSectionHeaders && meaningfulOut.length === 0)) {
+        const opCount = meaningfulLines.length > 0 ? String(meaningfulLines.length) : "0";
+        return policy.showSupersededBreadcrumbs
+            ? `[batch] ${opCount} ops (all superseded or truncated by later operations)`
+            : `[batch] ${opCount} ops (superseded)`;
+    }
     return out.join("\n");
 }
 /** Compress web tool result into compact metadata. */
@@ -233,8 +770,10 @@ function compressWebResult(text, args) {
         const ops = Array.isArray(a.o) ? a.o : Array.isArray(a.op) ? a.op : undefined;
         if (ops && ops.length > 0) {
             const firstOp = ops[0];
-            query = typeof firstOp.q === "string" ? firstOp.q : undefined;
-            url = typeof firstOp.u === "string" ? firstOp.u : undefined;
+            if (firstOp && typeof firstOp === "object") {
+                query = typeof firstOp.q === "string" ? firstOp.q : undefined;
+                url = typeof firstOp.u === "string" ? firstOp.u : undefined;
+            }
         }
     }
     // Search result format: numbered list
@@ -277,6 +816,113 @@ function compressAskUserResult(text, args) {
     }
     return `[ask_user] · ${text.length} chars`;
 }
+/** Compress batch_bash_poll tool result into compact metadata (S4 + B1). */
+function compressBatchBashPollResult(text, policy, options) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const out = [];
+    let i = 0;
+    const isDepth1 = policy.showPreviews;
+    const isPollSectionEnd = (l) => /^--- \[.+\]/.test(l);
+    while (i < lines.length) {
+        const line = lines[i];
+        const completedMatch = line.match(/^--- \[([^\]]+)\] (exit (\d+)|interrupted) ---$/);
+        const pendingMatch = line.match(/^--- \[([^\]]+)\] still running ---$/);
+        if (completedMatch || pendingMatch) {
+            const id = (completedMatch ?? pendingMatch)[1];
+            const isCompleted = !!completedMatch;
+            const exitCode = completedMatch?.[3] !== undefined ? Number(completedMatch[3]) : undefined;
+            // B1 cross-turn bash dedup for poll results
+            const normCmd = options?.bashIdToCommand?.get(id);
+            const isSuperseded = normCmd ? options?.latestBash?.get(normCmd) !== id : false;
+            if (isSuperseded) {
+                if (policy.showSupersededBreadcrumbs) {
+                    out.push(`[bash:poll] ${id} (superseded)`);
+                }
+                i++;
+                while (i < lines.length && !isPollSectionEnd(lines[i])) {
+                    i++;
+                }
+                continue;
+            }
+            i++;
+            let timingTier;
+            const stdoutLines = [];
+            let stderrLines = [];
+            let inStderr = false;
+            while (i < lines.length && !isPollSectionEnd(lines[i])) {
+                const contentLine = lines[i];
+                const timingMatch = contentLine.match(/^\[Execution time: (.+)\]$/);
+                if (timingMatch) {
+                    timingTier = timingMatch[1];
+                }
+                else if (contentLine === "[stderr]") {
+                    inStderr = true;
+                }
+                else if (contentLine === "[output so far]") {
+                    inStderr = false;
+                }
+                else if (contentLine.trim() === "") {
+                    // skip empty lines between sections
+                }
+                else {
+                    if (inStderr) {
+                        stderrLines.push(contentLine);
+                    }
+                    else {
+                        stdoutLines.push(contentLine);
+                    }
+                }
+                i++;
+            }
+            const tier = timingTier ? ` · ${timingTier}` : "";
+            if (isCompleted) {
+                const statusTag = exitCode !== undefined ? `exit ${exitCode}` : "interrupted";
+                const statusLabel = exitCode === 0 ? "ok" : "error";
+                if (statusLabel === "error" && stderrLines.length === 0 && stdoutLines.length > 0) {
+                    stderrLines = stdoutLines;
+                }
+                const targetLines = statusLabel === "error" ? stderrLines : stdoutLines;
+                const lineCount = targetLines.length;
+                if (isDepth1) {
+                    if (lineCount === 0) {
+                        out.push(`[bash:poll] ${id} · ${statusTag}${tier} · 0 lines`);
+                    }
+                    else {
+                        const linesLabel = statusLabel === "error"
+                            ? (lineCount === 1 ? "1 line stderr" : `${lineCount} lines stderr`)
+                            : (lineCount === 1 ? "1 line" : `${lineCount} lines`);
+                        const headPrefix = statusLabel === "error" ? "> stderr:" : "> head:";
+                        const head = targetLines.slice(0, 3).join("\n");
+                        out.push(`[bash:poll] ${id} · ${statusTag}${tier} · ${linesLabel}\n${headPrefix}\n${head}`);
+                    }
+                }
+                else {
+                    out.push(`[bash:poll] ${id} · ${statusTag}${tier}`);
+                }
+            }
+            else {
+                const lineCount = stdoutLines.length;
+                const linesLabel = lineCount === 1 ? "1 line partial" : `${lineCount} lines partial`;
+                if (isDepth1) {
+                    if (lineCount === 0) {
+                        out.push(`[bash:poll] ${id} · still running · 0 lines partial`);
+                    }
+                    else {
+                        const head = stdoutLines.slice(0, 3).join("\n");
+                        out.push(`[bash:poll] ${id} · still running · ${linesLabel}\n> head:\n${head}`);
+                    }
+                }
+                else {
+                    out.push(`[bash:poll] ${id} · still running`);
+                }
+            }
+            continue;
+        }
+        out.push(line);
+        i++;
+    }
+    return out.join("\n");
+}
 // ---------------------------------------------------------------------------
 // Shared: toolCallId → toolName mapping
 // ---------------------------------------------------------------------------
@@ -320,7 +966,8 @@ function buildToolCallIdToNameMap(lines) {
  * - `batch_read` results: replaced with compact metadata (paths + op count)
  *   since children have `batch` and can re-read files themselves.
  */
-export function compressToolResults(snapshot, cache) {
+export function compressToolResults(snapshot, cache, depthPolicy) {
+    const policy = depthPolicy ?? depthToPolicy(1);
     const lines = snapshot.trimEnd().split("\n");
     // Quick check: if there are no flow cache entries and no compressible tool calls,
     // nothing to compress — return early.
@@ -331,7 +978,7 @@ export function compressToolResults(snapshot, cache) {
                 return entry?.type === "message" && entry.message?.role === "assistant" &&
                     Array.isArray(entry.message.content) &&
                     entry.message.content.some((p) => p.type === "toolCall" &&
-                        ["batch_read", "batch", "web", "ask_user"].includes(p.name));
+                        ["batch_read", "batch", "web", "ask_user", "batch_bash_poll"].includes(p.name));
             }
             catch {
                 return false;
@@ -371,11 +1018,31 @@ export function compressToolResults(snapshot, cache) {
             continue;
         for (const part of content) {
             if (part.type === "toolCall" && (part.id || part.toolCallId) && part.arguments) {
-                toolCallIdToArgs.set(part.id ?? part.toolCallId, part.arguments);
+                toolCallIdToArgs.set((part.id ?? part.toolCallId), part.arguments);
             }
         }
     }
+    // Extract session cwd from header for path normalization
+    let sessionCwd = process.cwd();
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry?.type === "session" || entry?.type === "header") {
+            if (typeof entry.cwd === "string") {
+                sessionCwd = entry.cwd;
+                break;
+            }
+        }
+    }
+    // === PASS 1 (pre-scan): Build DedupIndex for batch and web tool results (W1 + E1 + Q1) ===
+    const dedupIndex = buildDedupIndex(lines, toolCallIdToName, toolCallIdToArgs, sessionCwd);
     const result = [];
+    let webSummaryEmitted = false;
     // Second pass: compress matching tool results
     for (const line of lines) {
         let entry;
@@ -430,51 +1097,115 @@ export function compressToolResults(snapshot, cache) {
                 // Cache miss (never populated or evicted) — do NOT pass megabytes of raw
                 // flow output verbatim into child context. Render a minimal placeholder.
                 originalText = extractToolResultText(entry) ?? "";
-                const rawContent = entry.message?.content;
-                const contentSize = rawContent
-                    ? (typeof rawContent === "string" ? rawContent.length : JSON.stringify(rawContent).length)
-                    : 0;
-                const size = originalText.length || contentSize || line.length;
-                rendered = `[flow] prior result · ${size} chars — full context unavailable (result not cached at this depth)`;
+                const flowArgs = toolCallIdToArgs.get(toolCallId);
+                let flowTypeSuffix = '';
+                if (flowArgs && typeof flowArgs === 'object') {
+                    const flowArr = Array.isArray(flowArgs.flow)
+                        ? flowArgs.flow
+                        : undefined;
+                    if (flowArr && flowArr.length > 0 && typeof flowArr[0].type === 'string') {
+                        flowTypeSuffix = `:${flowArr[0].type}`;
+                    }
+                    else if (typeof flowArgs.type === 'string') {
+                        flowTypeSuffix = `:${flowArgs.type}`;
+                    }
+                }
+                const statusLabel = entry.message.isError ? 'failed' : 'completed';
+                rendered = `[flow${flowTypeSuffix}] ${statusLabel} · see prior session`;
             }
             else {
-                const renderResults = compressed.map(renderCompressedFlowResult);
-                const hasAnyUndefined = renderResults.some(r => r === undefined);
-                if (hasAnyUndefined) {
-                    // Safety net: compression produced garbage, fall back to truncated raw.
-                    originalText = extractToolResultText(entry) ?? "";
-                    const size = originalText.length;
-                    rendered = size > 2000
-                        ? originalText.slice(0, 2000) + "\n[truncated]"
-                        : originalText;
-                }
-                else {
-                    rendered = renderResults.filter((r) => r !== undefined).join("\n\n");
+                const renderedParts = [];
+                for (const r of compressed) {
+                    const renderedResult = renderCompressedFlowResult(r);
+                    if (renderedResult === undefined) {
+                        // Granular fallback: only this element is malformed, don't waste
+                        // valid siblings by falling back the entire array to raw text.
+                        const flowType = r.type ?? "unknown";
+                        const status = r.status ?? "unknown";
+                        renderedParts.push(`[flow:${flowType}] ${status} (cache miss)`);
+                    }
+                    else {
+                        renderedParts.push(renderedResult);
+                    }
                 }
+                rendered = renderedParts.join("\n\n");
             }
         }
-        // Note: batch_read tool results are now compressed in stripBatchReadToolCalls
-        // before compressToolResults runs, so this branch is no longer needed.
-        // Kept as a no-op safety net for any edge cases.
-        else if (toolName === "batch_read") {
-            rendered = undefined; // handled upstream
-        }
-        // --- Compress batch tool results (selective: keep bash, truncate reads) ---
+        // --- Compress batch tool results (selective: compress bash, truncate reads, dedup writes/edits/deletes) ---
         else if (toolName === "batch") {
             originalText = extractToolResultText(entry) ?? "";
-            rendered = compressBatchResult(originalText);
+            rendered = compressBatchResult(originalText, {
+                depthPolicy: policy,
+                toolCallId,
+                latestWrite: dedupIndex.latestWrite,
+                latestEdit: dedupIndex.latestEdit,
+                latestDelete: dedupIndex.latestDelete,
+                bashIdToCommand: dedupIndex.bashIdToCommand,
+                latestBash: dedupIndex.latestBash,
+                cwd: sessionCwd,
+            });
+        }
+        // --- Compress batch_bash_poll tool results (S4 + B1) ---
+        else if (toolName === "batch_bash_poll") {
+            originalText = extractToolResultText(entry) ?? "";
+            rendered = compressBatchBashPollResult(originalText, policy, {
+                bashIdToCommand: dedupIndex.bashIdToCommand,
+                latestBash: dedupIndex.latestBash,
+            });
         }
-        // --- Compress web tool results ---
+        // --- Compress web tool results (Q1 dedup) ---
         else if (toolName === "web") {
             originalText = extractToolResultText(entry) ?? "";
             const args = toolCallIdToArgs.get(toolCallId);
-            rendered = compressWebResult(originalText, args);
+            const { isSuperseded, marker } = checkWebDedup(args, toolCallId, dedupIndex);
+            if (isSuperseded) {
+                if (policy.showSupersededBreadcrumbs) {
+                    rendered = marker;
+                }
+                else {
+                    // At depth 2+, drop superseded web results entirely
+                    continue;
+                }
+            }
+            else {
+                rendered = compressWebResult(originalText, args);
+                if (!policy.showSupersededBreadcrumbs && !webSummaryEmitted) {
+                    const searchCount = dedupIndex.latestWebSearch.size;
+                    const fetchCount = dedupIndex.latestWebFetch.size;
+                    const total = searchCount + fetchCount;
+                    if (total > 0) {
+                        const fetchLabel = fetchCount === 1 ? "fetch" : "fetches";
+                        rendered = `[web] ${total} unique queries (${searchCount} searches, ${fetchCount} ${fetchLabel}) · latest per query below\n${rendered}`;
+                        webSummaryEmitted = true;
+                    }
+                }
+            }
         }
-        // --- Compress ask_user tool results ---
+        // --- Compress ask_user tool results (A1 dedup) ---
         else if (toolName === "ask_user") {
             originalText = extractToolResultText(entry) ?? "";
             const args = toolCallIdToArgs.get(toolCallId);
-            rendered = compressAskUserResult(originalText, args);
+            let question = "";
+            if (args && typeof args === "object") {
+                const q = args.question;
+                if (typeof q === "string") {
+                    question = q;
+                }
+            }
+            const normQuestion = question.trim().toLowerCase().slice(0, 120);
+            const latestTc = normQuestion ? dedupIndex.latestAskUser.get(normQuestion) : undefined;
+            if (latestTc && latestTc !== toolCallId) {
+                if (policy.showSupersededBreadcrumbs) {
+                    rendered = `[ask_user] "${question}" (superseded by later ask_user)`;
+                }
+                else {
+                    // At depth 2+, drop superseded ask_user results entirely
+                    continue;
+                }
+            }
+            else {
+                rendered = compressAskUserResult(originalText, args);
+            }
         }
         if (rendered !== undefined) {
             logCompress(toolName ?? "unknown", originalText.length || line.length, rendered.length);
@@ -523,13 +1254,6 @@ function extractToolResultText(entry) {
     }
     return undefined;
 }
-/**
- * Backward-compatible alias for compressToolResults.
- * @deprecated Use compressToolResults instead.
- */
-export function compressFlowToolResults(snapshot, cache) {
-    return compressToolResults(snapshot, cache);
-}
 // ---------------------------------------------------------------------------
 // batch_read tool call stripping
 // ---------------------------------------------------------------------------
@@ -543,6 +1267,44 @@ export function compressFlowToolResults(snapshot, cache) {
  * results causes strict API providers (e.g. kimi-coding, DeepSeek) to reject
  * the request with `tool_call_id is not found`.
  */
+/**
+ * Check if an assistant message is empty (continuation marker with no semantic value).
+ * Empty means: no substantive text, no tool calls.
+ */
+function isEmptyAssistantMessage(message) {
+    if (message.role !== "assistant")
+        return false;
+    const content = message.content;
+    // Null/undefined/empty string
+    if (content === null || content === undefined || content === "")
+        return true;
+    // Whitespace-only string
+    if (typeof content === "string" && content.trim() === "")
+        return true;
+    // Array content: check for no text parts or only whitespace text parts, and NO tool calls
+    if (Array.isArray(content)) {
+        const hasToolCall = content.some((p) => p.type === "toolCall");
+        if (hasToolCall)
+            return false;
+        const textParts = content.filter((p) => p.type === "text" && typeof p.text === "string");
+        if (textParts.length === 0)
+            return true;
+        const allWhitespace = textParts.every((p) => p.text.trim() === "");
+        if (allWhitespace)
+            return true;
+        // Low-signal detection: short text with no actionable markers
+        const fullText = textParts.map((p) => p.text).join("");
+        if (fullText.length < 300) {
+            const hasFilePath = /\w+\.\w+/.test(fullText);
+            const hasToolReference = /\[[a-z_]+[^\]]*\]/.test(fullText);
+            const hasCodeBlock = fullText.includes("```");
+            const hasActionableMarkers = hasFilePath || hasToolReference || hasCodeBlock;
+            if (!hasActionableMarkers)
+                return true;
+        }
+    }
+    return false;
+}
 export function stripBatchReadToolCalls(snapshot) {
     const lines = snapshot.trimEnd().split("\n");
     // Pass 1: Collect all batch_read toolCallIds from assistant messages.
@@ -562,7 +1324,7 @@ export function stripBatchReadToolCalls(snapshot) {
             continue;
         for (const part of content) {
             if (part.type === "toolCall" && part.name === "batch_read" && (part.id || part.toolCallId)) {
-                batchReadToolCallIds.add(part.id ?? part.toolCallId);
+                batchReadToolCallIds.add((part.id ?? part.toolCallId));
             }
         }
     }
@@ -607,7 +1369,9 @@ export function stripBatchReadToolCalls(snapshot) {
         }
         const filteredContent = content.filter((part) => !(part.type === "toolCall" && part.name === "batch_read"));
         if (filteredContent.length === 0) {
-            filteredContent.push({ type: "text", text: "" });
+            // Skip assistant messages that have no content after stripping batch_read
+            // — an empty text placeholder wastes tokens and conveys nothing.
+            continue;
         }
         result.push(JSON.stringify({
             ...entry,
@@ -620,6 +1384,75 @@ export function stripBatchReadToolCalls(snapshot) {
     return `${result.join("\n")}\n`;
 }
 // ---------------------------------------------------------------------------
+// Flow tool call argument compression
+// ---------------------------------------------------------------------------
+/**
+ * Compress verbose `flow` tool call arguments in assistant messages.
+ *
+ * The child flow already receives its own `-p` activation prompt, so the full
+ * mission text inside the JSONL assistant message is pure duplication.
+ * Replaces the arguments with a compact summary `{type, aim, steps}`.
+ */
+export function compressFlowToolCallArgs(snapshot) {
+    const lines = snapshot.trimEnd().split("\n");
+    const result = [];
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            result.push(line);
+            continue;
+        }
+        if (entry?.type !== "message" || entry.message?.role !== "assistant") {
+            result.push(line);
+            continue;
+        }
+        const content = entry.message.content;
+        if (!Array.isArray(content)) {
+            result.push(line);
+            continue;
+        }
+        let modified = false;
+        const newContent = content.map((part) => {
+            if (part.type !== "toolCall" || part.name !== "flow")
+                return part;
+            const args = part.arguments;
+            if (!args || typeof args !== "object")
+                return part;
+            const flowArr = Array.isArray(args.flow)
+                ? args.flow
+                : undefined;
+            if (!flowArr || flowArr.length === 0)
+                return part;
+            const firstFlow = flowArr[0];
+            const type = typeof firstFlow?.type === "string" ? firstFlow.type : undefined;
+            const aim = typeof firstFlow?.aim === "string" ? firstFlow.aim : undefined;
+            const steps = Array.isArray(firstFlow?.steps) ? firstFlow.steps.length : undefined;
+            if (!type && !aim && steps === undefined)
+                return part;
+            modified = true;
+            return {
+                ...part,
+                arguments: { type, aim, steps },
+            };
+        });
+        if (!modified) {
+            result.push(line);
+            continue;
+        }
+        result.push(JSON.stringify({
+            ...entry,
+            message: {
+                ...entry.message,
+                content: newContent,
+            },
+        }));
+    }
+    return `${result.join("\n")}\n`;
+}
+// ---------------------------------------------------------------------------
 // Reparent orphans
 // ---------------------------------------------------------------------------
 /**
@@ -635,42 +1468,58 @@ function reparentOrphans(snapshot) {
             const id = entry?.message?.id ?? entry?.message?.messageId ?? entry?.id;
             if (typeof id === "string" && id)
                 survivingIds.add(id);
-            const parentId = entry?.parentId ?? entry?.parentMessageId ?? entry?.message?.parentId ?? entry?.message?.parentMessageId;
-            if (typeof parentId === "string" && parentId && !(typeof id === "string" && id))
-                survivingIds.add(parentId);
+            // Only ids of actual entries should be in survivingIds; parentId refs
+            // are checked in the second pass, not added here.
+        }
+        catch (err) {
+            logWarn(`[pi-agent-flow] reparentOrphans id scan failed: ${err}`);
         }
-        catch { /* ignore */ }
     }
     for (let i = 0; i < lines.length; i++) {
         try {
             let entry = JSON.parse(lines[i]);
-            const entryParentId = entry.parentId ?? entry.parentMessageId;
-            const messageParentId = entry.message?.parentId ?? entry.message?.parentMessageId;
-            const parentId = entryParentId ?? messageParentId;
-            if (typeof parentId === "string" && parentId && !survivingIds.has(parentId)) {
-                let modified = false;
-                if (entry.parentId === parentId || entry.parentMessageId === parentId) {
-                    const { parentId: _pid, parentMessageId: _pmid, ...restEntry } = entry;
+            let modified = false;
+            const isMessageEntry = entry?.type === "message";
+            // Fix top-level parentId only for message entries (not session headers).
+            if (isMessageEntry) {
+                if (typeof entry.parentId === "string" && entry.parentId && !survivingIds.has(entry.parentId)) {
+                    const { parentId: _pid, ...restEntry } = entry;
                     entry = restEntry;
                     modified = true;
                 }
-                if (entry.message && (entry.message.parentId === parentId || entry.message.parentMessageId === parentId)) {
-                    const { parentId: _pid, parentMessageId: _pmid, ...restMessage } = entry.message;
+                if (typeof entry.parentMessageId === "string" && entry.parentMessageId && !survivingIds.has(entry.parentMessageId)) {
+                    const { parentMessageId: _pmid, ...restEntry } = entry;
+                    entry = restEntry;
+                    modified = true;
+                }
+            }
+            // Fix message-level parentId for all entries.
+            const msg = entry.message;
+            if (msg) {
+                if (typeof msg.parentId === "string" && msg.parentId && !survivingIds.has(msg.parentId)) {
+                    const { parentId: _pid, ...restMessage } = msg;
                     entry = { ...entry, message: restMessage };
                     modified = true;
                 }
-                if (modified) {
-                    lines[i] = JSON.stringify(entry);
+                if (typeof msg.parentMessageId === "string" && msg.parentMessageId && !survivingIds.has(msg.parentMessageId)) {
+                    const { parentMessageId: _pmid, ...restMessage } = msg;
+                    entry = { ...entry, message: restMessage };
+                    modified = true;
                 }
             }
+            if (modified) {
+                lines[i] = JSON.stringify(entry);
+            }
+        }
+        catch (err) {
+            logWarn(`[pi-agent-flow] reparentOrphans breadcrumb fix failed: ${err}`);
         }
-        catch { /* ignore */ }
     }
     return `${lines.join("\n")}\n`;
 }
 export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
     if (!snapshot)
-        return { result: snapshot, passesApplied: [] };
+        return { result: snapshot, passesApplied: [], stats: null };
     const preBytes = snapshot.length;
     const lines = snapshot.trimEnd().split("\n");
     const sanitizedLines = [];
@@ -681,29 +1530,26 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
         try {
             entry = JSON.parse(line);
         }
-        catch {
+        catch (err) {
+            logWarn(`[pi-agent-flow] sanitizeForkSnapshot parse failed: ${err}`);
             sanitizedLines.push(line);
             continue;
         }
         let changed = false;
-        // Header (first line): merge fork metadata and replace parent system prompt.
+        // Strip outer entry timestamp from all entries — child replay doesn't need it
+        // (JSONL line ordering is sufficient).
+        if ("timestamp" in entry) {
+            const { timestamp, ...restEntry } = entry;
+            entry = restEntry;
+            changed = true;
+            subPasses.add("stripTimestamps");
+        }
+        // Header (first line): replace parent system prompt.
         if (i === 0 && entry && typeof entry === "object") {
-            // Inject fork metadata so children know their lineage.
-            if (options && (options.forkedFrom || options.forkedAt || options.parentFlow || options.depth !== undefined)) {
-                entry = {
-                    ...entry,
-                    ...(options.forkedFrom !== undefined ? { forkedFrom: options.forkedFrom } : {}),
-                    ...(options.forkedAt !== undefined ? { forkedAt: options.forkedAt } : {}),
-                    ...(options.parentFlow !== undefined ? { parentFlow: options.parentFlow } : {}),
-                    ...(options.depth !== undefined ? { depth: options.depth } : {}),
-                };
-                changed = true;
-                subPasses.add("forkMetadataInjection");
-            }
-            // Replace the parent orchestrator system prompt with a brief note.
+            // Replace the parent root state system prompt with a brief note.
             // Children receive their own directive in the <activation> block.
             if (entry.systemPrompt && typeof entry.systemPrompt === "string") {
-                entry = { ...entry, systemPrompt: "[parent orchestrator system prompt stripped — child receives its own directive]" };
+                entry = { ...entry, systemPrompt: "[parent root state system prompt stripped — child receives its own directive]" };
                 changed = true;
                 subPasses.add("stripSystemPrompt");
             }
@@ -717,14 +1563,36 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
                 subPasses.add('stripSessionId');
             }
         }
-        // Drop type: "system" entries — the parent orchestrator system prompt was already
+        // Whitelist session entry fields to prevent unknown metadata leaks.
+        const isSessionHeader = i === 0 || entry?.type === "session";
+        if (isSessionHeader && entry && typeof entry === "object") {
+            const allowedHeaderKeys = new Set([
+                "type", "systemPrompt", "version", "cwd",
+                "forkedFrom", "forkedAt", "parentFlow", "depth", "parentId",
+                "meta",
+            ]);
+            const entryKeys = Object.keys(entry);
+            const hasUnknownHeaderField = entryKeys.some((k) => !allowedHeaderKeys.has(k));
+            if (hasUnknownHeaderField) {
+                const whitelisted = {};
+                for (const key of entryKeys) {
+                    if (allowedHeaderKeys.has(key)) {
+                        whitelisted[key] = entry[key];
+                    }
+                }
+                entry = whitelisted;
+                changed = true;
+                subPasses.add("stripUnknownHeaderFields");
+            }
+        }
+        // Drop type: "system" entries — the parent root state system prompt was already
         // stripped from the header above. Standalone system events leak the full prompt.
         // Children receive their own directive in the <activation> block.
         if (entry?.type === "system") {
             subPasses.add("dropSystemEvents");
             continue;
         }
-        // Drop custom_message entries — hidden orchestrator instructions (e.g.
+        // Drop custom_message entries — hidden root state instructions (e.g.
         // flow continuation hook messages with display:false) that children
         // should never see.
         if (entry?.type === "custom_message") {
@@ -788,10 +1656,11 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
                 subPasses.add("stripTimestamps");
             }
             // Strip API metadata fields that children don't need (~5-7 KB per assistant message).
-            // IMPORTANT: keep `usage` (including `totalTokens`). The child `pi` process replays
+            // IMPORTANT: keep `usage.totalTokens` ONLY. The child `pi` process replays
             // this JSONL and core/session code reads `message.usage.totalTokens`; stripping
             // `usage` causes: Cannot read properties of undefined (reading 'totalTokens').
-            // Strip `cost` from `usage` — it's always zeros in forked context and children never need it.
+            // Other fields (input, output, cacheRead, cacheWrite) are consumed only from
+            // live child stdout events (runner-events.ts), never from fork snapshot replay.
             if (message.role === "assistant") {
                 const { api, provider, model, stopReason, responseId, responseModel, usage, ...rest } = message;
                 let stripped = false;
@@ -799,12 +1668,16 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
                     stopReason !== undefined || responseId !== undefined || responseModel !== undefined) {
                     stripped = true;
                 }
-                // Strip cost sub-object from usage while preserving totalTokens and other fields.
-                let cleanedUsage = usage;
-                if (usage && typeof usage === "object" && "cost" in usage) {
-                    const { cost, ...usageWithoutCost } = usage;
-                    cleanedUsage = usageWithoutCost;
-                    stripped = true;
+                // Compress usage to totalTokens only — child pi replay requires totalTokens.
+                // Other fields (input, output, cacheRead, cacheWrite) are consumed only from
+                // live child stdout events (runner-events.ts), never from fork snapshot replay.
+                let cleanedUsage;
+                if (usage && typeof usage === "object") {
+                    const ttl = usage.totalTokens;
+                    if (typeof ttl === "number") {
+                        cleanedUsage = { totalTokens: ttl };
+                        stripped = true;
+                    }
                 }
                 if (stripped) {
                     message = { ...rest, ...(cleanedUsage !== undefined ? { usage: cleanedUsage } : {}) };
@@ -812,6 +1685,20 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
                     subPasses.add("stripApiMetadata");
                 }
             }
+            // Collapse empty/low-signal assistant messages to a minimal continuation marker.
+            if (message.role === "assistant" && isEmptyAssistantMessage(message)) {
+                const totalTokens = message.usage?.totalTokens;
+                const { usage: _usage, ...rest } = message;
+                message = {
+                    ...rest,
+                    ...(totalTokens !== undefined ? { usage: { totalTokens } } : {}),
+                    content: totalTokens !== undefined
+                        ? `[assistant: ${totalTokens} tokens, no action]`
+                        : "[assistant:continuation]",
+                };
+                changed = true;
+                subPasses.add("collapseEmptyAssistantMessages");
+            }
             // Strip `details` from tool/toolResult messages — carries FlowDetails UI metadata
             // (mode, flowStyle, projectAgentsDir, results) that children never need.
             if (message.role === "tool" || message.role === "toolResult") {
@@ -831,14 +1718,12 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
                     changed = true;
                     subPasses.add("stripSteeringHints");
                 }
-                // Strip strategic hints from tool results
-                if (message.role === "tool" || message.role === "toolResult") {
-                    const afterHints = stripStrategicHintsFromContent(modifiedContent);
-                    if (!isJsonEqual(afterHints, modifiedContent)) {
-                        modifiedContent = afterHints;
-                        changed = true;
-                        subPasses.add("stripStrategicHints");
-                    }
+                // Strip strategic hints from all messages
+                const afterHints = stripStrategicHintsFromContent(modifiedContent);
+                if (!isJsonEqual(afterHints, modifiedContent)) {
+                    modifiedContent = afterHints;
+                    changed = true;
+                    subPasses.add("stripStrategicHints");
                 }
                 // Compress parent activation prompts in nested snapshot JSONL
                 // (detect user messages containing <context-seal> at depth >= 2).
@@ -892,37 +1777,48 @@ export function sanitizeForkSnapshot(snapshot, cache = new Map(), options) {
         sanitizedLines.push(outLine);
     }
     const passesApplied = [];
+    const passDeltas = {};
+    const measureBytes = (s) => new TextEncoder().encode(s).length;
     let sanitized = `${sanitizedLines.join("\n")}\n`;
     passesApplied.push(...subPasses);
+    passDeltas["mainLoop"] = measureBytes(sanitized);
     // Reparent orphaned parentIds after steering-hint messages were dropped.
     sanitized = reparentOrphans(sanitized);
     passesApplied.push("reparentOrphans");
+    passDeltas["reparentOrphans1"] = measureBytes(sanitized);
     // Strip batch_read tool calls from assistant messages.
     // Children don't have batch_read in their active tools.
     sanitized = stripBatchReadToolCalls(sanitized);
     passesApplied.push("stripBatchRead");
+    passDeltas["stripBatchRead"] = measureBytes(sanitized);
+    // Compress verbose flow tool call arguments in assistant messages.
+    sanitized = compressFlowToolCallArgs(sanitized);
+    passesApplied.push("compressFlowToolCallArgs");
+    passDeltas["compressFlowToolCallArgs"] = measureBytes(sanitized);
     // Compress tool results (flow, batch, web, ask_user).
-    sanitized = compressToolResults(sanitized, cache);
+    sanitized = compressToolResults(sanitized, cache, depthToPolicy(options?.depth ?? 1));
     passesApplied.push("compressToolResults");
+    passDeltas["compressToolResults"] = measureBytes(sanitized);
     // Reparent again after stripBatchRead and compressToolResults may have
     // dropped additional messages, leaving new orphaned parentIds.
     sanitized = reparentOrphans(sanitized);
     passesApplied.push("reparentOrphans");
+    passDeltas["reparentOrphans2"] = measureBytes(sanitized);
     // Telemetry: measure total delta across sanitization, stripping, and compression.
     const postBytes = sanitized.length;
-    const reduction = preBytes > 0 ? ((1 - postBytes / preBytes) * 100).toFixed(0) : "0";
+    const reduction = preBytes > 0 ? Math.round((1 - postBytes / preBytes) * 1000) / 10 : 0;
     if (DEBUG_CONTEXT) {
         logError(`[context-snapshot] pre: ${preBytes} → post: ${postBytes} bytes (${reduction}% reduction)`);
     }
-    // Always emit compression-stats as a trailing metadata entry so the dump contains
-    // observability data regardless of DEBUG_CONTEXT setting.
-    sanitized = sanitized.trimEnd() + "\n" + JSON.stringify({
-        type: "compression-stats",
+    // Stats are returned out-of-band for dump consumers only.
+    // Do NOT append to child-visible JSONL — it's telemetry noise for the model.
+    const stats = {
         preBytes,
         postBytes,
-        reductionPercent: Number(reduction),
+        reductionPercent: reduction,
         passesApplied,
-    }) + "\n";
-    return { result: sanitized, passesApplied };
+        passDeltas,
+    };
+    return { result: sanitized, passesApplied, stats };
 }
 //# sourceMappingURL=snapshot.js.map