@bachi/pi-coder 1.0.0

package/extensions/statusline/line.test.ts

@@ -0,0 +1,316 @@
+/**
+ * Tests for line.ts — the statusline main line and the extension-status line.
+ *
+ * Run with:  node --test clients/pi/extensions/statusline/line.test.ts
+ *
+ * line.ts never imports pi / pi-tui, so plain fakes reach every branch: `plain` drops
+ * colours (assert exact visible text), `painted` wraps each run as `color(text)` (assert
+ * which theme colour slot every part uses).
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import {
+	type StatuslineGitSource,
+	type StatuslineSource,
+	type StatuslineState,
+	type StatuslineTheme,
+	BRANCH_ICON,
+	composeFooterLines,
+	ELLIPSIS,
+	formatExtensionStatuses,
+	formatMainLine,
+} from "./line.ts";
+
+const plain: StatuslineTheme = { fg: (_color, text) => text };
+const painted: StatuslineTheme = { fg: (color, text) => `${color}(${text})` };
+
+const FLASH = { id: "qwen3.8-flash" };
+const DOC = "⚡️ qwen3.8-flash/xhigh | Ctx 0.0%";
+
+function sourceOf(
+	percent: number | null = 0,
+	model: { id?: string } | null = FLASH,
+	level = "xhigh",
+): StatuslineSource {
+	const resolved = model === null ? undefined : model;
+	return {
+		model: resolved,
+		thinkingLevel: level,
+		getContextUsage: () => (percent === null ? undefined : { percent }),
+	};
+}
+
+function gitOf(
+	branch: string | null,
+	statuses: ReadonlyMap<string, string> = new Map(),
+): StatuslineGitSource {
+	return { getGitBranch: () => branch, getExtensionStatuses: () => statuses };
+}
+
+function stateOf(overrides: Partial<StatuslineState> = {}): StatuslineState {
+	return { streaming: false, activeTools: new Map(), diffStat: undefined, ...overrides };
+}
+
+describe("BRANCH_ICON", () => {
+	it("pins the exact private-use code point of the branch glyph", () => {
+		// 私有区字形在字体缺字形时只是看不见的方块，贴错成近形码位也 review 不出来，
+		// 所以这里用转义把码位钉死，而不依赖源码里的裸字形。
+		assert.equal(BRANCH_ICON, "\ue0a0");
+		assert.equal(BRANCH_ICON.codePointAt(0), 0xe0a0);
+		assert.equal([...BRANCH_ICON].length, 1);
+	});
+});
+
+describe("formatMainLine", () => {
+	it("renders the documented line inside a repo", () => {
+		assert.equal(
+			formatMainLine(plain, sourceOf(0), gitOf("main"), stateOf({ diffStat: { added: 0, deleted: 0 } })),
+			`${DOC} | \ue0a0 main | (+0,-0)`,
+		);
+	});
+
+	it("shows real diff counts", () => {
+		assert.equal(
+			formatMainLine(plain, sourceOf(), gitOf("main"), stateOf({ diffStat: { added: 12, deleted: 3 } })),
+			`${DOC} | \ue0a0 main | (+12,-3)`,
+		);
+	});
+
+	it("shows zeros before the first git read lands", () => {
+		assert.equal(formatMainLine(plain, sourceOf(), gitOf("main"), stateOf()), `${DOC} | \ue0a0 main | (+0,-0)`);
+	});
+
+	it("replaces both git segments outside a repo", () => {
+		assert.equal(
+			formatMainLine(plain, sourceOf(), gitOf(null), stateOf({ diffStat: { added: 9, deleted: 9 } })),
+			`${DOC} | \ue0a0 no git | (no git)`,
+		);
+	});
+
+	it("renders a detached head", () => {
+		assert.ok(formatMainLine(plain, sourceOf(), gitOf("detached"), stateOf()).includes("\ue0a0 detached"));
+	});
+
+	it("appends thinking while streaming and the tool name instead once a tool runs", () => {
+		assert.equal(
+			formatMainLine(plain, sourceOf(), gitOf("main"), stateOf({ streaming: true })),
+			`${DOC} | \ue0a0 main | (+0,-0) | thinking`,
+		);
+		assert.equal(
+			formatMainLine(
+				plain,
+				sourceOf(),
+				gitOf("main"),
+				stateOf({ streaming: true, activeTools: new Map([["bash", 1]]) }),
+			),
+			`${DOC} | \ue0a0 main | (+0,-0) | bash`,
+		);
+	});
+
+	it("annotates repeated and additional concurrent tools", () => {
+		const twice = formatMainLine(plain, sourceOf(), gitOf("main"), stateOf({ activeTools: new Map([["read", 2]]) }));
+		const several = formatMainLine(
+			plain,
+			sourceOf(),
+			gitOf("main"),
+			stateOf({ activeTools: new Map([["read", 1], ["bash", 1]]) }),
+		);
+		assert.ok(twice.endsWith("| read×2"), twice);
+		assert.ok(several.endsWith("| read+1"), several);
+	});
+
+	it("questions the context when usage is unknown", () => {
+		assert.equal(
+			formatMainLine(plain, sourceOf(null, { id: "mystery" }), gitOf("main"), stateOf()),
+			"⚡️ mystery/xhigh | Ctx ? | \ue0a0 main | (+0,-0)",
+		);
+	});
+
+	it("survives a missing model", () => {
+		assert.equal(
+			formatMainLine(plain, sourceOf(null, null), gitOf(null), stateOf()),
+			"⚡️ no-model/xhigh | Ctx ? | \ue0a0 no git | (no git)",
+		);
+	});
+
+	it("appends the current thinking level to the model id", () => {
+		for (const level of ["off", "low", "high", "max"]) {
+			assert.ok(
+				formatMainLine(plain, sourceOf(0, FLASH, level), gitOf("main"), stateOf()).startsWith(
+					`⚡️ qwen3.8-flash/${level} | `,
+				),
+				level,
+			);
+		}
+	});
+
+	it("drops the level suffix when it is empty or the getter throws", () => {
+		assert.ok(
+			formatMainLine(plain, sourceOf(0, FLASH, ""), gitOf("main"), stateOf()).startsWith(
+				"⚡️ qwen3.8-flash | ",
+			),
+		);
+		const throwing: StatuslineSource = {
+			model: FLASH,
+			get thinkingLevel(): never {
+				throw new Error("stale context");
+			},
+			getContextUsage: () => ({ percent: 0 }),
+		};
+		assert.ok(
+			formatMainLine(plain, throwing, gitOf("main"), stateOf()).startsWith("⚡️ qwen3.8-flash | "),
+		);
+	});
+
+	it("treats throwing context getters as unknown", () => {
+		const stale: StatuslineSource = {
+			get model(): never {
+				throw new Error("stale context");
+			},
+			get thinkingLevel(): never {
+				throw new Error("stale context");
+			},
+			getContextUsage(): never {
+				throw new Error("stale context");
+			},
+		};
+		assert.equal(formatMainLine(plain, stale, gitOf("main"), stateOf()), "⚡️ no-model | Ctx ? | \ue0a0 main | (+0,-0)");
+	});
+
+	it("paints labels and separators dim, model / branch / percent by role", () => {
+		assert.equal(
+			formatMainLine(painted, sourceOf(0), gitOf("main"), stateOf({ diffStat: { added: 1, deleted: 2 } })),
+			"⚡️ accent(qwen3.8-flash)dim(/)syntaxFunction(xhigh)dim( | )dim(Ctx) success(0.0%)dim( | )" +
+				"dim(\ue0a0) accent(main)dim( | )dim(()success(+1)dim(,)error(-2)dim())",
+		);
+	});
+
+	it("shifts the context colour at 70% and 90%", () => {
+		const colored = (percent: number | null) => formatMainLine(painted, sourceOf(percent), gitOf("main"), stateOf());
+		assert.ok(colored(69.9).includes("success(69.9%)"));
+		assert.ok(colored(70).includes("warning(70.0%)"));
+		assert.ok(colored(95.4).includes("error(95.4%)"));
+		assert.ok(colored(null).includes("dim(?)"));
+	});
+
+	it("paints the state segment warning and nothing when idle", () => {
+		assert.ok(
+			formatMainLine(painted, sourceOf(), gitOf("main"), stateOf({ streaming: true })).endsWith("dim( | )warning(thinking)"),
+		);
+		assert.ok(
+			formatMainLine(
+				painted,
+				sourceOf(),
+				gitOf("main"),
+				stateOf({ activeTools: new Map([["bash", 1]]) }),
+			).endsWith("dim( | )warning(bash)"),
+		);
+		assert.equal(formatMainLine(painted, sourceOf(), gitOf("main"), stateOf()).includes("thinking"), false);
+	});
+});
+
+describe("formatExtensionStatuses", () => {
+	it("joins statuses set by other extensions", () => {
+		const statuses = new Map([
+			["cwd", " 📁 /Users/bachi/jaylli/litellm-any"],
+			["rewind", "◆ 3 checkpoints"],
+		]);
+		assert.equal(
+			formatExtensionStatuses(plain, gitOf("main", statuses)),
+			"📁 /Users/bachi/jaylli/litellm-any | ◆ 3 checkpoints",
+		);
+	});
+
+	it("keeps pre-coloured status text verbatim and mutes plain text", () => {
+		const esc = String.fromCharCode(27);
+		const coloured = `${esc}[2m` + "◆ " + "checkpoints" + `${esc}[0m`;
+		const statuses = new Map([
+			["rewind", coloured],
+			["cwd", " 📁 /tmp/repo"],
+		]);
+		const rendered = formatExtensionStatuses(painted, gitOf("main", statuses));
+		assert.ok(rendered.startsWith(coloured + "dim( | )"), rendered);
+		assert.ok(rendered.endsWith("muted(📁 /tmp/repo)"), rendered);
+	});
+
+	it("skips blank values and its own statusline key", () => {
+		const statuses = new Map([
+			["statusline", "stale"],
+			["retry", "   "],
+			["cwd", " 📁 /tmp/repo"],
+		]);
+		assert.equal(formatExtensionStatuses(plain, gitOf("main", statuses)), "📁 /tmp/repo");
+		assert.equal(formatExtensionStatuses(plain, gitOf("main", new Map())), "");
+	});
+
+	it("caps the status line at five entries", () => {
+		const statuses = new Map(
+			Array.from({ length: 7 }, (_, i): [string, string] => [`k${i}`, `v${i}`]),
+		);
+		const rendered = formatExtensionStatuses(plain, gitOf("main", statuses));
+		assert.equal(rendered.split(" | ").length, 5);
+		assert.ok(rendered.endsWith("v4") && !rendered.includes("v5"), rendered);
+	});
+});
+
+describe("composeFooterLines", () => {
+	function recorder() {
+		const calls: Array<{ text: string; width: number; ellipsis: string }> = [];
+		const truncate = (text: string, max: number, ellipsis: string) => {
+			calls.push({ text, width: max, ellipsis });
+			return [...text].length > max ? `${[...text].slice(0, max - 1).join("")}${ellipsis}` : text;
+		};
+		return { calls, truncate };
+	}
+
+	it("indents every line by exactly one space and never wraps", () => {
+		const { truncate } = recorder();
+		const statuses = new Map([["cwd", " 📁 /tmp/repo"]]);
+		const lines = composeFooterLines(
+			plain,
+			sourceOf(),
+			gitOf("main", statuses),
+			stateOf(),
+			200,
+			truncate,
+		);
+		assert.equal(lines.length, 2);
+		for (const line of lines) {
+			assert.ok(line.startsWith(" "), JSON.stringify(line));
+			assert.ok(!line.startsWith("  "), JSON.stringify(line));
+			assert.equal(line.includes("\n"), false);
+		}
+		assert.ok(lines[0]?.includes(`${DOC} | \ue0a0 main | (+0,-0)`), lines[0]);
+		assert.equal(lines[1], " 📁 /tmp/repo");
+	});
+
+	it("emits a single line when no other extension set a status", () => {
+		const lines = composeFooterLines(plain, sourceOf(), gitOf("main"), stateOf(), 200, (t) => t);
+		assert.equal(lines.length, 1);
+	});
+
+	it("truncates an over-long line and leaves a short one intact", () => {
+		const { calls, truncate } = recorder();
+		const lines = composeFooterLines(
+			plain,
+			sourceOf(),
+			gitOf("main", new Map([["cwd", " 📁 /tmp/repo"]])),
+			stateOf(),
+			20,
+			truncate,
+		);
+		assert.equal(calls.length, 2);
+		assert.equal(calls[0]?.width, 20);
+		assert.equal(calls[0]?.ellipsis, ELLIPSIS);
+		assert.equal([...(lines[0] ?? "")].length, 20, lines[0]);
+		assert.ok(lines[0]?.endsWith(ELLIPSIS), lines[0]);
+		assert.equal(lines[0]?.includes("\n"), false);
+		assert.equal(lines[1], " 📁 /tmp/repo");
+	});
+
+	it("renders nothing for a non-positive width", () => {
+		assert.deepEqual(composeFooterLines(plain, sourceOf(), gitOf("main"), stateOf(), 0, (t) => t), []);
+	});
+});

package/extensions/statusline/line.ts

@@ -0,0 +1,201 @@
+/**
+ * line.ts — statusline 主行 / 状态行的纯格式化
+ *
+ * 这个模块**不 import pi / pi-tui**（只用结构化最小接口描述需要的字段），所以
+ * `node --test` 能直接拿假对象跑满每个分支；pi 的真实 `Theme` / `ExtensionContext` /
+ * `ReadonlyFooterDataProvider` 结构兼容，index.ts 里原样传进来即可。
+ */
+
+/** pi 的 Theme.fg 子集（方法声明双变，真实 Theme 可直接赋值）。 */
+export interface StatuslineTheme {
+	fg(color: string, text: string): string;
+}
+
+/** ctx 里渲染主行需要的部分（`thinkingLevel` 在 pi 的 ctx 上是 live getter，可选且可能抛）。 */
+export interface StatuslineSource {
+	model: { id?: string } | undefined;
+	thinkingLevel?: string;
+	getContextUsage(): { percent: number | null | undefined } | undefined;
+}
+
+/** footerData 里需要的部分。 */
+export interface StatuslineGitSource {
+	getGitBranch(): string | null;
+	getExtensionStatuses(): ReadonlyMap<string, string>;
+}
+
+export interface DiffStat {
+	added: number;
+	deleted: number;
+}
+
+export interface StatuslineState {
+	streaming: boolean;
+	/** 渲染路径只读，只有 index.ts 的事件回调会改。 */
+	activeTools: Map<string, number>;
+	/** undefined = 还没读到 / 不在 git 仓库。 */
+	diffStat: DiffStat | undefined;
+}
+
+export const SEPARATOR = " | ";
+export const ELLIPSIS = "…";
+/**
+ * 模型段前缀图标（取代早期的 `Model:` 文字标签，省 4 列）。
+ * 刻意**不上色**：emoji 是自带颜色的字形，`theme.fg` 包一层只多出一对没有视觉效果的
+ * ANSI 码。宽度按 pi-tui `visibleWidth` 是 2 列（RGI emoji），与终端实际渲染一致，
+ * 所以 `truncateToWidth` 的截断数学不受影响。
+ * 带 VS16（U+FE0F）强制 emoji 呈现：裸 `\u26a1` 在 pi-tui 里同样量 2 列，但 VS16
+ * 能保证个别终端/字体不把它渲染成单色窄字形（那会和宽度口径错位 1 列）。
+ */
+export const MODEL_ICON = "⚡️";
+/**
+ * 分支段前缀图标：U+E0A0（Powerline / Nerd Font 的 git branch 字形），取代早期的 `⎇`(U+2387)。
+ * 这码位在私有区，源码里只写转义不写裸字形 —— 裸字形在字体缺字形时是看不见的方块，贴错成
+ * 近形码位（U+E0A2 / U+E0B0）review 时也看不出来，所以测试用转义把码位钉死。
+ * 宽度按 pi-tui `visibleWidth` 是 1 列，与旧图标相同，`truncateToWidth` 的截断预算不用动。
+ * 前提是终端用 Nerd Font —— 本机 Ghostty 配的 JetBrainsMonoNL Nerd Font Mono 即是。
+ */
+export const BRANCH_ICON = "\ue0a0";
+/** 行首缩进：整行不顶格。 */
+export const LEADING_INDENT = " ";
+/** 本扩展自己的 setStatus key（清残留用，渲染时也跳过）。 */
+export const STATUSLINE_KEY = "statusline";
+const MAX_STATUS_ITEMS = 5;
+
+/** 主行：`⚡️ x/xhigh | Ctx 0.0% | \ue0a0 branch | (+a,-b)[ | 状态]`，各段已着色。 */
+export function formatMainLine(
+	theme: StatuslineTheme,
+	source: StatuslineSource,
+	git: StatuslineGitSource,
+	state: StatuslineState,
+): string {
+	const branch = git.getGitBranch();
+	const segments = [
+		formatModelSegment(theme, source),
+		formatContextSegment(theme, source),
+		formatBranchSegment(theme, branch),
+		formatDiffSegment(theme, branch, state.diffStat),
+		formatStateSegment(theme, state),
+	].filter((segment): segment is string => Boolean(segment));
+	return segments.join(dim(theme, SEPARATOR));
+}
+
+/**
+ * footer 的完整输出：一个主行（+ 可选状态行），行首恒缩进一格，超长只截断省略、绝不折行。
+ * `truncate` 由 index.ts 注入 pi-tui 的 `truncateToWidth`（ANSI / 宽字符安全），
+ * 这样这条关键约定也能在单测里直接断言。
+ */
+export function composeFooterLines(
+	theme: StatuslineTheme,
+	source: StatuslineSource,
+	git: StatuslineGitSource,
+	state: StatuslineState,
+	width: number,
+	truncate: (text: string, width: number, ellipsis: string) => string,
+): string[] {
+	if (width <= 0) return [];
+	const lines = [`${LEADING_INDENT}${formatMainLine(theme, source, git, state)}`];
+	const statuses = formatExtensionStatuses(theme, git);
+	if (statuses) lines.push(`${LEADING_INDENT}${statuses}`);
+	return lines.map((line) => truncate(line, width, ELLIPSIS));
+}
+
+/**
+ * 第二行：其它扩展 `ctx.ui.setStatus()` 的文本（cwd-statusline / rewind / simple-task）。
+ * 自带 ANSI 的原样渲染（那些扩展已经自己配过色），没色的统一给 muted。
+ */
+export function formatExtensionStatuses(theme: StatuslineTheme, git: StatuslineGitSource): string {
+	const visible = [...git.getExtensionStatuses().entries()]
+		.filter(([key, value]) => key !== STATUSLINE_KEY && value.trim().length > 0)
+		.slice(0, MAX_STATUS_ITEMS)
+		.map(([, value]) => (hasAnsi(value) ? value : theme.fg("muted", value.trim())));
+	return visible.join(dim(theme, SEPARATOR));
+}
+
+/** 模型图标 + id + 推理强度：`⚡️ qwen3.8-flash/xhigh`（id 用 accent，斜杠 dim，level 用 syntaxFunction）；level 读不到（stale ctx）时只报 id。 */
+function formatModelSegment(theme: StatuslineTheme, source: StatuslineSource): string {
+	const id = readModel(source)?.id ?? "no-model";
+	const level = readThinkingLevel(source);
+	const suffix = level ? `${dim(theme, "/")}${theme.fg("syntaxFunction", level)}` : "";
+	return `${MODEL_ICON} ${theme.fg("accent", id)}${suffix}`;
+}
+
+function formatContextSegment(theme: StatuslineTheme, source: StatuslineSource): string {
+	const percent = readContextUsage(source)?.percent ?? null;
+	const percentText = percent === null ? "?" : `${percent.toFixed(1)}%`;
+	return `${dim(theme, "Ctx")} ${theme.fg(contextColor(percent), percentText)}`;
+}
+
+function formatBranchSegment(theme: StatuslineTheme, branch: string | null): string {
+	if (!branch) return dim(theme, `${BRANCH_ICON} no git`);
+	return `${dim(theme, BRANCH_ICON)} ${theme.fg("accent", branch)}`;
+}
+
+function formatDiffSegment(
+	theme: StatuslineTheme,
+	branch: string | null,
+	diffStat: DiffStat | undefined,
+): string {
+	if (!branch) return dim(theme, "(no git)");
+	return `${dim(theme, "(")}${theme.fg("success", `+${diffStat?.added ?? 0}`)}${dim(theme, ",")}${theme.fg("error", `-${diffStat?.deleted ?? 0}`)}${dim(theme, ")")}`;
+}
+
+/** 末段状态：有工具在跑 → 工具名（并发带计数），否则流式中 → thinking，空闲 → 整段不出现；整段用 warning 着色。 */
+function formatStateSegment(theme: StatuslineTheme, state: StatuslineState): string | undefined {
+	const active = [...state.activeTools.entries()];
+	if (active.length > 0) {
+		const [name, count] = active[0] ?? ["tool", 1];
+		const suffix = count > 1 ? `×${count}` : active.length > 1 ? `+${active.length - 1}` : "";
+		return theme.fg("warning", `${name}${suffix}`);
+	}
+	return state.streaming ? theme.fg("warning", "thinking") : undefined;
+}
+
+function contextColor(percent: number | null): string {
+	if (percent === null) return "dim";
+	if (percent >= 90) return "error";
+	if (percent >= 70) return "warning";
+	return "success";
+}
+
+/** ctx 的 getter 在会话被换掉后可能抛（stale ctx），状态栏不值得为此挂掉渲染。 */
+function readContextUsage(
+	source: StatuslineSource,
+): { percent: number | null | undefined } | undefined {
+	try {
+		return source.getContextUsage();
+	} catch {
+		return undefined;
+	}
+}
+
+/** thinkingLevel 在 stale ctx 上同样可能抛，一律兜底成「无 level」。 */
+function readThinkingLevel(source: StatuslineSource): string | undefined {
+	try {
+		const level = source.thinkingLevel;
+		return typeof level === "string" && level.length > 0 ? level : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** ctx.model 在 stale ctx 上也可能抛，一律走这里取。 */
+function readModel(
+	source: StatuslineSource,
+): { id?: string; contextWindow?: number } | undefined {
+	try {
+		return source.model;
+	} catch {
+		return undefined;
+	}
+}
+
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/;
+
+function hasAnsi(value: string): boolean {
+	return ANSI_PATTERN.test(value);
+}
+
+function dim(theme: StatuslineTheme, text: string): string {
+	return theme.fg("dim", text);
+}

package/extensions/subagent-log-guard/filter.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Tests for filter.ts — the "[pi-subagents] …" stderr-chunk classifier behind subagent-log-guard.
+ *
+ * Run with:  node --test clients/pi/extensions/subagent-log-guard/filter.test.ts
+ *
+ * filter.ts never imports pi / pi-tui (that is the point of the split), so these tests need
+ * nothing but node:test. The classifier is deliberately prefix-only: pi-subagents formats one
+ * console.warn call into one "text + newline" write, so a real diagnostic always starts the
+ * chunk — and a `[pi-subagents]` mention in the middle of someone else's write must survive.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { chunkToText, splitSubagentDiagnostics, SUBAGENT_LOG_PREFIX } from "./filter.ts";
+
+/** The real line that smeared a live session (pulled verbatim from a runner.stderr.log). */
+const REAL_DIAGNOSTIC =
+	`${SUBAGENT_LOG_PREFIX} Agent 'researcher': host runtime tool availability omitted [web_search, fetch_content, ` +
+	"get_search_content, source_check]. Requested tool names: [read, write, web_search, fetch_content, " +
+	"get_search_content, source_check, contact_supervisor]; effective tool allowlist: [read, write, " +
+	"contact_supervisor]. This is a non-fatal tool-plan diagnostic, not verification of the child's runtime " +
+	"tool menu.\n";
+
+describe("splitSubagentDiagnostics", () => {
+	it("captures a real diagnostic and strips the prefix plus the trailing newline", () => {
+		const { passThrough, captured } = splitSubagentDiagnostics(REAL_DIAGNOSTIC);
+		assert.equal(passThrough, "");
+		assert.equal(captured.length, 1);
+		assert.ok(captured[0]?.startsWith("Agent 'researcher': host runtime tool availability omitted"));
+		assert.ok(captured[0]?.endsWith("runtime tool menu."));
+		assert.ok(!captured[0]?.includes(SUBAGENT_LOG_PREFIX));
+	});
+
+	it("passes ordinary stderr through untouched, byte for byte", () => {
+		const text = "Error: something exploded\n";
+		const { passThrough, captured } = splitSubagentDiagnostics(text);
+		assert.equal(passThrough, text);
+		assert.deepEqual(captured, []);
+	});
+
+	it("keeps a mid-chunk mention of the prefix instead of swallowing the whole write", () => {
+		// e.g. an extension echoing a log file line, or the model quoting the package name.
+		const text = `see ${SUBAGENT_LOG_PREFIX} lines in runner.stderr.log\n`;
+		const { passThrough, captured } = splitSubagentDiagnostics(text);
+		assert.equal(passThrough, text);
+		assert.deepEqual(captured, []);
+	});
+
+	it("captures a multi-line diagnostic as one entry (no continuation line leaks out)", () => {
+		const text = `${SUBAGENT_LOG_PREFIX} first line\nsecond line\n`;
+		const { passThrough, captured } = splitSubagentDiagnostics(text);
+		assert.equal(passThrough, "");
+		assert.deepEqual(captured, ["first line\nsecond line"]);
+	});
+
+	it("handles a prefix-only write without inventing content", () => {
+		const { passThrough, captured } = splitSubagentDiagnostics(`${SUBAGENT_LOG_PREFIX}\n`);
+		assert.equal(passThrough, "");
+		assert.deepEqual(captured, [""]);
+	});
+
+	it("handles an empty write", () => {
+		const { passThrough, captured } = splitSubagentDiagnostics("");
+		assert.equal(passThrough, "");
+		assert.deepEqual(captured, []);
+	});
+});
+
+describe("chunkToText", () => {
+	it("returns string chunks as-is", () => {
+		assert.equal(chunkToText("plain"), "plain");
+	});
+
+	it("decodes Buffer / Uint8Array chunks the way console writes them", () => {
+		const buffer = Buffer.from(REAL_DIAGNOSTIC, "utf8");
+		assert.equal(chunkToText(buffer), REAL_DIAGNOSTIC);
+		const { captured } = splitSubagentDiagnostics(chunkToText(buffer));
+		assert.equal(captured.length, 1);
+	});
+
+	it("keeps multi-byte characters intact across a Buffer boundary", () => {
+		assert.equal(chunkToText(Buffer.from("工具调用失败\n", "utf8")), "工具调用失败\n");
+	});
+});

package/extensions/subagent-log-guard/filter.ts

@@ -0,0 +1,32 @@
+/**
+ * subagent-log-guard 的纯判定层：一段写向 stderr 的文本，是 pi-subagents 的诊断行吗？
+ * 不 import pi / pi-tui / 任何运行时依赖，所以 `node --test` 可以直接跑（见 filter.test.ts）。
+ */
+
+/** pi-subagents 的诊断前缀：它的 console.warn / console.error 调用点统一以它开头。 */
+export const SUBAGENT_LOG_PREFIX = "[pi-subagents]";
+
+export interface ChunkSplit {
+	/** 原样放行给终端的内容（非诊断时就是原文，可能为空串） */
+	passThrough: string;
+	/** 拦下的诊断（已去掉前缀与首尾空白）；长度 > 0 表示这一段是诊断 */
+	captured: string[];
+}
+
+/** process.stderr.write 的 chunk 可能是 string 也可能是 Uint8Array，统一成文本再比。 */
+export function chunkToText(chunk: string | Uint8Array): string {
+	return typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+}
+
+/**
+ * 只看**开头**：Node 的 console.warn / console.error 会把整条消息格式化成「文本 + 换行」
+ * 一次写入，所以 pi-subagents 的诊断必然落在 chunk 的开头。
+ * 反过来，出现在 chunk 中间的 `[pi-subagents]` 不是诊断开头（可能是模型输出、别的扩展
+ * 打印的引用文本），放行才不会误吞别人的内容。
+ */
+export function splitSubagentDiagnostics(text: string): ChunkSplit {
+	if (!text.startsWith(SUBAGENT_LOG_PREFIX)) {
+		return { passThrough: text, captured: [] };
+	}
+	return { passThrough: "", captured: [text.slice(SUBAGENT_LOG_PREFIX.length).trim()] };
+}