@selesai/code 0.6.2 → 0.7.0

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

@@ -3,8 +3,10 @@ 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 type { ExtensionContext } from "@selesai/code";
 import { buildCompletionKey } from "../../src/runs/background/completion-dedupe.ts";
 import { createResultWatcher } from "../../src/runs/background/result-watcher.ts";
+import { createScheduledRunManager, scheduledRunStorePath } from "../../src/runs/background/scheduled-runs.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 import type { SubagentState } from "../../src/shared/types.ts";
 
@@ -71,6 +73,64 @@ describe("result watcher", () => {
 		}
 	});
 
+	it("observes retained-project completions without changing active-session delivery", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-scheduled-"));
+		const resultsDir = path.join(root, "results");
+		const project = path.join(root, "project-a");
+		fs.mkdirSync(resultsDir);
+		fs.mkdirSync(project);
+		const ctx = {
+			cwd: project,
+			sessionManager: {
+				getSessionId: () => "session-a",
+				getSessionFile: () => path.join(project, "session-a.jsonl"),
+			},
+		} as unknown as ExtensionContext;
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(root, "stores"),
+			launch: async () => ({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "scheduled-a" } }),
+		});
+		try {
+			manager.bindSession(ctx);
+			await manager.handleToolCall({ action: "schedule.create", id: "retained", every: "1h", agent: "builder" }, ctx);
+			await manager.handleToolCall({ action: "schedule.run", id: "retained" }, ctx);
+			const scheduleDir = path.join(scheduledRunStorePath(project, undefined, path.join(root, "stores")), "retained");
+			assert.equal(fs.existsSync(path.join(scheduleDir, "active.lock")), true);
+
+			const emitted: Array<{ event: string; data: unknown }> = [];
+			const state = createState();
+			state.currentSessionId = "session-b";
+			const resultPath = path.join(resultsDir, "scheduled-a.json");
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "scheduled-a", sessionId: "session-a", success: true, summary: "done" }), "utf-8");
+			const watcher = createResultWatcher({
+				events: {
+					on: () => () => {},
+					emit(event: string, data: unknown) { emitted.push({ event, data }); },
+				},
+			}, state, resultsDir, 60_000, {
+				observeCompletion: (result) => manager.handleAsyncCompletion(result),
+				notifier: { deliver: async () => assert.fail("inactive-session completion must not reach the live notifier") },
+			});
+			try {
+				watcher.startResultWatcher();
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			} finally {
+				watcher.stopResultWatcher();
+			}
+
+			assert.equal(state.currentSessionId, "session-b");
+			assert.equal(emitted.length, 0);
+			assert.equal(fs.existsSync(path.join(scheduleDir, "active.lock")), false);
+			assert.match(fs.readFileSync(path.join(scheduleDir, "history.json"), "utf-8"), /"state": "completed"/);
+			assert.equal(fs.existsSync(resultPath), true, "the owning session keeps delivery ownership of its result file");
+		} finally {
+			manager.stop();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("uses native completion delivery without attempting external grouped intercom when disabled", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-native-delivery-"));
 		try {
@@ -93,7 +153,7 @@ describe("result watcher", () => {
 				success: false,
 				state: "failed",
 				summary: "Subagent process terminated by signal SIGTERM.",
-				results: [{ agent: "worker", output: "", success: false, exitCode: 1, processSignal: "SIGTERM" }],
+				results: [{ agent: "builder", output: "", success: false, exitCode: 1, processSignal: "SIGTERM" }],
 				intercomTarget: "native-parent",
 			}), "utf-8");
 			const watcher = createResultWatcher(pi, state, resultsDir, 60_000, {
@@ -157,24 +217,24 @@ describe("result watcher", () => {
 			try {
 				fs.writeFileSync(ownerResultPath, JSON.stringify({
 					id: "owner-run",
-					agent: "worker",
+					agent: "builder",
 					mode: "single",
 					success: true,
 					state: "complete",
 					summary: "owner output",
-					results: [{ agent: "worker", output: "owner output", success: true }],
+					results: [{ agent: "builder", output: "owner output", success: true }],
 					sessionId: "session-owner",
 					cwd: "/repo",
 					intercomTarget: "owner-target",
 				}), "utf-8");
 				fs.writeFileSync(sessionlessResultPath, JSON.stringify({
 					id: "sessionless-run",
-					agent: "worker",
+					agent: "builder",
 					mode: "single",
 					success: true,
 					state: "complete",
 					summary: "legacy cwd-scoped output",
-					results: [{ agent: "worker", output: "legacy cwd-scoped output", success: true }],
+					results: [{ agent: "builder", output: "legacy cwd-scoped output", success: true }],
 					cwd: "/repo",
 					intercomTarget: "sessionless-target",
 				}), "utf-8");
@@ -341,11 +401,7 @@ describe("result watcher", () => {
 				assert.notEqual(state.watcherRestartTimer, null);
 
 				fs.writeFileSync(childSessionPath, "", "utf-8");
-				const childOutputA = path.join(resultsDir, "child-a.md");
-			const childOutputB = path.join(resultsDir, "child-b.md");
-			fs.writeFileSync(childOutputA, "Result from a", "utf-8");
-			fs.writeFileSync(childOutputB, "Result from b", "utf-8");
-			fs.writeFileSync(path.join(resultsDir, "async-fallback.json"), JSON.stringify({
+				fs.writeFileSync(path.join(resultsDir, "async-fallback.json"), JSON.stringify({
 					id: "async-fallback",
 					runId: "run-fallback",
 					agent: "parallel:a+b",
@@ -354,8 +410,8 @@ describe("result watcher", () => {
 					state: "complete",
 					summary: "Combined summary",
 					results: [
-						{ agent: "a", output: "Result from a", outputPath: childOutputA, success: true, sessionFile: childSessionPath, intercomTarget: "subagent-a-run-fallback-1" },
-						{ agent: "b", output: "Result from b", outputPath: childOutputB, success: false, error: "B failed", intercomTarget: "subagent-b-run-fallback-2" },
+						{ agent: "a", output: "Result from a", success: true, sessionFile: childSessionPath, intercomTarget: "subagent-a-run-fallback-1" },
+						{ agent: "b", output: "Result from b", success: false, error: "B failed", intercomTarget: "subagent-b-run-fallback-2" },
 					],
 					sessionId: "session-1",
 					intercomTarget: "subagent-chat-main",
@@ -381,12 +437,8 @@ describe("result watcher", () => {
 			assert.equal(completion?.results?.[0]?.sessionPath, childSessionPath);
 			assert.equal(payload.children?.[1]?.status, "failed");
 			assert.equal(completion?.results?.[1]?.status, "failed");
-			// Reference-only async delivery: child summaries are built from the
-			// authoritative output path (error/status first for failed children).
-			assert.match(payload.children?.[1]?.summary ?? "", /^B failed\n\nOutput saved to: .*child-b\.md/);
-			assert.match(completion?.results?.[1]?.summary ?? "", /^B failed\n\nOutput saved to: /);
-			assert.match(payload.children?.[0]?.summary ?? "", /^Output saved to: .*child-a\.md/);
-			assert.doesNotMatch(payload.children?.[1]?.summary ?? "", /Result from b/);
+			assert.equal(payload.children?.[1]?.summary, "B failed\n\nOutput:\nResult from b");
+			assert.equal(completion?.results?.[1]?.summary, "B failed\n\nOutput:\nResult from b");
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
@@ -613,7 +665,7 @@ describe("result watcher", () => {
 					depth: 1,
 					path: [{ runId: "async-nested-root", stepIndex: 0 }],
 					state: "complete",
-					agent: "nested-reviewer",
+					agent: "nested-commentator",
 					sessionFile: path.join(resultsDir, "nested-child.jsonl"),
 				},
 			});
@@ -958,7 +1010,7 @@ describe("result watcher", () => {
 		}
 	});
 
-	it("logs one unacknowledged grouped async intercom delivery before completing", async () => {
+	it("uses local completion fallback silently when no grouped-result listener is available", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-"));
 		try {
 			const emitted: Array<{ event: string; data: unknown }> = [];
@@ -974,7 +1026,7 @@ describe("result watcher", () => {
 			};
 			const state = createState();
 			state.currentSessionId = "session-1";
-			const watcher = createResultWatcher(pi, state, resultsDir, 60_000);
+			const watcher = createResultWatcher(pi, state, resultsDir, 60_000, { deliverIntercomResults: false });
 			const originalError = console.error;
 			const logged: unknown[][] = [];
 			console.error = (...args: unknown[]) => {
@@ -984,7 +1036,7 @@ describe("result watcher", () => {
 				fs.writeFileSync(path.join(resultsDir, "async-2.json"), JSON.stringify({
 					id: "async-2",
 					runId: "run-456",
-					agent: "worker",
+					agent: "builder",
 					success: true,
 					state: "complete",
 					summary: "Worker summary",
@@ -992,31 +1044,22 @@ describe("result watcher", () => {
 					intercomTarget: "orchestrator",
 				}), "utf-8");
 				watcher.primeExistingResults();
-				const deadline = Date.now() + 1000;
-				while (true) {
-					const sawWarning = logged.some((entry) => /Subagent async grouped result intercom delivery was not acknowledged/.test(String(entry[0] ?? "")));
-					const sawCompletion = emitted.some((entry) => entry.event === "subagent:async-complete");
-					if ((sawWarning && sawCompletion) || Date.now() > deadline) break;
-					await new Promise((resolve) => setTimeout(resolve, 25));
-				}
+				await new Promise((resolve) => setTimeout(resolve, 100));
 			} finally {
 				console.error = originalError;
 				watcher.stopResultWatcher();
 			}
 
-			const grouped = emitted.filter((entry) => entry.event === "subagent:result-intercom");
-			assert.equal(grouped.length, 1);
-			assert.match(String((grouped[0]?.data as { message?: string } | undefined)?.message ?? ""), /output unknown/);
-			assert.doesNotMatch(String((grouped[0]?.data as { message?: string } | undefined)?.message ?? ""), /Inspect that output before retrying/);
+			assert.equal(emitted.some((entry) => entry.event === "subagent:result-intercom"), false);
 			assert.equal(emitted.some((entry) => entry.event === "subagent:async-complete"), true);
-			assert.equal(logged.some((entry) => /Subagent async grouped result intercom delivery was not acknowledged/.test(String(entry[0] ?? ""))), true);
+			assert.equal(logged.some((entry) => /Subagent async grouped result intercom delivery was not acknowledged/.test(String(entry[0] ?? ""))), false);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
 
-	it("marks acknowledged grouped intercom results so local notification is suppressed", async () => {
-		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-intercom-ack-"));
+	it("warns when an available grouped-result listener does not acknowledge delivery", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-unacknowledged-listener-"));
 		try {
 			const emitted: Array<{ event: string; data: unknown }> = [];
 			const listeners = new Map<string, Set<(payload: unknown) => void>>();
@@ -1031,26 +1074,20 @@ describe("result watcher", () => {
 					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 delivered: Array<{ intercomDelivered?: boolean }> = [];
-			const watcher = createResultWatcher(pi, state, resultsDir, 60_000, {
-				notifier: { async deliver(result) { delivered.push({ intercomDelivered: result.intercomDelivered }); return true; } },
-			});
+			const watcher = createResultWatcher(pi, state, resultsDir, 60_000);
+			const originalError = console.error;
+			const logged: unknown[][] = [];
+			console.error = (...args: unknown[]) => { logged.push(args); };
 			try {
-				fs.writeFileSync(path.join(resultsDir, "acknowledged.json"), JSON.stringify({
-					id: "acknowledged",
-					runId: "run-acknowledged",
-					agent: "worker",
+				fs.writeFileSync(path.join(resultsDir, "unacknowledged.json"), JSON.stringify({
+					id: "unacknowledged",
+					runId: "run-unacknowledged",
+					agent: "builder",
 					success: true,
 					state: "complete",
 					summary: "Worker summary",
@@ -1058,82 +1095,70 @@ describe("result watcher", () => {
 					intercomTarget: "orchestrator",
 				}), "utf-8");
 				watcher.primeExistingResults();
-				await new Promise((resolve) => setTimeout(resolve, 100));
+				await new Promise((resolve) => setTimeout(resolve, 600));
 			} finally {
+				console.error = originalError;
 				watcher.stopResultWatcher();
 			}
 
-			assert.deepEqual(delivered, [{ intercomDelivered: true }]);
-			const completion = emitted.find((entry) => entry.event === "subagent:async-complete")?.data as { intercomDelivered?: boolean } | undefined;
-			assert.equal(completion?.intercomDelivered, true);
+			assert.equal(emitted.filter((entry) => entry.event === "subagent:result-intercom").length, 1);
+			assert.equal(logged.some((entry) => /Subagent async grouped result intercom delivery was not acknowledged/.test(String(entry[0] ?? ""))), true);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
 
-	it("uses a bounded fallback when a child output path is absent or unreadable", async () => {
-		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-fallback-"));
+	it("marks acknowledged grouped intercom results so local notification is suppressed", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-intercom-ack-"));
 		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);
+						const eventListeners = listeners.get(event) ?? new Set();
+						eventListeners.add(handler);
+						listeners.set(event, eventListeners);
+						return () => eventListeners.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);
-			const missingOutputPath = path.join(resultsDir, "missing-child.md");
-			const unreadablePath = path.join(resultsDir, "unreadable-child.md");
-			fs.writeFileSync(unreadablePath, "unreadable child output", "utf-8");
-			fs.chmodSync(unreadablePath, 0o000);
+			const delivered: Array<{ intercomDelivered?: boolean }> = [];
+			const watcher = createResultWatcher(pi, state, resultsDir, 60_000, {
+				notifier: { async deliver(result) { delivered.push({ intercomDelivered: result.intercomDelivered }); return true; } },
+			});
 			try {
-				fs.writeFileSync(path.join(resultsDir, "fallback.json"), JSON.stringify({
-					id: "fallback",
-					runId: "run-fallback",
-					agent: "parallel:a+b",
-					mode: "parallel",
-					success: false,
-					state: "failed",
-					summary: "run summary that must never leak",
-					results: [
-						{ agent: "a", outputPath: missingOutputPath, output: "internal a", success: false, error: "A exploded" },
-						{ agent: "b", outputPath: unreadablePath, output: "internal b", success: false, error: "B exploded" },
-					],
+				fs.writeFileSync(path.join(resultsDir, "acknowledged.json"), JSON.stringify({
+					id: "acknowledged",
+					runId: "run-acknowledged",
+					agent: "builder",
+					success: true,
+					state: "complete",
+					summary: "Worker summary",
 					sessionId: "session-1",
+					intercomTarget: "orchestrator",
 				}), "utf-8");
 				watcher.primeExistingResults();
 				await new Promise((resolve) => setTimeout(resolve, 100));
 			} finally {
-				fs.chmodSync(unreadablePath, 0o644);
 				watcher.stopResultWatcher();
 			}
-			const completion = emitted.find((entry) => entry.event === "subagent:async-complete")?.data as { results?: Array<{ summary?: string }> } | undefined;
-			assert.ok(completion, "expected an async completion");
-			const summaryA = completion.results?.[0]?.summary ?? "";
-			const summaryB = completion.results?.[1]?.summary ?? "";
-			assert.match(summaryA, /\[Full output unavailable\]/);
-			assert.match(summaryA, /Failed to read saved output: ENOENT/);
-			assert.match(summaryA, /missing-child\.md/);
-			assert.match(summaryB, /\[Full output unavailable\]/);
-			assert.match(summaryB, /Failed to read saved output: EACCES: permission denied/);
-			assert.match(summaryB, /unreadable-child\.md/);
-			// Only a bounded excerpt of the internal text is exposed, never the raw
-			// full output shape or the run summary.
-			assert.match(summaryA, /internal a/);
-			assert.match(summaryB, /internal b/);
-			assert.doesNotMatch(summaryA, /Output:\ninternal a/);
-			assert.doesNotMatch(summaryA + summaryB, /run summary that must never leak/);
+
+			assert.deepEqual(delivered, [{ intercomDelivered: true }]);
+			const completion = emitted.find((entry) => entry.event === "subagent:async-complete")?.data as { intercomDelivered?: boolean } | undefined;
+			assert.equal(completion?.intercomDelivered, true);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
@@ -1147,7 +1172,7 @@ describe("result watcher", () => {
 			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 result = { sessionId: "session-1", agent: "builder", 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);
@@ -1176,7 +1201,7 @@ describe("result watcher", () => {
 				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");
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "retry", sessionId: "session-1", agent: "builder", success: true, summary: "done", timestamp: 1 }), "utf-8");
 			try {
 				watcher.primeExistingResults();
 				await new Promise((resolve) => setTimeout(resolve, 50));
@@ -1204,7 +1229,7 @@ describe("result watcher", () => {
 				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");
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "stale", sessionId: "session-1", agent: "builder", success: true, summary: "done", timestamp: 1 }), "utf-8");
 			watcher.primeExistingResults();
 			await new Promise((resolve) => setTimeout(resolve, 50));
 			watcher.stopResultWatcher();
@@ -1227,7 +1252,7 @@ describe("result watcher", () => {
 			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");
+			fs.writeFileSync(path.join(resultsDir, "quiet.json"), JSON.stringify({ id: "quiet", sessionId: "session-1", agent: "builder", success: true, summary: "done", timestamp: 1, intercomTarget: "host" }), "utf-8");
 			try {
 				watcher.primeExistingResults({ triggerTurn: false });
 				await new Promise((resolve) => setTimeout(resolve, 75));