@selesai/code 0.5.28 → 0.6.1

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

@@ -71,6 +71,51 @@ describe("result watcher", () => {
 		}
 	});
 
+	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 {
+			const emitted: Array<{ event: string; data: unknown }> = [];
+			const delivered: unknown[] = [];
+			const pi = {
+				events: {
+					on: () => () => {},
+					emit(event: string, data: unknown) { emitted.push({ event, data }); },
+				},
+			};
+			const state = createState();
+			state.currentSessionId = "session-native";
+			const resultPath = path.join(resultsDir, "native-run.json");
+			fs.writeFileSync(resultPath, JSON.stringify({
+				id: "native-run",
+				runId: "native-run",
+				sessionId: "session-native",
+				mode: "single",
+				success: false,
+				state: "failed",
+				summary: "Subagent process terminated by signal SIGTERM.",
+				results: [{ agent: "worker", output: "", success: false, exitCode: 1, processSignal: "SIGTERM" }],
+				intercomTarget: "native-parent",
+			}), "utf-8");
+			const watcher = createResultWatcher(pi, state, resultsDir, 60_000, {
+				deliverIntercomResults: false,
+				notifier: { deliver: async (result) => { delivered.push(result); return true; } },
+			});
+			try {
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			} finally {
+				watcher.stopResultWatcher();
+			}
+			assert.equal(emitted.some((entry) => entry.event === "subagent:result-intercom"), false);
+			assert.equal(emitted.filter((entry) => entry.event === "subagent:async-complete").length, 1);
+			const notification = delivered[0] as { results?: Array<{ status?: string }> } | undefined;
+			assert.equal(notification?.results?.[0]?.status, "stopped");
+			assert.equal(fs.existsSync(resultPath), false);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("delivers result files only to the exact owning session when another watcher shares the same repo", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-scope-"));
 		const createPi = () => {
@@ -296,7 +341,11 @@ describe("result watcher", () => {
 				assert.notEqual(state.watcherRestartTimer, null);
 
 				fs.writeFileSync(childSessionPath, "", "utf-8");
-				fs.writeFileSync(path.join(resultsDir, "async-fallback.json"), JSON.stringify({
+				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({
 					id: "async-fallback",
 					runId: "run-fallback",
 					agent: "parallel:a+b",
@@ -305,8 +354,8 @@ describe("result watcher", () => {
 					state: "complete",
 					summary: "Combined summary",
 					results: [
-						{ 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" },
+						{ 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" },
 					],
 					sessionId: "session-1",
 					intercomTarget: "subagent-chat-main",
@@ -332,8 +381,12 @@ describe("result watcher", () => {
 			assert.equal(completion?.results?.[0]?.sessionPath, childSessionPath);
 			assert.equal(payload.children?.[1]?.status, "failed");
 			assert.equal(completion?.results?.[1]?.status, "failed");
-			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");
+			// 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/);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
@@ -447,8 +500,8 @@ describe("result watcher", () => {
 					state: "complete",
 					summary: "Combined summary",
 					results: [
-						{ agent: "a", output: "Result from a", success: true, sessionFile: firstSession, artifactPaths: { outputPath: "/tmp/a-output.md" }, intercomTarget: "subagent-a-run-123-1" },
-						{ agent: "b", output: "Result from b", success: false, sessionFile: missingSession, artifactPaths: { outputPath: "/tmp/b-output.md" }, intercomTarget: "subagent-b-run-123-2" },
+						{ agent: "a", output: "Result from a", outputState: "present", success: true, sessionFile: firstSession, artifactPaths: { outputPath: "/tmp/a-output.md" }, intercomTarget: "subagent-a-run-123-1" },
+						{ agent: "b", output: "Result from b", outputState: "present", success: false, sessionFile: missingSession, artifactPaths: { outputPath: "/tmp/b-output.md" }, intercomTarget: "subagent-b-run-123-2" },
 					],
 					sessionId: "session-1",
 					sessionFile: "/tmp/session.jsonl",
@@ -472,6 +525,8 @@ describe("result watcher", () => {
 			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.match(message, /Outputs: 2 present \(semantic adequacy unassessed\)/);
+			assert.match(message, /Inspect that output before retrying/);
 			assert.equal(message.includes(missingSession), false);
 			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");
@@ -517,8 +572,8 @@ describe("result watcher", () => {
 					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" },
+						{ agent: "a", output: "Result from a", outputState: "present", success: true },
+						{ agent: "b", output: "Subagent stopped by user.", outputState: "absent", success: false, stopped: true, state: "stopped" },
 					],
 					sessionId: "session-1",
 					intercomTarget: "subagent-chat-main",
@@ -535,8 +590,8 @@ describe("result watcher", () => {
 			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/);
+			assert.match(message, /1\. a — process completed · output present/);
+			assert.match(message, /2\. b — process stopped · output absent/);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
@@ -877,8 +932,8 @@ describe("result watcher", () => {
 					state: "paused",
 					summary: "Paused after interrupt. Waiting for explicit next action.",
 					results: [
-						{ agent: "a", output: "Result from a", success: true, intercomTarget: "subagent-a-run-paused-1" },
-						{ agent: "b", output: "Paused after interrupt", success: false, intercomTarget: "subagent-b-run-paused-2" },
+						{ agent: "a", output: "Result from a", outputState: "present", success: true, intercomTarget: "subagent-a-run-paused-1" },
+						{ agent: "b", output: "Paused after interrupt", outputState: "absent", success: false, intercomTarget: "subagent-b-run-paused-2" },
 					],
 					sessionId: "session-1",
 					intercomTarget: "subagent-chat-main",
@@ -895,9 +950,9 @@ describe("result watcher", () => {
 			assert.equal(payload.mode, "chain");
 			assert.equal(payload.status, "paused");
 			assert.equal(payload.children?.every((child) => child.status === "paused"), true);
-			assert.match(String(payload.message ?? ""), /Status: paused/);
-			assert.match(String(payload.message ?? ""), /1\. a — paused/);
-			assert.match(String(payload.message ?? ""), /2\. b — paused/);
+			assert.match(String(payload.message ?? ""), /Process status: paused/);
+			assert.match(String(payload.message ?? ""), /1\. a — process paused · output present/);
+			assert.match(String(payload.message ?? ""), /2\. b — process paused · output absent/);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
@@ -949,7 +1004,10 @@ describe("result watcher", () => {
 				watcher.stopResultWatcher();
 			}
 
-			assert.equal(emitted.filter((entry) => entry.event === "subagent:result-intercom").length, 1);
+			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:async-complete"), true);
 			assert.equal(logged.some((entry) => /Subagent async grouped result intercom delivery was not acknowledged/.test(String(entry[0] ?? ""))), true);
 		} finally {
@@ -957,6 +1015,130 @@ describe("result watcher", () => {
 		}
 	});
 
+	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 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 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, "acknowledged.json"), JSON.stringify({
+					id: "acknowledged",
+					runId: "run-acknowledged",
+					agent: "worker",
+					success: true,
+					state: "complete",
+					summary: "Worker summary",
+					sessionId: "session-1",
+					intercomTarget: "orchestrator",
+				}), "utf-8");
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			} finally {
+				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);
+		} 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-"));
+		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);
+					},
+				},
+			};
+			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);
+			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" },
+					],
+					sessionId: "session-1",
+				}), "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/);
+		} finally {
+			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 {