@gavin-hu/my-pi-agent 0.17.0 → 0.18.0

package/lib/repo-key.ts

@@ -0,0 +1,74 @@
+/**
+ * The per-repository storage key that outlives one checkout.
+ *
+ * Two extensions file state by repository — `session-bus` its sessions, mail, and
+ * claims, `plan` its plans — and both must resolve the same key from any
+ * worktree, so a plan approved in `.pi/worktrees/x` is the same plan from the
+ * main checkout. The key is the repository's *common* git directory, which every
+ * worktree of that repository shares; outside a repository the working directory
+ * is the identity.
+ *
+ * Hashing keeps a mail directory, a claims directory, and a plans directory short
+ * enough to read and safe on every filesystem, while staying unique per
+ * repository.
+ */
+
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createExecRunner, gitCommonDir, repoRoot } from "./git/index.ts";
+
+/** Hex characters kept from the digest: collision-free in practice and short enough for a path. */
+export const REPO_KEY_LENGTH = 12;
+
+/** The key for one identity string, hashed and shortened. */
+export function repoKeyOf(value: string): string {
+	return createHash("sha256").update(canonical(value)).digest("hex").slice(0, REPO_KEY_LENGTH);
+}
+
+/**
+ * One path, one spelling.
+ *
+ * git prints the path it was told to work from, so a repository reached through a
+ * symlinked prefix reports a different common dir for the same repository. Two
+ * spellings would file one repository's plans and claims under two keys, so the
+ * real path is what gets hashed; a path that cannot be resolved keeps its own
+ * spelling rather than failing.
+ */
+function canonical(value: string): string {
+	try {
+		return realpathSync.native(value);
+	} catch {
+		return value;
+	}
+}
+
+/** A resolved repository identity. */
+export interface RepoKey {
+	/** Absolute repository root, or `cwd` when git did not answer. */
+	root: string;
+	/** The shared key, derived from the common git directory. */
+	key: string;
+	/**
+	 * Whether git resolved the repository. A caller that needs a *project-local*
+	 * location branches on this; one that only needs a stable directory does not.
+	 */
+	fromGit: boolean;
+}
+
+/**
+ * Resolve the repository identity for `cwd`.
+ *
+ * Never throws: without git, or when a git call fails, the working directory is
+ * the identity — which is what a caller outside a repository wants anyway.
+ */
+export async function repoKeyFor(pi: Pick<ExtensionAPI, "exec">, cwd: string): Promise<RepoKey> {
+	try {
+		const run = createExecRunner(pi);
+		const [common, root] = await Promise.all([gitCommonDir(run, cwd), repoRoot(run, cwd)]);
+		if (root) return { root, key: repoKeyOf(common ?? root), fromGit: true };
+	} catch {
+		// Fall through: no git, or a git call that failed, is the same answer here.
+	}
+	return { root: cwd, key: repoKeyOf(cwd), fromGit: false };
+}

package/lib/report.ts

@@ -2,12 +2,15 @@
  * The pending-report coordinator: how a live feature tells the model what
  * happened without interrupting it.
  *
- * A watcher match and a finished job follow one rule — report at the next turn,
- * and raise at most one triggered turn when the work opted into `wake`. The two
- * traps are subtle enough to have been re-derived once per extension:
+ * A watcher match, a finished job, and arriving mail follow one rule — report at
+ * the next turn, and raise at most one triggered turn per burst when the work
+ * opted into `wake`, as soon as the agent is idle. The three traps are subtle
+ * enough to have been re-derived once per extension:
  *
  * - a wake is only safe while the agent is idle, so an outcome that arrives
- *   mid-turn must be queued rather than sent;
+ *   mid-turn is queued rather than sent, and `agent_settled` retries it;
+ * - an outcome outlives the run it arrived in, so the retry asks
+ *   `wakeRequested()` rather than trusting the one call that queued it;
  * - between the triggered send and the `agent_start` it causes, the agent still
  *   looks idle, so a second outcome in that window must not trigger a second
  *   turn. `waking` closes that window.
@@ -33,6 +36,11 @@ export interface PendingReporterOptions<T> {
 	markReported(items: T[]): void;
 	/** Build the notice for one burst: model text plus renderer details. */
 	buildNotice(items: T[]): NoticeMessage;
+	/**
+	 * Whether any pending outcome asks for a triggered turn. Called by the settle
+	 * retry, so a mid-turn outcome still wakes once the agent is idle.
+	 */
+	wakeRequested(): boolean;
 	/** The notice's source, so only its own stale entries are pruned. */
 	source: string;
 	/** Runs after a wake turn was successfully requested, for an extra announcement. */
@@ -47,8 +55,8 @@ export interface PendingReporter {
 	sessionStart(): void;
 	/** A turn began: outcomes queue up, and none of them triggers a turn. */
 	agentStart(): void;
-	/** The turn settled: a later outcome may wake again. */
-	agentSettled(): void;
+	/** The turn settled: retry a wake it suppressed, unless it was aborted. */
+	agentSettled(event?: { aborted?: boolean }): void;
 	/** Report what is queued at the start of a turn, without triggering one. */
 	beforeAgentStart(): { message: NoticeMessage } | undefined;
 	/** Drop this source's older notices from the outgoing context. */
@@ -56,26 +64,29 @@ export interface PendingReporter {
 }
 
 export function createPendingReporter<T>(options: PendingReporterOptions<T>): PendingReporter {
-	const { wake, pending, markReported, buildNotice, source, onWoke } = options;
+	const { wake, pending, markReported, buildNotice, wakeRequested, source, onWoke } = options;
 	let busy = false;
 	let waking = false;
 
+	const report = (): void => {
+		if (busy || waking) return;
+		if (!wakeRequested()) return;
+		const items = pending();
+		if (items.length === 0) return;
+		try {
+			wake(buildNotice(items));
+		} catch {
+			// Reporting is best-effort; the next turn reports the same items.
+			return;
+		}
+		// Mark only after the send succeeded, so a throw changes nothing.
+		markReported(items);
+		waking = true;
+		onWoke?.(items);
+	};
+
 	return {
-		report: () => {
-			if (busy || waking) return;
-			const items = pending();
-			if (items.length === 0) return;
-			try {
-				wake(buildNotice(items));
-			} catch {
-				// Reporting is best-effort; the next turn reports the same items.
-				return;
-			}
-			// Mark only after the send succeeded, so a throw changes nothing.
-			markReported(items);
-			waking = true;
-			onWoke?.(items);
-		},
+		report,
 		sessionStart: () => {
 			busy = false;
 			waking = false;
@@ -83,9 +94,13 @@ export function createPendingReporter<T>(options: PendingReporterOptions<T>): Pe
 		agentStart: () => {
 			busy = true;
 		},
-		agentSettled: () => {
+		agentSettled: (event) => {
 			busy = false;
 			waking = false;
+			// An interrupted run is not a request to interrupt again; its outcomes
+			// stay queued for the next turn.
+			if (event?.aborted === true) return;
+			report();
 		},
 		beforeAgentStart: () => {
 			const items = pending();
@@ -103,10 +118,14 @@ export function createPendingReporter<T>(options: PendingReporterOptions<T>): Pe
 
 /** The session-scoped state a channel drives, narrowed to what its hooks need. */
 export interface PendingChannelRuntime {
-	/** Load this session's records; called on every session start. */
-	load(ctx: ExtensionContext): void;
-	/** Repaint the status chip. */
-	setStatus(ctx: ExtensionContext): void;
+	/**
+	 * Load this session's records on every session start. A promise is awaited, so a
+	 * runtime that resolves a repository or opens a store is fully loaded before the
+	 * report trigger is armed.
+	 */
+	load(ctx: ExtensionContext): void | Promise<void>;
+	/** Repaint the status chip; a runtime that publishes none omits it. */
+	setStatus?(ctx: ExtensionContext): void;
 	/** Release the session's resources; idempotent. */
 	shutdown(): Promise<void>;
 }
@@ -135,29 +154,29 @@ export function registerPendingChannel(
 	pi: Pick<ExtensionAPI, "on">,
 	{ reporter, runtime, onSessionStart, onSessionShutdown }: PendingChannelOptions,
 ): void {
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
 		reporter.sessionStart();
-		runtime.load(ctx);
+		await runtime.load(ctx);
 		onSessionStart?.(ctx);
 	});
 
 	// Tree navigation does not change the pending records; only repaint.
 	pi.on("session_tree", (_event, ctx) => {
-		runtime.setStatus(ctx);
+		runtime.setStatus?.(ctx);
 	});
 
 	pi.on("agent_start", () => {
 		reporter.agentStart();
 	});
-	pi.on("agent_settled", () => {
-		reporter.agentSettled();
+	pi.on("agent_settled", (event) => {
+		reporter.agentSettled(event);
 	});
 
 	// Report what is queued at the start of the next turn, without triggering one.
 	pi.on("before_agent_start", (_event, ctx) => {
 		const reported = reporter.beforeAgentStart();
 		if (!reported) return undefined;
-		runtime.setStatus(ctx);
+		runtime.setStatus?.(ctx);
 		return reported;
 	});
 

package/lib/requirements.ts

@@ -19,7 +19,6 @@ import { configSection, configValueAt, type JsonReadResult, SHARED_CONFIG_FILE }
 import type { WebSearchProviderEvent } from "./events.ts";
 import { pdfGuidance } from "./pdf.ts";
 import { getPiInvocation, type PiInvocation } from "./pi-invocation.ts";
-
 /** How a check came out. Only `missing` is worth interrupting a session for. */
 export type FindingSeverity = "ok" | "missing" | "degraded" | "info";
 
@@ -216,7 +215,6 @@ export const REQUIREMENTS: Readonly<Record<string, ExtensionRequirements>> = {
 		notes: ["Runs the project's detected command through a shell; a stack with no detector needs `check.command`."],
 	},
 	plan: {
-		optional: [gitCheck("project-local `.pi/plans` (otherwise plans land in the agent directory)")],
 		notes: ["Needs an interactive UI to enter plan mode."],
 	},
 	subagent: {
@@ -267,6 +265,7 @@ export const REQUIREMENTS: Readonly<Record<string, ExtensionRequirements>> = {
 		optional: [gitCheck("project-scope memory under the repository root")],
 	},
 	context: {},
+	"session-bus": {},
 	wechat: {
 		optional: [
 			{

package/lib/tui/README.md

@@ -35,8 +35,8 @@ Reach for a `lib/tui/` primitive before composing your own: `plainRule` /
 `fitCells` for two columns, `LinePane` for a scrollable log, `ListCursor` /
 `IdCursor` for selection, `byRunningFirst` for a live list's order,
 `DockListScreen` for a list that opens a pane, `TailResult` for a tool result
-that lists rows or tails output, `screenFooter` for a screen's own last three
-rows, and `ConfirmState` before a destructive action.
+that lists rows, heads several row sections, or tails output, `screenFooter` for a
+screen's own last three rows, and `ConfirmState` before a destructive action.
 
 ## Docked list screens
 
@@ -81,6 +81,20 @@ what a plain list wants — do not hand-roll the frame to get one of them:
   (`c` collect, `x` cancel). Return `true` for the keys it claimed; everything
   else falls through to the pane's scroll keys.
 
+A pane is a log by default: it opens at the tail and its subtitle says
+`following` or `paused`. Two more fields cover the other body:
+
+- `DetailContents.text` — prose instead of `lines`, wrapped to the width the pane
+  renders at and re-wrapped on a resize. One source line is one paragraph; a blank
+  line stays blank. `lines` remains the right shape for output that is already
+  split.
+- `DetailContents.tail: false` — a prose or list pane opens at the top and never
+  claims to follow anything. Leave it out for a log.
+
+A screen whose list is one of several scopes overrides `headerLabel()` (the
+header rule's name) and `emptyLabel()` (the empty-list line), so `Tab` can change
+what is listed without a second renderer; both default to the screen's options.
+
 A destructive action asks through [`confirm.ts`](./confirm.ts):
 `ConfirmState.ask(prompt, accept)` holds the question, `resolve(data)` accepts on
 `y`/`Y`/Enter, dismisses on `n`/`N`/Esc/`q`, and returns `undefined` for any

package/lib/tui/dock-screen.ts

@@ -20,11 +20,13 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, type Component, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { detailBlockRows, dockListFrame, screenHint, type ScreenHint, type ViewportRowsSource } from "./chrome.ts";
 import { clip, fitCells } from "./columns.ts";
 import { ConfirmState } from "./confirm.ts";
 import { fitRows, formatRange, IdCursor, isCloseKey, navIntent, wheelDelta } from "./cursor.ts";
 import { SEPARATORS } from "./glyphs.ts";
+import { BODY_INDENT } from "./indent.ts";
 import { LinePane } from "./line-pane.ts";
 import { emptyState } from "./rows.ts";
 import { titleRule } from "./rules.ts";
@@ -43,12 +45,23 @@ const DETAIL_CHROME_ROWS = 6;
 export interface DetailContents {
 	/** Pane title, e.g. `j1 build`. */
 	title: string;
-	/** The body lines, already sanitized by the caller. */
-	lines: string[];
+	/** The body lines, already sanitized by the caller. Omit for a `text` pane. */
+	lines?: string[];
+	/**
+	 * Prose body, built once at open and wrapped to the render width on every
+	 * frame. Takes precedence over `lines`. A resize re-wraps; a blank line in the
+	 * source stays a blank line in the pane.
+	 */
+	text?: string;
 	/** More lines exist above the ones supplied. */
 	more?: boolean;
 	/** Subtitle under the title, e.g. the log file path. */
 	subtitle?: string;
+	/**
+	 * Whether the pane follows its tail. Default true, which is a log's behavior;
+	 * false opens a prose or list pane at the top and never says `following`.
+	 */
+	tail?: boolean;
 	/**
 	 * Rows above the scrollable body that depend on the width: key/value facts,
 	 * a legend, a divider. Read fresh every frame with the live width and already
@@ -101,6 +114,9 @@ export abstract class DockListScreen<T> implements Component {
 	private readonly confirmState = new ConfirmState();
 	private feedback: string | undefined;
 	private detailFacts: ((width: number) => string[]) | undefined;
+	/** Prose body for the open pane, wrapped to the width it is rendered at. */
+	private detailText: string | undefined;
+	private detailWrap: { width: number; lines: string[] } | undefined;
 
 	constructor(protected readonly options: DockListScreenOptions) {}
 
@@ -163,6 +179,19 @@ export abstract class DockListScreen<T> implements Component {
 		this.options.requestRender();
 	}
 
+	/**
+	 * The header rule's label. A screen whose list is one of several scopes
+	 * overrides it, so the rule names what is on screen.
+	 */
+	protected headerLabel(): string {
+		return this.options.title;
+	}
+
+	/** The empty-list line; a screen whose scopes differ overrides it. */
+	protected emptyLabel(): string {
+		return this.options.emptyList;
+	}
+
 	/** Show one line of feedback in place of the hints. */
 	protected notify(text: string): void {
 		this.feedback = text;
@@ -182,6 +211,12 @@ export abstract class DockListScreen<T> implements Component {
 		// Facts stay with the pane unless this update supplies its own, so a poll that
 		// only refreshes the body cannot drop the facts the row opened with.
 		if (contents.facts) this.detailFacts = contents.facts;
+		// `text` and `tail` belong to the row that opened the pane; an update either
+		// replaces the prose or settles the pane back onto a line buffer.
+		if (contents.text !== undefined || contents.lines !== undefined) {
+			this.detailText = contents.text;
+			this.detailWrap = undefined;
+		}
 		const changed =
 			contents.subtitle === undefined
 				? this.pane.update({ title: contents.title, lines: contents.lines, more: contents.more })
@@ -201,6 +236,7 @@ export abstract class DockListScreen<T> implements Component {
 
 	/** Re-read the open detail pane, so a poll cannot show stale lines. */
 	refreshDetail(id: string): void {
+		if (this.detailText !== undefined) return;
 		const source = this.detailById?.(id);
 		if (source && this.pane.update({ lines: source.lines, more: source.more })) this.options.requestRender();
 	}
@@ -242,10 +278,30 @@ export abstract class DockListScreen<T> implements Component {
 		const contents = this.detailFor(row);
 		this.mode = "detail";
 		this.detailFacts = contents.facts;
-		this.pane.open(this.idOf(row), contents);
+		this.detailText = contents.text;
+		this.detailWrap = undefined;
+		this.pane.open(
+			this.idOf(row),
+			{
+				title: contents.title,
+				lines: contents.text === undefined ? (contents.lines ?? []) : [],
+				more: contents.more,
+				subtitle: contents.subtitle,
+			},
+			contents.tail ?? true,
+		);
 		this.options.requestRender();
 	}
 
+	/** Leave detail mode and drop everything that belonged to the open row. */
+	private closeDetail(): void {
+		this.mode = "list";
+		this.pane.close();
+		this.detailFacts = undefined;
+		this.detailText = undefined;
+		this.detailWrap = undefined;
+	}
+
 	private handleListKey(data: string): void {
 		if (isCloseKey(data) || data === "q") {
 			this.options.onClose();
@@ -294,9 +350,7 @@ export abstract class DockListScreen<T> implements Component {
 
 	private handleDetailKey(data: string): void {
 		if (matchesKey(data, Key.escape) || matchesKey(data, Key.backspace) || data === "q") {
-			this.mode = "list";
-			this.pane.close();
-			this.detailFacts = undefined;
+			this.closeDetail();
 			this.options.requestRender();
 			return;
 		}
@@ -307,11 +361,11 @@ export abstract class DockListScreen<T> implements Component {
 	}
 
 	/** The footer: a pending confirmation, one line of feedback, or the hints. */
-	private hint(width: number, rows: readonly T[]): string {
+	private footer(width: number, hints: ScreenHint[]): string {
 		const pending = this.confirmState.pending;
 		if (pending) return clip(`  ${paint(this.theme, "warn", pending.prompt)}`, width);
 		if (this.feedback) return clip(`  ${paint(this.theme, "meta", this.feedback)}`, width);
-		return screenHint(this.theme, width, this.listHints(rows));
+		return screenHint(this.theme, width, hints);
 	}
 
 	private summary(rows: readonly T[], width: number): string {
@@ -343,7 +397,7 @@ export abstract class DockListScreen<T> implements Component {
 		const body: string[] = [];
 		let range: string | undefined;
 		if (rows.length === 0) {
-			body.push(...emptyState(this.theme, w, { label: this.options.emptyList }));
+			body.push(...emptyState(this.theme, w, { label: this.emptyLabel() }));
 		} else {
 			const end = Math.min(rows.length, this.cursor.scroll + this.cursor.visible);
 			for (let i = this.cursor.scroll; i < end; i++) body.push(this.rowLine(rows[i], w, i === index));
@@ -355,12 +409,12 @@ export abstract class DockListScreen<T> implements Component {
 		return dockListFrame({
 			theme: this.theme,
 			width: w,
-			header: titleRule(this.theme, w, this.options.title),
+			header: titleRule(this.theme, w, this.headerLabel()),
 			summary: this.summary(rows, w),
 			body,
 			range,
 			detail: block.map((line) => clip(`  ${paint(this.theme, "meta", line)}`, w)),
-			hint: this.hint(w, rows),
+			hint: this.footer(w, this.listHints(rows)),
 		});
 	}
 
@@ -368,6 +422,7 @@ export abstract class DockListScreen<T> implements Component {
 		this.syncDetail();
 		// A live pane whose row is gone has already closed itself: draw the list.
 		if (this.mode !== "detail") return this.renderList(w);
+		this.syncText(w);
 		const facts = this.detailFacts ? this.detailFacts(w) : [];
 		const visible = fitRows(
 			this.options.viewportRowsSource,
@@ -397,14 +452,15 @@ export abstract class DockListScreen<T> implements Component {
 			summary: clip(`  ${paint(this.theme, "faint", this.pane.subtitleLine())}`, w),
 			body,
 			range,
-			hint: screenHint(this.theme, w, this.detailHints(this.detailRow)),
+			hint: this.footer(w, this.detailHints(this.detailRow)),
 		});
 	}
 
 	/**
 	 * Re-read a live pane in place. This runs inside a render, so it must not ask
 	 * for another frame; a source that disappeared closes the pane instead of
-	 * showing lines the list no longer has a row for.
+	 * showing lines the list no longer has a row for. A prose pane is skipped here:
+	 * `syncText` owns its lines, and this still closes it when the row is gone.
 	 */
 	private syncDetail(): void {
 		if (!this.liveDetail()) return;
@@ -412,11 +468,23 @@ export abstract class DockListScreen<T> implements Component {
 		if (!id) return;
 		const source = this.detailById?.(id);
 		if (!source) {
-			this.mode = "list";
-			this.pane.close();
-			this.detailFacts = undefined;
+			this.closeDetail();
 			return;
 		}
-		this.pane.update({ lines: source.lines, more: source.more });
+		if (this.detailText === undefined) this.pane.update({ lines: source.lines, more: source.more });
+	}
+
+	/**
+	 * Wrap a prose body to the width the pane actually renders at, once per width.
+	 * The pane's body lines are built at open, so this is the one source that can
+	 * follow a resize.
+	 */
+	private syncText(width: number): void {
+		if (this.detailText === undefined) return;
+		const inner = Math.max(1, width - BODY_INDENT);
+		if (this.detailWrap?.width === inner) return;
+		const lines = this.detailText.split("\n").flatMap((line) => (line === "" ? [""] : wrapTextWithAnsi(line, inner)));
+		this.detailWrap = { width: inner, lines };
+		this.pane.update({ lines });
 	}
 }

package/lib/tui/line-pane.ts

@@ -45,6 +45,11 @@ export class LinePane {
 	visible = 1;
 	/** Whether the view is parked at the tail; set false once the user scrolls up. */
 	follow = true;
+	/**
+	 * Whether this pane follows its tail. A log does; a prose or list pane does not:
+	 * it opens at the top and never reports `following`/`paused`.
+	 */
+	tail = true;
 
 	private buffer: string[] = [];
 	private label = "";
@@ -66,16 +71,21 @@ export class LinePane {
 		return Math.max(0, this.buffer.length - this.visible);
 	}
 
-	/** Open the pane on a row, reset to the tail. */
-	open(id: string, source: PaneSource): void {
+	/** Open the pane on a row, reset to the tail for a log, or to the top for prose. */
+	open(id: string, source: PaneSource, tail = true): void {
 		this.id = id;
 		this.buffer = [];
 		this.label = "";
 		this.subtitle = undefined;
 		this.more = false;
 		this.scroll = 0;
-		this.follow = true;
+		this.tail = tail;
+		this.follow = tail;
 		this.update(source);
+		if (!tail) {
+			this.follow = false;
+			this.scroll = 0;
+		}
 	}
 
 	/** Close the pane and drop its buffer. */
@@ -87,6 +97,7 @@ export class LinePane {
 		this.more = false;
 		this.scroll = 0;
 		this.follow = true;
+		this.tail = true;
 	}
 
 	/**
@@ -127,7 +138,7 @@ export class LinePane {
 		const parts: string[] = [];
 		if (this.subtitle) parts.push(this.subtitle);
 		if (this.more && this.buffer.length > 0) parts.push(`showing last ${this.buffer.length} lines`);
-		if (this.buffer.length > 0) parts.push(this.follow ? "following" : "paused");
+		if (this.tail && this.buffer.length > 0) parts.push(this.follow ? "following" : "paused");
 		return parts.join(" · ");
 	}
 

package/lib/tui/tool.ts

@@ -200,18 +200,29 @@ export function earlierHint(theme: Theme, hidden: number, label: string): string
 /** The row renderer a {@link TailResult} list uses: the extension's row grammar at a width. */
 export type TailRowLine<Row> = (row: Row, width: number, theme: Theme) => string;
 
-/** What a {@link TailResult} draws: the caller's rows plus a hidden count, or a bounded tail. */
+/** One group of rows inside a {@link TailResult}, under an optional faint heading. */
+export interface TailSection<Row> {
+	/** A faint heading above the rows, e.g. `Claims`; omit for the block's primary list. */
+	label?: string;
+	rows: readonly Row[];
+	more: number;
+	rowLine: TailRowLine<Row>;
+}
+
+/** What a {@link TailResult} draws: the caller's rows plus a hidden count, a headed row list, or a bounded tail. */
 export type TailResultInput<Row> =
 	| { kind: "list"; rows: readonly Row[]; more: number; rowLine: TailRowLine<Row> }
+	| { kind: "sections"; sections: readonly TailSection<Row>[] }
 	| { kind: "lines"; lines: readonly string[]; earlier: number; earlierLabel: string };
 
 /**
  * The transcript result block a tool that lists rows or tails output shares.
  *
  * One leading blank line per the block grammar, then either the caller's rows
- * (already ordered and capped) with a "more" note, or the themed tail with an
- * "earlier" note. The caller owns the row renderer, so the extension's own row
- * grammar — a peer-session tag, a status glyph — stays with its vocabulary.
+ * (already ordered and capped) with a "more" note, one headed group of rows per
+ * section, or the themed tail with an "earlier" note. The caller owns the row
+ * renderer, so the extension's own row grammar — a peer-session tag, a status
+ * glyph — stays with its vocabulary.
  */
 export class TailResult<Row> implements Component {
 	private input: TailResultInput<Row>;
@@ -239,6 +250,14 @@ export class TailResult<Row> implements Component {
 			if (input.more > 0) lines.push(clip(`  ${overflowHint(this.theme, input.more)}`, w));
 			return lines;
 		}
+		if (input.kind === "sections") {
+			for (const section of input.sections) {
+				if (section.label) lines.push(clip(paint(this.theme, "faint", section.label), w));
+				for (const row of section.rows) lines.push(section.rowLine(row, w, this.theme));
+				if (section.more > 0) lines.push(clip(`  ${overflowHint(this.theme, section.more)}`, w));
+			}
+			return lines;
+		}
 		if (input.earlier > 0) lines.push(clip(earlierHint(this.theme, input.earlier, input.earlierLabel), w));
 		for (const line of input.lines) lines.push(this.theme.fg("toolOutput", clip(line, w)));
 		return lines;

package/lib/web/components.ts

@@ -60,7 +60,7 @@ export const WEB_COMPONENTS_CSS = `.bf-brand{display:inline-flex;align-items:cen
 .bf-dialog mark{background:transparent;color:var(--warn);font-weight:var(--fw-semibold)}
 .bf-dialog__head{display:flex;align-items:center;gap:var(--space-3);padding:var(--space-3) var(--space-4);border-bottom:1px solid var(--border)}
 .bf-dialog__head h2{margin:0;font-size:var(--fs-lg)}
-.bf-dialog__body{padding:var(--space-3) var(--space-4);font-size:var(--fs-sm);line-height:var(--lh-relaxed)}
+.bf-dialog__body{padding:var(--space-3) var(--space-4);font-size:var(--fs-sm);line-height:var(--lh-relaxed);overflow:auto;min-height:0}
 .bf-dialog__body p{margin:0 0 var(--space-2)}
 .bf-dialog__body p:last-child{margin:0}
 .bf-dialog__hint{color:var(--muted)}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gavin-hu/my-pi-agent",
-  "version": "0.17.0",
-  "description": "Personal Pi customizations, packaged as a Pi package: worktree isolation and rewind snapshots, question, todo, goal, plan, subagent, job, watch, web-access, file-browse, file-open, file-read, check, memory, context, wechat, and bytefly.",
+  "version": "0.18.0",
+  "description": "Personal Pi customizations, packaged as a Pi package: worktree isolation and rewind snapshots, question, todo, goal, plan, subagent, job, watch, web-access, file-browse, file-open, file-read, check, memory, context, session-bus, wechat, and bytefly.",
   "keywords": [
     "pi-package",
     "pi",
@@ -101,6 +101,7 @@
       "./extensions/file-open/index.ts",
       "./extensions/memory/index.ts",
       "./extensions/context/index.ts",
+      "./extensions/session-bus/index.ts",
       "./extensions/wechat/index.ts",
       "./extensions/bytefly/index.ts"
     ],