@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/workflow-resume-hint.test.ts

@@ -0,0 +1,365 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
+import { resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import { DIRS, type AsyncStatus, type SubagentState } from "../../src/shared/types.ts";
+
+const cleanupRoots: string[] = [];
+
+function createState(sessionId: string | null): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: sessionId,
+		asyncJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		pendingForegroundControlNotices: new Map(),
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+function createExecutor(state: SubagentState, cwd: string) {
+	return createSubagentExecutor({
+		pi: { events: { emit() {}, on() { return () => {}; } }, getSessionName() { return "parent"; } } as never,
+		state,
+		config: { maxSubagentDepth: 2, control: {}, intercomBridge: {} } as never,
+		asyncByDefault: false,
+		tempArtifactsDir: cwd,
+		getSubagentSessionRoot: () => path.join(cwd, "sessions"),
+		expandTilde: (value) => value,
+		discoverAgents: () => ({ agents: [{ name: "worker" }] as never }),
+	});
+}
+
+function createContext(cwd: string) {
+	return {
+		cwd,
+		hasUI: false,
+		ui: {},
+		sessionManager: {
+			getSessionId() { return "session-1644"; },
+			getSessionFile() { return null; },
+		},
+		modelRegistry: { getAvailable() { return []; } },
+	} as never;
+}
+
+function makeIds(label: string): { parentRunId: string; childRunId: string } {
+	const suffix = `${label}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+	return { parentRunId: `workflow-parent-${suffix}`, childRunId: `workflow-child-${suffix}` };
+}
+
+function writeRetainedChild(input: {
+	root: string;
+	childRunId: string;
+	sessionId: string;
+	state?: AsyncStatus["state"];
+	stepStatus?: NonNullable<AsyncStatus["steps"]>[number]["status"];
+	writeSession?: boolean;
+}): void {
+	const childDir = path.join(DIRS.async, input.childRunId);
+	fs.mkdirSync(childDir, { recursive: true });
+	const sessionFile = path.join(input.root, `${input.childRunId}.jsonl`);
+	if (input.writeSession !== false) fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+	const state = input.state ?? "complete";
+	const stepStatus = input.stepStatus ?? "complete";
+	fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
+		runId: input.childRunId,
+		sessionId: input.sessionId,
+		mode: "single",
+		state,
+		startedAt: 100,
+		endedAt: state === "complete" ? 200 : undefined,
+		cwd: input.root,
+		sessionFile,
+		steps: [{ agent: "worker", status: stepStatus, sessionFile }],
+	}), "utf-8");
+}
+
+function writeWorkflowStatus(input: {
+	parentRunId: string;
+	childRunId: string;
+	key?: string;
+	sessionId?: string;
+	parentState?: AsyncStatus["state"];
+	steps?: Array<Record<string, unknown>>;
+	workflowChildren?: unknown;
+	malformed?: boolean;
+}): string {
+	const asyncDir = path.join(DIRS.async, input.parentRunId);
+	fs.mkdirSync(asyncDir, { recursive: true });
+	const statusPath = path.join(asyncDir, "status.json");
+	if (input.malformed) {
+		fs.writeFileSync(statusPath, "{not-json", "utf-8");
+	} else {
+		fs.writeFileSync(statusPath, JSON.stringify({
+			runId: input.parentRunId,
+			sessionId: input.sessionId ?? "session-1644",
+			mode: "workflow",
+			state: input.parentState ?? "complete",
+			startedAt: 100,
+			endedAt: 200,
+			steps: input.steps ?? [{ agent: "worker", workflowKey: input.key ?? "advisor", runId: input.childRunId, status: "complete" }],
+			...(input.workflowChildren === undefined ? {} : { workflowChildren: input.workflowChildren }),
+		}), "utf-8");
+	}
+	fs.writeFileSync(path.join(asyncDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.workflow.child.completed", runId: input.parentRunId, childRunId: input.childRunId })}\n`, "utf-8");
+	return asyncDir;
+}
+
+async function runMissingReceiptResume(input: {
+	root: string;
+	parentRunId: string;
+	key?: string;
+	state?: SubagentState;
+}): Promise<string> {
+	const state = input.state ?? createState("session-1644");
+	const executor = createExecutor(state, input.root);
+	const key = input.key ?? "advisor";
+	const result = await executor.execute(
+		`resume-hint-request-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+		{
+			async: false,
+			mission: false,
+			workflowScript: `return runs.run("follow-up", { resume: { workflowRunId: ${JSON.stringify(input.parentRunId)}, key: ${JSON.stringify(key)}, latest: true }, task: "Continue" });`,
+		},
+		new AbortController().signal,
+		undefined,
+		createContext(input.root),
+	);
+	return result.content.map((part) => part.text ?? "").join("\n");
+}
+
+function cleanupRun(runId: string): void {
+	fs.rmSync(path.join(DIRS.async, runId), { recursive: true, force: true });
+}
+
+afterEach(() => {
+	for (const root of cleanupRoots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("workflow keyed resume recovery hint", () => {
+	it("names a directly resumable child when the parent receipt is missing", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-resume-hint-"));
+		cleanupRoots.push(root);
+		const { parentRunId, childRunId } = makeIds("positive");
+		writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+		const workflowChildren = {
+			version: 1,
+			parentToolCallId: "tool-call",
+			workflowRunId: parentRunId,
+			inventoryComplete: true,
+			workflowState: "completed",
+			children: [{ childId: "advisor", runId: childRunId, state: "completed" }],
+		};
+		writeWorkflowStatus({ parentRunId, childRunId, workflowChildren });
+
+		const text = await runMissingReceiptResume({ root, parentRunId });
+
+		assert.match(text, new RegExp(`Direct resumable child for workflow key 'advisor': subagent\\(\\{ action: "resume", id: ${JSON.stringify(childRunId)}, message: "\\.\\.\\." \\}\\)`));
+		assert.match(text, /terminal receipt writing failed/);
+		const target = resolveAsyncResumeTarget({ id: childRunId }, {}, { requireSessionFile: true, sessionId: "session-1644" });
+		assert.equal(target.kind, "revive");
+		assert.equal(target.runId, childRunId);
+		cleanupRun(parentRunId);
+		cleanupRun(childRunId);
+	});
+
+	it("does not hint when status proof or direct resumability is not safe", async () => {
+		const cases: Array<{
+			name: string;
+			configure: (root: string, parentRunId: string, childRunId: string) => SubagentState | undefined;
+		}> = [
+			{
+				name: "running parent",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, parentState: "running" });
+					return undefined;
+				},
+			},
+			{
+				name: "queued parent",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, parentState: "queued" });
+					return undefined;
+				},
+			},
+			{
+				name: "paused parent",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, parentState: "paused" });
+					return undefined;
+				},
+			},
+			{
+				name: "stopped parent",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, parentState: "stopped" });
+					return undefined;
+				},
+			},
+			{
+				name: "rejected parent",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, parentState: "rejected" });
+					return undefined;
+				},
+			},
+			{
+				name: "live child",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644", state: "running", stepStatus: "running" });
+					writeWorkflowStatus({ parentRunId, childRunId });
+					return undefined;
+				},
+			},
+			{
+				name: "pending child",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644", state: "running", stepStatus: "pending" });
+					writeWorkflowStatus({ parentRunId, childRunId });
+					return undefined;
+				},
+			},
+			{
+				name: "stopped child",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644", state: "stopped", stepStatus: "stopped" });
+					writeWorkflowStatus({ parentRunId, childRunId });
+					return undefined;
+				},
+			},
+			{
+				name: "missing session",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644", writeSession: false });
+					writeWorkflowStatus({ parentRunId, childRunId });
+					return undefined;
+				},
+			},
+			{
+				name: "foreign parent",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, sessionId: "other-session" });
+					return undefined;
+				},
+			},
+			{
+				name: "duplicate status key",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, steps: [
+						{ agent: "worker", workflowKey: "advisor", runId: childRunId, status: "complete" },
+						{ agent: "worker", workflowKey: "advisor", runId: childRunId, status: "complete" },
+					] });
+					return undefined;
+				},
+			},
+			{
+				name: "workflow child mismatch",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({
+						parentRunId,
+						childRunId,
+						workflowChildren: {
+							version: 1,
+							parentToolCallId: "tool-call",
+							workflowRunId: parentRunId,
+							inventoryComplete: true,
+							workflowState: "completed",
+							children: [{ childId: "advisor", runId: "other-child", state: "completed" }],
+						},
+					});
+					return undefined;
+				},
+			},
+			{
+				name: "complete summary missing key",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({
+						parentRunId,
+						childRunId,
+						workflowChildren: {
+							version: 1,
+							parentToolCallId: "tool-call",
+							workflowRunId: parentRunId,
+							inventoryComplete: true,
+							workflowState: "completed",
+							children: [],
+						},
+					});
+					return undefined;
+				},
+			},
+			{
+				name: "unsafe child id",
+				configure(root, parentRunId, childRunId) {
+					writeWorkflowStatus({
+						parentRunId,
+						childRunId,
+						steps: [{ agent: "worker", workflowKey: "advisor", runId: "../outside", status: "complete" }],
+					});
+					return undefined;
+				},
+			},
+			{
+				name: "whitespace child id",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({
+						parentRunId,
+						childRunId,
+						steps: [{ agent: "worker", workflowKey: "advisor", runId: `${childRunId} `, status: "complete" }],
+					});
+					return undefined;
+				},
+			},
+			{
+				name: "malformed receipt",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					const asyncDir = writeWorkflowStatus({ parentRunId, childRunId });
+					fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), "{not-json", "utf-8");
+					return undefined;
+				},
+			},
+			{
+				name: "malformed parent status",
+				configure(root, parentRunId, childRunId) {
+					writeRetainedChild({ root, childRunId, sessionId: "session-1644" });
+					writeWorkflowStatus({ parentRunId, childRunId, malformed: true });
+					return undefined;
+				},
+			},
+		];
+
+		for (const testCase of cases) {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), `pi-workflow-resume-hint-${testCase.name.replaceAll(" ", "-")}-`));
+			cleanupRoots.push(root);
+			const { parentRunId, childRunId } = makeIds(testCase.name.replaceAll(" ", "-"));
+			const state = testCase.configure(root, parentRunId, childRunId);
+			const text = await runMissingReceiptResume({ root, parentRunId, state });
+			assert.doesNotMatch(text, /Direct resumable child for workflow key/);
+			cleanupRun(parentRunId);
+			cleanupRun(childRunId);
+		}
+	});
+});