@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

package/src/execution/__tests__/notifier-flush.test.ts

@@ -49,7 +49,7 @@ describe("BgNotifier.flushPendingNotifications — deliverAs 契约", () => {
 	it("flush 时调 sendMessage 的 options.deliverAs === 'steer'（FR-3/AC-3）", () => {
 		notifier.notify({
 			id: "bg-test-1",
-			status: "done",
+			status: "closed",
 			agent: "explorer",
 			result: "done",
 			startedAt: Date.now() - 1000,
@@ -65,7 +65,7 @@ describe("BgNotifier.flushPendingNotifications — deliverAs 契约", () => {
 	it("flush 时 triggerTurn 也必须为 true（让父 agent 立即唤醒）", () => {
 		notifier.notify({
 			id: "bg-test-2",
-			status: "failed",
+			status: "closed",
 			agent: "worker",
 			error: "boom",
 			startedAt: Date.now(),
@@ -100,7 +100,7 @@ describe("BgNotifier — isIdle gate 竞态修复", () => {
 		host.isIdle.mockReturnValue(false);
 		notifier.notify({
 			id: "bg-race-1",
-			status: "done",
+			status: "closed",
 			agent: "worker",
 			result: "ok",
 			startedAt: Date.now(),
@@ -131,7 +131,7 @@ describe("BgNotifier — isIdle gate 竞态修复", () => {
 		host.isIdle.mockReturnValue(false);
 		notifier.notify({
 			id: "bg-starve-1",
-			status: "done",
+			status: "closed",
 			agent: "worker",
 			result: "ok",
 			startedAt: Date.now(),
@@ -155,7 +155,7 @@ describe("BgNotifier — isIdle gate 竞态修复", () => {
 		const legacyNotifier = new BgNotifier(legacyHost);
 		legacyNotifier.notify({
 			id: "bg-legacy-1",
-			status: "done",
+			status: "closed",
 			agent: "worker",
 			result: "ok",
 			startedAt: Date.now(),
@@ -171,7 +171,7 @@ describe("BgNotifier — isIdle gate 竞态修复", () => {
 		host.isIdle.mockReturnValue(false);
 		notifier.notify({
 			id: "bg-dispose-1",
-			status: "done",
+			status: "closed",
 			agent: "worker",
 			result: "ok",
 			startedAt: Date.now(),
@@ -183,4 +183,206 @@ describe("BgNotifier — isIdle gate 竞态修复", () => {
 		vi.advanceTimersByTime(10_000);
 		expect(host.sendMessageCalls).toHaveLength(0);
 	});
-});
+});
+
+describe("BgNotifier dedup 按轮次（G1 决策 9：对话模式豁免 60s dedup）", () => {
+	let host: ReturnType<typeof makeMockHost>;
+	let notifier: BgNotifier;
+
+	beforeEach(() => {
+		host = makeMockHost();
+		// hasRunningBackground=false → notify 立即 flush（不排队）；dedup 仍在 push 前生效
+		notifier = new BgNotifier(host);
+	});
+
+	afterEach(() => {
+		notifier.dispose();
+	});
+
+	it("对话模式：同 id 不同 round 的两次 notify 不互相吞（round 参与 dedup key）", () => {
+		notifier.notify({
+			id: "sa-chat", status: "idle", agent: "w", round: 1, result: "round1",
+			startedAt: 1, endedAt: 2,
+		});
+		notifier.notify({
+			id: "sa-chat", status: "idle", agent: "w", round: 2, result: "round2",
+			startedAt: 3, endedAt: 4,
+		});
+
+		// MF-1 修复：dedup key=id:round，不同 round 不互相吞
+		expect(host.sendMessageCalls).toHaveLength(2);
+	});
+
+	it("同 id 同 round 60s 内第二次被 dedup 吞（防重复通知）", () => {
+		notifier.notify({
+			id: "sa-dup", status: "idle", agent: "w", round: 1, result: "r",
+			startedAt: 1, endedAt: 2,
+		});
+		notifier.notify({
+			id: "sa-dup", status: "idle", agent: "w", round: 1, result: "r",
+			startedAt: 3, endedAt: 4,
+		});
+
+		// 第二条被吞（dedup key=sa-dup:1 命中）
+		expect(host.sendMessageCalls).toHaveLength(1);
+	});
+
+	it("非 chatMode（round undefined → key=id:0）行为同旧（向后兼容，60s 内同 id 吞）", () => {
+		// round undefined → dedup key="sa-once:0"，与旧 record.id 单 key 行为一致
+		notifier.notify({
+			id: "sa-once", status: "closed", agent: "w", result: "done",
+			startedAt: 1, endedAt: 2,
+		});
+		notifier.notify({
+			id: "sa-once", status: "closed", agent: "w", result: "done",
+			startedAt: 3, endedAt: 4,
+		});
+
+		// 第二条被吞（旧 dedup 行为不变，一次性模式回归）
+		expect(host.sendMessageCalls).toHaveLength(1);
+	});
+});
+
+describe("BgNotifier buildLlmContent 指针行（wave2：chatMode sessionFile 透传）", () => {
+	let host: ReturnType<typeof makeMockHost>;
+	let notifier: BgNotifier;
+
+	beforeEach(() => {
+		host = makeMockHost();
+		// hasRunningBackground=false → notify 立即 flush，sendMessageCalls 恰 1 条
+		notifier = new BgNotifier(host);
+	});
+
+	afterEach(() => {
+		notifier.dispose();
+	});
+
+	/** 取唯一一条已发消息的 content（前置断言恰 1 条）。 */
+	function sentContent(): string {
+		expect(host.sendMessageCalls).toHaveLength(1);
+		return (host.sendMessageCalls[0]!.message as { content: string }).content;
+	}
+
+	it("running（轮次通知）+ sessionFile → 末尾追加 \\n\\n 空行分隔的指针行", () => {
+		notifier.notify({
+			id: "sa-ptr-1", status: "running", agent: "w", round: 1, result: "round1 text",
+			sessionFile: "/tmp/sessions/child-1.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		expect(sentContent()).toBe(
+			'Subagent "w" (sa-ptr-1) finished a round. Reply:\nround1 text' +
+			"\n\nFull transcript: /tmp/sessions/child-1.jsonl",
+		);
+	});
+
+	it("closed 成功文案 + sessionFile → 指针行追加在最终串末尾", () => {
+		notifier.notify({
+			id: "sa-ptr-2", status: "closed", agent: "w", result: "final result",
+			sessionFile: "/tmp/sessions/child-2.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		expect(sentContent()).toBe(
+			'Subagent "w" (sa-ptr-2) completed. Result:\nfinal result' +
+			"\n\nFull transcript: /tmp/sessions/child-2.jsonl",
+		);
+	});
+
+	it("closed + patchFile + sessionFile → 指针行追加在 patch 提示串末尾（最终串）", () => {
+		notifier.notify({
+			id: "sa-ptr-3", status: "closed", agent: "w", result: "did work",
+			patchFile: "/tmp/patches/sa-ptr-3.patch",
+			sessionFile: "/tmp/sessions/child-3.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		const content = sentContent();
+		expect(content).toContain("git apply /tmp/patches/sa-ptr-3.patch");
+		expect(content.endsWith("\n\nFull transcript: /tmp/sessions/child-3.jsonl")).toBe(true);
+	});
+
+	it("sessionFile 缺失 → 省略整行（running 通知正文与无指针形态逐字节一致）", () => {
+		notifier.notify({
+			id: "sa-ptr-4", status: "running", agent: "w", round: 2, result: "round2 text",
+			startedAt: 1, endedAt: 2,
+		});
+
+		expect(sentContent()).toBe('Subagent "w" (sa-ptr-4) finished a round. Reply:\nround2 text');
+	});
+
+	it("cancelled → 不追加指针行（即使 sessionFile 有值）", () => {
+		notifier.notify({
+			id: "sa-ptr-5", status: "closed", closedReason: "cancelled", agent: "w",
+			sessionFile: "/tmp/sessions/child-5.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		expect(sentContent()).toBe('Subagent "w" (sa-ptr-5) cancelled.');
+	});
+
+	it("gc-failed（closed + closedReason=gc + error 有值）→ 不追加指针行", () => {
+		notifier.notify({
+			id: "sa-ptr-6", status: "closed", closedReason: "gc", agent: "w",
+			error: "spawn EPIPE",
+			sessionFile: "/tmp/sessions/child-6.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		expect(sentContent()).toBe('Subagent "w" (sa-ptr-6) failed: spawn EPIPE');
+	});
+
+	it("[review 修复] gc-failed + patchFile 并存 → failed 文案优先（失败轮也会写 patchFile，patch 提示不可达）", () => {
+		// 回归锚定：doFinalizeRecord Step 0 对 worktreeHandle 无条件 collectPatch，gc 失败 +
+		// worktree 并存时 patchFile 有值。判定顺序必须与 deriveClosedDisplay / renderRecordLines
+		// 同构（cancelled → gc+error → patch/result），否则 LLM 被告知 completed 掩盖失败。
+		notifier.notify({
+			id: "sa-ptr-8", status: "closed", closedReason: "gc", agent: "w",
+			error: "spawn EPIPE",
+			patchFile: "/tmp/patches/sa-ptr-8.patch",
+			sessionFile: "/tmp/sessions/child-8.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		expect(sentContent()).toBe('Subagent "w" (sa-ptr-8) failed: spawn EPIPE');
+	});
+
+	it("one-shot（sessionFile 未透传 → undefined）→ closed 通知与改造前逐字节一致（基线常量锚定）", () => {
+		notifier.notify({
+			id: "sa-ptr-7", status: "closed", agent: "worker", result: "done",
+			startedAt: 1, endedAt: 2,
+		});
+
+		// 改造前形态：sessionFile undefined 时指针为空串，追加不改变输出——逐字节锁定
+		expect(sentContent()).toBe('Subagent "worker" (sa-ptr-7) completed. Result:\ndone');
+	});
+
+	it("[C-2] closed + totalRounds（chatMode close 终态通知）→ 文案附轮次统计 after N rounds", () => {
+		notifier.notify({
+			id: "sa-rounds-1", status: "closed", agent: "w", totalRounds: 3, result: "",
+			sessionFile: "/tmp/sessions/child-rounds.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		// 设计 D2 路径①：closed 分支文案附轮次统计 + sessionFile 提示；
+		// 路径②正文空串（idle close）形态也走本分支（result 空串非 nullish，不触发 (empty)）
+		expect(sentContent()).toBe(
+			'Subagent "w" (sa-rounds-1) completed after 3 rounds. Result:\n' +
+			"\n\nFull transcript: /tmp/sessions/child-rounds.jsonl",
+		);
+	});
+
+	it("[C-2] 对照：totalRounds 缺失（one-shot 完成通知）→ 无轮次统计，文案逐字节保持 completed. Result:", () => {
+		notifier.notify({
+			id: "sa-rounds-2", status: "closed", agent: "w", result: "done",
+			sessionFile: "/tmp/sessions/child-oneshot.jsonl",
+			startedAt: 1, endedAt: 2,
+		});
+
+		// one-shot record 无轮次语义（totalRounds 不设置）——G4：文案不含统计
+		expect(sentContent()).toBe(
+			'Subagent "w" (sa-rounds-2) completed. Result:\ndone' +
+			"\n\nFull transcript: /tmp/sessions/child-oneshot.jsonl",
+		);
+	});
+});

package/src/execution/__tests__/one-shot-upgrade.test.ts

@@ -0,0 +1,205 @@
+// src/execution/__tests__/one-shot-upgrade.test.ts
+//
+// SP-5 one-shot upgrade：非 chatMode active record 收到 message 时自动升级 chatMode。
+//
+// 场景：one-shot subagent（conversation=false）完成首轮后 record 仍在内存（running/idle），
+// LLM 调 message 续聊 → messageHandler 检测非 chatMode + active → 置 chatMode=true（upgrade）→
+// 走 deliverMessage 统一路径（热路径或冷路径 resume）。
+//
+// mock 策略：真实 SubagentService + mock runSpawn（受控），getChildByRecord/spawnedChildren
+// 提供真实 Map 语义（deliverMessage 热路径需要 child 存在）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// mock logger
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn(), info: vi.fn() },
+}));
+vi.mock("@zhushanwen/pi-extension-logger", () => ({ getLogger: () => loggerMock }));
+
+// mock session-runner：runSpawn 受控 + killAllSpawnedChildren 空实现；
+// getChildByRecord/spawnedChildren 提供真实 Map 语义。
+vi.mock("../session-runner.ts", () => {
+  const spawnedChildren = new Map<string, unknown>();
+  return {
+    runSpawn: vi.fn(),
+    killAllSpawnedChildren: vi.fn(),
+    spawnedChildren,
+    getChildByRecord: (id: string): unknown => spawnedChildren.get(id),
+  };
+});
+
+import { runSpawn, spawnedChildren } from "../session-runner.ts";
+import type { SessionRunnerContext } from "../session-runner.ts";
+import { createRecord } from "../execution-record.ts";
+import { ModelConfigService } from "../model-config-service.ts";
+import type { ModelInfo } from "../model-resolver.ts";
+import { RecordStore } from "../record-store.ts";
+import { SubagentService } from "../subagent-service.ts";
+import type { PiLike } from "../subagent-service.ts";
+import type { AgentResult, ExecutionRecord } from "../types.ts";
+import { messageHandler } from "../../interface/subagent-actions.ts";
+
+const mockRunSpawn = vi.mocked(runSpawn);
+
+const STUB_MODEL: ModelInfo = { id: "test-model", name: "Test", provider: "test", reasoning: false };
+
+function makeTmpAgentDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "upgrade-test-"));
+}
+
+function makePi(): PiLike & {
+  appendEntry: ReturnType<typeof vi.fn>;
+  events: { emit: ReturnType<typeof vi.fn> };
+  sendMessage: ReturnType<typeof vi.fn>;
+} {
+  return { appendEntry: vi.fn(), events: { emit: vi.fn() }, sendMessage: vi.fn() };
+}
+
+function makeResult(success: boolean): AgentResult {
+  return {
+    text: success ? "done" : "err",
+    turns: 1,
+    durationMs: 100,
+    success,
+    error: success ? undefined : "boom",
+    sessionId: "sess-1",
+    toolCalls: [],
+  };
+}
+
+interface ServiceInternals {
+  store: RecordStore;
+  sessionRootId: string | null;
+}
+
+/** 非 chatMode background record（one-shot 模式）。 */
+function makeOneShotRecord(
+  sessionRootId: string,
+  status: "running" = "running",
+  id = "sa-oneshot",
+): ExecutionRecord {
+  const record = createRecord(id, {
+    agent: "general-purpose",
+    model: "test/test-model",
+    thinkingLevel: "low",
+    mode: "background",
+    task: "one-shot task",
+    slug: "oneshot",
+    startedAt: 1000,
+    rootSessionId: sessionRootId,
+    // chatMode 不传 = undefined = 非 chatMode（one-shot）
+  });
+  record.status = status;
+  record.controller = new AbortController();
+  // v4 B-1：one-shot 完成后 record 为 running（idle 折入 running）+ isResumable（无活进程）。
+  // sessionFile 总设（resumeRound 冷路径校验需要，热路径无害）。
+  record.sessionFile = "/tmp/fake-session.jsonl";
+  record.round = 1;
+  return record;
+}
+
+// ============================================================
+// SP-5 one-shot upgrade
+// ============================================================
+
+describe("SP-5 one-shot upgrade（message → chatMode + 冷 resume）", () => {
+  let agentDir: string;
+  let service: SubagentService;
+  let store: RecordStore;
+  let sessionRootId: string;
+
+  beforeEach(() => {
+    agentDir = makeTmpAgentDir();
+    const modelService = new ModelConfigService({ agentDir });
+    service = new SubagentService({ cwd: agentDir, modelService });
+    service.initSession({ pi: makePi(), sessionId: "root-session" });
+    const internals = service as unknown as ServiceInternals;
+    store = internals.store;
+    sessionRootId = internals.sessionRootId!;
+  });
+
+  afterEach(() => {
+    service.dispose();
+    fs.rmSync(agentDir, { recursive: true, force: true });
+  });
+
+  // TC-1: one-shot done 后 message 触发 upgrade（chatMode=true）
+  // 场景：one-shot running record → message → chatMode 被置 true → deliverMessage 热路径（child 存在）
+  it("TC-1: one-shot running record 收到 message → chatMode 升级为 true", async () => {
+    const record = makeOneShotRecord(sessionRootId, "running");
+    store.register(record);
+
+    // 注册 mock child 让 deliverMessage 走热路径
+    const mockChild = { killed: false, pid: 12345, stdin: { write: vi.fn(() => true) } };
+    spawnedChildren.set(record.id, mockChild as unknown);
+
+    // 验证升级前 chatMode 为 falsy
+    expect(record.chatMode).toBeFalsy();
+
+    await messageHandler(service, { subagentId: record.id, text: "follow-up" });
+
+    // 验证 chatMode 被升级
+    expect(record.chatMode).toBe(true);
+    // 验证 record 仍为 running（deliverMessage 热路径设 running）
+    expect(record.status).toBe("running");
+    // 验证 record 在内存中（非终态，未被 archive）
+    expect(store.getMutable(record.id)).toBeDefined();
+
+    // 清理
+    spawnedChildren.delete(record.id);
+  });
+
+  // TC-2: upgrade 后走冷路径 resume
+  // 场景：one-shot idle record（进程已死）→ message → chatMode=true → deliverMessage 冷路径 → resumeRound
+  it("TC-2: one-shot idle record 收到 message → chatMode 升级 + 冷路径 resume", async () => {
+    // one-shot 完成态 record（running + isResumable）需要 sessionFile（resumeRound 冷路径校验）
+    fs.writeFileSync("/tmp/fake-session.jsonl", "");
+    const record = makeOneShotRecord(sessionRootId);
+    store.register(record);
+
+    // mock runSpawn 返回成功（resume 后的 spawn）
+    mockRunSpawn.mockImplementation(async (_ctx: SessionRunnerContext) => {
+      return makeResult(true);
+    });
+
+    expect(record.chatMode).toBeFalsy();
+
+    await messageHandler(service, { subagentId: record.id, text: "resume message" });
+
+    // 验证 chatMode 被升级
+    expect(record.chatMode).toBe(true);
+    // 验证走了 resumeRound → runSpawn（冷路径）
+    expect(mockRunSpawn).toHaveBeenCalled();
+    // record 被 resumeRound 设为 running，runAndFinalize 完成后保持 running（v4 B-1 idle 折入 running）
+    // 关键是 record 不在终态
+    expect(record.status).not.toBe("closed");
+  });
+
+  // TC-3: upgrade 后 record 可续聊（非终态）
+  // 场景：验证升级后的 record 不会被 finalize 为终态，仍可接受后续 message
+  it("TC-3: upgrade 后 record 可续聊（非终态，仍在内存）", async () => {
+    const record = makeOneShotRecord(sessionRootId);
+    store.register(record);
+
+    // runSpawn 返回成功
+    mockRunSpawn.mockImplementation(async () => makeResult(true));
+
+    await messageHandler(service, { subagentId: record.id, text: "first resume" });
+
+    // chatMode 已升级
+    expect(record.chatMode).toBe(true);
+
+    // 关键验证：record 仍在内存（getMutable 返回非 undefined）——未被 archive 到终态
+    const mutable = store.getMutable(record.id);
+    expect(mutable).toBeDefined();
+    expect(mutable!.chatMode).toBe(true);
+
+    // 验证 status 不是终态（closed 是终态；running 是非终态，v4 B-1 idle 折入 running）
+    expect(record.status).toBe("running");
+  });
+});