@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/test/integration/result-watcher.test.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
+import { buildCompletionKey } from "../../src/runs/background/completion-dedupe.ts";
 import { createResultWatcher } from "../../src/runs/background/result-watcher.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 import type { SubagentState } from "../../src/shared/types.ts";
@@ -452,6 +453,7 @@ describe("result watcher", () => {
 					sessionId: "session-1",
 					sessionFile: "/tmp/session.jsonl",
 					asyncDir: "/tmp/async-1",
+					parallelHandoff: { version: 1, path: "/tmp/async-1/handoff.json", groupCount: 1, childCount: 2, changedPatches: 1, cleanupState: "complete" },
 					intercomTarget: "subagent-chat-main",
 				}), "utf-8");
 				watcher.primeExistingResults();
@@ -462,14 +464,79 @@ describe("result watcher", () => {
 
 			const intercomEvents = emitted.filter((entry) => entry.event === "subagent:result-intercom");
 			assert.equal(intercomEvents.length, 1);
-			const eventData = intercomEvents[0]?.data as { message?: string; mode?: string; status?: string };
+			const eventData = intercomEvents[0]?.data as { message?: string; mode?: string; status?: string; parallelHandoff?: { path?: string } };
 			assert.equal(eventData.mode, "parallel");
 			assert.equal(eventData.status, "failed");
+			assert.equal(eventData.parallelHandoff?.path, "/tmp/async-1/handoff.json");
 			const message = String(eventData.message ?? "");
 			assert.match(message, /Revive child: subagent\(\{ action: "resume", id: "async-1", index: 0, message: "\.\.\." \}\)/);
 			assert.ok(message.includes(`Session: ${firstSession}`));
+			assert.match(message, /Parallel handoff: \/tmp\/async-1\/handoff\.json/);
 			assert.equal(message.includes(missingSession), false);
-			assert.equal(emitted.some((entry) => entry.event === "subagent:async-complete"), true);
+			const completion = emitted.find((entry) => entry.event === "subagent:async-complete")?.data as { parallelHandoff?: { path?: string } } | undefined;
+			assert.equal(completion?.parallelHandoff?.path, "/tmp/async-1/handoff.json");
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not mark completed siblings as stopped when the overall async result is stopped", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-stopped-siblings-"));
+		try {
+			const emitted: Array<{ event: string; data: unknown }> = [];
+			const listeners = new Map<string, Set<(payload: unknown) => void>>();
+			const pi = {
+				events: {
+					on(event: string, handler: (payload: unknown) => void) {
+						const set = listeners.get(event) ?? new Set();
+						set.add(handler);
+						listeners.set(event, set);
+						return () => set.delete(handler);
+					},
+					emit(event: string, data: unknown) {
+						emitted.push({ event, data });
+						for (const handler of listeners.get(event) ?? []) handler(data);
+						if (event === "subagent:result-intercom") {
+							const requestId = data && typeof data === "object" ? (data as { requestId?: unknown }).requestId : undefined;
+							if (typeof requestId === "string") setImmediate(() => pi.events.emit("subagent:result-intercom-delivery", { requestId, delivered: true }));
+						}
+					},
+				},
+			};
+			const state = createState();
+			state.currentSessionId = "session-1";
+			const watcher = createResultWatcher(pi, state, resultsDir, 60_000);
+			try {
+				fs.writeFileSync(path.join(resultsDir, "async-stopped.json"), JSON.stringify({
+					id: "async-stopped",
+					runId: "async-stopped",
+					agent: "parallel:a+b",
+					mode: "parallel",
+					success: false,
+					state: "stopped",
+					stopped: true,
+					summary: "Stopped by user",
+					results: [
+						{ agent: "a", output: "Result from a", success: true },
+						{ agent: "b", output: "Subagent stopped by user.", success: false, stopped: true, state: "stopped" },
+					],
+					sessionId: "session-1",
+					intercomTarget: "subagent-chat-main",
+				}, null, 2), "utf-8");
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			} finally {
+				watcher.stopResultWatcher();
+			}
+
+			const intercomEvents = emitted.filter((entry) => entry.event === "subagent:result-intercom");
+			assert.equal(intercomEvents.length, 1);
+			const eventData = intercomEvents[0]?.data as { message?: string; status?: string };
+			assert.equal(eventData.status, "stopped");
+			const message = String(eventData.message ?? "");
+			assert.match(message, /Children: 1 completed, 1 stopped/);
+			assert.match(message, /1\. a — completed/);
+			assert.match(message, /2\. b — stopped/);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
@@ -889,4 +956,107 @@ describe("result watcher", () => {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
+
+	it("delivers a result when a previous duplicate key has expired", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-expired-"));
+		try {
+			const state = createState();
+			state.currentSessionId = "session-1";
+			const emitted: string[] = [];
+			const watcher = createResultWatcher({ events: { on: () => () => {}, emit(event) { emitted.push(event); } } }, state, resultsDir, 60_000);
+			const resultFile = "expired.json";
+			const result = { sessionId: "session-1", agent: "worker", success: true, summary: "new result", timestamp: 123 };
+			const resultPath = path.join(resultsDir, resultFile);
+			fs.writeFileSync(resultPath, JSON.stringify(result), "utf-8");
+			state.completionSeen.set(buildCompletionKey(result, `result:${resultFile}`), Date.now() - 61_000);
+			try {
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 75));
+			} finally {
+				watcher.stopResultWatcher();
+			}
+
+			assert.equal(fs.existsSync(resultPath), false);
+			assert.deepEqual(emitted, ["subagent:async-complete"]);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps an unaccepted result for retry and deletes it only after notifier acceptance", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-notifier-retry-"));
+		try {
+			const state = createState();
+			state.currentSessionId = "session-1";
+			const emitted: string[] = [];
+			let attempts = 0;
+			const watcher = createResultWatcher({ events: { on: () => () => {}, emit(event) { emitted.push(event); } } }, state, resultsDir, 60_000, {
+				notifier: { async deliver() { attempts += 1; return attempts > 1; } },
+			});
+			const resultPath = path.join(resultsDir, "retry.json");
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "retry", sessionId: "session-1", agent: "worker", success: true, summary: "done", timestamp: 1 }), "utf-8");
+			try {
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				assert.equal(fs.existsSync(resultPath), true);
+				await new Promise((resolve) => setTimeout(resolve, 180));
+			} finally {
+				watcher.stopResultWatcher();
+			}
+			assert.equal(attempts, 2);
+			assert.equal(fs.existsSync(resultPath), false);
+			assert.deepEqual(emitted, ["subagent:async-complete"]);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("drops stale watcher authority without emitting or deleting", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-stale-"));
+		try {
+			const state = createState();
+			state.currentSessionId = "session-1";
+			const emitted: string[] = [];
+			let accept!: (value: boolean) => void;
+			const watcher = createResultWatcher({ events: { on: () => () => {}, emit(event) { emitted.push(event); } } }, state, resultsDir, 60_000, {
+				notifier: { deliver: () => new Promise<boolean>((resolve) => { accept = resolve; }) },
+			});
+			const resultPath = path.join(resultsDir, "stale.json");
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "stale", sessionId: "session-1", agent: "worker", success: true, summary: "done", timestamp: 1 }), "utf-8");
+			watcher.primeExistingResults();
+			await new Promise((resolve) => setTimeout(resolve, 50));
+			watcher.stopResultWatcher();
+			accept(true);
+			await new Promise((resolve) => setTimeout(resolve, 50));
+			assert.equal(fs.existsSync(resultPath), true);
+			assert.deepEqual(emitted, []);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("marks reload backlog display-only", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-quiet-"));
+		try {
+			const state = createState();
+			state.currentSessionId = "session-1";
+			const delivered: Array<{ triggerTurn?: boolean }> = [];
+			const emitted: string[] = [];
+			const watcher = createResultWatcher({ events: { on: () => () => {}, emit(event) { emitted.push(event); } } }, state, resultsDir, 60_000, {
+				notifier: { async deliver(result) { delivered.push({ triggerTurn: result.triggerTurn }); return true; } },
+			});
+			fs.writeFileSync(path.join(resultsDir, "quiet.json"), JSON.stringify({ id: "quiet", sessionId: "session-1", agent: "worker", success: true, summary: "done", timestamp: 1, intercomTarget: "host" }), "utf-8");
+			try {
+				watcher.primeExistingResults({ triggerTurn: false });
+				await new Promise((resolve) => setTimeout(resolve, 75));
+			} finally {
+				watcher.stopResultWatcher();
+			}
+			assert.deepEqual(delivered, [{ triggerTurn: false }]);
+			assert.equal(emitted.includes("subagent:result-intercom"), false);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 });