@yagni-app/code-staging 1.0.0-staging.1184.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/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

package/dist/extension/index.d.ts

@@ -186,6 +186,12 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 export type { TokenProvider, TokenProviderDeps, ScheduleFn } from "./tokenProvider.js";
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
 export type { SpoolEntry, SpoolClientOpts, FlushOutcome, JudgmentWriteOutcome } from "./spool.js";
+export { registerCondensedTools, displayPath, isScratchpadPath, primaryArg, formatRowTitle, formatWriteBody, formatEditBody, formatBashErrorBody, formatBashPartialBody, formatExpandedOutput, splitBashError, countPatchAdditions, WRITE_PREVIEW_LINES, DIFF_PREVIEW_LINES, } from "./condensedTools.js";
+export type { RegisterCondensedToolsDeps, RowStatus } from "./condensedTools.js";
+export { ToolRunTracker, summarizeRun, isQuiet, kindForTool } from "./toolRuns.js";
+export type { RowKind, ToolRow, ToolRowPatch } from "./toolRuns.js";
+export { registerWorkingLine, composeWorkingMessage, NULL_WORKING_LINE, WORKING_INDICATOR_FRAMES, WORKING_VERBS, } from "./workingLine.js";
+export type { WorkingLineHandle, RegisterWorkingLineDeps } from "./workingLine.js";
 export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
 export type { CrashReporter, CrashReporterOpts, FatalCrashOpts, SanitizedCrash } from "./crashReport.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/extension/index.js

@@ -49,6 +49,9 @@ import { registerChipEditor } from "./chipEditor.js";
 import { defaultMineBeatGit, fileMineBeatMarkers, maybeOfferMiningBeat as defaultMaybeOfferMiningBeat, } from "./mineBeat.js";
 import { makeFlywheelState } from "./flywheel.js";
 import { registerSilentTurnReminder } from "./silentTurnReminder.js";
+import { registerCondensedTools } from "./condensedTools.js";
+import { isDesktopSurface } from "./surface.js";
+import { registerWorkingLine, WORKING_INDICATOR_FRAMES } from "./workingLine.js";
 function isEvalMode(env = process.env) {
     return env.YAGNI_CODE_EVAL_MODE === "1";
 }
@@ -161,6 +164,11 @@ export async function registerYagni(pi, deps = {}) {
     // no-position record suggestions reach the model) and record_decision
     // (flywheel-attributed records send dedupe: true). Run 7.
     const flywheelState = makeFlywheelState();
+    // The composed streaming status line ("Shaping… (12m 54s · ↓ 47.5k tokens)").
+    // Registered before the subagent/advisor tools: they publish their live
+    // progress through this handle so the elapsed/token suffix survives their
+    // overrides. TUI-gated internally (agent_start checks ctx.mode).
+    const workingLine = registerWorkingLine(pi);
     pi.registerTool(makeAskYagniTool({ ...toolOpts, flywheel: flywheelState, getRepo: () => sessionRepo }));
     // WebFetch (YAG-578): read an arbitrary URL as clean markdown + a
     // standard-tier extraction, replacing the bash + curl + python dance.
@@ -178,7 +186,7 @@ export async function registerYagni(pi, deps = {}) {
     // hide it forever from a session that switched TO Advanced. One state handle
     // per session, shared with /advise so they draw on the same cap.
     const advisorState = makeAdvisorState();
-    const askAdvisorTool = makeAskAdvisorTool({ state: advisorState });
+    const askAdvisorTool = makeAskAdvisorTool({ state: advisorState, workingLine });
     pi.registerTool(askAdvisorTool);
     // /advise runs the SAME tool, sharing the state handle, so a manual consult
     // draws on the same cap rather than opening a side channel around it.
@@ -218,7 +226,7 @@ export async function registerYagni(pi, deps = {}) {
     // driver's delegation identity for the diamond directive (see the
     // before_agent_start handler below) and widens the tool's fan-out ceiling.
     const ultraHolder = createUltraHolder();
-    registerSubagents(pi, { isUltra: () => ultraHolder.get() });
+    registerSubagents(pi, { isUltra: () => ultraHolder.get(), workingLine });
     registerUltraCommand(pi, ultraHolder);
     // Shared fetch timeout for the small, interactive display-path reads below
     // (/cost's spend + headroom, and Task 8's per-run spend for /go's summary):
@@ -620,6 +628,25 @@ export async function registerYagni(pi, deps = {}) {
             });
         }
     }
+    // The condensed Claude Code-style transcript: the seven built-ins re-render
+    // as flat "● Tool(arg)" rows, quiet runs collapse into one "Read 2 files,
+    // ran 2 shell commands" summary line, and project writes/edits keep visible
+    // previews. Execution delegates to the same factory-made built-ins pi would
+    // have used (settings-honoring), so ONLY presentation changes — which is why
+    // eval mode keeps pi's stock registration (measured behavior stays
+    // byte-identical) and the desktop surface keeps the structured pipeline.
+    // YAGNI_CLASSIC_TOOL_ROWS=1 is the debugging escape hatch back to pi's
+    // boxed renderers.
+    if (!evalMode && !isDesktopSurface() && env.YAGNI_CLASSIC_TOOL_ROWS !== "1") {
+        try {
+            registerCondensedTools(pi, {
+                ...(scratchpadDirPath ? { scratchpadDir: scratchpadDirPath } : {}),
+            });
+        }
+        catch {
+            // Rendering must never break activation; pi's built-ins remain.
+        }
+    }
     // Own the identity + inject live company context (and repo rules) on every
     // turn. The extension loads identically in every pi process this app spawns —
     // the interactive driver AND every `/go` stage child, subagent, and advisor
@@ -847,6 +874,14 @@ export async function registerYagni(pi, deps = {}) {
             catch {
                 // A label must never disrupt session start.
             }
+            // The pulsing star indicator that pairs with the composed working line.
+            // Fails closed to pi's default spinner.
+            try {
+                ctx.ui?.setWorkingIndicator?.({ frames: [...WORKING_INDICATOR_FRAMES], intervalMs: 140 });
+            }
+            catch {
+                // An indicator must never disrupt session start.
+            }
             // One-time hint naming what changed now that reasoning is collapsed by
             // default (option 2). Gated on the launcher's YAGNI_HIDE_THINKING_SEEDED
             // marker so it fires only on the launch that actually seeded the key — it
@@ -1043,5 +1078,10 @@ export { makeTokenProvider, makeAuthedFetch, persistRotationToProfile, PROACTIVE
 // W4 trust plumbing: the durable write-spool for the judgment-capture tools
 // (idempotencyKey-replayed; server-side dedup makes flush safe).
 export { appendToSpool, loadSpool, flushSpool, sendOrSpool, spoolFile, MAX_SPOOL_AGE_MS, _setSpoolHomeForTest, } from "./spool.js";
+// The condensed Claude Code-style transcript: flat tool rows, run summaries,
+// and the composed streaming status line.
+export { registerCondensedTools, displayPath, isScratchpadPath, primaryArg, formatRowTitle, formatWriteBody, formatEditBody, formatBashErrorBody, formatBashPartialBody, formatExpandedOutput, splitBashError, countPatchAdditions, WRITE_PREVIEW_LINES, DIFF_PREVIEW_LINES, } from "./condensedTools.js";
+export { ToolRunTracker, summarizeRun, isQuiet, kindForTool } from "./toolRuns.js";
+export { registerWorkingLine, composeWorkingMessage, NULL_WORKING_LINE, WORKING_INDICATOR_FRAMES, WORKING_VERBS, } from "./workingLine.js";
 export { crashReportsDisabled, installUncaughtExceptionMonitor, makeCrashReporter, reportFatalCrash, sanitizeCrashError, sanitizeCrashText, } from "./crashReport.js";
 //# sourceMappingURL=index.js.map

package/dist/extension/subagents.d.ts

@@ -19,6 +19,7 @@
  */
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import type { WorkingLineHandle } from "./workingLine.js";
 import { runStage } from "./pipeline/runner.js";
 import { type ModelTier, type PipelineStage } from "./pipeline/types.js";
 import { renderSubagentCall, renderSubagentResult } from "./subagentRender.js";
@@ -96,6 +97,12 @@ export interface MakeSubagentToolDeps {
     homeDir?: string;
     /** Live ultra-mode probe (/ultra): widens the per-call fan-out ceiling. */
     isUltra?: () => boolean;
+    /**
+     * The session working-line manager (workingLine.ts). When present, live
+     * progress goes through it (so the elapsed/token suffix survives); absent,
+     * the tool falls back to setting ui.setWorkingMessage directly.
+     */
+    workingLine?: WorkingLineHandle;
 }
 export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
     name: string;
@@ -110,6 +117,7 @@ export declare function makeSubagentTool(deps?: MakeSubagentToolDeps): {
             agent: Type.TOptional<Type.TString>;
         }>>>;
     }>;
+    renderShell: "self";
     renderCall: typeof renderSubagentCall;
     renderResult: typeof renderSubagentResult;
     execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: (update: {
@@ -141,6 +149,8 @@ export interface RegisterSubagentsDeps {
     homeDir?: string;
     /** Live ultra-mode probe (/ultra): widens the per-call fan-out ceiling. */
     isUltra?: () => boolean;
+    /** Session working-line manager; see MakeSubagentToolDeps.workingLine. */
+    workingLine?: WorkingLineHandle;
 }
 /** Wire the subagent tool and the /agents listing command. */
 export declare function registerSubagents(pi: ExtensionAPI, deps?: RegisterSubagentsDeps): void;

package/dist/extension/subagents.js

@@ -350,6 +350,8 @@ export function makeSubagentTool(deps = {}) {
             "(list them with /agents); omit `agent` for the general-purpose one.",
         promptSnippet: "subagent: delegate a self-contained task (or parallel tasks) to a fresh-context agent; returns its report.",
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall: renderSubagentCall,
         renderResult: renderSubagentResult,
         async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -397,9 +399,12 @@ export function makeSubagentTool(deps = {}) {
                     },
                 });
                 const working = formatWorkingMessage(progresses, now);
-                if (ui && working !== lastWorking) {
+                if (working !== lastWorking) {
                     lastWorking = working;
-                    ui.setWorkingMessage?.(working);
+                    if (deps.workingLine)
+                        deps.workingLine.setActivity(working);
+                    else
+                        ui?.setWorkingMessage?.(working);
                 }
             };
             emit();
@@ -429,7 +434,10 @@ export function makeSubagentTool(deps = {}) {
             }
             finally {
                 // Restore the default "Working…" text whether we resolved or threw.
-                ui?.setWorkingMessage?.();
+                if (deps.workingLine)
+                    deps.workingLine.setActivity(undefined);
+                else
+                    ui?.setWorkingMessage?.();
             }
             const allFailed = outcomes.every((o) => o.result.exitCode !== 0);
             const sections = outcomes.map((o) => {

package/dist/extension/toolRuns.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Run model for the condensed tool transcript (Claude Code-style).
+ *
+ * A "run" is a maximal stretch of consecutive QUIET tool rows (reads, searches,
+ * listings, successful shell commands, scratchpad edits) uninterrupted by an
+ * assistant/user message or a visible row (errors, project writes/edits, image
+ * reads). Collapsed, every row in a completed run renders zero lines except the
+ * run's tail, which paints one summary line: "Read 2 files, ran 2 shell
+ * commands". Expanded (ctrl+o) bypasses this model entirely.
+ *
+ * The tracker is built purely from render calls (idempotent upserts keyed by
+ * toolCallId, in first-render order, which matches display order both live and
+ * on session replay). Message boundaries arrive via {@link ToolRunTracker.markBreak}
+ * from live `message_start` events only — after a resume, runs that were
+ * separated by prose may merge into one summary. That is a deliberate trade:
+ * render-derived state is the only state that survives replay.
+ *
+ * Everything here is PURE (no pi imports) so tests run against plain objects;
+ * the pi wiring lives in condensedTools.ts.
+ */
+/** Aggregation category of one tool row. */
+export type RowKind = "read" | "shell" | "search" | "list" | "write" | "edit";
+/** Facts about one tool row; `quiet` is derived, never stored. */
+export interface ToolRow {
+    id: string;
+    kind: RowKind;
+    /** The row's target path lives under the session scratchpad dir. */
+    scratchpad: boolean;
+    /** The tool call errored (visible regardless of kind). */
+    error: boolean;
+    /** The result carries inline images (a read screenshot must stay visible). */
+    images: boolean;
+    /** The result is final (not partial/streaming). */
+    final: boolean;
+    /** Added lines (scratchpad edits surface as "+N" in the summary). */
+    added: number;
+    /** An assistant/user message landed between the previous row and this one. */
+    breakBefore: boolean;
+    /** Repaint hook for this row's component (captured from the render context). */
+    invalidate?: () => void;
+    /** A deferred repaint is already queued for this row. */
+    invalidatePending?: boolean;
+}
+export type ToolRowPatch = Partial<Pick<ToolRow, "kind" | "scratchpad" | "error" | "images" | "final" | "added" | "invalidate">>;
+/** Aggregation kind for a built-in tool name (undefined for non-built-ins). */
+export declare function kindForTool(toolName: string): RowKind | undefined;
+/**
+ * Whether a row folds into a run summary. Reads, searches, listings, and
+ * successful shell commands always do; writes/edits only when they target the
+ * scratchpad (project mutations must stay visible). Errors and image-bearing
+ * results are always visible.
+ */
+export declare function isQuiet(row: Pick<ToolRow, "kind" | "scratchpad" | "error" | "images">): boolean;
+/**
+ * One summary line for a completed run, phrases in first-occurrence order:
+ * "Read 2 files, ran 2 shell commands, made 1 scratchpad edit +20".
+ */
+export declare function summarizeRun(rows: readonly Pick<ToolRow, "kind" | "scratchpad" | "added">[]): string;
+/**
+ * Ordered row registry. Upserts are idempotent and diff-aware: only a change
+ * invalidates the affected run's tail (the one component whose output depends
+ * on neighbors), so repaints converge instead of looping.
+ */
+export declare class ToolRunTracker {
+    private rows;
+    private indexById;
+    private breakPending;
+    /** Record an assistant/user message boundary; the next new row starts a fresh run. */
+    markBreak(): void;
+    get(id: string): ToolRow | undefined;
+    upsert(id: string, patch: ToolRowPatch): ToolRow;
+    /**
+     * The one summary line for `id`, present only when `id` is the tail of a
+     * fully-final quiet run. Every other member of the run gets undefined.
+     */
+    summaryFor(id: string): string | undefined;
+    /** The contiguous quiet run containing `row` (just `[row]` when visible). */
+    private runOf;
+    private invalidateTailOf;
+    /**
+     * Defer a row's repaint to a microtask, deduped per row. Upserts run INSIDE
+     * pi's synchronous `updateDisplay` pass (renderers call them), and the
+     * component's `invalidate()` re-enters `updateDisplay` immediately — a
+     * synchronous call from a renderer would rebuild the container while the
+     * outer frame is still appending to it, stacking duplicate children.
+     * Deferring means every repaint runs as its own clean top-level pass; it
+     * still cannot loop, because the diff-aware upsert only schedules on an
+     * actual change.
+     */
+    private scheduleInvalidate;
+}
+//# sourceMappingURL=toolRuns.d.ts.map

package/dist/extension/toolRuns.js

@@ -0,0 +1,201 @@
+/**
+ * Run model for the condensed tool transcript (Claude Code-style).
+ *
+ * A "run" is a maximal stretch of consecutive QUIET tool rows (reads, searches,
+ * listings, successful shell commands, scratchpad edits) uninterrupted by an
+ * assistant/user message or a visible row (errors, project writes/edits, image
+ * reads). Collapsed, every row in a completed run renders zero lines except the
+ * run's tail, which paints one summary line: "Read 2 files, ran 2 shell
+ * commands". Expanded (ctrl+o) bypasses this model entirely.
+ *
+ * The tracker is built purely from render calls (idempotent upserts keyed by
+ * toolCallId, in first-render order, which matches display order both live and
+ * on session replay). Message boundaries arrive via {@link ToolRunTracker.markBreak}
+ * from live `message_start` events only — after a resume, runs that were
+ * separated by prose may merge into one summary. That is a deliberate trade:
+ * render-derived state is the only state that survives replay.
+ *
+ * Everything here is PURE (no pi imports) so tests run against plain objects;
+ * the pi wiring lives in condensedTools.ts.
+ */
+const KIND_BY_TOOL = {
+    read: "read",
+    bash: "shell",
+    grep: "search",
+    find: "list",
+    ls: "list",
+    write: "write",
+    edit: "edit",
+};
+/** Aggregation kind for a built-in tool name (undefined for non-built-ins). */
+export function kindForTool(toolName) {
+    return KIND_BY_TOOL[toolName];
+}
+/**
+ * Whether a row folds into a run summary. Reads, searches, listings, and
+ * successful shell commands always do; writes/edits only when they target the
+ * scratchpad (project mutations must stay visible). Errors and image-bearing
+ * results are always visible.
+ */
+export function isQuiet(row) {
+    if (row.error || row.images)
+        return false;
+    if (row.kind === "write" || row.kind === "edit")
+        return row.scratchpad;
+    return true;
+}
+function plural(n, singular, pluralForm = `${singular}s`) {
+    return n === 1 ? singular : pluralForm;
+}
+/**
+ * One summary line for a completed run, phrases in first-occurrence order:
+ * "Read 2 files, ran 2 shell commands, made 1 scratchpad edit +20".
+ */
+export function summarizeRun(rows) {
+    const order = [];
+    const counts = new Map();
+    for (const row of rows) {
+        const category = row.kind === "write" || row.kind === "edit" ? "scratch" : row.kind;
+        let entry = counts.get(category);
+        if (!entry) {
+            entry = { n: 0, added: 0 };
+            counts.set(category, entry);
+            order.push(category);
+        }
+        entry.n += 1;
+        entry.added += row.added;
+    }
+    const phrases = order.map((category) => {
+        const { n, added } = counts.get(category);
+        switch (category) {
+            case "read":
+                return `read ${n} ${plural(n, "file")}`;
+            case "shell":
+                return `ran ${n} shell ${plural(n, "command")}`;
+            case "search":
+                return `searched for ${n} ${plural(n, "pattern")}`;
+            case "list":
+                return `listed ${n} ${plural(n, "path")}`;
+            default:
+                return `made ${n} scratchpad ${plural(n, "edit")}${added > 0 ? ` +${added}` : ""}`;
+        }
+    });
+    const line = phrases.join(", ");
+    return line.charAt(0).toUpperCase() + line.slice(1);
+}
+/**
+ * Ordered row registry. Upserts are idempotent and diff-aware: only a change
+ * invalidates the affected run's tail (the one component whose output depends
+ * on neighbors), so repaints converge instead of looping.
+ */
+export class ToolRunTracker {
+    rows = [];
+    indexById = new Map();
+    breakPending = true;
+    /** Record an assistant/user message boundary; the next new row starts a fresh run. */
+    markBreak() {
+        this.breakPending = true;
+    }
+    get(id) {
+        const i = this.indexById.get(id);
+        return i === undefined ? undefined : this.rows[i];
+    }
+    upsert(id, patch) {
+        const existingIndex = this.indexById.get(id);
+        if (existingIndex === undefined) {
+            const row = {
+                id,
+                kind: patch.kind ?? "shell",
+                scratchpad: patch.scratchpad ?? false,
+                error: patch.error ?? false,
+                images: patch.images ?? false,
+                final: patch.final ?? false,
+                added: patch.added ?? 0,
+                breakBefore: this.breakPending,
+                ...(patch.invalidate ? { invalidate: patch.invalidate } : {}),
+            };
+            this.breakPending = false;
+            this.indexById.set(id, this.rows.length);
+            this.rows.push(row);
+            // The previous row may have been its run's tail (painting a summary);
+            // now that the run extends past it, repaint it as a hidden member.
+            // (invalidateTailOf(prev) would be wrong here: prev's run now includes
+            // this new row, so its tail is the row currently painting, not prev.)
+            const prev = this.rows[this.rows.length - 2];
+            if (prev && isQuiet(prev) && !row.breakBefore)
+                this.scheduleInvalidate(prev);
+            return row;
+        }
+        const row = this.rows[existingIndex];
+        if (patch.invalidate)
+            row.invalidate = patch.invalidate;
+        let changed = false;
+        for (const key of ["kind", "scratchpad", "error", "images", "final", "added"]) {
+            const next = patch[key];
+            if (next !== undefined && row[key] !== next) {
+                row[key] = next;
+                changed = true;
+            }
+        }
+        if (changed)
+            this.invalidateTailOf(row);
+        return row;
+    }
+    /**
+     * The one summary line for `id`, present only when `id` is the tail of a
+     * fully-final quiet run. Every other member of the run gets undefined.
+     */
+    summaryFor(id) {
+        const row = this.get(id);
+        if (!row || !isQuiet(row) || !row.final)
+            return undefined;
+        const run = this.runOf(row);
+        if (run[run.length - 1] !== row)
+            return undefined;
+        if (run.some((r) => !r.final))
+            return undefined;
+        return summarizeRun(run);
+    }
+    /** The contiguous quiet run containing `row` (just `[row]` when visible). */
+    runOf(row) {
+        if (!isQuiet(row))
+            return [row];
+        const i = this.indexById.get(row.id);
+        let start = i;
+        while (start > 0 && !this.rows[start].breakBefore && isQuiet(this.rows[start - 1]))
+            start--;
+        let end = i;
+        while (end < this.rows.length - 1 &&
+            !this.rows[end + 1].breakBefore &&
+            isQuiet(this.rows[end + 1])) {
+            end++;
+        }
+        return this.rows.slice(start, end + 1);
+    }
+    invalidateTailOf(row) {
+        const run = this.runOf(row);
+        const tail = run[run.length - 1];
+        if (tail)
+            this.scheduleInvalidate(tail);
+    }
+    /**
+     * Defer a row's repaint to a microtask, deduped per row. Upserts run INSIDE
+     * pi's synchronous `updateDisplay` pass (renderers call them), and the
+     * component's `invalidate()` re-enters `updateDisplay` immediately — a
+     * synchronous call from a renderer would rebuild the container while the
+     * outer frame is still appending to it, stacking duplicate children.
+     * Deferring means every repaint runs as its own clean top-level pass; it
+     * still cannot loop, because the diff-aware upsert only schedules on an
+     * actual change.
+     */
+    scheduleInvalidate(row) {
+        if (row.invalidatePending)
+            return;
+        row.invalidatePending = true;
+        queueMicrotask(() => {
+            row.invalidatePending = false;
+            row.invalidate?.();
+        });
+    }
+}
+//# sourceMappingURL=toolRuns.js.map

package/dist/extension/webFetchTool.js

@@ -44,6 +44,8 @@ export function makeWebFetchTool(opts) {
             "Use web_fetch to read a URL's content instead of bash + curl when you need a page or a summary of it.",
         ],
         parameters,
+        // Self-framed: the condensed transcript look has no tinted tool boxes.
+        renderShell: "self",
         renderCall(args, theme) {
             const t = theme;
             const url = clipLine(args?.url ?? "…", 80);

package/dist/extension/workingLine.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/** What subagents/advisor publish instead of calling setWorkingMessage. */
+export interface WorkingLineHandle {
+    setActivity(text?: string): void;
+}
+/** A no-op handle for callers wired without a manager (tests, children). */
+export declare const NULL_WORKING_LINE: WorkingLineHandle;
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export declare const WORKING_VERBS: readonly string[];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export declare const WORKING_INDICATOR_FRAMES: string[];
+export interface ComposeWorkingOpts {
+    /** Override head from a running subagent/advisor (verb used when absent). */
+    activity?: string | undefined;
+    verb: string;
+    elapsedMs: number;
+    outputTokens: number;
+}
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export declare function composeWorkingMessage(opts: ComposeWorkingOpts): string;
+export interface RegisterWorkingLineDeps {
+    now?: () => number;
+    pickVerb?: (verbs: readonly string[]) => string;
+    /** Refresh cadence for the elapsed clock. */
+    tickMs?: number;
+}
+export declare function registerWorkingLine(pi: ExtensionAPI, deps?: RegisterWorkingLineDeps): WorkingLineHandle;
+//# sourceMappingURL=workingLine.d.ts.map

package/dist/extension/workingLine.js

@@ -0,0 +1,116 @@
+/**
+ * The Claude Code-style streaming status line: `Shaping… (12m 54s · ↓ 47.5k
+ * tokens)` in place of pi's static "Working...".
+ *
+ * One manager owns `ctx.ui.setWorkingMessage` for the whole session so the
+ * verb, the elapsed clock, and the token counter never fight the subagent /
+ * advisor progress text: those tools publish their activity line through
+ * {@link WorkingLineHandle.setActivity} (instead of calling setWorkingMessage
+ * directly), and the manager splices it in as the head of the same composed
+ * message. Elapsed time spans the whole agent loop (agent_start → agent_end);
+ * the token counter accumulates assistant output tokens across the loop's
+ * messages (message_end), which is when pi learns usage — subagent tokens live
+ * in the subagent's own activity text, not this counter.
+ *
+ * TUI-only by the agent_start guard; a headless /go child or desktop surface
+ * never gets a working line. Everything is fail-soft: a status line must never
+ * break a turn.
+ */
+import { usageFromMessage } from "./costHud.js";
+import { formatDuration, formatTokens } from "./subagentRender.js";
+/** A no-op handle for callers wired without a manager (tests, children). */
+export const NULL_WORKING_LINE = { setActivity: () => { } };
+/**
+ * The verb pool. Neutral gerunds — one is picked per agent loop, so long
+ * sessions read as a person at work rather than a stuck spinner.
+ */
+export const WORKING_VERBS = [
+    "Working",
+    "Thinking",
+    "Exploring",
+    "Tracing",
+    "Shaping",
+    "Wiring",
+    "Weighing",
+    "Sketching",
+    "Assembling",
+    "Distilling",
+    "Untangling",
+    "Polishing",
+];
+/** Pulse frames for the streaming indicator (pi renders them verbatim). */
+export const WORKING_INDICATOR_FRAMES = ["·", "✢", "✳", "✶", "✳", "✢"];
+/** `Shaping… (12m 54s · ↓ 47.5k tokens)` — pure, exported for tests. */
+export function composeWorkingMessage(opts) {
+    const head = opts.activity ?? `${opts.verb}…`;
+    const stats = [
+        formatDuration(opts.elapsedMs),
+        opts.outputTokens > 0 ? `↓ ${formatTokens(opts.outputTokens)} tokens` : undefined,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+    return `${head} (${stats})`;
+}
+export function registerWorkingLine(pi, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const pickVerb = deps.pickVerb ?? ((verbs) => verbs[Math.floor(Math.random() * verbs.length)]);
+    const tickMs = deps.tickMs ?? 1_000;
+    let ui;
+    let timer;
+    let startedAt;
+    let outputTokens = 0;
+    let verb = WORKING_VERBS[0];
+    let activity;
+    const refresh = () => {
+        if (!ui || startedAt === undefined)
+            return;
+        try {
+            ui.setWorkingMessage?.(composeWorkingMessage({ activity, verb, elapsedMs: now() - startedAt, outputTokens }));
+        }
+        catch {
+            // The status line must never break a turn.
+        }
+    };
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        startedAt = undefined;
+        activity = undefined;
+        try {
+            ui?.setWorkingMessage?.();
+        }
+        catch {
+            // Restoring the default label is best-effort.
+        }
+    };
+    pi.on("agent_start", (_event, ctx) => {
+        if (ctx.mode !== "tui" || !ctx.hasUI)
+            return;
+        ui = ctx.ui;
+        startedAt = now();
+        outputTokens = 0;
+        activity = undefined;
+        verb = pickVerb(WORKING_VERBS);
+        refresh();
+        if (timer)
+            clearInterval(timer);
+        timer = setInterval(refresh, tickMs);
+        timer.unref?.();
+    });
+    pi.on("agent_end", () => stop());
+    pi.on("message_end", (event) => {
+        const message = event.message;
+        if (message?.role !== "assistant")
+            return;
+        outputTokens += usageFromMessage(message).output;
+        refresh();
+    });
+    return {
+        setActivity(text) {
+            activity = text;
+            refresh();
+        },
+    };
+}
+//# sourceMappingURL=workingLine.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.0-staging.1184.1",
+  "version": "1.0.0-staging.1185.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -41,5 +41,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "4e0c38ced9c2bc27fd28c01af4e22a1539fd1637"
+  "yagniSourceSha": "970cc138faff85585c7d21243aeb553937df2a40"
 }