@gavin-hu/my-pi-agent 0.13.0 → 0.14.0

package/extensions/bytefly/panel/tui.ts

@@ -43,6 +43,7 @@ import {
 import {
 	editHints,
 	projectNote,
+	sectionJsonPane,
 	settingDetail,
 	settingRow,
 	settingsHints,
@@ -103,6 +104,8 @@ export class PanelComponent implements Component {
 	private notice: string | undefined;
 	/** The text row being edited: its id, the buffer, and the caret offset. */
 	private editing: { id: string; buffer: string; caret: number } | undefined;
+	/** True while the Settings detail pane shows the focused row's section as JSON. */
+	private json = false;
 	/** The visible section. */
 	private section: PanelSection;
 
@@ -182,6 +185,8 @@ export class PanelComponent implements Component {
 			);
 			return;
 		}
+		// The JSON pane names a file, so a scope switch has to close it.
+		this.json = false;
 		this.options.runtime.setScope(next);
 		this.options.requestRender();
 	}
@@ -234,6 +239,29 @@ export class PanelComponent implements Component {
 			.then(() => this.options.requestRender());
 	}
 
+	/** Delete the focused setting's leaf, so its default applies again. */
+	private resetSetting(): void {
+		const entry = this.activeEntries()[this.cursor.selected];
+		if (entry?.kind !== "setting") return;
+		const scope = this.options.runtime.scope();
+		this.chain = this.chain
+			.then(() => this.options.settings.reset(scope, entry.setting.id))
+			.catch((error: unknown) => this.notify(error instanceof Error ? error.message : String(error)))
+			.then(() => this.options.requestRender());
+	}
+
+	/** Toggle the detail pane between the row and its whole section as stored. */
+	private toggleJson(): void {
+		const entry = this.activeEntries()[this.cursor.selected];
+		if (entry?.kind !== "setting") return;
+		if (!entry.setting.config) {
+			this.notify(`${entry.setting.label} is a Pi setting; bytefly.json has no section for it.`);
+			return;
+		}
+		this.json = !this.json;
+		this.options.requestRender();
+	}
+
 	/** Store the editor's buffer; a refusal keeps it open with the reason shown. */
 	private commitEdit(): void {
 		const editing = this.editing;
@@ -348,6 +376,7 @@ export class PanelComponent implements Component {
 	private switchSection(next: PanelSection): void {
 		if (next === this.section) return;
 		this.section = next;
+		this.json = false;
 		this.prime();
 		this.options.requestRender();
 	}
@@ -362,6 +391,14 @@ export class PanelComponent implements Component {
 			this.select(lastRow(this.activeEntries()));
 			return;
 		}
+		if (data === "[") {
+			this.jumpGroup(-1);
+			return;
+		}
+		if (data === "]") {
+			this.jumpGroup(1);
+			return;
+		}
 		switch (navIntent(data)) {
 			case "up":
 				this.move(-1);
@@ -384,6 +421,26 @@ export class PanelComponent implements Component {
 		}
 	}
 
+	/** Move to the first row of the next (or previous) group. */
+	private jumpGroup(direction: -1 | 1): void {
+		const entries = this.activeEntries();
+		const headers = entries.flatMap((entry, index) => (entry.kind === "group" ? [index] : []));
+		const selected = this.cursor.selected;
+		// Step past the focused row's own header: landing on it would not move.
+		const own = headers.filter((index) => index < selected).at(-1);
+		const target =
+			direction === 1
+				? headers.find((index) => index > selected)
+				: headers.filter((index) => index < (own ?? 0)).at(-1);
+		if (target === undefined) return;
+		for (let index = target + 1; index < entries.length; index += 1) {
+			if (isSelectable(entries[index])) {
+				this.select(index);
+				return;
+			}
+		}
+	}
+
 	/** Settings keys: change, scope, navigation. `←`/`→` stay on sections. */
 	private handleSettingsInput(data: string): void {
 		this.clampSelection(this.activeEntries());
@@ -395,6 +452,14 @@ export class PanelComponent implements Component {
 			this.switchScope();
 			return;
 		}
+		if (data === "u") {
+			this.resetSetting();
+			return;
+		}
+		if (data === "J") {
+			this.toggleJson();
+			return;
+		}
 		this.navigate(data);
 	}
 
@@ -483,7 +548,7 @@ export class PanelComponent implements Component {
 		if (this.editing) return hintLine(this.theme, width, editHints());
 		const hints =
 			this.section === "settings"
-				? settingsHints()
+				? settingsHints(this.json)
 				: extensionHints({
 						expanded,
 						refreshing: this.refreshing,
@@ -527,33 +592,36 @@ export class PanelComponent implements Component {
 			this.theme,
 			width,
 			this.section,
-			settingsSummary(this.theme, width, scope, this.options.settings.count(scope)),
+			settingsSummary(this.theme, width, scope, views.length),
 		);
 		const entries = settingEntries(views);
 		const note = scope === "project" ? projectNote(this.theme, width) : undefined;
 
-		if (entries.length === 0) {
-			return dockListFrame({
-				header,
-				summary,
-				body: emptyState(this.theme, width, { label: "No settings found." }),
-				hint: this.hintRow(width),
-			});
-		}
-
 		this.retainFocus(entries);
 		this.clampSelection(entries);
 
 		const focusedEntry = entries[this.cursor.selected];
 		const focused = focusedEntry?.kind === "setting" ? focusedEntry.setting : undefined;
-		const detail = settingDetail({
-			theme: this.theme,
-			width,
-			view: focused,
-			budget: this.detailRows(false),
-			dirty: this.dirty,
-			paths: { scope, cwd: this.options.cwd, agentDir: this.options.agentDir },
-		});
+		const jsonConfig = this.json ? focused?.config : undefined;
+		const detail =
+			jsonConfig && focused
+				? sectionJsonPane({
+						theme: this.theme,
+						width,
+						section: jsonConfig.section,
+						view: focused,
+						document: this.options.settings.sectionDocument(scope, jsonConfig.section),
+						budget: this.detailRows(true),
+						paths: { scope, cwd: this.options.cwd, agentDir: this.options.agentDir },
+					})
+				: settingDetail({
+						theme: this.theme,
+						width,
+						view: focused,
+						budget: this.detailRows(false),
+						dirty: this.dirty,
+						paths: { scope, cwd: this.options.cwd, agentDir: this.options.agentDir },
+					});
 
 		this.cursor.visible = fitRows(
 			this.options.viewportRows,

package/extensions/bytefly/separator/component.ts

@@ -1,27 +1,28 @@
 /**
  * The transcript component that draws one separator entry.
  *
- * It is stateless: the line is derived from the stored turn number and the
- * width passed to `render`, so there is nothing to invalidate.
+ * It is stateless: the line is derived from the stored entry data and the width
+ * passed to `render`, so there is nothing to invalidate.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 import { separatorLine } from "./format.ts";
+import type { TurnSeparatorData } from "./types.ts";
 
-/** Renders one separator entry; `turn` comes from the stored entry data. */
+/** Renders one separator entry; the data comes from the stored entry. */
 export class SeparatorComponent implements Component {
 	constructor(
-		private readonly turn: number,
+		private readonly data: TurnSeparatorData,
 		private readonly theme: Theme,
 		private readonly pad = 0,
 	) {}
 
 	invalidate(): void {
-		// Stateless: the line is derived from `turn` and the width passed to render.
+		// Stateless: the line is derived from the data and the width passed to render.
 	}
 
 	render(width: number): string[] {
-		return separatorLine(this.turn, width, this.theme, this.pad);
+		return separatorLine(this.data, width, this.theme, this.pad);
 	}
 }

package/extensions/bytefly/separator/config.ts

@@ -22,6 +22,16 @@ export const CONFIG = {
 	dashRole: "ruleStrong",
 	/** Role for the label. */
 	labelRole: "meta",
+	/** Role for a turn with a failed tool. */
+	failureRole: "bad",
+	/** Role for an aborted turn; escape is a warning, not an error. */
+	abortedRole: "warn",
+	/** Smallest run duration printed on the receipt; shorter turns keep the label quiet. */
+	minDurationMs: 1000,
+	/** Word appended when the run was aborted. */
+	abortedLabel: "aborted",
+	/** Glyph before a failed tool count. */
+	failureGlyph: GLYPHS.cross,
 } as const satisfies {
 	customType: string;
 	glyph: string;
@@ -29,4 +39,9 @@ export const CONFIG = {
 	pad: number;
 	dashRole: TuiRole;
 	labelRole: TuiRole;
+	failureRole: TuiRole;
+	abortedRole: TuiRole;
+	minDurationMs: number;
+	abortedLabel: string;
+	failureGlyph: string;
 };

package/extensions/bytefly/separator/format.ts

@@ -1,14 +1,67 @@
 /**
  * Pure formatting for bytefly's turn separator line.
  *
- * The centered `╌╌╌ turn N ╌╌╌` layout comes from the design system's
- * `centeredRule`, so this module only names the turn; the shared rule owns the
- * centering, the degradation, and the colors.
+ * The line is a receipt for the settled run: the turn number, then as much of
+ * the duration, the top-level tool count, and the outcome as the width can
+ * carry. The centered `╌╌╌ turn N ╌╌╌` layout comes from the design system's
+ * `centeredRule`, so this module only builds the label and picks its role; the
+ * shared rule owns the centering and the dashes.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { formatDuration, formatToolCount } from "../../../lib/format.ts";
+import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
 import { centeredRule } from "../../../lib/tui/rules.ts";
+import type { TuiRole } from "../../../lib/tui/tokens.ts";
 import { CONFIG } from "./config.ts";
+import type { TurnSeparatorData } from "./types.ts";
+
+/** Whether the label and `centeredRule`'s two pads leave room for a dash. */
+function fits(label: string, width: number): boolean {
+	return visibleWidth(label) + CONFIG.pad * 2 < width;
+}
+
+/**
+ * The widest receipt that fits, shed one field at a time.
+ *
+ * The tool count goes first, then the duration; the outcome stays beside the
+ * turn as long as it fits, because a failed or aborted run is the part the rule
+ * should not hide. The turn number itself is never dropped here — a terminal
+ * too narrow even for that falls back to `centeredRule`'s plain dashed rule.
+ */
+export function receiptLabel(data: TurnSeparatorData, width: number): string {
+	const turn = `${CONFIG.labelPrefix} ${data.turn}`;
+	const duration =
+		data.durationMs !== undefined && data.durationMs >= CONFIG.minDurationMs
+			? formatDuration(data.durationMs)
+			: undefined;
+	const tools = data.tools !== undefined && data.tools > 0 ? formatToolCount(data.tools) : undefined;
+	const outcome = data.aborted
+		? CONFIG.abortedLabel
+		: data.failures !== undefined && data.failures > 0
+			? `${CONFIG.failureGlyph}${data.failures}`
+			: undefined;
+
+	const steps: Array<Array<string | undefined>> = [
+		[turn, duration, tools, outcome],
+		[turn, duration, outcome],
+		[turn, outcome],
+		[turn],
+	];
+	for (const parts of steps) {
+		const label = parts.filter((part): part is string => part !== undefined).join(SEPARATORS.item);
+		if (fits(label, width)) return label;
+	}
+	return turn;
+}
+
+/** The label's role: an aborted turn warns, a failed tool is an error. */
+export function receiptRole(data: TurnSeparatorData): TuiRole {
+	if (data.aborted) return CONFIG.abortedRole;
+	if (data.failures !== undefined && data.failures > 0) return CONFIG.failureRole;
+	return CONFIG.labelRole;
+}
 
 /**
  * One rendered line: the centered turn rule, colored by role.
@@ -17,14 +70,15 @@ import { CONFIG } from "./config.ts";
  * component raw, so the rule insets itself symmetrically by that many columns,
  * keeping its left edge on the transcript's margin.
  */
-export function separatorLine(turn: number, width: number, theme: Theme, pad = 0): string[] {
+export function separatorLine(data: TurnSeparatorData, width: number, theme: Theme, pad = 0): string[] {
 	const w = Math.max(1, Math.floor(width));
 	const inset = Math.max(0, Math.min(Math.floor(pad), Math.floor((w - 1) / 2)));
-	const line = centeredRule(theme, Math.max(1, w - inset * 2), `${CONFIG.labelPrefix} ${turn}`, {
+	const ruleWidth = Math.max(1, w - inset * 2);
+	const line = centeredRule(theme, ruleWidth, receiptLabel(data, ruleWidth), {
 		glyph: CONFIG.glyph,
 		pad: CONFIG.pad,
 		fillRole: CONFIG.dashRole,
-		labelRole: CONFIG.labelRole,
+		labelRole: receiptRole(data),
 	});
 	return [`${" ".repeat(inset)}${line}`];
 }

package/extensions/bytefly/separator/register.ts

@@ -4,11 +4,15 @@
  * Pi has no built-in turn separator. On every fully settled agent run
  * (`agent_settled`, one per user turn) this appends an inert custom entry that
  * is excluded from LLM context, and a registered entry renderer draws it as a
- * centered `╌╌╌ turn N ╌╌╌` rule in the interactive transcript.
+ * centered `╌╌╌ turn N ╌╌╌` rule in the interactive transcript. The entry also
+ * carries the run's receipt — duration, top-level tool count, failed tools, and
+ * whether the user aborted it — so the rule can read as a flight log.
  *
  * `agent_settled` is deliberate: `turn_end` fires once per assistant message,
  * so tool-calling rounds would each get a line, while a settled run is exactly
- * one user turn.
+ * one user turn. The run's first `agent_start` opens the receipt and later
+ * starts (a retry or a continuation) stay in it, so the duration covers the
+ * whole settled run rather than one attempt.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -17,6 +21,12 @@ import { SeparatorComponent } from "./component.ts";
 import { CONFIG } from "./config.ts";
 import type { TurnSeparatorData } from "./types.ts";
 
+/** Host seams, injected by tests so the duration is deterministic. */
+export interface SeparatorDeps {
+	/** The clock the duration is read from. */
+	now?: () => number;
+}
+
 /** Count separators already on the branch, so numbering survives resume and fork. */
 function countSeparators(entries: readonly { type: string; customType?: string }[]): number {
 	let count = 0;
@@ -27,17 +37,66 @@ function countSeparators(entries: readonly { type: string; customType?: string }
 }
 
 /** Register the separator renderer and append one on every settled turn. */
-export function registerTurnSeparator(pi: ExtensionAPI, pad: PadSource = createPadStore()): void {
+export function registerTurnSeparator(
+	pi: ExtensionAPI,
+	pad: PadSource = createPadStore(),
+	deps: SeparatorDeps = {},
+): void {
+	const now = deps.now ?? (() => Date.now());
+	// The current run's receipt. `startedAt` is the first `agent_start`; the
+	// counters span every top-level tool in the settled run.
+	let startedAt: number | undefined;
+	let tools = 0;
+	let failures = 0;
+
+	const reset = (): void => {
+		startedAt = undefined;
+		tools = 0;
+		failures = 0;
+	};
+
 	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, pad.resolve());
+		const data = entry.data;
+		if (!data || typeof data.turn !== "number" || !Number.isFinite(data.turn)) return undefined;
+		return new SeparatorComponent(data, theme, pad.resolve());
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		if (ctx.mode !== "tui" || startedAt !== undefined) return;
+		startedAt = now();
+		tools = 0;
+		failures = 0;
 	});
 
-	pi.on("agent_settled", (_event, ctx) => {
+	// A nested tool is an implementation detail of its parent, not a transcript
+	// block, so it neither counts nor contributes a failure.
+	pi.on("tool_execution_start", (event) => {
+		if (startedAt === undefined || event.parentToolCallId) return;
+		tools += 1;
+	});
+
+	pi.on("tool_execution_end", (event) => {
+		if (startedAt === undefined || event.parentToolCallId || !event.isError) return;
+		failures += 1;
+	});
+
+	pi.on("agent_settled", (event, ctx) => {
 		// The transcript is interactive-only; keep RPC/JSON/print sessions clean.
-		if (ctx.mode !== "tui") return;
+		if (ctx.mode !== "tui") {
+			reset();
+			return;
+		}
 		const turn = countSeparators(ctx.sessionManager.getBranch()) + 1;
-		pi.appendEntry<TurnSeparatorData>(CONFIG.customType, { turn });
+		const data: TurnSeparatorData = { turn };
+		if (startedAt !== undefined) {
+			data.durationMs = Math.max(0, now() - startedAt);
+			if (tools > 0) data.tools = tools;
+			if (failures > 0) data.failures = failures;
+		}
+		if (event.aborted) data.aborted = true;
+		pi.appendEntry<TurnSeparatorData>(CONFIG.customType, data);
+		reset();
 	});
+
+	pi.on("session_shutdown", () => reset());
 }

package/extensions/bytefly/separator/types.ts

@@ -9,4 +9,12 @@
 export interface TurnSeparatorData {
 	/** 1-based index of the completed user turn this separator follows. */
 	turn: number;
+	/** From the run's first `agent_start` to `agent_settled`, in milliseconds. */
+	durationMs?: number;
+	/** Top-level tool calls the run started. */
+	tools?: number;
+	/** Top-level tool calls that ended in error. */
+	failures?: number;
+	/** Whether the run ended because the user aborted it. */
+	aborted?: boolean;
 }

package/extensions/bytefly/working/config.ts

@@ -1,13 +1,12 @@
 /**
- * Tuning for bytefly's live working timer.
+ * Tuning for bytefly's live working line.
  *
- * 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.
+ * While Pi's working row is up, the message is written into the row beside Pi's
+ * spinner. Edit this file to change the words or how often the count advances.
  */
 
 export const WORKING_CONFIG = {
-	/** Word before the count. */
+	/** Word before the count, before the first tool starts. */
 	working: "Working",
 	/** Between the word and the count. */
 	ellipsis: "…",

package/extensions/bytefly/working/format.ts

@@ -1,13 +1,24 @@
 /**
- * Pure text for the live working timer.
+ * Pure text for the live working line.
  *
- * 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.
+ * Before the first tool starts it is a plain count (`Working… 42s`). After that
+ * it names the last top-level tool and how many this run has started, then the
+ * elapsed time (`edit · 3 tools · 42s`). Whole seconds, because the tick
+ * advances once a second; negative and non-finite input reads as `0s`.
  */
 
+import { sanitizeLine, formatToolCount } from "../../../lib/format.ts";
+import { SEPARATORS } from "../../../lib/tui/glyphs.ts";
 import { WORKING_CONFIG } from "./config.ts";
 
+/** What the current run has done so far, for the live line. */
+export interface WorkingRun {
+	/** The last top-level tool started, or `null` before the first one. */
+	readonly tool: string | null;
+	/** Top-level tool calls started in this run. */
+	readonly tools: number;
+}
+
 /** 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;
@@ -19,7 +30,13 @@ export function formatElapsed(ms: number): string {
 	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)}`;
+/** The working-row message: `Working… 4s` until a tool starts, then the run line. */
+export function workingCounter(ms: number, run?: WorkingRun): string {
+	const elapsed = formatElapsed(ms);
+	const tools = run?.tools ?? 0;
+	const tool = run?.tool ? sanitizeLine(run.tool) : "";
+	if (tools > 0) {
+		return [tool, formatToolCount(tools), elapsed].filter((part) => part !== "").join(SEPARATORS.item);
+	}
+	return `${WORKING_CONFIG.working}${WORKING_CONFIG.ellipsis} ${elapsed}`;
 }

package/extensions/bytefly/working/register.ts

@@ -1,9 +1,11 @@
 /**
- * bytefly's live working timer.
+ * bytefly's live working line.
  *
  * 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.
+ * up, and hands it back to Pi when the row comes down. Once a top-level tool
+ * starts, the message also names that tool and how many this run has started,
+ * turning the row into a live run line (`edit · 3 tools · 12s`).
  *
  * 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`
@@ -12,6 +14,11 @@
  * 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.
  *
+ * A nested tool call (one carrying `parentToolCallId`, such as a codemode
+ * script's inner call) is not counted and does not take over the line, so the
+ * number matches the tool blocks the transcript shows. The tool events repaint
+ * the row immediately; the one-second tick is still the only timer.
+ *
  * 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
@@ -49,6 +56,17 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 	let startedAt = 0;
 	// A boolean, not `startedAt === 0`: an injected clock is allowed to start at 0.
 	let active = false;
+	// The last top-level tool and how many this run has started. Reset with the run.
+	let tool: string | null = null;
+	let tools = 0;
+
+	/** The current row text, from the run state and the elapsed time. */
+	const message = (): string => workingCounter(now() - startedAt, { tool, tools });
+
+	/** Repaint an active row now, so a tool start does not wait for the next tick. */
+	const refresh = (ctx: ExtensionContext): void => {
+		if (active) ctx.ui.setWorkingMessage(message());
+	};
 
 	/** Stop the tick and hand the working message back to Pi. Idempotent. */
 	const stop = (ctx: ExtensionContext): void => {
@@ -56,6 +74,8 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		cancel = undefined;
 		if (!active) return;
 		active = false;
+		tool = null;
+		tools = 0;
 		ctx.ui.setWorkingMessage(undefined);
 	};
 
@@ -64,8 +84,10 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		if (active) return;
 		startedAt = now();
 		active = true;
+		tool = null;
+		tools = 0;
 		const tick = (): void => {
-			ctx.ui.setWorkingMessage(workingCounter(now() - startedAt));
+			ctx.ui.setWorkingMessage(message());
 		};
 		tick();
 		cancel = schedule(tick, WORKING_CONFIG.intervalMs);
@@ -78,6 +100,15 @@ export function registerWorkingTimer(pi: ExtensionAPI, deps: WorkingDeps = {}):
 		start(ctx);
 	});
 
+	// A nested tool is an implementation detail of its parent run, not a
+	// transcript block, so it neither counts nor takes over the line.
+	pi.on("tool_execution_start", (event, ctx) => {
+		if (ctx.mode !== "tui" || !active || event.parentToolCallId) return;
+		tool = event.toolName;
+		tools += 1;
+		refresh(ctx);
+	});
+
 	// The host clears the working indicator at `agent_end`.
 	pi.on("agent_end", (_event, ctx) => {
 		if (ctx.mode !== "tui") return;

package/extensions/job/format.ts

@@ -13,8 +13,8 @@
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
 import { formatDuration } from "../../lib/format.ts";
+import { clip, LABEL_WIDTH, labelLine } from "../../lib/tui/columns.ts";
 import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import type { JobRecord, JobStatus } from "./types.ts";
@@ -22,9 +22,6 @@ import type { JobRecord, JobStatus } from "./types.ts";
 /** Longest sanitized log line kept for display; longer lines are clipped. */
 const MAX_LOG_LINE = 200;
 
-/** Longest label shown in the transcript or `/jobs` screen. */
-const MAX_DISPLAY_LABEL = 48;
-
 /** ESC-introduced sequences: OSC, CSI, and single-character escapes. */
 const OSC = /\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
 const CSI = /\u001b\[[0-?]*[ -/]*[@-~]/g;
@@ -111,7 +108,7 @@ function statusWord(job: JobRecord): string {
 
 /** A label clipped to one safe display line. */
 export function clipLabel(text: string): string {
-	return truncateToWidth(sanitizeLogLine(text), MAX_DISPLAY_LABEL, "…");
+	return labelLine(text, sanitizeLogLine);
 }
 
 /** A job's label (falling back to its command) clipped to one safe display line. */
@@ -180,7 +177,7 @@ export function formatCallText(action: string, args: Record<string, unknown>, ar
 		case "start": {
 			const command = typeof args.command === "string" ? sanitizeLogLine(args.command.trim()) : "";
 			if (!command) return argsComplete ? "start" : "start …";
-			const preview = truncateToWidth(command, MAX_DISPLAY_LABEL, "…");
+			const preview = clip(command, LABEL_WIDTH);
 			return `start → ${preview}`;
 		}
 		case "kill":
@@ -188,7 +185,7 @@ export function formatCallText(action: string, args: Record<string, unknown>, ar
 		case "send": {
 			if (!target) return "send";
 			const input = typeof args.input === "string" ? sanitizeLogLine(args.input) : "";
-			const preview = input ? truncateToWidth(input, MAX_DISPLAY_LABEL, "…") : "";
+			const preview = input ? clip(input, LABEL_WIDTH) : "";
 			const parts = [preview, args.eof === true ? "EOF" : ""].filter(Boolean).join(" + ");
 			return parts ? `send ${target} → ${parts}` : `send ${target}`;
 		}

package/extensions/memory/README.md

@@ -7,6 +7,8 @@ live as human-editable markdown, not in the session branch, so they survive
 `AGENTS.md`; `memory` is for the one-liners the model should not have to be
 reminded of twice.
 
+<img src="../../assets/memory.png" alt="The /memory picker: a Memory title rule, an `All · 3 project, 2 global` summary, five notes tagged by scope with the focused one marked, and the key hints" width="100%">
+
 ```bash
 pi --extension ./extensions/memory    # load just this extension
 pi -e .                               # load the whole @gavin-hu/my-pi-agent package