@yagni-app/code-staging 1.0.0-staging.1183.1 → 1.0.0-staging.1185.1

package/dist/extension/askAdvisorTool.d.ts

@@ -29,6 +29,7 @@ import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-age
 import { type Component } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { type AdvisorLimits, type AdvisorStateHandle } from "./advisor.js";
+import type { WorkingLineHandle } from "./workingLine.js";
 import { runStage as defaultRunStage } from "./pipeline/runner.js";
 import { type PipelineStage } from "./pipeline/types.js";
 import { type RenderTheme, type SubagentTaskProgress } from "./subagentRender.js";
@@ -49,6 +50,12 @@ export interface MakeAskAdvisorToolOptions {
     limits?: AdvisorLimits;
     /** Injectable so tests never spawn a child. */
     runStage?: typeof defaultRunStage;
+    /**
+     * The session working-line manager (workingLine.ts). When present, live
+     * consult progress goes through it (so the elapsed/token suffix survives);
+     * absent, the tool falls back to ui.setWorkingMessage directly.
+     */
+    workingLine?: WorkingLineHandle;
 }
 /**
  * Assemble the consult brief. The advisor's persona already tells it not to take

package/dist/extension/askAdvisorTool.js

@@ -125,6 +125,8 @@ export function makeAskAdvisorTool(opts) {
             "The advice comes back as plain text: act on it, and call record_decision when it settles a product-intent call so the next agent inherits it.",
         ],
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall: renderAdvisorCall,
         renderResult: renderSubagentResult,
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -159,9 +161,12 @@ export function makeAskAdvisorTool(opts) {
                     },
                 });
                 const working = formatWorkingMessage([progress], now);
-                if (ui && working !== lastWorking) {
+                if (working !== lastWorking) {
                     lastWorking = working;
-                    ui.setWorkingMessage?.(working);
+                    if (opts.workingLine)
+                        opts.workingLine.setActivity(working);
+                    else
+                        ui?.setWorkingMessage?.(working);
                 }
             };
             emit();
@@ -181,7 +186,10 @@ export function makeAskAdvisorTool(opts) {
             }
             finally {
                 // Restore the default "Working…" text whether we resolved or threw.
-                ui?.setWorkingMessage?.();
+                if (opts.workingLine)
+                    opts.workingLine.setActivity(undefined);
+                else
+                    ui?.setWorkingMessage?.();
             }
             const cost = result.usage?.cost ?? 0;
             const state = opts.state.record(cost);

package/dist/extension/askYagniTool.js

@@ -56,6 +56,8 @@ export function makeAskYagniTool(opts) {
             "Answers carry a standing: treat a confirmed decision as settled; when you lean on an unverified assumption or an inference, say so where the work is reviewed; when there is no recorded position, follow the answer's instruction to record the assumption you proceed on.",
         ],
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall(args, theme) {
             const t = theme;
             let text = `${t.fg("toolTitle", t.bold("ask_yagni"))} ${t.fg("dim", clipLine(args?.question ?? "…", 100))}`;

package/dist/extension/chipEditor.d.ts

@@ -109,7 +109,28 @@ export declare class ChipEditor extends CustomEditor {
     /** Drop all stashed images. Called after a successful submit so a sent image
      * is not re-attached to the next message. */
     clearStash(): void;
-    /** Re-style the chip tokens so they read as chips; layout is untouched. */
+    /**
+     * Re-style chip tokens AND lay down the Kimi-style prompt box: a rounded
+     * border on all four sides, with a bold `›` caret on the first content
+     * line and continuation lines indented so wrapped text aligns under it.
+     *
+     * The base editor renders full-width lines carrying its own 1-column left
+     * padding, so we render it narrower, strip that padding, and re-wrap each
+     * line in the frame. Exact column layout (0-indexed):
+     *
+     *   0        ╭ │ ╰  border
+     *   1        space
+     *   2        ›  (first line) / space (continuation)
+     *   3        space
+     *   4…       text — same column on every line
+     *   width-2  space
+     *   width-1  │  border
+     *
+     * Box-drawing glyphs are drawn centered in their cell while text glyphs
+     * start at the cell's left bearing, so no whole-column position lands the
+     * border ink exactly on the footer's text column: column 0 reads a hair
+     * outside it, column 1 a hair inside. Column 0 is the accepted tradeoff.
+     */
     render(width: number): string[];
 }
 /**

package/dist/extension/chipEditor.js

@@ -22,7 +22,7 @@
  * the extension's pi imports to the same module instance pi uses.
  */
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
-import { matchesKey } from "@earendil-works/pi-tui";
+import { matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { spawnSync } from "node:child_process";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -381,11 +381,64 @@ export class ChipEditor extends CustomEditor {
     clearStash() {
         this.stashed = [];
     }
-    /** Re-style the chip tokens so they read as chips; layout is untouched. */
+    /**
+     * Re-style chip tokens AND lay down the Kimi-style prompt box: a rounded
+     * border on all four sides, with a bold `›` caret on the first content
+     * line and continuation lines indented so wrapped text aligns under it.
+     *
+     * The base editor renders full-width lines carrying its own 1-column left
+     * padding, so we render it narrower, strip that padding, and re-wrap each
+     * line in the frame. Exact column layout (0-indexed):
+     *
+     *   0        ╭ │ ╰  border
+     *   1        space
+     *   2        ›  (first line) / space (continuation)
+     *   3        space
+     *   4…       text — same column on every line
+     *   width-2  space
+     *   width-1  │  border
+     *
+     * Box-drawing glyphs are drawn centered in their cell while text glyphs
+     * start at the cell's left bearing, so no whole-column position lands the
+     * border ink exactly on the footer's text column: column 0 reads a hair
+     * outside it, column 1 a hair inside. Column 0 is the accepted tradeoff.
+     */
     render(width) {
-        return super
-            .render(width)
-            .map((line) => line.replace(CHIP_RE, (m) => `${CHIP_ON}${m}${CHIP_OFF}`));
+        const styled = super.render(Math.max(1, width - 4)).map((line) => line.replace(CHIP_RE, (m) => `${CHIP_ON}${m}${CHIP_OFF}`));
+        const border = (s) => this.borderColor(s);
+        const CARET = "\u001b[1m›\u001b[22m";
+        const FIRST_PREFIX = `${border("│")} ${CARET} `;
+        const NEXT_PREFIX = `${border("│")}   `;
+        const SUFFIX = ` ${border("│")}`;
+        const contentWidth = Math.max(1, width - 6);
+        const out = [];
+        let borderCount = 0;
+        let firstContentLine = true;
+        for (const line of styled) {
+            const stripped = stripTerminalSequences(line);
+            if (/^─+$/.test(stripped) || /^─*\s*[↑↓]/.test(stripped)) {
+                borderCount += 1;
+                const [left, right] = borderCount === 1 ? ["╭", "╮"] : ["╰", "╯"];
+                // One corner + one dash on each side lands the row at `width`.
+                out.push(`${border(`${left}─`)}${line}${border(`─${right}`)}`);
+                continue;
+            }
+            // Strip the base editor's own left padding (the frame replaces it),
+            // then fit the body to the content width exactly so no line can
+            // exceed the terminal width.
+            let body = line.startsWith(" ") ? line.slice(1) : line;
+            if (visibleWidth(body) > contentWidth)
+                body = truncateToWidth(body, contentWidth, "");
+            const pad = " ".repeat(Math.max(0, contentWidth - visibleWidth(body)));
+            if (borderCount !== 1) {
+                // Autocomplete rows (after the bottom border): align under the text.
+                out.push(`${" ".repeat(4)}${body}${pad}${" ".repeat(2)}`);
+                continue;
+            }
+            out.push(`${firstContentLine ? FIRST_PREFIX : NEXT_PREFIX}${body}${pad}${SUFFIX}`);
+            firstContentLine = false;
+        }
+        return out;
     }
 }
 /**

package/dist/extension/condensedTools.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Condensed, Claude Code-style rendering for pi's seven built-in tools.
+ *
+ * pi resolves renderers per slot (`toolDefinition.renderCall ?? builtIn.renderCall`),
+ * so re-registering a built-in by name with the SAME factory-made definition
+ * spread underneath swaps ONLY the presentation: name, description, parameters,
+ * prompt metadata, and execution semantics stay byte-identical with the
+ * built-in (execution delegates to the same `create*ToolDefinition` the session
+ * would have built, including the settings-driven bash shellPath/commandPrefix
+ * and read image auto-resize). pi 0.84.1 registers such overrides silently —
+ * there is no built-in-override startup warning in this version (verified
+ * against dist; the extensions.md claim is stale).
+ *
+ * Rendering contract per row (renderShell "self", so no tinted Box):
+ *  - renderCall paints the TITLE slot: a live "● Tool(arg)" line while running,
+ *    a "● Tool(arg)" line for visible rows, the run summary line for the tail
+ *    of a completed quiet run, or nothing (a zero-line component removes the
+ *    row entirely, including its spacer).
+ *  - renderResult paints the BODY slot: condensed write/edit previews, bash
+ *    error/partial output tails, or nothing. Expanded (ctrl+o) shows full
+ *    output for every row.
+ *
+ * String assembly is pure over {@link RenderTheme} (subagentRender.ts's
+ * pattern) so tests run against plain text. Renderer exceptions are swallowed
+ * by pi (degrading to the built-in fallback), so everything stays total.
+ */
+import { SettingsManager, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { RenderTheme } from "./subagentRender.js";
+import { ToolRunTracker } from "./toolRuns.js";
+/** Lines of write content shown collapsed (mirrors Claude Code's preview). */
+export declare const WRITE_PREVIEW_LINES = 8;
+/** Visual lines of a diff shown collapsed. */
+export declare const DIFF_PREVIEW_LINES = 12;
+/** Output tail lines shown under a failed shell command. */
+export declare const ERROR_TAIL_LINES = 5;
+/** Output tail lines shown under a still-running shell command. */
+export declare const PARTIAL_TAIL_LINES = 3;
+declare const BUILTIN_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
+type BuiltinName = (typeof BUILTIN_NAMES)[number];
+export type RowStatus = "running" | "ok" | "error";
+/** Home-collapse, and prefer cwd-relative for paths inside the project. */
+export declare function displayPath(rawPath: string, cwd?: string): string;
+/** Whether a tool-call path targets the session scratchpad. */
+export declare function isScratchpadPath(rawPath: unknown, scratchpadDir: string | undefined, cwd?: string): boolean;
+/** The one argument worth showing in a title: path, command, or pattern. */
+export declare function primaryArg(name: BuiltinName, args: Record<string, unknown> | undefined, cwd?: string): string;
+/** `● Tool(arg)` — the visible-row (and live-row) title line. */
+export declare function formatRowTitle(name: BuiltinName, args: Record<string, unknown> | undefined, status: RowStatus, theme: RenderTheme, cwd?: string): string;
+/** Extract "Command exited with code N" from a bash error body, if present. */
+export declare function splitBashError(outputText: string): {
+    output: string;
+    exitLine: string | undefined;
+};
+/** `⎿ exit line` + a dim tail of output under a failed shell command. */
+export declare function formatBashErrorBody(outputText: string, theme: RenderTheme): string[];
+/** A dim tail of live output under a still-running shell command. */
+export declare function formatBashPartialBody(outputText: string, theme: RenderTheme): string[];
+/** Count added lines in a unified patch (edit summaries surface "+N"). */
+export declare function countPatchAdditions(patch: string | undefined): number;
+/**
+ * `⎿ Wrote N lines to path` + a numbered, syntax-highlighted preview.
+ * `highlight` is injectable so tests stay independent of pi's theme state.
+ */
+export declare function formatWriteBody(rawPath: string, content: string, expanded: boolean, theme: RenderTheme, cwd?: string, highlight?: (code: string, filePath: string) => string[]): string[];
+/**
+ * `⎿ Updated path (+A -R)` + a colored diff preview.
+ * `paintDiff` is injectable for the same reason as `highlight` above.
+ */
+export declare function formatEditBody(rawPath: string, details: {
+    diff?: string;
+    patch?: string;
+} | undefined, expanded: boolean, theme: RenderTheme, cwd?: string, paintDiff?: (diffText: string) => string): string[];
+/** Expanded body: the raw output, dimmed and capped. */
+export declare function formatExpandedOutput(outputText: string, theme: RenderTheme): string[];
+export interface RegisterCondensedToolsDeps {
+    /** Session scratchpad dir; writes/edits under it aggregate instead of rendering. */
+    scratchpadDir?: string;
+    /** Registration-time cwd (defaults to process.cwd()). */
+    cwd?: string;
+    /**
+     * Settings loader seam. The default mirrors what pi's session does when it
+     * builds base tools: bash gets shellPath + shellCommandPrefix, read gets
+     * image autoResize. Injectable so tests never touch the config dir.
+     */
+    loadSettings?: (cwd: string) => SettingsManager;
+}
+/**
+ * Re-register the seven built-ins with condensed renderers. Returns the
+ * tracker so callers (and tests) can feed message boundaries into it.
+ */
+export declare function registerCondensedTools(pi: ExtensionAPI, deps?: RegisterCondensedToolsDeps): ToolRunTracker;
+export {};
+//# sourceMappingURL=condensedTools.d.ts.map

package/dist/extension/condensedTools.js

@@ -0,0 +1,392 @@
+/**
+ * Condensed, Claude Code-style rendering for pi's seven built-in tools.
+ *
+ * pi resolves renderers per slot (`toolDefinition.renderCall ?? builtIn.renderCall`),
+ * so re-registering a built-in by name with the SAME factory-made definition
+ * spread underneath swaps ONLY the presentation: name, description, parameters,
+ * prompt metadata, and execution semantics stay byte-identical with the
+ * built-in (execution delegates to the same `create*ToolDefinition` the session
+ * would have built, including the settings-driven bash shellPath/commandPrefix
+ * and read image auto-resize). pi 0.84.1 registers such overrides silently —
+ * there is no built-in-override startup warning in this version (verified
+ * against dist; the extensions.md claim is stale).
+ *
+ * Rendering contract per row (renderShell "self", so no tinted Box):
+ *  - renderCall paints the TITLE slot: a live "● Tool(arg)" line while running,
+ *    a "● Tool(arg)" line for visible rows, the run summary line for the tail
+ *    of a completed quiet run, or nothing (a zero-line component removes the
+ *    row entirely, including its spacer).
+ *  - renderResult paints the BODY slot: condensed write/edit previews, bash
+ *    error/partial output tails, or nothing. Expanded (ctrl+o) shows full
+ *    output for every row.
+ *
+ * String assembly is pure over {@link RenderTheme} (subagentRender.ts's
+ * pattern) so tests run against plain text. Renderer exceptions are swallowed
+ * by pi (degrading to the built-in fallback), so everything stays total.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, getAgentDir, getLanguageFromPath, highlightCode, renderDiff, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { Container, Text } from "@earendil-works/pi-tui";
+import { isQuiet, kindForTool, ToolRunTracker } from "./toolRuns.js";
+/** Lines of write content shown collapsed (mirrors Claude Code's preview). */
+export const WRITE_PREVIEW_LINES = 8;
+/** Visual lines of a diff shown collapsed. */
+export const DIFF_PREVIEW_LINES = 12;
+/** Output tail lines shown under a failed shell command. */
+export const ERROR_TAIL_LINES = 5;
+/** Output tail lines shown under a still-running shell command. */
+export const PARTIAL_TAIL_LINES = 3;
+/** Hard cap on expanded body lines so a huge output cannot stall a repaint. */
+const EXPANDED_MAX_LINES = 1000;
+/** Title arg preview width. */
+const ARG_PREVIEW_MAX = 96;
+const BUILTIN_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+const TITLE_BY_NAME = {
+    read: "Read",
+    bash: "Bash",
+    edit: "Edit",
+    write: "Write",
+    grep: "Grep",
+    find: "Find",
+    ls: "List",
+};
+/** Collapse whitespace and clip to `max`, appending an ellipsis when cut. */
+function clip(text, max) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= max)
+        return collapsed;
+    return `${collapsed.slice(0, max - 1)}…`;
+}
+/** Forward slashes for comparison and display, on every platform. */
+function slashed(p) {
+    return p.replace(/\\/g, "/");
+}
+/** Home-collapse, and prefer cwd-relative for paths inside the project. */
+export function displayPath(rawPath, cwd) {
+    if (!rawPath)
+        return rawPath;
+    let display = slashed(rawPath);
+    if (cwd) {
+        // Resolve BOTH sides so a POSIX-style cwd and Windows' drive-letter
+        // absolute paths compare in the same space.
+        const absolute = slashed(path.resolve(cwd, rawPath));
+        const base = slashed(path.resolve(cwd)).replace(/\/+$/, "");
+        if (absolute.startsWith(`${base}/`))
+            return absolute.slice(base.length + 1);
+        display = absolute;
+    }
+    const home = slashed(os.homedir());
+    return display.startsWith(home) ? `~${display.slice(home.length)}` : display;
+}
+/** Whether a tool-call path targets the session scratchpad. */
+export function isScratchpadPath(rawPath, scratchpadDir, cwd) {
+    if (typeof rawPath !== "string" || !rawPath || !scratchpadDir)
+        return false;
+    const absolute = slashed(path.resolve(cwd ?? process.cwd(), rawPath));
+    const base = slashed(path.resolve(scratchpadDir)).replace(/\/+$/, "");
+    return absolute === base || absolute.startsWith(`${base}/`);
+}
+/** The one argument worth showing in a title: path, command, or pattern. */
+export function primaryArg(name, args, cwd) {
+    const a = args ?? {};
+    const str = (v) => (typeof v === "string" ? v : "");
+    switch (name) {
+        case "bash":
+            return clip(str(a.command) || "…", ARG_PREVIEW_MAX);
+        case "grep": {
+            const pattern = str(a.pattern) || "…";
+            const where = str(a.path);
+            return clip(where ? `${pattern} in ${displayPath(where, cwd)}` : pattern, ARG_PREVIEW_MAX);
+        }
+        case "find":
+            return clip(str(a.pattern) || "…", ARG_PREVIEW_MAX);
+        case "ls":
+            return clip(displayPath(str(a.path) || ".", cwd), ARG_PREVIEW_MAX);
+        default: {
+            const p = str(a.path);
+            let display = p ? displayPath(p, cwd) : "…";
+            if (name === "read" && (a.offset !== undefined || a.limit !== undefined)) {
+                const start = typeof a.offset === "number" ? a.offset : 1;
+                const end = typeof a.limit === "number" ? start + a.limit - 1 : undefined;
+                display += `:${start}${end !== undefined ? `-${end}` : ""}`;
+            }
+            return clip(display, ARG_PREVIEW_MAX);
+        }
+    }
+}
+function statusDot(status, theme) {
+    if (status === "error")
+        return theme.fg("error", "●");
+    if (status === "running")
+        return theme.fg("accent", "●");
+    return theme.fg("success", "●");
+}
+/** `● Tool(arg)` — the visible-row (and live-row) title line. */
+export function formatRowTitle(name, args, status, theme, cwd) {
+    const title = theme.bold(theme.fg("toolTitle", TITLE_BY_NAME[name]));
+    return `${statusDot(status, theme)} ${title}(${theme.fg("accent", primaryArg(name, args, cwd))})`;
+}
+/** Extract "Command exited with code N" from a bash error body, if present. */
+export function splitBashError(outputText) {
+    const match = outputText.match(/\n*(Command exited with code \d+)\s*$/);
+    if (!match)
+        return { output: outputText.trimEnd(), exitLine: undefined };
+    return { output: outputText.slice(0, match.index).trimEnd(), exitLine: match[1] };
+}
+function indent(lines, pad) {
+    return lines.map((line) => pad + line);
+}
+/** `⎿ exit line` + a dim tail of output under a failed shell command. */
+export function formatBashErrorBody(outputText, theme) {
+    const { output, exitLine } = splitBashError(outputText);
+    const lines = [];
+    lines.push(`  ${theme.fg("muted", "⎿")} ${theme.fg("error", exitLine ?? "Command failed")}`);
+    const tail = output.split("\n").filter((l) => l.length > 0).slice(-ERROR_TAIL_LINES);
+    lines.push(...indent(tail.map((l) => theme.fg("toolOutput", l)), "     "));
+    return lines;
+}
+/** A dim tail of live output under a still-running shell command. */
+export function formatBashPartialBody(outputText, theme) {
+    const tail = outputText.split("\n").filter((l) => l.length > 0).slice(-PARTIAL_TAIL_LINES);
+    return indent(tail.map((l) => theme.fg("dim", l)), "     ");
+}
+/** Count added lines in a unified patch (edit summaries surface "+N"). */
+export function countPatchAdditions(patch) {
+    if (!patch)
+        return 0;
+    let added = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            added += 1;
+    }
+    return added;
+}
+function countPatchRemovals(patch) {
+    if (!patch)
+        return 0;
+    let removed = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("-") && !line.startsWith("---"))
+            removed += 1;
+    }
+    return removed;
+}
+const EXPAND_HINT = "(ctrl+o to expand)";
+/**
+ * `⎿ Wrote N lines to path` + a numbered, syntax-highlighted preview.
+ * `highlight` is injectable so tests stay independent of pi's theme state.
+ */
+export function formatWriteBody(rawPath, content, expanded, theme, cwd, highlight = highlightForPath) {
+    const allLines = content.replace(/\n$/, "").split("\n");
+    const total = allLines.length;
+    const shownCount = expanded ? Math.min(total, EXPANDED_MAX_LINES) : Math.min(total, WRITE_PREVIEW_LINES);
+    const head = `  ${theme.fg("muted", "⎿")} Wrote ${total} ${total === 1 ? "line" : "lines"} to ${theme.fg("accent", displayPath(rawPath, cwd))}`;
+    const shown = allLines.slice(0, shownCount);
+    const painted = highlight(shown.join("\n"), rawPath);
+    const numberWidth = String(shownCount).length;
+    const body = painted
+        .slice(0, shownCount)
+        .map((line, i) => `     ${theme.fg("dim", String(i + 1).padStart(numberWidth))} ${line}`);
+    const lines = [head, ...body];
+    if (total > shownCount) {
+        lines.push(`     ${theme.fg("muted", `… +${total - shownCount} lines ${EXPAND_HINT}`)}`);
+    }
+    return lines;
+}
+/** Default highlighter: pi's theme-backed syntax highlighting, failing to plain lines. */
+function highlightForPath(code, filePath) {
+    try {
+        return highlightCode(code, getLanguageFromPath(filePath));
+    }
+    catch {
+        return code.split("\n");
+    }
+}
+/**
+ * `⎿ Updated path (+A -R)` + a colored diff preview.
+ * `paintDiff` is injectable for the same reason as `highlight` above.
+ */
+export function formatEditBody(rawPath, details, expanded, theme, cwd, paintDiff = defaultPaintDiff) {
+    const added = countPatchAdditions(details?.patch);
+    const removed = countPatchRemovals(details?.patch);
+    const counts = added || removed
+        ? ` (${[added ? theme.fg("success", `+${added}`) : "", removed ? theme.fg("error", `-${removed}`) : ""]
+            .filter(Boolean)
+            .join(" ")})`
+        : "";
+    const head = `  ${theme.fg("muted", "⎿")} Updated ${theme.fg("accent", displayPath(rawPath, cwd))}${counts}`;
+    const diffText = details?.diff;
+    if (!diffText)
+        return [head];
+    const diffLines = paintDiff(diffText).split("\n");
+    const cap = expanded ? EXPANDED_MAX_LINES : DIFF_PREVIEW_LINES;
+    const lines = [head, ...indent(diffLines.slice(0, cap), "     ")];
+    if (diffLines.length > cap) {
+        lines.push(`     ${theme.fg("muted", `… +${diffLines.length - cap} lines ${EXPAND_HINT}`)}`);
+    }
+    return lines;
+}
+function defaultPaintDiff(diffText) {
+    try {
+        return renderDiff(diffText);
+    }
+    catch {
+        return diffText;
+    }
+}
+/** Expanded body: the raw output, dimmed and capped. */
+export function formatExpandedOutput(outputText, theme) {
+    const lines = outputText.replace(/\n$/, "").split("\n");
+    const shown = lines.slice(0, EXPANDED_MAX_LINES).map((l) => theme.fg("toolOutput", l));
+    if (lines.length > EXPANDED_MAX_LINES) {
+        shown.push(theme.fg("muted", `… +${lines.length - EXPANDED_MAX_LINES} lines`));
+    }
+    return shown;
+}
+function textOf(result) {
+    return (result?.content ?? [])
+        .filter((c) => c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text)
+        .join("\n");
+}
+function hasImages(result) {
+    return (result?.content ?? []).some((c) => c.type === "image");
+}
+function empty() {
+    return new Container();
+}
+function textComponent(lines) {
+    return lines.length === 0 ? empty() : new Text(lines.join("\n"), 0, 0);
+}
+function defaultLoadSettings(cwd) {
+    return SettingsManager.create(cwd, getAgentDir());
+}
+/**
+ * Re-register the seven built-ins with condensed renderers. Returns the
+ * tracker so callers (and tests) can feed message boundaries into it.
+ */
+export function registerCondensedTools(pi, deps = {}) {
+    const tracker = new ToolRunTracker();
+    const registrationCwd = deps.cwd ?? process.cwd();
+    // Assistant/user prose breaks a run; toolResult messages must not (they are
+    // interleaved between the very rows a run aggregates).
+    pi.on("message_start", (event) => {
+        const role = event.message?.role;
+        if (role === "assistant" || role === "user")
+            tracker.markBreak();
+    });
+    let toolOptions;
+    try {
+        const settings = (deps.loadSettings ?? defaultLoadSettings)(registrationCwd);
+        toolOptions = {
+            bash: { shellPath: settings.getShellPath(), commandPrefix: settings.getShellCommandPrefix() },
+            read: { autoResizeImages: settings.getImageAutoResize() },
+        };
+    }
+    catch {
+        toolOptions = { bash: {}, read: {} };
+    }
+    const buildDefinitions = (cwd) => ({
+        read: createReadToolDefinition(cwd, toolOptions.read),
+        bash: createBashToolDefinition(cwd, toolOptions.bash),
+        edit: createEditToolDefinition(cwd),
+        write: createWriteToolDefinition(cwd),
+        grep: createGrepToolDefinition(cwd),
+        find: createFindToolDefinition(cwd),
+        ls: createLsToolDefinition(cwd),
+    });
+    const definitionsByCwd = new Map();
+    const definitionsFor = (cwd) => {
+        let defs = definitionsByCwd.get(cwd);
+        if (!defs) {
+            defs = buildDefinitions(cwd);
+            definitionsByCwd.set(cwd, defs);
+        }
+        return defs;
+    };
+    definitionsByCwd.set(registrationCwd, buildDefinitions(registrationCwd));
+    for (const name of BUILTIN_NAMES) {
+        const base = definitionsFor(registrationCwd)[name];
+        const kind = kindForTool(name);
+        const upsertFromCall = (context) => {
+            const args = context.args;
+            return tracker.upsert(context.toolCallId, {
+                kind,
+                scratchpad: isScratchpadPath(args?.path, deps.scratchpadDir, context.cwd),
+                error: context.isError,
+                final: !context.isPartial,
+                invalidate: context.invalidate,
+            });
+        };
+        pi.registerTool({
+            ...base,
+            renderShell: "self",
+            execute(toolCallId, params, signal, onUpdate, ctx) {
+                const cwd = ctx?.cwd ?? registrationCwd;
+                return definitionsFor(cwd)[name].execute(toolCallId, params, signal, onUpdate, ctx);
+            },
+            renderCall(args, theme, context) {
+                const slice = context;
+                const row = upsertFromCall(slice);
+                const status = slice.isError ? "error" : slice.isPartial ? "running" : "ok";
+                const argsRecord = args;
+                if (slice.expanded || !isQuiet(row)) {
+                    return new Text(formatRowTitle(name, argsRecord, status, theme, slice.cwd), 0, 0);
+                }
+                if (!row.final) {
+                    return new Text(formatRowTitle(name, argsRecord, "running", theme, slice.cwd), 0, 0);
+                }
+                const summary = tracker.summaryFor(row.id);
+                return summary ? new Text(theme.fg("muted", summary), 0, 0) : empty();
+            },
+            renderResult(result, options, theme, context) {
+                const slice = context;
+                const args = (slice.args ?? {});
+                const row = tracker.upsert(slice.toolCallId, {
+                    kind,
+                    final: !options.isPartial,
+                    error: slice.isError,
+                    images: hasImages(result),
+                    added: name === "write" && typeof args.content === "string"
+                        ? args.content.replace(/\n$/, "").split("\n").length
+                        : name === "edit"
+                            ? countPatchAdditions(result.details?.patch)
+                            : 0,
+                });
+                if (options.expanded) {
+                    if (name === "write" && typeof args.path === "string" && typeof args.content === "string" && !slice.isError) {
+                        return textComponent(formatWriteBody(args.path, args.content, true, theme, slice.cwd));
+                    }
+                    if (name === "edit" && typeof args.path === "string" && !slice.isError && result.details) {
+                        return textComponent(formatEditBody(args.path, result.details, true, theme, slice.cwd));
+                    }
+                    const output = textOf(result);
+                    return output ? textComponent(formatExpandedOutput(output, theme)) : empty();
+                }
+                if (name === "bash" && options.isPartial) {
+                    return textComponent(formatBashPartialBody(textOf(result), theme));
+                }
+                if (isQuiet(row))
+                    return empty();
+                if (slice.isError) {
+                    if (name === "bash")
+                        return textComponent(formatBashErrorBody(textOf(result), theme));
+                    const message = textOf(result).split("\n").filter(Boolean).slice(-ERROR_TAIL_LINES);
+                    return textComponent(message.map((l, i) => (i === 0 ? `  ${theme.fg("muted", "⎿")} ${theme.fg("error", l)}` : `     ${theme.fg("toolOutput", l)}`)));
+                }
+                if (name === "write" && typeof args.path === "string" && typeof args.content === "string") {
+                    return textComponent(formatWriteBody(args.path, args.content, false, theme, slice.cwd));
+                }
+                if (name === "edit" && typeof args.path === "string") {
+                    return textComponent(formatEditBody(args.path, result.details, false, theme, slice.cwd));
+                }
+                // Visible for another reason (e.g. an image read): title already
+                // painted by renderCall; images render themselves below the row.
+                return empty();
+            },
+        });
+    }
+    return tracker;
+}
+//# sourceMappingURL=condensedTools.js.map