@zhushanwen/pi-goal 0.14.9 → 0.14.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-goal",
-  "version": "0.14.9",
+  "version": "0.14.11",
   "description": "Codex-style /goal command for Pi — persistent goal-driven autonomous loop with evidence-based completion, token budget, agent-reported blocking, and steering templates.",
   "type": "module",
   "main": "src/index.ts",
@@ -25,15 +25,16 @@
     "index.ts"
   ],
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.84.4",
-    "@earendil-works/pi-coding-agent": "^0.84.4",
-    "@earendil-works/pi-tui": "^0.84.4",
-    "typebox": "*",
-    "@zhushanwen/pi-pending-notifications": "0.8.0"
+    "@earendil-works/pi-ai": "^1.0.0",
+    "@earendil-works/pi-coding-agent": "^1.0.0",
+    "@earendil-works/pi-tui": "^1.0.0",
+    "typebox": "1.3.27",
+    "@zhushanwen/pi-pending-notifications": "0.8.2"
   },
   "dependencies": {
-    "@zhushanwen/extension-protocol": "0.16.0",
-    "@zhushanwen/pi-extension-logger": "0.6.1"
+    "@zhushanwen/extension-protocol": "0.18.0",
+    "@zhushanwen/pi-extension-logger": "0.6.2",
+    "@zhushanwen/pi-session-path": "0.1.0"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-tui": {

package/src/__tests__/active-path.test.ts

@@ -0,0 +1,226 @@
+/**
+ * U6c：reconstructGoalState 重建接活跃路径裁剪 + session_tree handler 即时重建。
+ *
+ * 从 leafId 沿 parentId 回溯得活跃路径，被撤子树的 goal-state entry 不进重建态
+ * （不得经 before_agent_start 逐轮注入模型上下文——A14）。
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { describe, expect, it, vi } from "vitest";
+
+import { createGoalState } from "../engine/goal";
+import { ENTRY_TYPE, serializeState } from "../persistence";
+import type { SessionEntryLike } from "../ports";
+import goalExtension from "../index";
+import {
+	createGoalSession,
+	reconstructGoalState,
+	type ActivePathSessionView,
+} from "../session";
+
+// ── fixture ─────────────────────────────────────────
+
+interface BranchEntry {
+	id: string;
+	parentId: string | null;
+	type: string;
+	customType?: string;
+	data?: unknown;
+}
+
+/** goal-state 快照 entry（append-only 全量快照，reconstruct 只读活跃路径内最新一条） */
+function goalStateEntry(id: string, parentId: string | null, objective: string): BranchEntry {
+	return {
+		type: "custom",
+		id,
+		parentId,
+		customType: ENTRY_TYPE,
+		data: serializeState(createGoalState(objective)),
+	};
+}
+
+/** 撤回后真实形态：label entry 落文件尾（parentId = 回退后叶子），leafId 指向它 */
+function labelEntry(id: string, parentId: string | null): BranchEntry {
+	return { type: "label", id, parentId, targetId: "u-x", label: "taiji:revoked" };
+}
+
+function makeView(entries: SessionEntryLike[], leafId: string | null): ActivePathSessionView {
+	return {
+		// 模拟 Pi SDK filter-copy 语义：返回新数组
+		getEntries: () => entries.slice(),
+		getLeafId: () => leafId,
+	};
+}
+
+// ── reconstructGoalState 活跃路径裁剪（U6c）──────────
+
+describe("reconstructGoalState 活跃路径裁剪（U6c）", () => {
+	it("有分支 fixture：被撤子树的 goal-state 不进重建态——取活跃路径内最新一条", () => {
+		// 树：e1(goal base) → e2(goal active-branch)；e1 → e3(goal revoked-branch，
+		// 物理后写 = 被撤子树)；撤回落 label 锚 L（parentId = 回退后叶子 e2），
+		// leafId = L → 活跃路径 {L, e2, e1}
+		const entries = [
+			goalStateEntry("e1", null, "base"),
+			goalStateEntry("e2", "e1", "active-branch"),
+			goalStateEntry("e3", "e1", "revoked-branch"),
+			labelEntry("L", "e2"),
+		];
+
+		const session = createGoalSession();
+		reconstructGoalState(session, makeView(entries, "L"));
+
+		expect(session.state).not.toBeNull();
+		expect(session.state!.objective).toBe("active-branch");
+		// 反向断言：被撤子树快照不进重建态（物理位置在 e2 之后，无裁剪时会命中）
+		expect(session.state!.objective).not.toBe("revoked-branch");
+	});
+
+	it("活跃路径内无 goal-state（撤回点早于 goal 创建）→ state=null，不回退到旧分支快照", () => {
+		const entries: BranchEntry[] = [
+			{ type: "custom", id: "e1", parentId: null, customType: "other-ext", data: {} },
+			goalStateEntry("e2", "e1", "only-on-revoked-branch"),
+			labelEntry("L", "e1"),
+		];
+
+		const session = createGoalSession();
+		reconstructGoalState(session, makeView(entries, "L"));
+
+		expect(session.state).toBeNull();
+	});
+
+	it("无分支回归：leafId = 文件尾 → 恢复最新一条（现行为不变）", () => {
+		const entries = [goalStateEntry("e1", null, "old"), goalStateEntry("e2", "e1", "new")];
+
+		const session = createGoalSession();
+		reconstructGoalState(session, makeView(entries, "e2"));
+
+		expect(session.state!.objective).toBe("new");
+	});
+
+	it("legacy fixture 回归：entry 无 id/parentId（duck-typed 最小形状）→ 线性全量，行为与裁剪前一致", () => {
+		const entries: SessionEntryLike[] = [
+			{ type: "custom", customType: ENTRY_TYPE, data: serializeState(createGoalState("legacy-old")) },
+			{ type: "custom", customType: ENTRY_TYPE, data: serializeState(createGoalState("legacy-new")) },
+		];
+
+		const session = createGoalSession();
+		reconstructGoalState(session, { getEntries: () => entries.slice() });
+
+		expect(session.state!.objective).toBe("legacy-new");
+	});
+
+	it("leafId 防御：null / 指向不存在 entry → 回退文件尾（不静默清空重建态）", () => {
+		const entries = [goalStateEntry("e1", null, "first"), goalStateEntry("e2", "e1", "tail-snapshot")];
+
+		for (const leafId of [null, "missing-id"]) {
+			const session = createGoalSession();
+			reconstructGoalState(session, makeView(entries, leafId));
+			expect(session.state!.objective).toBe("tail-snapshot");
+		}
+	});
+});
+
+// ── session_tree handler（U6c：即时重建，纯重建体）──
+
+interface HandlerFixture {
+	handlers: Map<string, (event: unknown, ctx: ExtensionContext) => Promise<unknown>>;
+	sendMessage: ReturnType<typeof vi.fn>;
+	appendEntry: ReturnType<typeof vi.fn>;
+}
+
+/** 实例化 goal 工厂并捕获事件 handler（最小 pi：注册面 vi.fn + 副作用面 vi.fn） */
+function makeHandlerFixture(): HandlerFixture {
+	const handlers = new Map<string, (event: unknown, ctx: ExtensionContext) => Promise<unknown>>();
+	const pi = {
+		registerCommand: vi.fn(),
+		registerTool: vi.fn(),
+		on: vi.fn((event: string, handler: (event: unknown, ctx: ExtensionContext) => Promise<unknown>) => {
+			// 真实 pi 的 on 是 handler 列表追加；此处每事件单 handler（goal 工厂每事件只注册一次）
+			handlers.set(event, handler);
+		}),
+		registerMessageRenderer: vi.fn(),
+		sendMessage: vi.fn(),
+		appendEntry: vi.fn(),
+	} as unknown as ExtensionAPI;
+	goalExtension(pi);
+	return { handlers, sendMessage: pi.sendMessage, appendEntry: pi.appendEntry };
+}
+
+/** 最小 ctx：sessionManager（分支树）+ ui 记录面 + getContextUsage（before_agent_start 用） */
+function makeCtx(entries: SessionEntryLike[], leafId: string | null) {
+	const setWidget = vi.fn();
+	const setStatus = vi.fn();
+	const ctx = {
+		hasUI: true,
+		getContextUsage: () => null,
+		ui: {
+			notify: vi.fn(),
+			setStatus,
+			setWidget,
+			theme: { fg: (_c: string, t: string) => t, bold: (t: string) => t },
+		},
+		sessionManager: {
+			getEntries: () => entries.slice(),
+			getLeafId: () => leafId,
+		},
+	} as unknown as ExtensionContext;
+	return { ctx, setWidget, setStatus };
+}
+
+describe("session_tree handler 即时重建（U6c）", () => {
+	it("触发 session_tree → 内存态重建为活跃路径态 + widget 刷新；handler 本身零注入零落盘", async () => {
+		const { handlers, sendMessage, appendEntry } = makeHandlerFixture();
+		const entries = [
+			goalStateEntry("e1", null, "base"),
+			goalStateEntry("e2", "e1", "active-branch"),
+			goalStateEntry("e3", "e1", "revoked-branch"),
+			labelEntry("L", "e2"),
+		];
+		const { ctx, setWidget } = makeCtx(entries, "L");
+
+		expect(handlers.has("session_tree")).toBe(true);
+		await handlers.get("session_tree")!({ type: "session_tree" }, ctx);
+
+		// 纯重建断言：handler 不注入消息（撤回编排自己不得发消息）、不落盘（不污染新分支文件尾）
+		expect(sendMessage).not.toHaveBeenCalled();
+		expect(appendEntry).not.toHaveBeenCalled();
+		// widget 反映活跃路径态（mock ctx 无 mode → setWidgetDual 走 TUI 臂，直接推 text 行）
+		const lines = setWidget.mock.calls.find(([name]) => name === "goal")?.[1] as string[] | undefined;
+		expect(lines?.join(" ")).toContain("active-branch");
+		expect(lines?.join(" ")).not.toContain("revoked-branch");
+	});
+
+	it("撤回点早于 goal 创建 → 重建态 null，widget 清除（live 态无残影，A14）", async () => {
+		const { handlers } = makeHandlerFixture();
+		const entries: BranchEntry[] = [
+			{ type: "custom", id: "e1", parentId: null, customType: "other-ext", data: {} },
+			goalStateEntry("e2", "e1", "only-on-revoked-branch"),
+			labelEntry("L", "e1"),
+		];
+		const { ctx, setWidget } = makeCtx(entries, "L");
+
+		await handlers.get("session_tree")!({ type: "session_tree" }, ctx);
+
+		expect(setWidget).toHaveBeenCalledWith("goal", undefined);
+	});
+
+	it("session_tree 重建后的内存态驱动 before_agent_start：下一轮注入不含被撤 goal", async () => {
+		const { handlers, appendEntry } = makeHandlerFixture();
+		const entries = [
+			goalStateEntry("e1", null, "active-branch"),
+			goalStateEntry("e2", "e1", "revoked-branch"),
+			labelEntry("L", "e1"),
+		];
+		const { ctx } = makeCtx(entries, "L");
+
+		await handlers.get("session_tree")!({ type: "session_tree" }, ctx);
+		// before_agent_start 读内存态不重算（现状契约）——新鲜度由 session_tree 重建保证
+		const result = (await handlers.get("before_agent_start")!({}, ctx)) as
+			| { message: { content: string } }
+			| undefined;
+
+		expect(result?.message?.content).toContain("active-branch");
+		expect(result?.message?.content).not.toContain("revoked-branch");
+		// before_agent_start 自身的 goal:log 落盘是该事件既有行为，不算 session_tree 副作用
+		expect(appendEntry).toHaveBeenCalled();
+	});
+});

package/src/__tests__/message-end.test.ts

@@ -0,0 +1,83 @@
+/**
+ * message_end handler 测试（D13① role 过滤 + FR-6.7 ESC 守卫）。
+ *
+ * 断言面：仅 user/assistant 的 message_end 进入 service 消费；system（pi 1.0
+ * 新形态）/ toolResult / 缺 role 在 handler 层显式拒绝；assistant 正常透传。
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { handleMessageEnd } from "../adapters/event-handlers/message-end";
+import { createGoalState } from "../engine/goal";
+import { applyEvent } from "../service";
+import { createGoalSession } from "../session";
+
+vi.mock("../service", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../service")>();
+	return { ...actual, applyEvent: vi.fn(actual.applyEvent) };
+});
+
+function makeSession(): ReturnType<typeof createGoalSession> {
+	const session = createGoalSession();
+	session.state = createGoalState("obj");
+	return session;
+}
+
+beforeEach(() => {
+	vi.mocked(applyEvent).mockClear();
+});
+
+function ctx(signalAborted = false): Parameters<typeof handleMessageEnd>[1] {
+	return { signal: { aborted: signalAborted } } as unknown as Parameters<typeof handleMessageEnd>[1];
+}
+
+function messageEndEvent(role: unknown): Parameters<typeof handleMessageEnd>[2] {
+	return { type: "message_end", message: { role } } as unknown as Parameters<typeof handleMessageEnd>[2];
+}
+
+describe("handleMessageEnd（D13① role 过滤）", () => {
+	it("assistant：透传 applyEvent（token 累加路径不受过滤影响）", async () => {
+		const session = makeSession();
+		const event = {
+			type: "message_end",
+			message: { role: "assistant", usage: { input: 100, output: 50, cacheRead: 20 } },
+		} as unknown as Parameters<typeof handleMessageEnd>[2];
+		await handleMessageEnd(session, ctx(), event);
+
+		// 加权口径同 service.test.ts：100×1 + 20×0.02 + 50×2 = 200.4
+		expect(session.state?.tokensUsed).toBe(200.4);
+	});
+
+	it("user：进入消费路径（applyEvent 被调；token 累加由 service 层 assistant-only 收窄）", async () => {
+		const session = makeSession();
+		const spy = vi.mocked(applyEvent);
+		await handleMessageEnd(session, ctx(), messageEndEvent("user"));
+
+		expect(spy).toHaveBeenCalledWith(session, "message_end", messageEndEvent("user"));
+	});
+
+	it("system（pi 1.0 新形态）：handler 层拒绝，不进 applyEvent", async () => {
+		const session = makeSession();
+		const spy = vi.mocked(applyEvent);
+		await handleMessageEnd(session, ctx(), messageEndEvent("system"));
+
+		expect(spy).not.toHaveBeenCalled();
+	});
+
+	it("toolResult / 缺 role：同样拒绝", async () => {
+		const session = makeSession();
+		const spy = vi.mocked(applyEvent);
+		await handleMessageEnd(session, ctx(), messageEndEvent("toolResult"));
+		await handleMessageEnd(session, ctx(), {} as Parameters<typeof handleMessageEnd>[2]);
+
+		expect(spy).not.toHaveBeenCalled();
+	});
+
+	it("ESC 守卫先于 role 过滤（aborted 直接返回）", async () => {
+		const session = makeSession();
+		const spy = vi.mocked(applyEvent);
+		await handleMessageEnd(session, ctx(true), messageEndEvent("assistant"));
+
+		expect(spy).not.toHaveBeenCalled();
+	});
+});

package/src/adapters/event-handlers/message-end.ts

@@ -4,6 +4,12 @@
  * FR-6.7 ESC 守卫：ctx.signal.aborted 时跳过 token 累加。
  * FR-8.6: token 累加算法（委托 service.applyEvent("message_end")）。
  *
+ * role 过滤（D13①，rename-session 先例同形态）：仅 user/assistant 的 message_end
+ * 进入消费——pi 1.0 起追加 system 消息（工具集变更高频写入）与嵌套形态，goal 的
+ * 事件消费是对话回合语义，系统/工具结果/扩展形态的 message_end 显式不消费。
+ * （token 累加在 service 层另有 assistant-only 收窄，本层过滤是消费关系显式化，
+ * 不依赖下游巧合兜住。）
+ *
  * 不 persist / updateWidget。
  */
 
@@ -12,6 +18,19 @@ import type { ExtensionContext, MessageEndEvent } from "@earendil-works/pi-codin
 import { applyEvent } from "../../service";
 import type { GoalSession } from "../../session";
 
+/**
+ * 畸形防御读取 message.role（D13①）：pi 事件经 JSON 解析，message 缺失 / 非对象 /
+ * 缺 role 的畸形形态不得崩 handler——一律按「非对话轴形态」拒绝（测试契约：
+ * toolResult / 缺 role / 缺 message 同走拒绝）。typeof + in 收窄替代 as 全可选
+ * 结构断言（后者任何对象都能通过，等于无校验）。
+ */
+function readMessageRole(event: MessageEndEvent): unknown {
+	const message: unknown = event.message;
+	if (typeof message !== "object" || message === null) return undefined;
+	if (!("role" in message)) return undefined;
+	return message.role;
+}
+
 export async function handleMessageEnd(
 	session: GoalSession,
 	ctx: ExtensionContext,
@@ -21,5 +40,9 @@ export async function handleMessageEnd(
 	// FR-6.7 ESC 守卫
 	if (ctx.signal?.aborted) return;
 
+	// D13① role 过滤：仅对话轴两形态（AgentMessage role 域为开放联合，宽比较）
+	const role = readMessageRole(event);
+	if (role !== "user" && role !== "assistant") return;
+
 	applyEvent(session, "message_end", event);
 }

package/src/index.ts

@@ -29,8 +29,9 @@ import { handleSessionStart } from "./adapters/event-handlers/session-start";
 import { handleTurnEnd } from "./adapters/event-handlers/turn-end";
 import { registerGoalControlTool } from "./adapters/goal-control-adapter";
 import { buildPorts } from "./adapters/ports";
+import { updateWidget } from "./projection/widget";
 import { createGoal } from "./service";
-import { createGoalSession, type GoalSession } from "./session";
+import { createGoalSession, reconstructGoalState, type GoalSession } from "./session";
 
 // ── Extension Factory ─────────────────────────────────
 
@@ -88,6 +89,21 @@ export default function goalExtension(pi: ExtensionAPI) {
 		await handleSessionStart(pi, session, ctx);
 	});
 
+	// U6c：树回退（撤回 __taiji_nav__ → navigateTree / 用户树跳转）后即时重建 goal
+	// 内存态——before_agent_start 注入读内存态不重算（现状契约），新鲜度由本 handler
+	// 保证；缺席时运行中撤回后被撤 goal 逐轮注入模型上下文（A14）。
+	// 纯重建体（todo 的 session_tree handler 同款）——只做 reconstruct + widget 刷新，
+	// 绝不加 sendMessage / appendEntry 副作用：本事件由撤回编排触发，注入会让撤回编排
+	// 自己发出消息（违背「被撤内容从未发生」语义），落盘会向回退后的新分支追加 entry
+	// 污染文件尾。
+	// updateWidget 无条件调用（session_start 仅 state 非空时刷新——那是启动期无残留可清；
+	// 此处撤回点早于 goal 创建时重建态为 null，条件刷新会让被撤 goal 的 widget 残留）。
+	pi.on("session_tree", async (_event: unknown, ctx: ExtensionContext) => {
+		const ports = buildPorts(pi, ctx);
+		reconstructGoalState(session, ctx.sessionManager);
+		updateWidget(session, ports.ui);
+	});
+
 	// MF-R2-1 根修：session_shutdown 在 runner invalidate 之前触发（此刻 pi/ctx
 	// 仍可用），取消待发的退避 continuation timer——覆盖 reload / new / resume /
 	// fork / quit 全部失效路径，旧 timer 不再携 stale ctx 闭包存活到到期
@@ -124,7 +140,7 @@ export default function goalExtension(pi: ExtensionAPI) {
 	 *
 	 * 通道形态（C-ext-06 globalThis slot 惯例）：裸函数直挂——plan 侧使用点以 typeof 守卫
 	 * 读取 `globalThis[Symbol.for("@zhushanwen/pi-goal.goalInit")]`（plan/src/compact.ts）。
-	 * 不挂 pi API 对象：pi 0.84.4 为每个扩展创建独立 ExtensionAPI，挂 pi 对象的字段
+	 * 不挂 pi API 对象：pi 为每个扩展创建独立 ExtensionAPI（1.0.0 复核同构），挂 pi 对象的字段
 	 * 跨扩展不可见。
 	 *
 	 * @param objective 目标描述

package/src/session.ts

@@ -2,7 +2,8 @@
  * Session 层 — 运行时句柄 + 状态重建（entry 不做 GC，只读最新一条）
  *
  * GoalSession 是进程内瞬态句柄（不持久化）。
- * reconstructGoalState 从 entry 恢复状态（session_start 时调）。
+ * reconstructGoalState 从 entry 恢复状态（session_start / session_tree 时调，
+ * U6c：重建输入接活跃路径裁剪——被撤子树的 goal-state 不进重建态）。
  *
  * FR-6.4: 删除 hasPendingInjection（僵尸字段）
  * FR-6.7: 删除 pendingPause（ESC 改用 aborted 守卫）
@@ -10,9 +11,11 @@
  * FR-3: 崩溃后保持原状态（active 重启计时；paused/blocked 保持；终态保持）
  */
 
+import { filterActivePath } from "@zhushanwen/pi-session-path";
+
 import type { GoalRuntimeState } from "./engine/types";
 import { deserializeState, ENTRY_TYPE } from "./persistence";
-import type { SessionEntryLike, SessionPort, UiPort } from "./ports";
+import type { SessionEntryLike, UiPort } from "./ports";
 
 // ── 运行时句柄 ────────────────────────────────────────
 
@@ -47,10 +50,28 @@ export function createGoalSession(): GoalSession {
 // 复用价值场景请参照 scheduler 的已验证方案：runtime.ts STALE_CTX_MARKER
 // 'stale after session replacement'（子串匹配真实文案）+ 代际计数治本（G1）。
 
-// ── reconstructGoalState（session_start 时调）──────────
+// ── 活跃路径裁剪（U6c）────────────────────────────────
+
+/**
+ * 活跃路径回溯所需的最小 session 视图（U6c）。getLeafId 可选：SessionPort
+ * （buildPorts 产物）不携带时按文件尾回退——session_start 时点 pi 树重放规则
+ * （叶子 = 文件最后一条 entry）使两锚等价；session_tree handler 传
+ * ctx.sessionManager（含 getLeafId），覆盖运行中树回退后 leaf ≠ 文件尾的形态。
+ */
+export interface ActivePathSessionView {
+	getEntries(): SessionEntryLike[];
+	getLeafId?(): string | null;
+}
+
+// 活跃路径裁剪（leafId 沿 parentId 回溯，撤回后被撤子树的 goal-state entry 不进
+// 重建输入）收敛于 @zhushanwen/pi-session-path 单一实现（四包同构副本收编，防御
+// 语义与回退口径见该包 filterActivePath 注释；runtime 侧 entry-tree-builder 保持
+// 独立——extension 不能 import runtime 包）。
+
+// ── reconstructGoalState（session_start / session_tree 时调）──────────
 
 /**
- * 从 session entries 恢复 goal state。
+ * 从 session entries 恢复 goal state（U6c：重建输入 = 活跃路径投影，非全文件）。
  *
  * Pi SDK 的 session 是 append-only，getEntries() 返回 filter-copy——splice
  * 无法修改真实 entries。Entry GC（goal-state 留 1、goal-history 留 20）在生产
@@ -60,11 +81,11 @@ export function createGoalSession(): GoalSession {
  *   paused/blocked 保持（用户/agent 主动叫停不被抹除），终态保持。
  * FR-8.1 G-024: deserialize throw → state=null（部分损坏全丢）
  */
-export function reconstructGoalState(session: GoalSession, sessionPort: SessionPort): void {
+export function reconstructGoalState(session: GoalSession, sessionPort: ActivePathSessionView): void {
 	session.state = null;
-	const entries = sessionPort.getEntries();
+	const entries = filterActivePath(sessionPort);
 
-	// 找到最新的 goal-state entry（从后往前）
+	// 找到最新的 goal-state entry（活跃路径内从后往前）
 	let latestStateIdx = -1;
 	for (let i = entries.length - 1; i >= 0; i--) {
 		if (isGoalStateEntry(entries[i]!)) {