pi-firecode 1.0.0 → 1.0.1

package/tools/round.ts

@@ -1,95 +0,0 @@
-/**
- * 轮记录：一段会话进行中（一次人类输入到歇下，含等子代理）的事后事实——整段时长与终态。
- * 歇下边沿写成官方 CustomEntry 持久化，自己不占行；过程组摘要行落定时读它，重载后依然有数。
- */
-import type { CustomEntry, EntryRenderer } from "@earendil-works/pi-coding-agent";
-import type { Component } from "@earendil-works/pi-tui";
-import type { SettledRound } from "../busy.js";
-import { parseEnvelopes } from "../deliver.js";
-import { textOf } from "../format.js";
-
-export const ROUND_ENTRY = "firecode-round";
-/** 轮记录写进会话之后在进程内总线上发布（无 payload）：订阅方此刻读分支一定已含这条记录，不依赖歇下边沿的订阅顺序。 */
-export const ROUND_RECORDED_CHANNEL = "firecode:round-recorded";
-
-export interface Round extends SettledRound {
-	/** 歇下时刻（宿主记录的 entry 时间戳）。 */
-	at: number;
-}
-
-/** 零行标记组件：只把记录带进聊天树，供投影按能力识别。 */
-interface RoundMarker extends Component {
-	round: Round;
-}
-
-/** 零行标记：投影按 roundOf 识别。会话里的轮记录经宿主渲染成它，没有轮记录的会话（子代理）也可按运行边界直接造。 */
-export function roundMarker(round: Round): Component {
-	const marker: RoundMarker = { round, render: () => [], invalidate() {} };
-	return marker;
-}
-
-/** 本模块写的 entry 一定带 data；类型上的 data? 只是宿主给所有 CustomEntry 的通用形状。 */
-export const renderRound: EntryRenderer<SettledRound> = (entry: CustomEntry<SettledRound>) =>
-	roundMarker({ ...(entry.data as SettledRound), at: Date.parse(entry.timestamp) });
-
-/** 一轮里更早的非完成终态的短标记。 */
-const EARLIER_TEXT = { aborted: "中断过", error: "请求失败过" } as const;
-
-/**
- * 一轮可能有多条记录（中断后又跑了一段，如 /fire-review 或命令触发的再次进行）。合成规则不丢信息：
- * 耗时累加（用户关心这一轮总共花了多久），终态与落定时刻取最后一条（这一轮最终怎样），更早的中断/请求失败
- * 以“中断过 N 次”追加；多段的均速没有请求墙钟无法合成，按“不出半截的数”不给。
- */
-export interface TurnRecord {
-	round: Round;
-	earlier: string[];
-}
-
-export function combineRounds(rounds: readonly Round[]): TurnRecord | undefined {
-	const last = rounds.at(-1);
-	if (!last) return undefined;
-	const elapsed = rounds.reduce((total, round) => total + round.elapsed, 0);
-	const round: Round = rounds.length === 1 ? last : { elapsed, outcome: last.outcome, at: last.at };
-	const earlier = (["aborted", "error"] as const).flatMap((outcome) => {
-		const count = rounds.slice(0, -1).filter((round) => round.outcome === outcome).length;
-		return count ? [`${EARLIER_TEXT[outcome]} ${count} 次`] : [];
-	});
-	return { round, earlier };
-}
-
-/** 会话分支条目里本模块读到的部分（宿主 SessionEntry 的结构子集）。 */
-export type BranchEntry =
-	| { type: "custom"; customType: string; data?: unknown; timestamp: string }
-	| { type: "message"; message: { role: string; content?: unknown } }
-	| { type: string };
-
-const isHumanEntry = (entry: BranchEntry) => entry.type === "message" && "message" in entry
-	&& entry.message.role === "user" && !parseEnvelopes(textOf(entry.message.content));
-
-/** 会话条目若是轮记录，给出它（带落定时刻）；子代理全过程视图与 Master 的本次运行耗时都按它读子代理会话。 */
-export function roundFromEntry(entry: unknown): Round | undefined {
-	const record = entry as { type?: unknown; customType?: unknown; data?: unknown; timestamp?: unknown };
-	if (record?.type !== "custom" || record.customType !== ROUND_ENTRY || typeof record.timestamp !== "string") return undefined;
-	return { ...(record.data as SettledRound), at: Date.parse(record.timestamp) };
-}
-
-/**
- * 当前分支最近一轮的落定事实：最近一条人类消息之后的全部轮记录，按 combineRounds 合成。
- * 输入框上边框落定态读它，与摘要行是同一份记录、同一条合成规则。
- */
-export function latestTurnRecord(branch: readonly BranchEntry[]): TurnRecord | undefined {
-	const rounds: Round[] = [];
-	for (let index = branch.length - 1; index >= 0; index--) {
-		const entry = branch[index];
-		if (isHumanEntry(entry)) break;
-		const round = roundFromEntry(entry);
-		if (round) rounds.unshift(round);
-	}
-	return combineRounds(rounds);
-}
-
-/** 宿主把 entry 包成 Container（Spacer + 渲染器组件）；按能力找标记，不依赖类身份。 */
-export function roundOf(component: Component): Round | undefined {
-	const children = (component as { children?: readonly Component[] }).children;
-	return children?.find((child): child is RoundMarker => "round" in child)?.round;
-}

package/tools/timing.ts

@@ -1,22 +0,0 @@
-/** 工具真实执行耗时：execute 侧写入，渲染侧按 toolCallId 取走。 */
-const durations = new Map<string, number>();
-
-export async function executeTimed<T>(id: string, execute: () => Promise<T>): Promise<T> {
-	const startedAt = performance.now();
-	try {
-		return await execute();
-	} finally {
-		durations.set(id, performance.now() - startedAt);
-	}
-}
-
-/** 取一次即释放，避免长会话里堆积。 */
-export function takeDuration(id: string): number | undefined {
-	const duration = durations.get(id);
-	if (duration !== undefined) durations.delete(id);
-	return duration;
-}
-
-export function clearDurations(): void {
-	durations.clear();
-}

package/tools/turn-clock.ts

@@ -1,41 +0,0 @@
-/**
- * 轮次时钟：把 busy.ts 的会话进行中事实投影到各轮摘要行——哪一轮开着、机器消息是否刚到。
- * 落定后的耗时与终态不在这里，来自聊天树里的轮记录（round.ts）。
- */
-import { type BusyView, IDLE } from "../busy.js";
-
-/** 子代理结果到达后摘要行高亮多久。 */
-export const ARRIVAL_FLASH_MS = 2500;
-
-export class TurnClock {
-	private busy: BusyView = IDLE;
-	private lastKey?: object;
-	private readonly arrivals = new WeakMap<object, number>();
-
-	constructor(readonly now: () => number = Date.now) {}
-
-	sync(view: BusyView): void {
-		this.busy = view;
-	}
-
-	/** 指挥官自己的回合在跑；否则这一段只是在等子代理，摘要行没有当前动作可说。 */
-	get agentRunning(): boolean {
-		return this.busy.agentRunning;
-	}
-
-	/** 投影每次渲染声明当前最后一轮。 */
-	track(key: object): void {
-		this.lastKey = key;
-	}
-
-	/** 会话正在进行且这是最后一轮。 */
-	live(key: object): boolean {
-		return this.busy.busy && key === this.lastKey;
-	}
-
-	/** 机器消息距首次出现多久；只有运行中出现的才算“新到达”，恢复的历史永远是旧的。 */
-	arrivalAge(item: object): number {
-		if (!this.arrivals.has(item)) this.arrivals.set(item, this.busy.busy ? this.now() : -Infinity);
-		return this.now() - this.arrivals.get(item)!;
-	}
-}

package/tools/turn-summary.ts

@@ -1,109 +0,0 @@
-/**
- * 一轮的摘要行：只承担运行状态、事后记录与异常提醒。运行中是火苗 + 当前动作（实时计时只在边框），落定后是 ✓ 整段耗时 · 均速，
- * 中断/请求失败是 ✗ 加终态字样；这一轮有子代理失败追加“N 个子代理失败”，宿主的 ⚠ 提示原文也追加。
- * 工具失败是模型的工作过程，不计数、不影响标记。纯渲染，不碰宿主组件。
- */
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { type Component, type TuiMouseEvent, visibleWidth } from "@earendil-works/pi-tui";
-import { HEAT_COLORS, flame, mix, paint, settleMark } from "../flame.js";
-import { OUTCOME_TEXT, roundTexts } from "../busy.js";
-import { clip } from "../format.js";
-import { CHAT_GUTTER } from "./line.js";
-import type { Round } from "./round.js";
-import { ARRIVAL_FLASH_MS } from "./turn-clock.js";
-
-export interface SummaryView {
-	/** 折入段内的首条宿主提示原文（缓存、丢思考、压缩计费）。 */
-	notice?: string;
-	live: boolean;
-	/** 运行中的当前动作（动作词 + 简短目标）；落定后或指挥官只在等子代理时没有，只画火苗。 */
-	action?: { word: string; target?: string };
-	/** 子代理结果刚到达：短暂替换当前动作。 */
-	arrival?: { text: string; failed: boolean; age: number };
-	/** 这一轮里失败的子代理数（按名字去重）。 */
-	failures?: number;
-	/** 落定后的轮记录：这一轮各段合成的耗时与终态（见 round.ts 的 combineRounds）。 */
-	round?: Round;
-	/** 这一轮更早几段的非完成终态短标记，如“中断过 1 次”。 */
-	earlier?: string[];
-	sinceEnd?: number;
-	/** 单轮展开/收起；全局展开时为空，点击无效。 */
-	toggle?: () => void;
-}
-
-/** 提示原文被目标挤压时至少保留的列数。 */
-const NOTICE_MIN = 12;
-/** 目标少于这个宽度就不显示，只留动作词。 */
-const MIN_TARGET = 4;
-
-export class TurnSummary implements Component {
-	constructor(private readonly view: SummaryView, private readonly theme: Theme) {}
-	invalidate(): void {}
-
-	render(full: number): string[] {
-		const width = full - CHAT_GUTTER;
-		const { theme, view } = this;
-		const sep = theme.fg("dim", " · ");
-		const outcome = this.outcomeText();
-		const word = view.live ? this.actionText() : outcome;
-		const target = view.live && view.action?.target && !this.flashing() ? view.action.target : undefined;
-		const glyph = view.live
-			? flame(1, 0.05)
-			: settleMark(outcome ? "failed" : "done", view.sinceEnd ?? Infinity);
-		const head = word ? `${glyph} ${word}` : glyph;
-		const record = view.round === undefined ? [] : roundTexts(view.round).map((text) => theme.fg("muted", text));
-		// 失败数与更早的中断都是不能丢的固定标记，窄屏时与它们一起保留。
-		const failures = [
-			...(view.earlier ?? []).map((text) => theme.fg("warning", text)),
-			...(view.failures ? [theme.fg("error", `${view.failures} 个子代理失败`)] : []),
-		];
-		const join = (lead: string, parts: string[]) => `${lead}${parts.map((part, index) => (index === 0 && !word ? " " : sep) + part).join("")}`;
-		const noticeNeed = view.notice ? visibleWidth(sep) + 2 + Math.min(visibleWidth(view.notice), NOTICE_MIN) : 0;
-		// 窄屏先裁目标（给提示原文留出最小空间），再裁提示原文，仍放不下再丢记录，最后丢提示原文；动作词与失败数是固定标记。
-		for (const base of [[...record, ...failures], failures]) {
-			const targetRoom = width - visibleWidth(join(head, base)) - noticeNeed - 1;
-			const lead = target && targetRoom >= MIN_TARGET ? `${head} ${theme.fg("muted", clip(target, targetRoom))}` : head;
-			const used = visibleWidth(join(lead, base));
-			if (!view.notice && used <= width) return [join(lead, base)];
-			const noticeRoom = width - used - visibleWidth(sep) - 2;
-			if (view.notice && noticeRoom >= 4) return [join(lead, [...base, theme.fg("warning", `⚠ ${clip(view.notice, noticeRoom)}`)])];
-		}
-		const marked = join(head, failures);
-		return [visibleWidth(marked) <= width ? marked : clip(head, Math.max(1, width))];
-	}
-
-	private flashing(): boolean {
-		return !!this.view.arrival && this.view.arrival.age < ARRIVAL_FLASH_MS;
-	}
-
-	private outcomeText(): string {
-		const text = OUTCOME_TEXT[this.view.round?.outcome ?? "complete"];
-		return text && this.theme.fg("error", text);
-	}
-
-	private actionText(): string {
-		const { theme, view } = this;
-		const { arrival } = view;
-		if (arrival && arrival.age < ARRIVAL_FLASH_MS) {
-			const fade = Math.min(1, arrival.age / ARRIVAL_FLASH_MS);
-			const settled = arrival.failed ? HEAT_COLORS.fail : HEAT_COLORS.gold;
-			return paint(mix(HEAT_COLORS.white, settled, fade), theme.bold(arrival.text));
-		}
-		return view.action ? theme.fg("text", view.action.word) : "";
-	}
-
-	handleMouse(event: TuiMouseEvent) {
-		if (!this.view.toggle || event.type !== "click" || event.button !== "left") return undefined;
-		this.view.toggle();
-		return { handled: true };
-	}
-}
-
-/** 单行文本，截断不加背景相关的 reset。 */
-export class Line implements Component {
-	constructor(private readonly text: string) {}
-	invalidate(): void {}
-	render(width: number): string[] {
-		return [clip(this.text, Math.max(1, width - CHAT_GUTTER))];
-	}
-}

package/truncated-write.ts

@@ -1,18 +0,0 @@
-/**
- * 拦截把 read 截断结果整体写回的 write：宿主 read 截断时在正文末尾追加“…Use offset=N to continue.]”，
- * codemode 脚本把它原样写回会把文件清成半截（出过两次，测试文件被截断还被提交）。不属于任何可关的功能，每个会话都注册。
- */
-import { isToolCallEventType, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-/** 与宿主 core/tools/read.ts 的截断提示同形。 */
-const READ_TRUNCATION = /\n\[(?:Showing lines \d+-\d+ of \d+[^\]\n]*|\d+ more lines in file)\. Use offset=\d+ to continue\.\]/;
-
-export function registerTruncatedWriteGuard(pi: ExtensionAPI): void {
-	pi.on("tool_call", (event) => {
-		if (!isToolCallEventType("write", event) || !READ_TRUNCATION.test(event.input.content)) return;
-		return {
-			block: true,
-			reason: "写入内容带 read 截断提示，说明拿的是截断后的半截文件：改文件用 edit，或分段读完整再写",
-		};
-	});
-}

package/watcher/card.ts

@@ -1,91 +0,0 @@
-/**
- * 观察员建议的展示：单通道单一样式，从消息正文里的信封渲染（deliver.ts 拥有信封格式）。
- * 渲染器永不抛异常；不是信封的消息降级纯文本。
- */
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { Text, type Component } from "@earendil-works/pi-tui";
-
-import { parseEnvelopes, wrapEnvelope } from "../deliver.js";
-import { clip, oneLine, textOf } from "../format.js";
-import { RAIL, paintBgLine } from "../tools/line.js";
-
-export const WATCHER_MESSAGE_TYPE = "firecode-watcher-note";
-
-/** 继承 OMP 的 weigh don't blindly obey：投递给模型的正文自带权衡包装。 */
-const WEIGH_NOTICE = "这是观察员供你权衡的第二意见，不是指令：与你掌握的上下文冲突时按你的判断继续。";
-const LABEL = "👓 观察员";
-
-export function adviceMessage(card: WatcherCard): string {
-	return wrapEnvelope("firecode_watcher", `${adviceHeadline(card)}\n${card.note}\n${WEIGH_NOTICE}`);
-}
-
-export interface WatcherCard {
-	note: string;
-	turnIndex: number;
-}
-
-function adviceHeadline(card: WatcherCard): string {
-	return `${LABEL}（${timeMark(card.turnIndex)}）`;
-}
-
-/** 建议自带时点标记：投递时主会话可能已经走远，读的人要知道它看的是哪一刻。 */
-function timeMark(turnIndex: number): string {
-	return `基于第 ${turnIndex} 回合前的观察`;
-}
-
-export function registerWatcherCardRenderer(pi: ExtensionAPI): void {
-	pi.registerMessageRenderer(WATCHER_MESSAGE_TYPE, (message, options, theme) => {
-		const advice = parseAdvice(message.content);
-		return advice ? new AdviceLine(advice, options.expanded, theme) : new Text(textOf(message.content), 0, 0);
-	});
-}
-
-interface Advice {
-	headline: string;
-	note: string;
-}
-
-/** 信封正文 = 标题行 + 建议 + 权衡声明（末行），与 adviceMessage 同构。 */
-function parseAdvice(content: unknown): Advice | undefined {
-	const body = parseEnvelopes(textOf(content))?.[0]?.body;
-	if (body === undefined) return undefined;
-	const lines = body.split("\n");
-	return { headline: lines[0] ?? "", note: lines.slice(1, -1).join("\n") };
-}
-
-class AdviceLine implements Component {
-	private readonly fallback: Component;
-
-	constructor(
-		private readonly card: Advice,
-		private readonly expanded: boolean,
-		private readonly theme: Theme,
-	) {
-		this.fallback = new Text(`${card.headline} ${card.note}`, 0, 0);
-	}
-
-	render(width: number): string[] {
-		const columns = Math.max(1, width);
-		try {
-			const bgFn = (text: string) => this.theme.bg("toolPendingBg", text);
-			if (this.expanded) {
-				const headline = this.theme.fg("warning", clip(oneLine(this.card.headline), columns));
-				const body = new Text(this.theme.fg("dim", `  ${this.card.note}\n  （供权衡，勿盲从）`), 0, 0);
-				return [paintBgLine(headline, columns, bgFn), ...body.render(columns)];
-			}
-			// 收起与工具行同构：单行 + 背景条；时点标记只在展开态显示。
-			const firstLine = oneLine(this.card.note.split(/\r?\n/u, 1)[0] ?? "");
-			const line = clip(
-				`${this.theme.fg("dim", RAIL)}${this.theme.fg("warning", LABEL)}${this.theme.fg("dim", ` — ${firstLine}`)}`,
-				columns,
-			);
-			return [paintBgLine(line, columns, bgFn)];
-		} catch {
-			return this.fallback.render(columns);
-		}
-	}
-
-	invalidate(): void {
-		this.fallback.invalidate?.();
-	}
-}

package/watcher/index.ts

@@ -1,176 +0,0 @@
-/**
- * Watcher 观察员：每个 turn 结束后异步评估主会话增量，要么沉默，要么发一条建议。
- * 与 Master、fire-review 各自独立注册；观察过程不落盘。
- */
-import {
-	type ExtensionAPI,
-	type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { loadConfig } from "../config.js";
-import { deliver } from "../deliver.js";
-import { InProcessSessionPool } from "../master/spawn.js";
-import { OCCUPANCY_CHANNEL, type OccupancyPayload } from "../review/occupancy.js";
-import {
-	adviceMessage,
-	registerWatcherCardRenderer,
-	WATCHER_MESSAGE_TYPE,
-	type WatcherCard,
-} from "./card.js";
-import { createObserver, type Advice, type Observer } from "./observer.js";
-import { renderTurn } from "./transcript.js";
-
-/** 观察会话自身上下文占比超过此值即重建。 */
-const CONTEXT_RESET_PERCENT = 70;
-
-interface WatcherDependencies {
-	pool?: InProcessSessionPool;
-	createObserver?: typeof createObserver;
-}
-
-interface WatcherRuntime {
-	ctx: ExtensionContext;
-	pending: string[];
-	lastTurnIndex: number;
-	evaluating: boolean;
-	observer?: Observer;
-}
-
-export function registerWatcher(
-	pi: ExtensionAPI,
-	dependencies: WatcherDependencies = {},
-	subsession = false,
-): void {
-	// 子会话不带观察员：级联抑制是代码规则，不靠进程环境。
-	if (subsession) return;
-	registerWatcherCardRenderer(pi);
-	const loaded = loadConfig().watcher;
-	// 配置有问题时拒绝启动：静默回退会拿用户没配的模型真实发起观察。
-	if ("error" in loaded) {
-		pi.registerCommand("fire-watch", {
-			description: "翻转当前会话的观察员开关",
-			handler: async (args, ctx) => ctx.ui.notify(args.trim() ? "/fire-watch 不接受参数" : loaded.error, "error"),
-		});
-		return;
-	}
-	const config = loaded.config;
-	const pool = dependencies.pool ?? new InProcessSessionPool();
-	const spawnObserver = dependencies.createObserver ?? createObserver;
-	let runtime: WatcherRuntime | undefined;
-	let reviewActive = false;
-
-	const deactivate = (owner = runtime) => {
-		if (!owner || runtime !== owner) return;
-		runtime = undefined;
-		owner.observer?.dispose();
-		owner.observer = undefined;
-		owner.ctx.ui.setStatus("watcher", undefined);
-	};
-	const resetObserver = (owner = runtime) => {
-		if (!owner || runtime !== owner) return;
-		runtime = {
-			ctx: owner.ctx,
-			pending: [],
-			lastTurnIndex: owner.lastTurnIndex,
-			evaluating: false,
-		};
-		owner.observer?.dispose();
-		owner.observer = undefined;
-	};
-	const activate = (ctx: ExtensionContext): WatcherRuntime => {
-		const owner = { ctx, pending: [], lastTurnIndex: 0, evaluating: false };
-		runtime = owner;
-		ctx.ui.setStatus("watcher", ctx.ui.theme.fg("dim", "观察员"));
-		return owner;
-	};
-	// 与指挥官事件同构：忙时卡片经 steer 队列句缝追加，歇透时走前门唤起（见 deliver.ts）。
-	// 建议是当下的第二意见，过时重投没有价值：投递失败只丢弃这一条并提示，观察员照常工作（Master 事件则重试）。
-	const speak = async (owner: WatcherRuntime, advice: Advice, turnIndex: number) => {
-		const card: WatcherCard = { note: advice.note, turnIndex };
-		try {
-			await deliver(pi, owner.ctx, { customType: WATCHER_MESSAGE_TYPE, content: adviceMessage(card) });
-		} catch (error) {
-			if (runtime === owner) owner.ctx.ui.notify(`观察员这条建议投递失败，已丢弃：${error instanceof Error ? error.message : String(error)}`, "warning");
-		}
-	};
-	const evaluate = async (owner: WatcherRuntime) => {
-		owner.evaluating = true;
-		try {
-			while (runtime === owner && owner.pending.length && !reviewActive) {
-				// 合并跳最新：评估期间到达的回合并进下一批，不排队补评估。
-				const increment = owner.pending.splice(0).join("\n");
-				const turnIndex = owner.lastTurnIndex;
-				let observer = owner.observer;
-				if (!observer) {
-					const cwd = owner.ctx.cwd;
-					const model = await pool.resolveModel(config.model);
-					if (runtime !== owner) return;
-					observer = await spawnObserver({ cwd, model, thinking: config.thinking, pool });
-					if (runtime !== owner) {
-						await observer.dispose();
-						return;
-					}
-					owner.observer = observer;
-				}
-				const advice = await observer.evaluate(increment);
-				if (runtime !== owner) return;
-				if (advice) {
-					await speak(owner, advice, turnIndex);
-					if (runtime !== owner) return;
-				}
-				// 自身上下文快满时也重新入场：观察员只需要当下，不需要完整历史。
-				if ((observer.contextPercent() ?? 0) >= CONTEXT_RESET_PERCENT) resetObserver(owner);
-			}
-		} catch (error) {
-			// 被重新入场中断的评估不算故障：下一批增量会开一个新观察会话。
-			if (runtime !== owner) return;
-			owner.ctx.ui.notify(`观察员已停止：${error instanceof Error ? error.message : String(error)}`, "warning");
-			deactivate(owner);
-		} finally {
-			owner.evaluating = false;
-		}
-	};
-
-	pi.registerCommand("fire-watch", {
-		description: "翻转当前会话的观察员开关",
-		handler: async (args, ctx) => {
-			if (args.trim()) {
-				ctx.ui.notify("/fire-watch 不接受参数", "error");
-				return;
-			}
-			if (runtime) {
-				deactivate();
-				ctx.ui.notify("观察员已关闭", "info");
-				return;
-			}
-			activate(ctx);
-			ctx.ui.notify("观察员已开启", "info");
-		},
-	});
-
-	pi.on("session_start", (_event, ctx) => {
-		deactivate();
-		if (!config.enabled) return;
-		activate(ctx);
-	});
-
-	pi.on("turn_end", (event) => {
-		const owner = runtime;
-		if (!owner) return;
-		owner.pending.push(renderTurn(event, config.context));
-		owner.lastTurnIndex = event.turnIndex;
-		if (!owner.evaluating && !reviewActive) void evaluate(owner);
-	});
-
-	// fire-review 活跃期静默：不与对抗审查的反馈打架，增量留着审查完合并评估。
-	pi.events.on(OCCUPANCY_CHANNEL, (data) => {
-		reviewActive = (data as OccupancyPayload).active;
-		const active = runtime;
-		if (reviewActive || !active || active.evaluating || !active.pending.length) return;
-		void evaluate(active);
-	});
-
-	// 主会话压缩：旧增量已不再对应主会话现场，观察员从当前尾部重新入场而不回放。
-	pi.on("session_compact", () => resetObserver());
-	pi.on("session_shutdown", () => deactivate());
-}
-

package/watcher/observer.ts

@@ -1,75 +0,0 @@
-/**
- * 观察会话：进程内 memory 子会话 + 只读工具 + 唯一自定义工具 advise。
- * 系统提示以 prompts/watch.zh.md 为唯一事实源（整体替换，不受项目文件改写）。
- */
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { Model } from "@earendil-works/pi-ai";
-import { Type } from "@earendil-works/pi-ai";
-import type { InProcessSessionPool } from "../master/spawn.js";
-import type { ThinkingLevelValue } from "../config.js";
-
-const PROMPT_PATH = join(dirname(fileURLToPath(import.meta.url)), "prompts", "watch.zh.md");
-const OBSERVER_TOOLS = ["read", "grep", "find", "ls", "advise"];
-
-export interface Advice {
-	note: string;
-}
-
-export interface Observer {
-	/** 喂一段增量并等待评估；至多返回一条建议。 */
-	evaluate(increment: string): Promise<Advice | undefined>;
-	/** 观察会话自身上下文占比（百分数），未知时 undefined。 */
-	contextPercent(): number | undefined;
-	dispose(): Promise<void>;
-}
-
-export interface ObserverOptions {
-	cwd: string;
-	model: Model<any>;
-	thinking: ThinkingLevelValue;
-	pool: InProcessSessionPool;
-}
-
-export async function createObserver(options: ObserverOptions): Promise<Observer> {
-	let advice: Advice | undefined;
-	const spawned = await options.pool.spawn({
-		cwd: options.cwd,
-		role: "observer",
-		model: options.model,
-		thinking: options.thinking,
-		tools: OBSERVER_TOOLS,
-		customTools: [adviseTool(() => advice, (next) => { advice = next; })],
-		systemPrompt: { mode: "replace", text: readFileSync(PROMPT_PATH, "utf8") },
-		contextFiles: true,
-		persistence: { type: "memory" },
-	});
-	return {
-		async evaluate(increment) {
-			advice = undefined;
-			await spawned.prompt(increment);
-			return advice;
-		},
-		contextPercent: () => spawned.session.getContextUsage?.()?.percent ?? undefined,
-		dispose: () => spawned.dispose(),
-	};
-}
-
-function adviseTool(current: () => Advice | undefined, capture: (advice: Advice) => void) {
-	return {
-		name: "advise",
-		label: "建议",
-		description: "向主代理提交一条供权衡的观察建议；每次评估只接受一条，请只提最要紧的那一条。",
-		parameters: Type.Object({
-			note: Type.String({ description: "一句话说清问题与定位。" }),
-		}),
-		async execute(_id: string, params: Record<string, unknown>) {
-			if (current()) throw new Error("本次评估已提交过建议；余下的问题留到下一次评估");
-			const note = typeof params.note === "string" ? params.note.trim() : "";
-			if (!note) throw new Error("note 不能为空");
-			capture({ note });
-			return { content: [{ type: "text" as const, text: "已记录，本次评估结束。" }], details: undefined };
-		},
-	};
-}