@gavin-hu/my-pi-agent 0.9.0 → 0.10.0

package/extensions/bytefly/separator/register.ts

@@ -12,6 +12,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createPadStore, type PadSource } from "../pad.ts";
 import { SeparatorComponent } from "./component.ts";
 import { CONFIG } from "./config.ts";
 import type { TurnSeparatorData } from "./types.ts";
@@ -26,11 +27,11 @@ function countSeparators(entries: readonly { type: string; customType?: string }
 }
 
 /** Register the separator renderer and append one on every settled turn. */
-export function registerTurnSeparator(pi: ExtensionAPI): void {
+export function registerTurnSeparator(pi: ExtensionAPI, pad: PadSource = createPadStore()): void {
 	pi.registerEntryRenderer<TurnSeparatorData>(CONFIG.customType, (entry, _options, theme) => {
 		const turn = entry.data?.turn;
 		if (typeof turn !== "number" || !Number.isFinite(turn)) return undefined;
-		return new SeparatorComponent(turn, theme);
+		return new SeparatorComponent(turn, theme, pad.resolve());
 	});
 
 	pi.on("agent_settled", (_event, ctx) => {

package/extensions/bytefly/working/config.ts

@@ -0,0 +1,20 @@
+/**
+ * Tuning for bytefly's live working timer.
+ *
+ * While Pi's working row is up, the counter is written into the working message
+ * Pi renders beside its spinner. Edit this file to change the word or how often
+ * the count advances.
+ */
+
+export const WORKING_CONFIG = {
+	/** Word before the count. */
+	working: "Working",
+	/** Between the word and the count. */
+	ellipsis: "…",
+	/** How often the count advances, in milliseconds. */
+	intervalMs: 1000,
+} as const satisfies {
+	working: string;
+	ellipsis: string;
+	intervalMs: number;
+};

package/extensions/bytefly/working/format.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure text for the live working timer.
+ *
+ * Whole seconds, because the counter advances on a one-second tick: `0s` at the
+ * start, `42s`, `1m05s`, `1h02m`. Negative and non-finite input reads as `0s`,
+ * so a clock that steps backwards cannot print a negative count.
+ */
+
+import { WORKING_CONFIG } from "./config.ts";
+
+/** Compact elapsed time in whole seconds: `0s`, `42s`, `1m05s`, `1h02m`. */
+export function formatElapsed(ms: number): string {
+	const total = Number.isFinite(ms) && ms > 0 ? Math.floor(ms / 1000) : 0;
+	const seconds = total % 60;
+	const minutes = Math.floor(total / 60) % 60;
+	const hours = Math.floor(total / 3600);
+	if (hours > 0) return `${hours}h${String(minutes).padStart(2, "0")}m`;
+	if (minutes > 0) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+	return `${seconds}s`;
+}
+
+/** The working-row message for an elapsed time, e.g. `Working… 4s`. */
+export function workingCounter(ms: number): string {
+	return `${WORKING_CONFIG.working}${WORKING_CONFIG.ellipsis} ${formatElapsed(ms)}`;
+}

package/extensions/bytefly/working/register.ts

@@ -0,0 +1,88 @@
+/**
+ * bytefly's live working timer.
+ *
+ * Pi's working row shows a static `Working`, so a long run reads the same as a
+ * short one. This surface advances the message once a second while the row is
+ * up, and hands it back to Pi when the row comes down.
+ *
+ * The timer is tied to the row's visibility. The host shows the working
+ * indicator in its own `turn_start` handler and clears it at `agent_end`
+ * (`interactive-mode.js`), so the tick starts at `turn_start` and stops at
+ * `agent_end` — the two moments the row appears and disappears. Turns inside
+ * one run do not restart it: the host leaves the same indicator up across
+ * turns, and `start` is a no-op while it is counting.
+ *
+ * Compaction and auto-retry also replace the row, but both run outside this
+ * window (`auto_retry_start` follows `agent_end`; the before-settle compaction
+ * runs after it), and neither is an extension event, so there is nothing to
+ * hook and nothing to undo.
+ *
+ * The handle is global (`setWorkingMessage` drives the single working row), so
+ * the tick is cancelled and the message reset on stop and, belt and braces, on
+ * `session_shutdown` — the factory itself only registers.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { WORKING_CONFIG } from "./config.ts";
+import { workingCounter } from "./format.ts";
+
+/** Host seams, injected by tests so the tick is deterministic. */
+export interface WorkingDeps {
+	/** The clock the count is read from. */
+	now?: () => number;
+	/** Start the repeating tick; returns a cancel handle. */
+	schedule?: (tick: () => void, intervalMs: number) => () => void;
+}
+
+/** A repeating timer that never holds the process open on its own. */
+function defaultSchedule(tick: () => void, intervalMs: number): () => void {
+	const timer = setInterval(tick, intervalMs);
+	(timer as { unref?: () => void }).unref?.();
+	return () => clearInterval(timer);
+}
+
+/** Register the timer; it runs only in interactive (`tui`) sessions. */
+export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}): void {
+	const now = deps.now ?? (() => Date.now());
+	const schedule = deps.schedule ?? defaultSchedule;
+	let cancel: (() => void) | undefined;
+	let startedAt = 0;
+	// A boolean, not `startedAt === 0`: an injected clock is allowed to start at 0.
+	let active = false;
+
+	/** Stop the tick and hand the working message back to Pi. Idempotent. */
+	const stop = (ctx: ExtensionContext): void => {
+		cancel?.();
+		cancel = undefined;
+		if (!active) return;
+		active = false;
+		ctx.ui.setWorkingMessage(undefined);
+	};
+
+	/** Start the count for the current turn; a no-op while already counting. */
+	const start = (ctx: ExtensionContext): void => {
+		if (active) return;
+		startedAt = now();
+		active = true;
+		const tick = (): void => {
+			ctx.ui.setWorkingMessage(workingCounter(now() - startedAt));
+		};
+		tick();
+		cancel = schedule(tick, WORKING_CONFIG.intervalMs);
+	};
+
+	// The host shows the working indicator on its own `turn_start` handler, so
+	// this is the first frame the row is up.
+	pi.on("turn_start", (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+		start(ctx);
+	});
+
+	// The host clears the working indicator at `agent_end`.
+	pi.on("agent_end", (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+		stop(ctx);
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => stop(ctx));
+}

package/extensions/document/README.md

@@ -8,6 +8,12 @@
 the effective working directory with the same symlink-aware guard the built-in
 path tools use.
 
+## Tool rendering
+
+How the `read_doc` call and its result look in the transcript — the call line as a headline and the body indented under it:
+
+<img src="../../assets/tools/read_doc.png" alt="The read_doc tool's result: the call line and an indented body with the file path, format, size, and the extracted text preview" width="100%">
+
 ## Quickstart
 
 ```bash
@@ -76,19 +82,20 @@ interactive transcript (and HTML exports).
 
 The call line carries the path (`~`-shortened, OSC-8 linked when the terminal
 supports it) and any paging options. The result line drops the path — it is
-already on the call line — and leads with the format and a humanized range:
+already on the call line — and leads with the format and the character range,
+grouped so a `k` suffix never sits on one bound and not the other:
 
 ```
 read_doc ~/docs/spec.pdf (from 40k, max 80k)
-PDF · 1–40k of 42k chars · more at 40k · ctrl+o
+PDF · chars 40,001–120,000 of 250,000 · next at 120,000 · ctrl+o
 ```
 
 Expanded adds a blank line before the preview body, matching the built-in
 header/output gap:
 
 ```
-read_doc ~/docs/spec.pdf
-PDF · 1–40k of 42k chars · more at 40k
+read_doc ~/docs/spec.pdf (from 40k, max 80k)
+PDF · chars 40,001–120,000 of 250,000 · next at 120,000
 
 Chapter 1
 This specification defines ...

package/extensions/document/paging.ts

@@ -6,7 +6,7 @@
  * the clean slice; the text adds a header and any truncation note.
  */
 
-import { formatTokens } from "../../lib/format.ts";
+import { formatCount } from "../../lib/format.ts";
 import type { FormatId } from "./formats.ts";
 
 export interface DocPageInput {
@@ -72,9 +72,9 @@ export interface DocSummaryInput {
 export interface DocSummary {
 	/** Uppercase format id, e.g. `PDF`. */
 	format: string;
-	/** Range detail, e.g. `1–40k of 42k chars`. */
+	/** Range detail, e.g. `chars 1–40,000 of 42,478`. */
 	detail: string;
-	/** `more at N` when truncated, `complete` for a non-first final page. */
+	/** `next at N` when truncated, `complete` for a non-first final page. */
 	note?: string;
 	/** Whether more text remains; the renderer colours the note with this. */
 	truncated: boolean;
@@ -83,9 +83,9 @@ export interface DocSummary {
 /**
  * Describe a `read_doc` result for the transcript, without theme colours.
  *
- * Counts are humanized. A complete first read shows the total; a paged read
- * shows the returned range so a truncated result is never mistaken for the
- * whole document.
+ * A complete first read shows the total; a paged read shows the returned range
+ * and where to continue, so a truncated result is never mistaken for the whole
+ * document.
  */
 export function summarizeDoc(input: DocSummaryInput): DocSummary {
 	const format = input.format.toUpperCase();
@@ -93,18 +93,18 @@ export function summarizeDoc(input: DocSummaryInput): DocSummary {
 	if (input.startIndex >= input.chars) {
 		return {
 			format,
-			detail: `no text at ${formatTokens(input.startIndex)} of ${formatTokens(input.chars)} chars`,
+			detail: `no text at ${formatCount(input.startIndex)} of ${formatCount(input.chars)} chars`,
 			truncated: false,
 		};
 	}
 	if (input.startIndex <= 0 && !input.truncated) {
-		return { format, detail: `${formatTokens(input.chars)} chars`, truncated: false };
+		return { format, detail: `${formatCount(input.chars)} chars`, truncated: false };
 	}
-	const range = `${formatTokens(input.startIndex + 1)}–${formatTokens(input.nextIndex)} of ${formatTokens(input.chars)} chars`;
+	const range = `chars ${formatCount(input.startIndex + 1)}–${formatCount(input.nextIndex)} of ${formatCount(input.chars)}`;
 	return {
 		format,
 		detail: range,
-		note: input.truncated ? `more at ${formatTokens(input.nextIndex)}` : "complete",
+		note: input.truncated ? `next at ${formatCount(input.nextIndex)}` : "complete",
 		truncated: input.truncated,
 	};
 }

package/extensions/document/render.ts

@@ -2,11 +2,11 @@
  * Transcript rendering for `read_doc`.
  *
  * Theme-aware formatting only: the tool definition in `tool.ts` wires these to
- * `renderCall` / `renderResult`. The call line carries the path (accent,
+ * `renderCall` / `renderResult`. The call line carries the path (body colour,
  * `~`-shortened, OSC-8 linked when the terminal supports it); the result line
- * leads with the format and a humanized range, so the path is never repeated.
- * The expanded view appends a sanitized, line-capped preview of the extracted
- * text. Every field is sanitized before a theme colour is applied.
+ * leads with the format and the exact character range, so the path is never
+ * repeated. The expanded view appends a sanitized, line-capped preview of the
+ * extracted text. Every field is sanitized before a theme colour is applied.
  */
 
 import { isAbsolute, resolve } from "node:path";
@@ -22,12 +22,12 @@ import { TOOL_NAME, type DocArgs, type DocResult } from "./schema.ts";
 /** Lines of extracted text shown in the expanded preview. */
 export const PREVIEW_LINES = 20;
 
-/** Render the argument path: accent, `~`-shortened, OSC-8 linked when supported. */
+/** Render the argument path: body colour, `~`-shortened, OSC-8 linked when supported. */
 export function renderDocPath(rawPath: string | undefined, theme: Theme, cwd: string): string {
 	if (typeof rawPath !== "string") return paint(theme, "bad", "[invalid arg]");
 	const value = sanitizeLine(rawPath);
 	if (!value) return theme.fg("toolOutput", "...");
-	const styled = paint(theme, "accent", shortenPath(value));
+	const styled = paint(theme, "label", shortenPath(value));
 	if (!getCapabilities().hyperlinks) return styled;
 	const abs = isAbsolute(value) ? value : resolve(cwd, value);
 	return hyperlink(styled, pathToFileURL(abs).href);
@@ -64,7 +64,7 @@ export function formatDocCall(args: DocArgs, theme: Theme, context: { cwd: strin
 	const options: string[] = [];
 	if (typeof startIndex === "number" && startIndex > 0) options.push(`from ${formatTokens(startIndex)}`);
 	if (typeof maxChars === "number") options.push(`max ${formatTokens(maxChars)}`);
-	if (options.length > 0) text += theme.fg("toolOutput", ` (${options.join(", ")})`);
+	if (options.length > 0) text += paint(theme, "faint", ` (${options.join(", ")})`);
 	return text;
 }
 

package/extensions/file-browse/README.md

@@ -63,7 +63,9 @@ pi -e .                                    # load the whole @gavin-hu/my-pi-agen
   code viewport while its body scrolls.
 - **Read-only and loopback-scoped.** No editing, no writing, no LAN exposure.
 - **Git context.** A read-only header chip shows the checked-out branch (or
-  detached head) and a dirty marker, and reflows on narrow screens.
+  detached head) and reflows on narrow screens. Uncommitted changes are stated
+  once, by the changes chip below; turn the diff view off (`gitDiff: false`) and
+  the header reports no changes at all.
 - **Git diff view.** A `● N changes +A −D` chip links to `/diff`, a change
   overview with `git diff --stat` and a per-file status table, and `/diff/<rel>`
   renders one file's unified diff, whose head carries its own `+A −D` and hunk

package/extensions/file-browse/client.ts

@@ -550,12 +550,19 @@ export const CLIENT_JS = `(function () {
 	// The hunk whose header is pinned (or last passed), then one step either way.
 	function moveHunk(delta) {
 		if (hunkAnchors.length === 0) return;
+		var scroller = primaryScroller();
+		// The line a pinned hunk header sticks to: the code viewport's top inset
+		// by its padding. With no scrolling pane (narrow screens) the page is the
+		// viewport, so the anchor is the window top.
+		var lineTop = 8;
+		if (scroller) lineTop = scroller.getBoundingClientRect().top + (parseFloat(getComputedStyle(scroller).paddingTop) || 0);
 		var current = -1;
 		for (var index = 0; index < hunkAnchors.length; index++) {
-			if (hunkAnchors[index].getBoundingClientRect().top <= 8) current = index;
+			if (hunkAnchors[index].getBoundingClientRect().top <= lineTop + 2) current = index;
 		}
 		var next = Math.max(0, Math.min(hunkAnchors.length - 1, current + delta));
-		hunkAnchors[next].scrollIntoView({ block: "start" });
+		if (scroller) scroller.scrollTop += hunkAnchors[next].getBoundingClientRect().top - lineTop;
+		else hunkAnchors[next].scrollIntoView({ block: "start" });
 	}
 
 	// The page's primary scroller: the card body for a file or diff, the main

package/extensions/file-browse/git.ts

@@ -1,8 +1,9 @@
 /**
  * Read-only git context for the browse pages.
  *
- * The header shows the checked-out branch (or the detached head) and a dirty
- * marker. Queries go through the shared `lib/git` seams so the read-only
+ * The header shows the checked-out branch (or the detached head); uncommitted
+ * changes are the changes chip's concern. Queries go through the shared
+ * `lib/git` seams so the read-only
  * plumbing lives in one place. State (the TTL cache) lives in the factory
  * closure, never in `lib/`.
  */
@@ -25,8 +26,6 @@ export interface GitStatus {
 	branch?: string;
 	/** Short object id, when HEAD is detached. */
 	head?: string;
-	/** True when `git status --porcelain` reports any change. */
-	dirty: boolean;
 }
 
 export type GitStatusProvider = () => Promise<GitStatus | undefined>;
@@ -60,9 +59,7 @@ export function createGitStatus(
 		const branch = await currentBranch(run, root);
 		const head = branch ? undefined : (await revParse(run, root, "HEAD"))?.slice(0, 7);
 		if (!branch && !head) return undefined;
-		const status = await run(["status", "--porcelain"], { cwd: root, timeoutMs: 1000 });
-		if (status.code !== 0) return undefined;
-		return { branch, head, dirty: status.stdout.trim().length > 0 };
+		return { branch, head };
 	}
 
 	return async () => {

package/extensions/file-browse/html.ts

@@ -41,15 +41,14 @@ function iconMarkup(spec: IconSpec, hidden = false): string {
 	return `<svg class="browse-cat ${spec.colorClass}"${hidden ? " hidden" : ""} aria-hidden="true" title="${escapeHtml(spec.label)}"><use href="${iconHref(spec.icon)}"/></svg>`;
 }
 
-/** The header's git chip: branch (or detached head) plus a dirty dot. */
+/** The header's git chip: the branch, or the detached head; changes are the changes chip's job. */
 function renderGit(git: GitStatus | undefined): string {
 	if (!git) return "";
 	const name = git.branch ?? git.head;
 	if (!name) return "";
 	const glyph = git.branch ? GLYPHS.branch : GLYPHS.detached;
-	const aria = `${git.branch ? `git branch ${git.branch}` : `git detached at ${git.head ?? ""}`}${git.dirty ? ", uncommitted changes" : ""}`;
-	const dot = git.dirty ? `<span class="browse-dirty" aria-hidden="true" title="uncommitted changes">●</span>` : "";
-	return `<span class="bf-chip browse-git${git.dirty ? " browse-git--dirty" : ""}" title="${escapeHtml(aria)}" aria-label="${escapeHtml(aria)}"><span class="browse-git__glyph" aria-hidden="true">${escapeHtml(glyph)}</span>${escapeHtml(name)}${dot}</span>`;
+	const aria = git.branch ? `git branch ${git.branch}` : `git detached at ${git.head ?? ""}`;
+	return `<span class="bf-chip browse-git" title="${escapeHtml(aria)}" aria-label="${escapeHtml(aria)}"><span class="browse-git__glyph" aria-hidden="true">${escapeHtml(glyph)}</span>${escapeHtml(name)}</span>`;
 }
 
 /** The changed-path index for markers, plus the totals shown in the chip. */
@@ -98,8 +97,6 @@ ${WEB_COMPONENTS_CSS}
 .browse-side{padding:var(--space-3)}
 .browse-root{flex:1 1 auto;direction:rtl;text-align:left}
 .browse-git{font-family:var(--font-mono)}
-.browse-git--dirty .browse-git__glyph{color:var(--warn)}
-.browse-dirty{color:var(--warn);font-size:9px;line-height:1}
 .browse-quick-open{display:flex;align-items:center;justify-content:space-between;gap:var(--space-2);width:100%;margin-bottom:var(--space-2);padding:6px var(--space-2);border:1px solid var(--border);border-radius:var(--radius-md);background:var(--canvas);color:var(--muted);font:var(--fs-sm) var(--font-ui);cursor:pointer}
 .browse-quick-open:hover{border-color:var(--accent);color:var(--accent)}
 .browse-quick-open kbd{font-family:var(--font-mono);font-size:var(--fs-xs);color:var(--dim)}
@@ -149,7 +146,10 @@ body.palette-open{overflow:hidden}
 .bf-diff-line--hunk{color:var(--accent);background:var(--canvas)}
 .bf-diff-line--meta{color:var(--muted)}
 .bf-diff-line--note{color:var(--muted);font-style:italic}
-/* A hunk header pins to the top of the diff viewport while its body scrolls. */
+/* A hunk header pins to the top of the diff viewport while its body scrolls.
+   Each hunk is a section so the pinned header is bounded by its own body and
+   cannot stack on the next one. */
+.bf-diff-hunk{display:block}
 .bf-diff .bf-diff-line--hunk{position:sticky;top:0;z-index:1}
 /* Reading progress, pinned to the sticky header's bottom edge. */
 .browse-progress{position:absolute;left:0;right:0;bottom:-1px;height:2px;overflow:hidden}
@@ -575,17 +575,27 @@ function highlightDiffText(lines: DiffLine[], language?: HighlightLanguage): str
 /** Render unified-diff lines with a two-column gutter and per-kind styling. */
 export function renderDiffLines(lines: DiffLine[], language?: HighlightLanguage): string {
 	const html = highlightDiffText(lines, language);
+	// Every hunk is a section so its sticky header is bounded by its own body;
+	// the section also gives the keyboard a stable, non-sticky scroll target.
+	const out: string[] = [];
 	let hunks = 0;
-	return lines
-		.map((line, index) => {
-			const sign = line.kind === "add" ? "+" : line.kind === "del" ? "-" : line.kind === "ctx" ? " " : "";
-			const gutter = `<span class="browse-diff-no" aria-hidden="true">${line.oldNo ?? ""}</span><span class="browse-diff-no" aria-hidden="true">${line.newNo ?? ""}</span>`;
-			const marker = `<span class="browse-diff-sign" aria-hidden="true">${sign}</span>`;
-			// Hunk headers carry an anchor so the keyboard can jump between them.
-			const anchor = line.kind === "hunk" ? ` id="hunk-${++hunks}" data-hunk="${hunks}"` : "";
-			return `<span class="bf-code__line bf-diff-line bf-diff-line--${line.kind}"${anchor}>${gutter}${marker}${html[index]}</span>`;
-		})
-		.join("");
+	let open = false;
+	lines.forEach((line, index) => {
+		if (line.kind === "hunk") {
+			if (open) out.push("</span>");
+			hunks += 1;
+			out.push(`<span class="bf-diff-hunk" id="hunk-${hunks}" data-hunk="${hunks}">`);
+			open = true;
+		}
+		const sign = line.kind === "add" ? "+" : line.kind === "del" ? "-" : line.kind === "ctx" ? " " : "";
+		const gutter = `<span class="browse-diff-no" aria-hidden="true">${line.oldNo ?? ""}</span><span class="browse-diff-no" aria-hidden="true">${line.newNo ?? ""}</span>`;
+		const marker = `<span class="browse-diff-sign" aria-hidden="true">${sign}</span>`;
+		out.push(
+			`<span class="bf-code__line bf-diff-line bf-diff-line--${line.kind}">${gutter}${marker}${html[index]}</span>`,
+		);
+	});
+	if (open) out.push("</span>");
+	return out.join("");
 }
 
 /** The scope label for a mode. */

package/extensions/file-open/README.md

@@ -5,6 +5,12 @@ handler, or reveals it in the file manager. `/open` does it interactively and
 the `open_path` tool does it from a script, both resolving the path against the
 effective working directory.
 
+## Tool rendering
+
+How the `open_path` call and its result look in the transcript — the call line as a headline and the body indented under it:
+
+<img src="../../assets/tools/open_path.png" alt="The open_path tool's call and result, drawn by the generic fallback" width="100%">
+
 ## Quickstart
 
 ```bash

package/extensions/goal/README.md

@@ -9,6 +9,12 @@ pi -e .                             # load the whole @gavin-hu/my-pi-agent packa
 pi install ./                       # install the package
 ```
 
+## Tool rendering
+
+How the `goal` call and its result look in the transcript — the call line as a headline and the body indented under it:
+
+<img src="../../assets/tools/goal.png" alt="The goal tool's result: the call line and an indented body with the Goal header and the objective body" width="100%">
+
 ## What it does
 
 - Registers one model-callable tool, `goal`, that records the session
@@ -110,14 +116,13 @@ The tool works in every mode. The persistent widget requires interactive
 `/goal <prompt>` runs the loop: each model call uses a cancellable `tui` spinner
 in interactive mode and runs directly in RPC; the questions and the confirm step
 are host dialogs, forwarded by RPC. In print and JSON mode the loop is skipped
-and the typed text is sent. The widget is always a single line; the transcript result
-keeps the full glyph rail, separated from the call line by a blank line:
+and the typed text is sent. The widget is always a single line; the transcript
+result is the status header alone, directly under the call line that names the
+objective:
 
 ```
 goal → set: Refactor the parser to support streaming input
-
-Goal · active
-  ⊚ Refactor the parser to support streaming input and ship it with tests
+  Goal · active
 ```
 
 The renderer reuses the slot's component (`context.lastComponent`) rather than
@@ -205,9 +210,10 @@ depends on config.
   hide all rails and restore them on close.
 - **One-line widget, achieved hidden by default.** The rail follows the
   `todo` grammar (`Goal · active · <objective>`): accent label leads, status
-  follows, no prefixed glyph, clipped to the terminal. The transcript keeps the
-  multi-line `⊚` / `✓` rail. `achieved: "show"` restores the dimmed line; config
-  only affects presentation.
+  follows, no prefixed glyph, clipped to the terminal. The transcript result is
+  the status header alone (`Goal · active`), because the call line above it
+  already carries the objective; it does not restate it. `achieved: "show"`
+  restores the dimmed widget line; config only affects presentation.
 - **Sanitize at the boundary.** `normalizeGoal` and `parseClarification` both route
   model text through `lib/format.ts`'s `sanitizeLine`, so an embedded newline
   cannot corrupt the widget and raw escapes cannot restyle the terminal.
@@ -223,9 +229,9 @@ depends on config.
 | `clarify-parse.ts` | Parse the `{ understood, goal, questions }` reply (and the plain-text fallback), normalize questions, and expose the limits (pure). |
 | `clarify.ts` | The two model calls, their cancellable loaders, the in-command questionnaire, and the confirm/edit dialog (host). |
 | `state.ts` | Branch reconstruction (pure). |
-| `format.ts` | Model-facing and terminal text plus the transcript `⊚` / `✓` symbols and the rail vocabulary (pure). |
+| `format.ts` | Model-facing and terminal text plus the header and rail vocabulary (pure). |
 | `config.ts` | Widget config load/validation (the `goal` section of `bytefly.json`). |
-| `tui.ts` | The persistent goal widget and the transcript result rail. |
+| `tui.ts` | The persistent goal widget and the transcript status header. |
 | `runtime.ts` | Session-scoped state and widget synchronization. |
 | `tools.ts` | `goal` tool registration and rendering. |
 | `commands.ts` | `/goal`. |

package/extensions/goal/format.ts

@@ -1,34 +1,21 @@
 /**
  * Model-facing and transcript text for the goal (pure).
  *
- * The transcript result is drawn as a glyph rail shared with `todo`: a header
- * line (`Goal · active`) and an indented body row led by `⊚` (active) or `✓`
- * (achieved), with wrapped continuation rows aligned under the text. The
- * persistent widget, by contrast, is a plain label-first line
- * (`Goal · active · <objective>`) matching the `todo` and `jobs` widgets. The
- * symbols and labels live here; the rail indent constants are shared with
- * `todo` in `lib/tui/glyphs.ts`.
+ * The transcript result is the status header (`Goal · active`) under the call
+ * line, which already names the objective; the persistent widget is a plain
+ * label-first line (`Goal · active · <objective>`) matching the `todo` and
+ * `jobs` widgets. The status labels live here.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { sliceByColumn, visibleWidth } from "@earendil-works/pi-tui";
-import { GLYPHS } from "../../lib/tui/glyphs.ts";
+import { SEPARATORS } from "../../lib/tui/glyphs.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import type { Goal, GoalStatus } from "./types.ts";
 
-/** Active-goal glyph. */
-export const ACTIVE_SYMBOL = GLYPHS.target;
-/** Achieved-goal glyph. */
-export const ACHIEVED_SYMBOL = GLYPHS.check;
-
 /** Longest objective preview shown in the transcript call line. */
 const CALL_PREVIEW_WIDTH = 48;
 
-/** Themed status glyph, shared by the widget and the transcript renderer. */
-export function goalGlyph(goal: Goal, theme: Theme): string {
-	return goal.status === "achieved" ? paint(theme, "ok", ACHIEVED_SYMBOL) : paint(theme, "accent", ACTIVE_SYMBOL);
-}
-
 /** Human label for a status, e.g. `active`. */
 export function goalStatusLabel(status: GoalStatus): string {
 	return status === "achieved" ? "achieved" : "active";
@@ -40,7 +27,7 @@ export function goalStatusLabel(status: GoalStatus): string {
  */
 export function goalHeader(goal: Goal, theme: Theme): string {
 	const label = paint(theme, "accent", "Goal");
-	const separator = paint(theme, "faint", " · ");
+	const separator = paint(theme, "faint", SEPARATORS.item);
 	const word = goalStatusLabel(goal.status);
 	const status = goal.status === "achieved" ? paint(theme, "ok", word) : paint(theme, "faint", word);
 	return `${label}${separator}${status}`;
@@ -53,7 +40,7 @@ export function goalHeader(goal: Goal, theme: Theme): string {
  * Callers clip it to the available width.
  */
 export function goalLine(goal: Goal, theme: Theme): string {
-	const separator = paint(theme, "faint", " · ");
+	const separator = paint(theme, "faint", SEPARATORS.item);
 	const word = goalStatusLabel(goal.status);
 	const status = goal.status === "achieved" ? paint(theme, "ok", word) : paint(theme, "faint", word);
 	return `${paint(theme, "accent", "Goal")}${separator}${status}${separator}${goalObjective(goal, theme)}`;

package/extensions/goal/tools.ts

@@ -8,13 +8,13 @@
  */
 
 import type { JsonValue } from "@earendil-works/pi-ai";
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { sanitizeLine } from "../../lib/format.ts";
 import { GOAL_TOOL } from "../../lib/tool-names.ts";
 import { reuseText, toolDetails } from "../../lib/tui/chrome.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import { GLYPHS } from "../../lib/tui/glyphs.ts";
-import { formatCallText, formatGoalText, goalObjective, previewObjective } from "./format.ts";
+import { formatCallText, formatGoalText } from "./format.ts";
 import type { GoalRuntime } from "./runtime.ts";
 import { GoalParams, GoalResult, normalizeGoal, type GoalArgs } from "./schema.ts";
 import { GoalResult as GoalResultView } from "./tui.ts";
@@ -22,9 +22,6 @@ import type { GoalAction, GoalDetails } from "./types.ts";
 
 export const TOOL_NAME = GOAL_TOOL;
 
-/** Longest objective shown in an unexpanded transcript result. */
-const RESULT_PREVIEW_WIDTH = 72;
-
 /** Best-effort action of a rejected call, for the error result's details. */
 function attemptedAction(args: Partial<GoalArgs>): GoalAction {
 	if (args.status === "achieved") return "achieve";
@@ -32,14 +29,6 @@ function attemptedAction(args: Partial<GoalArgs>): GoalAction {
 	return "set";
 }
 
-/** Themed body for the transcript result: the collapsed preview or the full objective. */
-function resultBody(goal: NonNullable<GoalDetails["goal"]>, expanded: boolean, theme: Theme): string {
-	const text = expanded ? goal.objective : previewObjective(goal.objective, RESULT_PREVIEW_WIDTH);
-	// Route both states through `goalObjective`, so an achieved goal is dimmed
-	// whether it is collapsed or expanded.
-	return goalObjective({ objective: text, status: goal.status }, theme);
-}
-
 /**
  * JSON-safe mirror of the goal for `structuredContent`.
  *
@@ -108,7 +97,7 @@ export function registerTools(pi: ExtensionAPI, runtime: GoalRuntime): void {
 			return text;
 		},
 
-		renderResult(result, { expanded }, theme, context) {
+		renderResult(result, _options, theme, context) {
 			const text = reuseText(context.lastComponent);
 			const details = toolDetails<GoalDetails>(result.details);
 			if (!details) {
@@ -125,12 +114,11 @@ export function registerTools(pi: ExtensionAPI, runtime: GoalRuntime): void {
 				text.setText(paint(theme, "faint", `${GLYPHS.stopped} `) + paint(theme, "meta", "Cleared the goal"));
 				return text;
 			}
-			const body = resultBody(details.goal, expanded, theme);
 			const view =
 				context.lastComponent instanceof GoalResultView
 					? context.lastComponent
-					: new GoalResultView(details.goal, body, theme);
-			view.update(details.goal, body, theme);
+					: new GoalResultView(details.goal, theme);
+			view.update(details.goal, theme);
 			return view;
 		},
 	});