pi-minimal 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -10,6 +10,42 @@ Releases are cut automatically: when the `version` in `package.json` changes on
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-27
+
+### Added
+
+- `editDiff` setting in `pi-minimal.json`: controls whether an `edit` row shows the
+  change itself. `"expanded"` (default) shows the unified diff in the `│`-ruled
+  block when the row is expanded with `ctrl+o`, where the bare "Successfully
+  replaced" text used to be. `"always"` shows it inline as soon as the edit lands,
+  capped at 40 lines with `… N more lines (ctrl+o)` for the rest. `"never"` keeps
+  the stats-only row. Lines use the theme's `toolDiffAdded` / `toolDiffRemoved` /
+  `toolDiffContext` colours and keep pi's line-number gutter; when one line
+  replaces one line, only the changed tokens are inverse-highlighted, as in pi's
+  own edit renderer. Failed edits and results without a diff are unchanged.
+
+## [0.3.1] - 2026-10-25
+
+### Added
+- Compact rows for tools that bring no renderer of their own, such as most MCP tools and
+  `subagents_enable`: `✓ mcp   re_mcp · query_prometheus query=… step=1m   12 lines · 1.4s`.
+  The verb is `mcp`, `agent` (subagent tools) or `tool`; up to three scalar arguments show as
+  `key=value`; a short single-line result shows verbatim, otherwise a line count. Failures show
+  their first line underneath; `ctrl+o` shows the full result. Tools that draw themselves
+  (the `subagent` live view, pi-gauntlet's trackers) keep their own renderer.
+
+### Changed
+- Bash rows drop `cd <session cwd> && ` and shorten other `cd <dir> && ` prefixes to the
+  directory name (`pi-subagents › sed -n …`), so the part that differs between rows is visible
+  and the outcome column stays put. Multi-line commands such as heredocs say how many lines follow
+  (`python3 - <<'EOF' · +4 lines`).
+- The thinking gutter `┊` now runs down every line of a thinking paragraph, including lines the
+  terminal wraps: paragraphs are pre-wrapped to the content width the host renders at (re-done on
+  resize). Previously only the first line of each paragraph had it, so wrapped thinking sat flush
+  with prose. Inline code stays whole; lists, quotes and fenced code are untouched.
+- The task tracker line is a segmented bar coloured by status (`Tasks ▰▰▰▰▱ 4/5`) instead of a
+  run of check marks; past 12 tasks it scales to 10 segments.
+
 ## [0.3.0] - 2026-10-25
 
 ### Added

package/README.md

@@ -30,9 +30,9 @@ Do not load this package beside the live `grok-chrome` extension. Disable or rem
 
 ## What it changes
 
-- **Tool rows** – every built-in tool call (`bash`, `read`, `edit`, `write`, `grep`, `find`, `ls`) renders as one line: status glyph (`◐` running, `✓` ok, `✗` failed), verb, item, and a right-aligned outcome (`34 lines · 1.0s`, `exit 1`, `+3 −1`, `4 matches`). Failed rows show the first line of output underneath; `ctrl+o` expands full output in a `│`-ruled block. `codemode` renders the same way, as a `code` row with one child row per nested tool call; `ctrl+o` shows the script and its output.
+- **Tool rows** – every built-in tool call (`bash`, `read`, `edit`, `write`, `grep`, `find`, `ls`) renders as one line: status glyph (`◐` running, `✓` ok, `✗` failed), verb, item, and a right-aligned outcome (`34 lines · 1.0s`, `exit 1`, `+3 −1`, `4 matches`). Failed rows show the first line of output underneath; `ctrl+o` expands full output in a `│`-ruled block. `codemode` renders the same way, as a `code` row with one child row per nested tool call; `ctrl+o` shows the script and its output. Tools without a renderer of their own (most MCP tools) get the same one-line row; tools that draw themselves keep their look. Bash rows drop a leading `cd <session cwd> &&` and shorten other `cd` prefixes to the directory name.
 - **Turn rule** – after each agent run a dim `── 15:51 · 12s · 4 tools ──` separator is appended (stored as a custom entry; never sent to the model).
-- **Thinking gutter** – thinking paragraphs are prefixed with `┊` so they read as secondary.
+- **Thinking gutter** – every line of a thinking paragraph, wrapped lines included, starts with `┊`, so thinking reads as a column beside prose.
 - **Status line** – one line above the editor: model · thinking level · context meter (amber at 70 %, red at 90 %) · cwd · `⎇ branch ±dirty` · Herdr siblings.
 - **Footer** – key hints appear only when the agent is idle and the editor is empty; `/compact` is suggested under context pressure.
 - **Code blocks** – fenced code renders as a closed box with the language as its title, keeping syntax highlighting, instead of literal ``` lines; long lines wrap inside the box.
@@ -49,10 +49,13 @@ The package loads JSON in this order:
 
 Project values override global values. A missing file, omitted key, or invalid value does not override the lower-precedence value.
 
-The only supported key is `hideGauntletWidgets`. It defaults to `true`.
+Supported keys:
+
+- `hideGauntletWidgets` (boolean, default `true`).
+- `editDiff` (`"always"` | `"never"` | `"expanded"`, default `"expanded"`) – when an `edit` row shows its diff. `"expanded"` puts it behind `ctrl+o`; `"always"` shows it inline as the edit lands (first 40 lines, the rest behind `ctrl+o`); `"never"` keeps the `+3 −1` stats only.
 
 ```json
-{ "hideGauntletWidgets": true }
+{ "hideGauntletWidgets": true, "editDiff": "always" }
 ```
 
 ## Optional footer activity API

package/dist/config.js

@@ -1,8 +1,10 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+export const EDIT_DIFF_MODES = ["always", "never", "expanded"];
 const DEFAULTS = {
     hideGauntletWidgets: true,
+    editDiff: "expanded",
 };
 export function loadPiMinimalConfig(options) {
     const config = { ...DEFAULTS };
@@ -32,14 +34,23 @@ function applyLayer(config, path) {
         console.error(`pi-minimal: expected an object in ${path}`);
         return;
     }
+    // Each key is validated on its own so one bad value does not discard the rest of the layer.
     const record = parsed;
-    if (!Object.hasOwn(record, "hideGauntletWidgets")) {
-        return;
-    }
-    const value = record.hideGauntletWidgets;
-    if (typeof value !== "boolean") {
-        console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`);
-        return;
+    if (Object.hasOwn(record, "hideGauntletWidgets")) {
+        const value = record.hideGauntletWidgets;
+        if (typeof value === "boolean")
+            config.hideGauntletWidgets = value;
+        else
+            console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`);
+    }
+    if (Object.hasOwn(record, "editDiff")) {
+        const value = record.editDiff;
+        if (isEditDiffMode(value))
+            config.editDiff = value;
+        else
+            console.error(`pi-minimal: editDiff must be one of ${EDIT_DIFF_MODES.map((mode) => `"${mode}"`).join(", ")} in ${path}`);
     }
-    config.hideGauntletWidgets = value;
+}
+function isEditDiffMode(value) {
+    return typeof value === "string" && EDIT_DIFF_MODES.includes(value);
 }

package/dist/index.js

@@ -7,7 +7,8 @@ import { bindFooterContributionEvents } from "./footer-contribution-events.js";
 import { installCwd } from "./cwd.js";
 import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
 import { hideGauntletWidgets } from "./tracker.js";
-import { installToolRenderers, stopLiveWatch } from "./tools.js";
+import { installToolRenderers, setEditDiffMode, stopLiveWatch } from "./tools.js";
+import { setSessionCwd } from "./tool-rows.js";
 import { applyReclaim, reclaimPolicy } from "./reclaim.js";
 import { installWorkingStatus } from "./working-status.js";
 import { installTurnRule } from "./turn-rule.js";
@@ -169,7 +170,9 @@ export default function piMinimalExtension(pi) {
             projectTrusted: ctx.isProjectTrusted(),
         });
         hideWidgets = config.hideGauntletWidgets;
+        setEditDiffMode(config.editDiff);
         currentCwd = ctx.cwd;
+        setSessionCwd(ctx.cwd);
         try {
             const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() });
             setChromeMargin(settings.getOutputPad());

package/dist/tool-rows.js

@@ -8,9 +8,42 @@ export function shortName(path) {
         return path || "";
     return parts.slice(-2).join("/");
 }
+let sessionCwd;
+let homeDir = process.env.HOME;
+/** The session cwd, so `cd <cwd> && \u2026` can be dropped from bash rows. */
+export function setSessionCwd(cwd, home = process.env.HOME) {
+    sessionCwd = cwd;
+    homeDir = home;
+}
+const CD_PREFIX = /^cd\s+("[^"]+"|'[^']+'|\S+)\s*&&\s*/;
+function expandHome(path) {
+    const unquoted = path.replace(/^(["'])(.*)\1$/, "$2").replace(/\/+$/, "");
+    if (homeDir && (unquoted === "~" || unquoted.startsWith("~/")))
+        return homeDir + unquoted.slice(1);
+    return unquoted;
+}
+/**
+ * The item column of a bash row. Long agent commands usually start with `cd <repo> && `, which
+ * pushes the part that differs between rows off the screen: drop it when it is the session cwd,
+ * otherwise shorten it to the directory name (`pi-subagents \u203a sed -n \u2026`). Multi-line
+ * commands (heredocs, scripts) say how many lines follow instead of ending at `<<'EOF'`.
+ */
+export function bashItem(command) {
+    const lines = command.replace(/\r/g, "").trim().split("\n");
+    let first = lines[0]?.trim() ?? "";
+    const cd = CD_PREFIX.exec(first);
+    if (cd && first.length > cd[0].length) {
+        const target = expandHome(cd[1]);
+        const rest = first.slice(cd[0].length);
+        const cwd = sessionCwd?.replace(/\/+$/, "");
+        first = cwd && target === cwd ? rest : `${target.split("/").filter(Boolean).at(-1) ?? target} \u203a ${rest}`;
+    }
+    const more = lines.slice(1).filter((line) => line.trim()).length;
+    return more > 0 ? `${first} \u00b7 +${more} line${more === 1 ? "" : "s"}` : first;
+}
 export function toolItem(kind, args) {
     if (kind === "bash") {
-        const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : "";
+        const command = typeof args?.command === "string" ? bashItem(args.command) : "";
         return command || "bash";
     }
     if (kind === "grep" || kind === "find") {

package/dist/tools.js

@@ -2,6 +2,7 @@ import { Container, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui
 import { rowIsRunning } from "./activity.js";
 import * as chrome from "./chrome.js";
 import { callSummary, codemodeOutcome, nestedCalls, nestedItem, scriptOutput } from "./codemode-rows.js";
+import { diffWords } from "diff";
 import { createLiveWatch } from "./live-watch.js";
 import { bashBody, formatDuration, formatOutcome, layoutRow, resultText, rowGlyph, toolItem, } from "./tool-rows.js";
 /** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
@@ -11,6 +12,13 @@ const live = createLiveWatch(400);
 const rowIndent = () => margin() + 1;
 /** Max lines of output shown when a row is expanded. */
 const EXPANDED_MAX_LINES = 400;
+/** Max diff lines shown inline under an edit row with `editDiff: "always"`; ctrl+o shows the rest. */
+const INLINE_DIFF_MAX_LINES = 40;
+let editDiffMode = "expanded";
+/** Applies the `editDiff` setting; read at session start, so a change needs a new session or /reload. */
+export function setEditDiffMode(mode) {
+    editDiffMode = mode;
+}
 export function stopLiveWatch() {
     live.stop();
 }
@@ -58,6 +66,97 @@ function outputBlock(kind, result, theme) {
         invalidate() { },
     };
 }
+function editDiffText(result) {
+    const details = result?.details;
+    return typeof details?.diff === "string" && details.diff.trim() ? details.diff : undefined;
+}
+/** pi's edit diff lines: "+123 content", "-123 content", " 123 context"; anything else (e.g. "...") is a separator. */
+function parseDiffLine(line) {
+    const match = /^([+\- ])(\s*\d*) (.*)$/.exec(line);
+    if (!match)
+        return undefined;
+    return { prefix: match[1], lineNum: match[2], content: match[3].replace(/\t/g, "   ") };
+}
+/** Word-level diff of a 1:1 replacement; changed tokens are inverted, leading indentation is left alone, as in pi. */
+function highlightPair(removed, added, theme) {
+    let out = { removed: "", added: "" };
+    let firstRemoved = true;
+    let firstAdded = true;
+    for (const part of diffWords(removed, added)) {
+        if (part.removed || part.added) {
+            const key = part.removed ? "removed" : "added";
+            let value = part.value;
+            if (part.removed ? firstRemoved : firstAdded) {
+                const ws = /^(\s*)/.exec(value)?.[1] ?? "";
+                value = value.slice(ws.length);
+                out = { ...out, [key]: out[key] + ws };
+                if (part.removed)
+                    firstRemoved = false;
+                else
+                    firstAdded = false;
+            }
+            if (value)
+                out = { ...out, [key]: out[key] + theme.inverse(value) };
+        }
+        else {
+            out = { removed: out.removed + part.value, added: out.added + part.value };
+        }
+    }
+    return out;
+}
+/** Colours pi's edit diff like pi does: theme diff colours per line, inverse on changed tokens of single-line replacements. */
+function colorDiffLines(lines, theme) {
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        const parsed = parseDiffLine(lines[i]);
+        if (!parsed) {
+            out.push(theme.fg("toolDiffContext", lines[i]));
+            i++;
+            continue;
+        }
+        if (parsed.prefix === " ") {
+            out.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${parsed.content}`));
+            i++;
+            continue;
+        }
+        const removed = [];
+        const added = [];
+        for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "-"; p = parseDiffLine(lines[++i] ?? ""))
+            removed.push(p);
+        for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "+"; p = parseDiffLine(lines[++i] ?? ""))
+            added.push(p);
+        if (removed.length === 1 && added.length === 1) {
+            const pair = highlightPair(removed[0].content, added[0].content, theme);
+            out.push(theme.fg("toolDiffRemoved", `-${removed[0].lineNum} ${pair.removed}`));
+            out.push(theme.fg("toolDiffAdded", `+${added[0].lineNum} ${pair.added}`));
+            continue;
+        }
+        for (const line of removed)
+            out.push(theme.fg("toolDiffRemoved", `-${line.lineNum} ${line.content}`));
+        for (const line of added)
+            out.push(theme.fg("toolDiffAdded", `+${line.lineNum} ${line.content}`));
+    }
+    return out;
+}
+/** The edit's diff in the `│`-ruled block. Inline views are capped; expanded views show up to the usual limit. */
+function diffBlock(diff, theme, expanded) {
+    const all = diff.replace(/\n$/, "").split("\n");
+    const max = expanded ? EXPANDED_MAX_LINES : INLINE_DIFF_MAX_LINES;
+    const lines = colorDiffLines(all.length > max ? all.slice(0, max) : all, theme);
+    const hidden = all.length - lines.length;
+    const indent = " ".repeat(rowIndent() + 2);
+    const rule = theme.fg("borderMuted", "│");
+    return {
+        render(width) {
+            const inner = Math.max(0, width - indent.length - 2);
+            const out = lines.map((line) => `${indent}${rule} ${truncateToWidth(line, inner)}`);
+            if (hidden > 0)
+                out.push(`${indent}${rule} ${theme.fg("dim", `… ${hidden} more lines${expanded ? "" : " (ctrl+o)"}`)}`);
+            return out;
+        },
+        invalidate() { },
+    };
+}
 function errorLineBlock(line, theme) {
     if (!line)
         return undefined;
@@ -149,15 +248,136 @@ export function compactRenderers(kind) {
                 live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)));
             }
             const container = new Container();
+            const expanded = Boolean(options.expanded);
             const errorLine = errorLineBlock(renderContext.state.outcome?.errorLine, theme);
-            if (errorLine && !options.expanded)
+            if (errorLine && !expanded)
                 container.addChild(errorLine);
-            if (options.expanded)
+            const diff = kind === "edit" && !renderContext.isError && !renderContext.isPartial ? editDiffText(typedResult) : undefined;
+            const showDiff = diff !== undefined && (editDiffMode === "always" || (editDiffMode === "expanded" && expanded));
+            if (showDiff)
+                container.addChild(diffBlock(diff, theme, expanded));
+            else if (expanded)
                 container.addChild(outputBlock(kind, typedResult, theme));
             return container;
         },
     };
 }
+/** One `glyph verb item … outcome` line in the tool-row grid, shared by every self-rendered row. */
+function rowLine(theme, width, status, frame, verb, item, right) {
+    const inner = Math.max(8, width - rowIndent());
+    const row = layoutRow(inner, verb, item, right);
+    const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim";
+    return (" ".repeat(rowIndent()) +
+        theme.fg(statusColor(status), rowGlyph(status, frame)) +
+        " " +
+        theme.fg("dim", row.verb) +
+        " " +
+        theme.fg(status === "error" ? "text" : "muted", row.item) +
+        " ".repeat(row.gap) +
+        theme.fg(rightColor, row.outcome));
+}
+/** Longest first result line shown verbatim as an outcome; longer results show a line count. */
+const OUTCOME_TEXT_MAX = 24;
+/** `mcp` for MCP tools, `agent` for subagent tools, `tool` for anything else. */
+export function genericVerb(toolName) {
+    if (toolName.startsWith("mcp__"))
+        return "mcp";
+    if (/subagent/.test(toolName))
+        return "agent";
+    return "tool";
+}
+/** `server · tool key=value …` for MCP tools, `name key=value …` for the rest. */
+export function genericItem(toolName, args) {
+    let json;
+    try {
+        json = JSON.stringify(args ?? {}) ?? "";
+    }
+    catch {
+        json = "";
+    }
+    const params = nestedItem({ name: toolName, args: json });
+    const mcp = /^mcp__(.+?)__(.+)$/.exec(toolName);
+    const label = mcp ? `${mcp[1]} \u00b7 ${mcp[2]}` : toolName;
+    return params ? `${label} ${params}` : label;
+}
+export function genericOutcome(result, isError, durationMs) {
+    const text = resultText(result);
+    const dur = formatDuration(durationMs);
+    const join = (...parts) => parts.filter(Boolean).join(" \u00b7 ");
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    if (isError)
+        return { text: join("failed", dur), errorLine: lines[0]?.trim() ?? "" };
+    if (lines.length === 0)
+        return { text: join("ok", dur) };
+    const first = lines[0].trim();
+    if (lines.length === 1 && visibleWidth(first) <= OUTCOME_TEXT_MAX)
+        return { text: join(first, dur) };
+    return { text: join(`${lines.length} line${lines.length === 1 ? "" : "s"}`, dur) };
+}
+/**
+ * A one-line row for tools that bring no renderer of their own (most MCP tools,
+ * `subagents_enable`): `\u2713 mcp   re_mcp \u00b7 query_prometheus query=\u2026   12 lines \u00b7 1.4s`.
+ * Without it they fall through to pi-core's default: bold name, JSON arguments, a text preview.
+ */
+export function genericRenderers(toolName) {
+    const verb = genericVerb(toolName);
+    return {
+        renderShell: "self",
+        renderCall(args, theme, rawContext) {
+            const context = rawContext;
+            const id = context.toolCallId || toolName;
+            const item = genericItem(toolName, args);
+            const running = rowIsRunning(context);
+            context.state.running = running;
+            if (running) {
+                context.state.startedAt ??= Date.now();
+                live.watch(id, context.invalidate);
+            }
+            else
+                live.unwatch(id);
+            return {
+                render(width) {
+                    const status = rowStatus(context);
+                    const frame = status === "running" && live.has(id) ? live.frame : 0;
+                    const right = status === "running"
+                        ? context.state.startedAt
+                            ? formatDuration(Date.now() - context.state.startedAt)
+                            : ""
+                        : (context.state.outcome?.text ?? "");
+                    return [rowLine(theme, width, status, frame, verb, item, right)];
+                },
+                invalidate() { },
+            };
+        },
+        renderResult(result, options, theme, rawContext) {
+            const context = rawContext;
+            const typed = result;
+            if (!context.isPartial) {
+                context.state.done = true;
+                context.state.running = false;
+                context.state.outcome = genericOutcome(typed, Boolean(context.isError), context.durationMs);
+                live.unwatch(context.toolCallId || toolName);
+            }
+            const container = new Container();
+            const expanded = Boolean(options.expanded);
+            const errorLine = context.state.outcome?.errorLine;
+            if (errorLine && !expanded)
+                container.addChild(errorLineBlock(errorLine, theme));
+            if (expanded) {
+                const text = resultText(typed);
+                if (text) {
+                    const indent = " ".repeat(rowIndent() + 2);
+                    container.addChild({ render: (width) => ruledLines(text, width, theme, indent), invalidate() { } });
+                }
+            }
+            return container;
+        },
+    };
+}
+/** True when a tool definition draws its own call or result. */
+function hasOwnRenderer(definition) {
+    return typeof definition?.renderCall === "function" || typeof definition?.renderResult === "function";
+}
 /** Max nested calls shown under a collapsed codemode row; the rest are counted. */
 const NESTED_PREVIEW = 8;
 /** Width of the nested tool-name column. */
@@ -209,19 +429,7 @@ export function codemodeRenderers() {
                     const frame = status === "running" && live.has(id) ? live.frame : 0;
                     const calls = state.calls ?? [];
                     const right = status === "running" ? (state.startedAt ? formatDuration(Date.now() - state.startedAt) : "") : (state.outcome?.text ?? "");
-                    const inner = Math.max(8, width - rowIndent());
-                    const row = layoutRow(inner, "code", callSummary(calls), right);
-                    const rightColor = status === "running" ? "warning" : status === "error" ? "error" : "dim";
-                    const lines = [
-                        " ".repeat(rowIndent()) +
-                            theme.fg(statusColor(status), rowGlyph(status, frame)) +
-                            " " +
-                            theme.fg("dim", row.verb) +
-                            " " +
-                            theme.fg(status === "error" ? "text" : "muted", row.item) +
-                            " ".repeat(row.gap) +
-                            theme.fg(rightColor, row.outcome),
-                    ];
+                    const lines = [rowLine(theme, width, status, frame, "code", callSummary(calls), right)];
                     const expanded = Boolean(context.expanded);
                     const shown = expanded ? calls : calls.slice(-NESTED_PREVIEW);
                     const childIndent = " ".repeat(rowIndent() + 4);
@@ -303,8 +511,12 @@ export function installToolRenderers(pi) {
     pi.registerToolRenderer((toolName, next) => {
         if (toolName === "codemode")
             return codemodeRenderers();
-        if (!isToolKind(toolName))
-            return next();
-        return compactRenderers(toolName);
+        if (isToolKind(toolName))
+            return compactRenderers(toolName);
+        // Tools that draw themselves (subagent's live view, gauntlet's trackers) keep their look.
+        const definition = next();
+        if (hasOwnRenderer(definition))
+            return definition;
+        return { ...definition, ...genericRenderers(toolName) };
     });
 }

package/dist/tracker.js

@@ -40,20 +40,24 @@ export function formatTrackerLines(ctx, theme) {
     }
     if (tasks && tasks.length > 0) {
         const done = tasks.filter((t) => t.status === "complete").length;
-        const icons = tasks
-            .map((t) => {
-            if (t.status === "complete")
-                return theme.fg("success", "✓");
-            if (t.status === "in_progress")
-                return theme.fg("warning", "→");
-            if (t.status === "failed")
-                return theme.fg("error", "✗");
-            return theme.fg("dim", "○");
-        })
-            .join("");
+        // One segment per task, coloured by status, so the list reads as a single bar instead of a
+        // row of check marks. Past 12 tasks the bar is scaled to 10 segments (status order kept).
+        const segment = (status) => {
+            if (status === "complete")
+                return theme.fg("success", "▰");
+            if (status === "in_progress")
+                return theme.fg("warning", "▰");
+            if (status === "failed")
+                return theme.fg("error", "▰");
+            return theme.fg("dim", "▱");
+        };
+        const shown = tasks.length <= 12
+            ? tasks.map((t) => t.status)
+            : Array.from({ length: 10 }, (_, i) => tasks[Math.floor((i * tasks.length) / 10)]?.status);
+        const icons = shown.map(segment).join("");
         const current = tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending");
         const name = current ? theme.fg("text", ` ${current.name}`) : "";
-        lines.push(`${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `(${done}/${tasks.length})`)}${name}`);
+        lines.push(`${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `${done}/${tasks.length}`)}${name}`);
     }
     return lines;
 }

package/dist/transcript.js

@@ -1,23 +1,77 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
 export const THINKING_GUTTER = "┊ ";
 const FENCE = /^\s*(```|~~~)/;
 const BLOCK_START = /^\s*(#{1,6}\s|[-*+]\s|\d+[.)]\s|>|\||```|~~~|---\s*$|\*\*\*\s*$|___\s*$)/;
+/** Below this width wrapping would only make thinking harder to read; prefix source lines instead. */
+const MIN_WRAP_WIDTH = 20;
+/** An inline code span stays whole; everything else splits on spaces. */
+const TOKEN = /`[^`]*`|[^\s`]+|`/g;
+function stripGutter(line) {
+    return line.startsWith(THINKING_GUTTER) ? line.slice(THINKING_GUTTER.length) : line;
+}
+/** Split a word wider than `room` into `room`-wide pieces (URLs, long paths). */
+function splitWide(word, room) {
+    if (word.startsWith("`") || visibleWidth(word) <= room)
+        return [word];
+    const pieces = [];
+    let piece = "";
+    for (const char of word) {
+        if (visibleWidth(piece + char) > room) {
+            pieces.push(piece);
+            piece = "";
+        }
+        piece += char;
+    }
+    if (piece)
+        pieces.push(piece);
+    return pieces;
+}
+/**
+ * Greedy word wrap at `room` cells. Markdown markers (`*`, backticks) count toward the width
+ * but are removed when rendered, so lines can only come out shorter than `room`, never wider.
+ */
+export function wrapLine(line, room) {
+    const words = (line.match(TOKEN) ?? []).flatMap((word) => splitWide(word, room));
+    if (words.length === 0)
+        return [""];
+    const out = [];
+    let current = "";
+    for (const word of words) {
+        if (!current)
+            current = word;
+        else if (visibleWidth(current) + 1 + visibleWidth(word) <= room)
+            current += ` ${word}`;
+        else {
+            out.push(current);
+            current = word;
+        }
+    }
+    out.push(current);
+    return out;
+}
 /**
- * Prefix the first line of every plain paragraph in thinking Markdown with a gutter glyph.
- * Lines that start a Markdown block (heading, list, quote, table, fence, rule) are left alone so
- * they keep parsing, and nothing inside a fenced code block is touched.
+ * Put the thinking gutter on every rendered line of every plain paragraph, so thinking reads as a
+ * column beside prose rather than a bullet on its first line. With `width` (the content width the
+ * host will render at) paragraph lines are pre-wrapped to `width - 2` so wrapped lines carry the
+ * gutter too; pi-tui keeps single newlines as line breaks. Without a usable width only source
+ * lines are prefixed.
+ *
+ * Block syntax (heading, list, quote, table, fence, rule) is left untouched so it still parses,
+ * including a list or quote that interrupts a paragraph, and nothing inside fenced code changes.
  */
-export function gutterThinking(markdown) {
+export function gutterThinking(markdown, width) {
     if (!markdown)
         return markdown;
-    const lines = markdown.split("\n");
+    const room = width !== undefined && width >= MIN_WRAP_WIDTH ? width - visibleWidth(THINKING_GUTTER) : undefined;
     const out = [];
     let inFence = false;
-    let atParagraphStart = true;
-    for (const line of lines) {
+    /** "para": inside a plain paragraph; "block": inside block syntax until the next blank line. */
+    let mode = "none";
+    for (const line of markdown.split("\n")) {
         if (FENCE.test(line)) {
             inFence = !inFence;
             out.push(line);
-            atParagraphStart = !inFence;
+            mode = "none";
             continue;
         }
         if (inFence) {
@@ -26,16 +80,21 @@ export function gutterThinking(markdown) {
         }
         if (line.trim() === "") {
             out.push(line);
-            atParagraphStart = true;
+            mode = "none";
             continue;
         }
-        if (atParagraphStart && !BLOCK_START.test(line) && !line.startsWith(THINKING_GUTTER)) {
-            out.push(`${THINKING_GUTTER}${line}`);
-        }
-        else {
+        const body = stripGutter(line);
+        if (mode === "block" || BLOCK_START.test(body)) {
             out.push(line);
+            mode = "block";
+            continue;
         }
-        atParagraphStart = false;
+        mode = "para";
+        if (room === undefined)
+            out.push(`${THINKING_GUTTER}${body}`);
+        else
+            for (const piece of wrapLine(body, room))
+                out.push(`${THINKING_GUTTER}${piece}`);
     }
     return out.join("\n");
 }
@@ -45,6 +104,6 @@ export function installTranscript(pi) {
     pi.registerMarkdownTransformer((markdown, context) => {
         if (context.messageType !== "assistant-thinking")
             return markdown;
-        return gutterThinking(markdown);
+        return gutterThinking(markdown, context.availableWidth);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimal",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -44,5 +44,8 @@
     "test": "tsc -p tsconfig.tests.json && node --test test-dist/test/*.test.js",
     "lint": "eslint .",
     "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "diff": "^8.0.4"
   }
 }