@bachi/pi-coder 1.0.0

package/extensions/statusline/git.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Tests for git.ts — the (+added,-deleted) working-tree counter.
+ *
+ * Run with:  node --test clients/pi/extensions/statusline/git.test.ts
+ *
+ * git.ts never imports pi: it takes an injected `exec`, so these tests drive the real
+ * `git` binary against throwaway repos in a temp dir. That covers the exact argv we send
+ * (`--numstat HEAD`, `ls-files --others --full-name`, `rev-parse --show-toplevel`) and the
+ * root-relative path joining, which a stub could not prove.
+ */
+
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import assert from "node:assert/strict";
+import { after, describe, it } from "node:test";
+
+import { countTextLines, parseNumstat, readGitDiffStat, sumDiffStats, type GitExecutor } from "./git.ts";
+
+const exec: GitExecutor = async (command, args, options) => {
+	const result = spawnSync(command, args, {
+		cwd: options.cwd,
+		encoding: "utf8",
+		timeout: options.timeout,
+	});
+	if (result.error) throw result.error;
+	return { stdout: result.stdout ?? "", code: result.status ?? 1, killed: result.signal !== null };
+};
+
+function git(cwd: string, ...args: string[]) {
+	const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+	assert.equal(result.status, 0, `git ${args.join(" ")}: ${result.stderr}`);
+	return result.stdout;
+}
+
+const dirs: string[] = [];
+
+/** New repo with one commit containing `lines.txt` (3 lines). */
+function makeRepo(body: string[] = ["a", "b", "c"]): string {
+	const dir = mkdtempSync(join(tmpdir(), "statusline-git-"));
+	dirs.push(dir);
+	git(dir, "init", "-q");
+	git(dir, "config", "user.email", "t@example.com");
+	git(dir, "config", "user.name", "t");
+	writeFileSync(join(dir, "lines.txt"), `${body.join("\n")}\n`);
+	git(dir, "add", "lines.txt");
+	git(dir, "commit", "-qm", "init");
+	return dir;
+}
+
+const noopSignal = (): AbortSignal => new AbortController().signal;
+
+describe("parseNumstat", () => {
+	it("sums added and deleted columns", () => {
+		assert.deepEqual(parseNumstat("12\t3\tgateway/config.yaml\n1\t0\tadapter/index.js\n"), {
+			added: 13,
+			deleted: 3,
+		});
+	});
+
+	it("counts binary files as zero", () => {
+		assert.deepEqual(parseNumstat("-\t-\tassets/blob.png\n4\t1\tline.ts"), { added: 4, deleted: 1 });
+	});
+
+	it("is zero for an empty diff", () => {
+		assert.deepEqual(parseNumstat(""), { added: 0, deleted: 0 });
+	});
+});
+
+describe("countTextLines", () => {
+	it("counts a trailing open line and ignores the final newline", () => {
+		assert.equal(countTextLines(""), 0);
+		assert.equal(countTextLines("a"), 1);
+		assert.equal(countTextLines("a\n"), 1);
+		assert.equal(countTextLines("a\nb"), 2);
+		assert.equal(countTextLines("a\nb\n"), 2);
+	});
+});
+
+describe("sumDiffStats", () => {
+	it("merges the empty-repo fallback halves", () => {
+		assert.deepEqual(sumDiffStats({ added: 2, deleted: 1 }, { added: 5, deleted: 0 }), {
+			added: 7,
+			deleted: 1,
+		});
+		assert.deepEqual(sumDiffStats({ added: 2, deleted: 1 }, undefined), { added: 2, deleted: 1 });
+	});
+});
+
+describe("readGitDiffStat", () => {
+	it("counts tracked edits plus untracked files", async () => {
+		const repo = makeRepo();
+		writeFileSync(join(repo, "lines.txt"), "a\nb\nX\n"); // "c" gone, "X" new: +1 / -1
+		writeFileSync(join(repo, "note.txt"), "u1\nu2\nu3\n"); // untracked +3
+		assert.deepEqual(await readGitDiffStat(exec, repo, noopSignal()), { added: 4, deleted: 1 });
+	});
+
+	it("counts repo-wide, including untracked files below the cwd", async () => {
+		const repo = makeRepo();
+		mkdirSync(join(repo, "deep", "deeper"), { recursive: true });
+		writeFileSync(join(repo, "lines.txt"), "a\nb\nX\n"); // +1 / -1
+		writeFileSync(join(repo, "deep", "deeper", "new.txt"), "s1\ns2\n"); // untracked below cwd
+		const nested = join(repo, "deep");
+		assert.deepEqual(await readGitDiffStat(exec, nested, noopSignal()), { added: 3, deleted: 1 });
+	});
+
+	it("reports zero for a clean tree", async () => {
+		const repo = makeRepo();
+		assert.deepEqual(await readGitDiffStat(exec, repo, noopSignal()), { added: 0, deleted: 0 });
+	});
+
+	it("skips untracked binaries and oversized files", async () => {
+		const repo = makeRepo();
+		writeFileSync(join(repo, "blob.bin"), Buffer.from([0x89, 0, 1, 2, 0, 3]));
+		writeFileSync(join(repo, "big.txt"), Buffer.alloc(600 * 1024, 0x41)); // > 512KiB
+		assert.deepEqual(await readGitDiffStat(exec, repo, noopSignal()), { added: 0, deleted: 0 });
+		writeFileSync(join(repo, "small.txt"), "one\ntwo\n");
+		assert.deepEqual(await readGitDiffStat(exec, repo, noopSignal()), { added: 2, deleted: 0 });
+	});
+
+	it("counts staged files in a repo without any commit", async () => {
+		const repo = mkdtempSync(join(tmpdir(), "statusline-empty-"));
+		dirs.push(repo);
+		git(repo, "init", "-q");
+		git(repo, "config", "user.email", "t@example.com");
+		git(repo, "config", "user.name", "t");
+		writeFileSync(join(repo, "staged.txt"), "s1\ns2\n");
+		writeFileSync(join(repo, "loose.txt"), "l1\n");
+		git(repo, "add", "staged.txt");
+		assert.deepEqual(await readGitDiffStat(exec, repo, noopSignal()), { added: 3, deleted: 0 });
+	});
+
+	it("returns undefined outside a repository", async () => {
+		const plain = mkdtempSync(join(tmpdir(), "statusline-nogit-"));
+		dirs.push(plain);
+		writeFileSync(join(plain, "file.txt"), "x\n");
+		assert.equal(await readGitDiffStat(exec, plain, noopSignal()), undefined);
+	});
+
+	it("returns undefined once the signal is aborted", async () => {
+		const repo = makeRepo();
+		const controller = new AbortController();
+		controller.abort();
+		assert.equal(await readGitDiffStat(exec, repo, controller.signal), undefined);
+	});
+
+	it("returns undefined when git itself cannot run", async () => {
+		const repo = makeRepo();
+		const broken: GitExecutor = async () => {
+			throw new Error("ENOENT git");
+		};
+		assert.equal(await readGitDiffStat(broken, repo, noopSignal()), undefined);
+	});
+
+	it("never asks git for optional locks", async () => {
+		const repo = makeRepo();
+		const argv: string[][] = [];
+		const spy: GitExecutor = async (command, args, options) => {
+			argv.push([command, ...args]);
+			return exec(command, args, options);
+		};
+		await readGitDiffStat(spy, repo, noopSignal());
+		assert.ok(argv.length >= 3, `expected at least 3 git calls, got ${argv.length}`);
+		for (const call of argv) {
+			assert.equal(call[0], "git");
+			assert.equal(call[1], "--no-optional-locks", call.join(" "));
+		}
+	});
+});
+
+after(() => {
+	for (const dir of dirs) rmSync(dir, { recursive: true, force: true });
+});

package/extensions/statusline/git.ts

@@ -0,0 +1,142 @@
+/**
+ * git.ts — 读工作区相对 HEAD 的 (+新增行,-删除行)
+ *
+ * 同样**不 import pi**：git 通过注入的 `exec`（`pi.exec` 的瘦接口）调用，纯 Node fs 读文件，
+ * 所以能被 `node --test` 直接驱动（真实的临时 git 仓库，见 git.test.ts）。
+ *
+ * 口径：
+ * - 已跟踪文件：`git diff --numstat HEAD` = staged + unstaged 相对 HEAD。空仓库（无 HEAD）
+ *   退化成 `git diff --numstat` + `git diff --cached --numstat`（工作区 vs index，再加 index vs 空树）。
+ * - 未跟踪文件：`git ls-files --others --exclude-standard --full-name`（仓库根相对路径，
+ *   跟着 `rev-parse --show-toplevel` 拼绝对路径），逐个数行。
+ * - 上限：最多 200 个未跟踪文件、单文件 512KiB，含 NUL 的（二进制）跳过 —— 状态栏要的是
+ *   「刚刚改了多少」，不是精确审计；超限就少算，绝不报错。
+ *
+ * 全程带 `--no-optional-locks`，不会去抢用户自己的 index.lock。
+ */
+
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import type { DiffStat } from "./line.ts";
+
+export interface ExecResultLike {
+	stdout: string;
+	code: number;
+	killed: boolean;
+}
+
+/** `pi.exec` 的结构化子集。 */
+export type GitExecutor = (
+	command: string,
+	args: string[],
+	options: { cwd: string; timeout: number; signal?: AbortSignal },
+) => Promise<ExecResultLike>;
+
+const GIT_TIMEOUT_MS = 3_000;
+const MAX_UNTRACKED_FILES = 200;
+const MAX_UNTRACKED_FILE_BYTES = 512 * 1024;
+
+/** 非 git 目录 / git 调用失败 / 已 abort → undefined。 */
+export async function readGitDiffStat(
+	exec: GitExecutor,
+	cwd: string,
+	signal: AbortSignal,
+): Promise<DiffStat | undefined> {
+	const run = (args: string[]) =>
+		exec("git", ["--no-optional-locks", ...args], { cwd, timeout: GIT_TIMEOUT_MS, signal }).catch(
+			() => undefined,
+		);
+
+	const [tracked, untracked, toplevel] = await Promise.all([
+		run(["diff", "--numstat", "HEAD"]),
+		run(["ls-files", "--others", "--exclude-standard", "--full-name"]),
+		run(["rev-parse", "--show-toplevel"]),
+	]);
+	if (signal.aborted || !tracked || tracked.killed) return undefined;
+
+	let stat: DiffStat | undefined = tracked.code === 0 ? parseNumstat(tracked.stdout) : undefined;
+	if (!stat) {
+		// 空仓库（无 HEAD）：工作区 vs index 加上 index vs 空树，未提交的内容也算进来。
+		const [worktree, staged] = await Promise.all([run(["diff", "--numstat"]), run(["diff", "--cached", "--numstat"])]);
+		if (!worktree || worktree.code !== 0 || worktree.killed) return undefined;
+		stat = sumDiffStats(
+			parseNumstat(worktree.stdout),
+			staged && staged.code === 0 && !staged.killed ? parseNumstat(staged.stdout) : undefined,
+		);
+	}
+
+	const root = toplevel && toplevel.code === 0 ? firstLine(toplevel.stdout) : undefined;
+	if (!root || !untracked || untracked.code !== 0 || untracked.killed) return stat;
+
+	const files = splitLines(untracked.stdout).slice(0, MAX_UNTRACKED_FILES);
+	if (files.length === 0) return stat;
+	return { added: stat.added + (await countUntrackedLines(files, root, signal)), deleted: stat.deleted };
+}
+
+/** `git diff --numstat` 文本 → 累加的 added/deleted；二进制列的 "-" 记 0。 */
+export function parseNumstat(output: string): DiffStat {
+	let added = 0;
+	let deleted = 0;
+	for (const line of splitLines(output)) {
+		const [adds, dels] = line.split("\t");
+		added += toCount(adds);
+		deleted += toCount(dels);
+	}
+	return { added, deleted };
+}
+
+/** 空仓库分支里把两个 numstat 合起来（工作区 vs index + index vs 空树）。 */
+export function sumDiffStats(base: DiffStat, other: DiffStat | undefined): DiffStat {
+	if (!other) return base;
+	return { added: base.added + other.added, deleted: base.deleted + other.deleted };
+}
+
+/** 文本行数：按换行计，末行没有换行也算一行；空文本 0。 */
+export function countTextLines(text: string): number {
+	if (!text) return 0;
+	let lines = 0;
+	for (let i = 0; i < text.length; i += 1) {
+		if (text.charCodeAt(i) === 10) lines += 1;
+	}
+	return text.endsWith("\n") ? lines : lines + 1;
+}
+
+async function countUntrackedLines(
+	files: string[],
+	root: string,
+	signal: AbortSignal,
+): Promise<number> {
+	let total = 0;
+	for (const relative of files) {
+		if (signal.aborted) break;
+		let handle: Awaited<ReturnType<typeof open>> | undefined;
+		try {
+			handle = await open(join(root, relative), "r");
+			const { size } = await handle.stat();
+			if (!size || size > MAX_UNTRACKED_FILE_BYTES) continue;
+			const buffer = Buffer.allocUnsafe(size);
+			const { bytesRead } = await handle.read(buffer, 0, size, 0);
+			const content = buffer.subarray(0, bytesRead);
+			if (content.includes(0)) continue; // 二进制
+			total += countTextLines(content.toString("utf8"));
+		} catch {
+			// 权限 / 竞态删除 / abort：算 0 就行，状态栏不为此报错。
+		} finally {
+			await handle?.close().catch(() => undefined);
+		}
+	}
+	return total;
+}
+
+function toCount(value: string | undefined): number {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function splitLines(output: string): string[] {
+	return output.split(/\r?\n/).filter(Boolean);
+}
+
+function firstLine(output: string): string | undefined {
+	return output.split(/\r?\n/)[0]?.trim();
+}

package/extensions/statusline/index.ts

@@ -0,0 +1,294 @@
+/**
+ * statusline — 极简 statusline（替代 npm:@narumitw/pi-statusline）
+ *
+ * 只有一主行 + 一状态行（沿用原 pi-statusline 的两行结构），无配置文件、无 powerline 块、
+ * 无 palette：颜色全走 `theme.fg(<语义色>)`，因此自动跟随当前主题（`theme` 是 pi 内部的
+ * live Proxy 单例，`/theme` 换肤后下一次渲染即生效）。
+ *
+ * 主行形态：
+ *
+ *   ⚡️ qwen3.8-flash/xhigh | Ctx 0.0% |  main | (+0,-0)
+ *   ⚡️ qwen3.8-flash/xhigh | Ctx 0.0% |  main | (+0,-0) | thinking   ← 生成中
+ *   ⚡️ qwen3.8-flash/xhigh | Ctx 0.0% |  no git | (no git)          ← 不在 git 仓库
+ *
+ * 行首的 `⚡️` 是模型段图标（`line.ts` 的 `MODEL_ICON`，取代早期的 `Model:` 文字标签，
+ * 省 4 列；emoji 自带颜色不上色）。模型段本体是 `ctx.model.id` + `ctx.thinkingLevel`
+ * （live getter）拼成的 `<id>/<推理强度>`（level 读不到时只报 id）。刻意不加 `[1m]`
+ * 那种上下文窗口后缀 —— 那是 Claude Code 的写法，pi 用不着。
+ *
+ * 换行策略：宁可截断也不折行 —— 每行都过 `truncateToWidth(..., width, "…")`；行首恒留一个
+ * 空格，不顶格。
+ *
+ * 拆四个模块：`line.ts`（纯格式化）+ `git.ts`（读 diff，注入 exec）+ `footer-guard.ts`
+ * （换会话期间冻结 footer，防默认 footer 闪一帧）+ 本文件（pi 事件接线）。
+ * 前三个都不 import pi / pi-tui，所以 `node --test clients/pi/extensions/statusline/*.test.ts`
+ * 能直接跑。
+ *
+ * git 读取一律在后台做（渲染路径上只有一次 Map 查找）：`turn_end` / `agent_end` /
+ * `tool_execution_end` 防抖 400ms 刷一次，分支变化立即刷，另有 30s 兜底轮询。
+ *
+ * 换会话（`/new`、`/clear`、`/resume`、fork、rewind）时 pi 会先把 footer 还原成内置那只、
+ * 清掉所有 `setStatus`，新会话 `session_start` 才让我们重装 —— 中间那几十毫秒会真的出帧，
+ * 于是底部「闪」一下。本扩展用 `footer-guard.ts` 在渲染路径上把这段窗口冻住（重放上一帧的
+ * 行），原因与约束见那个文件的头注释；关掉它只需把 `PI_STATUSLINE_FREEZE` 设为 `off`。
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { readGitDiffStat } from "./git.ts";
+import { findRenderContainer, freezeFooterContainer, releaseFooterGuard } from "./footer-guard.ts";
+import {
+	STATUSLINE_KEY,
+	ELLIPSIS,
+	type StatuslineState,
+	composeFooterLines,
+} from "./line.ts";
+
+const GIT_POLL_INTERVAL_MS = 30_000;
+const GIT_DEBOUNCE_MS = 400;
+const FROZEN_DISABLED = (process.env.PI_STATUSLINE_FREEZE ?? "").trim().toLowerCase() === "off";
+
+/** footer 容器要的是这个组件对象；只要 render/dispose 形状，便于在守卫里按身份比对。 */
+interface FooterComponent {
+	render(width: number): string[];
+	dispose(): void;
+	invalidate(): void;
+}
+
+export default function statusline(pi: ExtensionAPI) {
+	let generation = 0;
+	let activeTarget: { cwd: string; generation: number } | undefined;
+	let requestRender: (() => void) | undefined;
+	let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+	let abortController: AbortController | undefined;
+	let refreshInFlight = false;
+	let refreshQueued = false;
+
+	const state: StatuslineState = {
+		streaming: false,
+		activeTools: new Map<string, number>(),
+		diffStat: undefined,
+	};
+
+	// 冻结窗口要用的四样：TUI 根（找容器）、当前 footer 组件、它的容器、上一帧渲染出的行。
+	let tuiHandle: unknown;
+	let footerComponent: FooterComponent | undefined;
+	let footerContainer: unknown;
+	let lastFooterLines: string[] | undefined;
+	let guardRelease: (() => void) | undefined;
+
+	const render = () => requestRender?.();
+
+	const refreshDiffStat = async (target: { cwd: string; generation: number }) => {
+		if (target !== activeTarget) return;
+		if (refreshInFlight) {
+			refreshQueued = true;
+			return;
+		}
+		refreshInFlight = true;
+		abortController?.abort(new DOMException("Statusline Git refresh replaced", "AbortError"));
+		const controller = new AbortController();
+		abortController = controller;
+		try {
+			const next = await readGitDiffStat(
+				(command, args, options) => pi.exec(command, args, options),
+				target.cwd,
+				controller.signal,
+			);
+			if (target !== activeTarget || controller.signal.aborted) return;
+			state.diffStat = next;
+			render();
+		} catch {
+			if (target === activeTarget) {
+				state.diffStat = undefined;
+				render();
+			}
+		} finally {
+			if (abortController === controller) abortController = undefined;
+			refreshInFlight = false;
+			if (refreshQueued && target === activeTarget) {
+				refreshQueued = false;
+				void refreshDiffStat(target);
+			}
+		}
+	};
+
+	const scheduleDiffRefresh = (delayMs: number) => {
+		const target = activeTarget;
+		if (!target) return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		if (delayMs <= 0) {
+			debounceTimer = undefined;
+			void refreshDiffStat(target);
+			return;
+		}
+		debounceTimer = setTimeout(() => {
+			debounceTimer = undefined;
+			void refreshDiffStat(target);
+		}, delayMs);
+	};
+
+	const cancelDiffRefresh = () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+			debounceTimer = undefined;
+		}
+		abortController?.abort(new DOMException("Statusline Git refresh cancelled", "AbortError"));
+		refreshQueued = false;
+	};
+
+	const resetState = () => {
+		state.streaming = false;
+		state.activeTools.clear();
+		state.diffStat = undefined;
+	};
+
+	const installFooter = (ctx: ExtensionContext) => {
+		// 先交还上一段换会话窗口的冻结再装新 footer：两步在同一个同步块里，中间出不了帧。
+		guardRelease?.();
+		guardRelease = undefined;
+		cancelDiffRefresh();
+		generation += 1;
+		resetState();
+		// print / rpc / json 模式没有 footer，别白跑 git。
+		activeTarget = ctx.mode === "tui" ? { cwd: ctx.cwd, generation } : undefined;
+		ctx.ui.setStatus(STATUSLINE_KEY, undefined);
+		if (!activeTarget) {
+			requestRender = undefined;
+			return;
+		}
+		const target = activeTarget;
+
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			requestRender = () => tui.requestRender();
+			tuiHandle = tui;
+			const unsubscribeBranch = footerData.onBranchChange(() => {
+				state.diffStat = undefined;
+				tui.requestRender();
+				scheduleDiffRefresh(0);
+			});
+			const clock = setInterval(() => scheduleDiffRefresh(0), GIT_POLL_INTERVAL_MS);
+
+			const component: FooterComponent = {
+				dispose() {
+					unsubscribeBranch();
+					clearInterval(clock);
+					// 只有仍属当前会话时才清，避免旧 footer 的 dispose 抹掉新会话的状态。
+					if (target === activeTarget) {
+						activeTarget = undefined;
+						state.diffStat = undefined;
+						requestRender = undefined;
+					}
+				},
+				invalidate() {},
+				render(width: number): string[] {
+					// 截断 / 缩进 / 不折行的约定在 line.ts 里，统一由单测覆盖。
+					const lines = composeFooterLines(theme, ctx, footerData, state, width, truncateToWidth);
+					// 换会话时按身份比对我们是否还在容器里，不在就拿这份行重放（见 footer-guard.ts）。
+					lastFooterLines = lines;
+					return lines;
+				},
+			};
+			footerComponent = component;
+			return component;
+		});
+
+		// 组件此刻已被 pi 挂进 footer 容器（`setFooter` 是同步的），按对象身份认出那个容器；
+		// 换会话时冻结要用。顺手解除别的扩展实例遗留的接管（`/reload` 之后可能有一次）。
+		footerContainer = findRenderContainer(tuiHandle, footerComponent);
+		if (footerContainer) releaseFooterGuard(footerContainer);
+		scheduleDiffRefresh(0);
+	};
+
+	/**
+	 * 换会话窗口内把 footer 钉在上一帧：pi 紧接着（在我们的 `session_shutdown` 回调之后）会
+	 * 还原内置 footer 并清空 statuses，此时接管容器渲染，默认 footer 一帧都不会出。
+	 */
+	const freezeFooter = () => {
+		if (FROZEN_DISABLED || !footerContainer || !footerComponent) return;
+		const component = footerComponent;
+		const lines = lastFooterLines;
+		guardRelease = freezeFooterContainer({
+			container: footerContainer,
+			ownComponent: component,
+			frozenRender: (width) =>
+				lines
+					? lines.map((line) => truncateToWidth(line, width, ELLIPSIS))
+					: component.render(width),
+		});
+	};
+
+	const releaseFooter = (ctx: ExtensionContext) => {
+		generation += 1;
+		cancelDiffRefresh();
+		activeTarget = undefined;
+		resetState();
+		requestRender = undefined;
+		ctx.ui.setFooter(undefined);
+		ctx.ui.setStatus(STATUSLINE_KEY, undefined);
+		freezeFooter();
+	};
+
+	const bumpTool = (toolName: string, delta: number) => {
+		const next = (state.activeTools.get(toolName) ?? 0) + delta;
+		if (next <= 0) state.activeTools.delete(toolName);
+		else state.activeTools.set(toolName, next);
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		installFooter(ctx);
+	});
+
+	// resume / fork / rewind 会换掉会话对象，footer 得按新 ctx 重装
+	pi.on("session_tree", (_event, ctx) => {
+		installFooter(ctx);
+		render();
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		releaseFooter(ctx);
+	});
+
+	pi.on("model_select", () => render());
+
+	pi.on("thinking_level_select", () => render());
+
+	pi.on("agent_start", () => {
+		state.streaming = true;
+		render();
+	});
+
+	pi.on("turn_start", () => {
+		state.streaming = true;
+		render();
+	});
+
+	pi.on("agent_end", () => {
+		state.activeTools.clear();
+		scheduleDiffRefresh(GIT_DEBOUNCE_MS);
+		render();
+	});
+
+	// agent_end 之后 pi 还可能自动重试 / 压缩 / 跑排队消息，settled 才算真停
+	pi.on("agent_settled", () => {
+		state.streaming = false;
+		state.activeTools.clear();
+		render();
+	});
+
+	pi.on("turn_end", () => {
+		scheduleDiffRefresh(GIT_DEBOUNCE_MS);
+		render();
+	});
+
+	pi.on("tool_execution_start", (event) => {
+		bumpTool(event.toolName, 1);
+		render();
+	});
+
+	pi.on("tool_execution_end", (event) => {
+		bumpTool(event.toolName, -1);
+		scheduleDiffRefresh(GIT_DEBOUNCE_MS);
+		render();
+	});
+}