@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/integration/async-job-tracker.test.ts

@@ -4,9 +4,10 @@ import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { registerExternalJobProvider } from "../../src/api/external-job-provider.ts";
 import { getArtifactsDir } from "../../src/shared/artifacts.ts";
-import { SUBAGENT_CHILD_STATUS_EVENT } from "../../src/shared/types.ts";
+import { SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_CONTROL_EVENT, type ControlEvent } from "../../src/shared/types.ts";
 import { ACTIVE_RUN_INDEX_DIR, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { EXTERNAL_JOB_BRIDGE_REQUEST_DIR } from "../../src/runs/shared/external-job-bridge.ts";
+import { createNativeSupervisorChannel, ensureSupervisorChannelDir, resolveSupervisorChannelDir } from "../../src/intercom/native-supervisor-channel.ts";
 import { SubagentFleetComponent } from "../../src/tui/fleet.ts";
 import { createNestedRoute } from "../../src/runs/shared/nested-events.ts";
 import { createTempDir, removeTempDir, tryImport } from "../support/helpers.ts";
@@ -26,6 +27,7 @@ interface AsyncJobTrackerModule {
 			watch?: typeof fs.watch;
 			kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 			now?: () => number;
+			supervisorRequestState?: (event: ControlEvent) => "pending" | "resolved" | "unknown";
 		},
 	): {
 		ensurePoller(): void;
@@ -89,6 +91,85 @@ function createEventRecorder() {
 	};
 }
 
+function writeSupervisorRequest(input: { sessionId: string; runId: string; toolCallId: string }): { channelDir: string; requestId: string } {
+	const channelDir = resolveSupervisorChannelDir(input.runId, "worker", 0);
+	ensureSupervisorChannelDir(channelDir);
+	const requestId = `request-${input.toolCallId}`;
+	fs.writeFileSync(path.join(channelDir, "requests", `${requestId}.json`), JSON.stringify({
+		type: "subagent.supervisor.request",
+		id: requestId,
+		createdAt: Date.now(),
+		reason: "need_decision",
+		message: "Need a decision",
+		expectsReply: true,
+		orchestratorSessionId: input.sessionId,
+		runId: input.runId,
+		agent: "worker",
+		childIndex: 0,
+		toolCallId: input.toolCallId,
+	}), "utf-8");
+	return { channelDir, requestId };
+}
+
+function writeControlRecord(runDir: string, event: ControlEvent): void {
+	fs.appendFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({ type: "subagent.control", channels: ["event"], event })}\n`, "utf-8");
+}
+
+function supervisorControlEvent(runId: string, toolCallId: string, currentTool = "contact_supervisor"): ControlEvent {
+	return {
+		type: "needs_attention",
+		to: "needs_attention",
+		ts: Date.now(),
+		runId,
+		agent: "worker",
+		index: 0,
+		message: "worker is waiting for a supervisor reply",
+		reason: "supervisor_request",
+		currentTool,
+		toolCallId,
+	};
+}
+
+function writeRunningAsyncStatus(runDir: string, runId: string, sessionId: string): void {
+	fs.mkdirSync(runDir, { recursive: true });
+	fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+		runId,
+		mode: "single",
+		state: "running",
+		sessionId,
+		startedAt: Date.now(),
+		lastUpdate: Date.now(),
+		steps: [{ agent: "worker", status: "running" }],
+	}), "utf-8");
+}
+
+function createNativeSupervisorHarness(sessionId: string) {
+	const nativeState = createState();
+	(nativeState as { currentSessionId: string; lastUiContext: unknown }).currentSessionId = sessionId;
+	(nativeState as { supervisorOwnerSessionId: string }).supervisorOwnerSessionId = sessionId;
+	(nativeState as { currentSessionId: string; lastUiContext: unknown }).lastUiContext = {
+		hasUI: false,
+		sessionManager: {
+			getSessionId: () => sessionId,
+			getSessionFile: () => null,
+			getEntries: () => [],
+		},
+	};
+	const tools = new Map<string, { execute: (id: string, params: Record<string, unknown>) => Promise<unknown> }>();
+	const sent: Array<{ customType?: string; options?: { triggerTurn?: boolean } }> = [];
+	const pi = {
+		getAllTools: () => [...tools.keys()].map((name) => ({ name })),
+		registerTool: (tool: { name: string; execute: (...args: unknown[]) => Promise<unknown> }) => {
+			tools.set(tool.name, { execute: (id, params) => tool.execute(id, params) });
+		},
+		sendMessage: (message: { customType?: string }, options?: { triggerTurn?: boolean }) => {
+			sent.push({ customType: message.customType, options });
+		},
+	};
+	const channel = createNativeSupervisorChannel(pi as never, nativeState as never, { platform: "win32" });
+	return { channel, tools, sent };
+}
+
 function pidGone(): never {
 	const error = new Error("missing") as NodeJS.ErrnoException;
 	error.code = "ESRCH";
@@ -430,7 +511,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			updateActiveRunIndex(runDir, "running");
 			const state = createState();
 			state.currentSessionId = "session-restored-nested";
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.restoreActiveJobs();
 			assert.equal(state.asyncJobs.get("run-restored-nested")?.nestedRoute?.eventSink, nestedRoute.eventSink);
 
@@ -483,7 +564,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			updateActiveRunIndex(runDir, "running");
 			const state = createState();
 			state.currentSessionId = "session-workflow";
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.restoreActiveJobs();
 			assert.deepEqual(state.asyncJobs.get("workflow-run")?.workflow?.emits, [{ stage: "scan" }]);
 			assert.equal(state.asyncJobs.get("workflow-run")?.sessionRoot, "/trusted/workflow-sessions");
@@ -513,7 +594,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			fs.mkdirSync(runDir, { recursive: true });
 			const state = createState();
 			state.currentSessionId = "session-late-status";
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.handleStarted({ id: "late-status-run", asyncDir: runDir, sessionId: "session-late-status", agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 150));
@@ -548,7 +629,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			const state = createState();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 				watch: (() => { throw new Error("native watcher disabled for test"); }) as never,
 			});
@@ -609,7 +690,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				reattach: () => ({ providerJobId: "provider-job", state: "completed" }),
 			});
 			const state = createState();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 				watch: (() => { throw new Error("native watcher disabled for test"); }) as never,
 			});
@@ -642,7 +723,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				steps: [{ agent: "worker", status: "running", runner: { type: "external-job", provider: "tracker-provider-late", options: {} } }],
 			}), "utf-8");
 			const state = createState();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 				watch: (() => { throw new Error("native watcher disabled for test"); }) as never,
 			});
@@ -692,7 +773,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			fs.mkdirSync(path.join(runDir, EXTERNAL_JOB_BRIDGE_REQUEST_DIR), { recursive: true });
 			fs.writeFileSync(path.join(runDir, EXTERNAL_JOB_BRIDGE_REQUEST_DIR, "malformed.json"), "{malformed", "utf-8");
 			const state = createState();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 				watch: (() => { throw new Error("native watcher disabled for test"); }) as never,
 			});
@@ -724,11 +805,16 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			}), "utf-8");
 			const state = createState();
 			const ui = createUiContext();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, { pollIntervalMs: 10 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+				watch: (() => { throw new Error("native watcher disabled for test"); }) as never,
+			});
 			tracker.resetJobs(ui.ctx as never);
 			tracker.handleStarted({ id: "quiet-run", asyncDir: runDir, agent: "worker" });
 
+			const rendersAfterStart = ui.renderRequests;
 			await waitForCondition(() => state.asyncJobs.get("quiet-run")?.status === "running", "quiet running job refresh");
+			await waitForCondition(() => ui.renderRequests > rendersAfterStart, "quiet running widget redraw");
 			const renderRequests = ui.renderRequests;
 			await new Promise((resolve) => setTimeout(resolve, 120));
 
@@ -755,7 +841,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const state = createState();
 			let nativeWatchCalls = 0;
 			let terminalHooks = 0;
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				platform: "darwin",
 				pollIntervalMs: 10,
 				onJobTerminal: () => terminalHooks++,
@@ -804,7 +890,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			};
 			fs.writeFileSync(statusPath, JSON.stringify(statusPayload), "utf-8");
 			const state = createState();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.handleStarted({ id: "run-nested-events", asyncDir: runDir, agent: "worker", nestedRoute });
 
 			await new Promise((resolve) => setTimeout(resolve, 150));
@@ -854,7 +940,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			updateActiveRunIndex(runDir, "running");
 			const state = createState();
 			state.currentSessionId = "session-workflow";
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, { pollIntervalMs: 10 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 10 });
 			tracker.restoreActiveJobs();
 			assert.equal(state.asyncJobs.get("workflow-child")?.parentWorkflowRunId, "workflow-parent");
 			assert.equal(state.asyncJobs.get("workflow-child")?.workflowKey, "review");
@@ -892,7 +978,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 
 			const state = createState();
 			state.currentSessionId = "session-owner";
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.restoreActiveJobs();
@@ -909,7 +995,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const state = createState();
 			state.currentSessionId = "session-owner";
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
@@ -1205,7 +1291,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const runDir = path.join(asyncRoot, "run-late-dir");
 			const state = createState();
-			const tracker = createTracker(createEventRecorder().selesai, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 60_000,
 			});
@@ -1472,6 +1558,135 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("suppresses a resolved native supervisor notice before async replay", async () => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-replay-resolved-");
+		const sessionId = `session-${Date.now()}`;
+		const runId = `run-${Date.now()}`;
+		const toolCallId = `call-${Date.now()}`;
+		const { channel, tools, sent } = createNativeSupervisorHarness(sessionId);
+		const { channelDir, requestId } = writeSupervisorRequest({ sessionId, runId, toolCallId });
+		try {
+			const runDir = path.join(asyncRoot, runId);
+			writeRunningAsyncStatus(runDir, runId, sessionId);
+			const event = supervisorControlEvent(runId, toolCallId);
+			writeControlRecord(runDir, event);
+
+			channel.start();
+			assert.equal(channel.getSupervisorRequestState(event), "pending");
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+				supervisorRequestState: channel.getSupervisorRequestState,
+			});
+			tracker.handleStarted({ id: runId, asyncDir: runDir, agent: "worker", sessionId });
+			await tools.get("subagent_supervisor")!.execute("reply", { action: "reply", replyTo: requestId, message: "Approved" });
+			assert.equal(channel.getSupervisorRequestState(event), "resolved");
+			await waitForCondition(() => (state.asyncJobs.get(runId)?.controlEventCursor ?? 0) > 0, "resolved control event cursor");
+
+			assert.equal(recorder.events.some((entry) => entry.channel === SUBAGENT_CONTROL_EVENT), false);
+			assert.deepEqual(sent, [{ customType: "subagent_supervisor_request", options: { triggerTurn: true } }]);
+		} finally {
+			channel.dispose();
+			fs.rmSync(channelDir, { recursive: true, force: true });
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("delivers a native supervisor notice while its request is pending through replay", async () => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-replay-pending-");
+		const sessionId = `session-${Date.now()}`;
+		const runId = `run-${Date.now()}`;
+		const toolCallId = `call-${Date.now()}`;
+		const { channel, sent } = createNativeSupervisorHarness(sessionId);
+		const { channelDir } = writeSupervisorRequest({ sessionId, runId, toolCallId });
+		try {
+			const runDir = path.join(asyncRoot, runId);
+			writeRunningAsyncStatus(runDir, runId, sessionId);
+			const event = supervisorControlEvent(runId, toolCallId);
+			writeControlRecord(runDir, event);
+
+			channel.start();
+			assert.equal(channel.getSupervisorRequestState(event), "pending");
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+				supervisorRequestState: channel.getSupervisorRequestState,
+			});
+			tracker.handleStarted({ id: runId, asyncDir: runDir, agent: "worker", sessionId });
+			await waitForCondition(() => recorder.events.some((entry) => entry.channel === SUBAGENT_CONTROL_EVENT), "pending control event replay");
+
+			const payload = recorder.events.find((entry) => entry.channel === SUBAGENT_CONTROL_EVENT)?.data as { event?: ControlEvent } | undefined;
+			assert.equal(payload?.event?.toolCallId, toolCallId);
+			assert.deepEqual(sent.map((entry) => entry.customType), ["subagent_supervisor_request"]);
+		} finally {
+			channel.dispose();
+			fs.rmSync(channelDir, { recursive: true, force: true });
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("keeps the first native supervisor notice after resolution and suppresses later replay", async () => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-replay-late-");
+		const sessionId = `session-${Date.now()}`;
+		const runId = `run-${Date.now()}`;
+		const toolCallId = `call-${Date.now()}`;
+		const { channel, tools } = createNativeSupervisorHarness(sessionId);
+		const { channelDir, requestId } = writeSupervisorRequest({ sessionId, runId, toolCallId });
+		try {
+			const runDir = path.join(asyncRoot, runId);
+			writeRunningAsyncStatus(runDir, runId, sessionId);
+			const event = supervisorControlEvent(runId, toolCallId);
+			writeControlRecord(runDir, event);
+
+			channel.start();
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+				supervisorRequestState: channel.getSupervisorRequestState,
+			});
+			tracker.handleStarted({ id: runId, asyncDir: runDir, agent: "worker", sessionId });
+			await waitForCondition(() => recorder.events.filter((entry) => entry.channel === SUBAGENT_CONTROL_EVENT).length === 1, "first control event replay");
+
+			await tools.get("subagent_supervisor")!.execute("reply", { action: "reply", replyTo: requestId, message: "Approved" });
+			writeControlRecord(runDir, event);
+			const eventSize = fs.statSync(path.join(runDir, "events.jsonl")).size;
+			await waitForCondition(() => (state.asyncJobs.get(runId)?.controlEventCursor ?? 0) >= eventSize, "resolved replay cursor");
+			assert.equal(recorder.events.filter((entry) => entry.channel === SUBAGENT_CONTROL_EVENT).length, 1);
+		} finally {
+			channel.dispose();
+			fs.rmSync(channelDir, { recursive: true, force: true });
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("delivers an external intercom ask with the native lifecycle lookup enabled", async () => {
+		const asyncRoot = createTempDir("pi-async-job-supervisor-replay-external-");
+		const sessionId = `session-${Date.now()}`;
+		const runId = `run-${Date.now()}`;
+		const { channel } = createNativeSupervisorHarness(sessionId);
+		try {
+			const runDir = path.join(asyncRoot, runId);
+			writeRunningAsyncStatus(runDir, runId, sessionId);
+			const event = supervisorControlEvent(runId, "external-call", "intercom");
+			writeControlRecord(runDir, event);
+			assert.equal(channel.getSupervisorRequestState(event), "unknown");
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+				supervisorRequestState: channel.getSupervisorRequestState,
+			});
+			tracker.handleStarted({ id: runId, asyncDir: runDir, agent: "worker", sessionId });
+			await waitForCondition(() => recorder.events.some((entry) => entry.channel === SUBAGENT_CONTROL_EVENT), "external control event replay");
+		} finally {
+			channel.dispose();
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("keeps incomplete async control event lines for the next poll", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		try {
@@ -1997,4 +2212,4 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			removeTempDir(asyncRoot);
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/error-handling.test.ts

@@ -130,13 +130,13 @@ describe("runSync error handling", { skip: !piAvailable ? "pi packages not avail
 		removeTempDir(tempDir);
 	});
 
-	it("captures stderr on non-zero exit", async () => {
+	it("reports a child session failure as the run error", async () => {
 		mockPi.onCall({ exitCode: 2, stderr: "Fatal: out of memory" });
 		const agents = makeAgentConfigs(["crash"]);
 
 		const result = await runSync(tempDir, agents, "crash", "Do heavy work", {});
 
-		assert.equal(result.exitCode, 2);
+		assert.equal(result.exitCode, 1);
 		assert.ok(result.error?.includes("out of memory"));
 	});
 
@@ -170,25 +170,11 @@ describe("runSync error handling", { skip: !piAvailable ? "pi packages not avail
 		const result = await runSync(tempDir, agents, "worker", "Do work", {});
 
 		assert.equal(result.exitCode, 1);
-		assert.match(result.error ?? "", /exited during 'bash' tool execution \(exit 0\)/);
+		assert.match(result.error ?? "", /ended during 'bash' tool execution before the tool completed/);
 		assert.match(result.error ?? "", /Earlier assistant output is not a terminal result/);
 		assert.doesNotMatch(result.error ?? "", /cold-start/);
 	});
 
-	it("includes an unexpected process signal in a mid-tool exit diagnosis", { skip: process.platform === "win32" ? "signal delivery differs on Windows" : undefined }, async () => {
-		mockPi.onCall({
-			jsonl: [events.toolStart("bash", { command: "wait" })],
-			signal: "SIGTERM",
-		});
-		const agents = makeAgentConfigs(["worker"]);
-
-		const result = await runSync(tempDir, agents, "worker", "Do work", {});
-
-		assert.equal(result.exitCode, 1);
-		assert.match(result.error ?? "", /exited during 'bash' tool execution/);
-		assert.match(result.error ?? "", /signal SIGTERM/);
-	});
-
 	it("keeps a terminal answer authoritative over an earlier tool timeout", async () => {
 		mockPi.onCall({
 			steps: [
@@ -278,4 +264,4 @@ describe("runSync error handling", { skip: !piAvailable ? "pi packages not avail
 		assert.ok(elapsed < 5000, `should abort early, took ${elapsed}ms`);
 		assert.doesNotMatch(result.error ?? "", /exited during 'bash' tool execution/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/foreign-workflow-steering.test.ts

@@ -0,0 +1,95 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { events, makeAgent, makeMinimalCtx, createEventBus } from "../support/helpers.ts";
+import { installAsyncExecutionHooks, available, createSubagentExecutor, waitForMockPiCall, waitForAsyncState, ASYNC_DIR, tempDir, mockPi } from "../support/async-execution-fixture.ts";
+import { steerRequestsDir } from "../../src/runs/background/control-channel.ts";
+const repo = fileURLToPath(new URL("../../", import.meta.url));
+const execFileAsync = promisify(execFile);
+async function hostB(sessionFile: string, params: object, label: string, policy = "auto"): Promise<any> {
+	const output = path.join(tempDir, `${label}.json`);
+	await execFileAsync(process.execPath, ["--experimental-strip-types", "--import", pathToFileURL(path.join(repo, "test/support/register-loader.mjs")).href, path.join(repo, "test/support/foreign-workflow-steer-host.mjs"), tempDir, sessionFile, JSON.stringify(params), output, policy], { cwd: repo, env: process.env, timeout: 15000, killSignal: "SIGKILL" });
+	return JSON.parse(fs.readFileSync(output, "utf8"));
+}
+
+describe("foreign workflow tool steering (separate processes)", () => {
+	installAsyncExecutionHooks();
+	it("delivers ID and directory requests with file-preferred identity; refuses wrong sessions and terminal runs", { timeout: 60000 }, async () => {
+		assert.ok(available && createSubagentExecutor, "fixture must not skip");
+		const release = path.join(tempDir, "release");
+		mockPi.onCall({ steps: [{ waitForPath: release, jsonl: [events.assistantMessage("done")] }] });
+		const sessionFile = path.join(tempDir, "parent-session.jsonl");
+		const ctx = makeMinimalCtx(tempDir);
+		ctx.sessionManager.getSessionFile = () => sessionFile;
+		ctx.sessionManager.getSessionId = () => "different-runtime-id-in-owner";
+		const state: any = { baseCwd: tempDir, currentSessionId: null, asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null };
+		const executor = createSubagentExecutor({ pi: { events: createEventBus(), getSessionName: () => undefined }, state, config: {}, asyncByDefault: false, tempArtifactsDir: tempDir, getSubagentSessionRoot: () => tempDir, expandTilde: p => p, discoverAgents: () => ({ agents: [makeAgent("worker", { completionGuard: false })] }) });
+		const launch = await executor.execute("owner", { workflowScript: 'return await runs.run("A", { agent: "worker", task: "Wait" });', async: true, mission: false }, new AbortController().signal, undefined, ctx);
+		assert.notEqual(launch.isError, true, JSON.stringify(launch));
+		const runId = launch.details.asyncId!;
+		const dir = path.join(ASYNC_DIR, runId);
+		try {
+			await waitForMockPiCall(mockPi, 0, 10000);
+			assert.equal(state.workflowControllers.has(runId), true);
+			const status = JSON.parse(fs.readFileSync(path.join(dir, "status.json"), "utf8"));
+			assert.equal(status.sessionId, sessionFile);
+			for (const [label, params] of [["id", { id: runId }], ["dir", { dir, index: 0 }]] as const) {
+				const b = await hostB(sessionFile, params, label);
+				assert.notEqual(b.pid, process.pid);
+				assert.notEqual(b.completionOwnerId, status.completionOwnerId);
+				assert.equal(b.sessionId, sessionFile);
+				assert.equal(b.controllers, 0); assert.equal(b.controls, 0);
+				assert.notEqual(b.result.isError, true, JSON.stringify(b));
+				assert.equal(b.result.details.steering.state, "delivered");
+				const receipt = JSON.parse(fs.readFileSync(path.join(dir, "status.json"), "utf8")).steering.recent.find((r: any) => r.id === b.result.details.steering.requestId);
+				assert.equal(receipt.targets[0].state, "delivered");
+			}
+			assert.match(fs.readFileSync(path.join(mockPi.dir, "steers.jsonl"), "utf8"), /B actual tool route/);
+			const wrong = await hostB(`${sessionFile}-wrong`, { id: runId }, "wrong");
+			assert.equal(wrong.result.isError, true);
+			assert.match(wrong.result.content[0].text, /active session/);
+			const malformed = await hostB(sessionFile, { dir, index: 0.5 }, "malformed");
+			assert.equal(malformed.result.isError, true);
+			assert.deepEqual(fs.readdirSync(steerRequestsDir(dir)), []);
+			fs.writeFileSync(release, "go");
+			await waitForAsyncState(runId, s => s.state === "complete", 10000);
+			const terminal = await hostB(sessionFile, { dir }, "terminal");
+			assert.equal(terminal.result.isError, true);
+			assert.match(terminal.result.content[0].text, /not running or queued/);
+		} finally { fs.writeFileSync(release, "go"); }
+	});
+
+	it("leaves an unavailable owner's request pending without reconciliation or recovery", { timeout: 20000 }, async () => {
+		const runId = "foreign-unacknowledged";
+		const dir = path.join(ASYNC_DIR, runId);
+		fs.mkdirSync(dir, { recursive: true });
+		const sessionFile = path.join(tempDir, "parent.jsonl");
+		const status = JSON.stringify({ runId, mode: "workflow", state: "running", sessionId: sessionFile, completionOwnerId: "unavailable-owner", pid: 99999999, updatedAt: 1, steps: [{ status: "running", workflowKey: "A" }, { status: "running", workflowKey: "B" }] });
+		fs.writeFileSync(path.join(dir, "status.json"), status);
+		for (const policy of ["forbid", "confirm"]) {
+			const refused = await hostB(sessionFile, { dir }, policy, policy);
+			assert.equal(refused.result.isError, true);
+			assert.match(refused.result.content[0].text, /Authority policy/);
+			assert.equal(fs.existsSync(steerRequestsDir(dir)), false);
+		}
+		const mismatch = await hostB(sessionFile, { dir, id: "another-workflow" }, "mismatch");
+		assert.equal(mismatch.result.isError, true);
+		assert.match(mismatch.result.content[0].text, /does not match directory/);
+		const b = await hostB(sessionFile, { id: runId }, "noack");
+		assert.notEqual(b.result.isError, true, JSON.stringify(b));
+		assert.equal(b.result.details.steering.state, "pending");
+		assert.equal(b.result.details.steering.deliveryStatus, "queued");
+		assert.deepEqual(b.result.details.steering.targets, []);
+		assert.equal(fs.readFileSync(path.join(dir, "status.json"), "utf8"), status);
+		const requests = fs.readdirSync(steerRequestsDir(dir));
+		assert.equal(requests.length, 1);
+		const request = JSON.parse(fs.readFileSync(path.join(steerRequestsDir(dir), requests[0]!), "utf8"));
+		assert.equal(request.id, b.result.details.steering.requestId);
+		assert.equal(request.targetIndex, undefined); assert.equal(request.targetIndexes, undefined);
+		assert.deepEqual(fs.readdirSync(dir).sort(), ["control", "status.json"]);
+	});
+});

package/dist/extensions/pi-subagents/test/integration/fork-context-execution.test.ts

@@ -192,10 +192,6 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			.filter((sessionFile): sessionFile is string => Boolean(sessionFile));
 	}
 
-	function isTaskFileArg(arg: string): boolean {
-		return arg.startsWith("@") && arg.endsWith("task.md");
-	}
-
 	function readSessionArg(args: string[]): string {
 		const sessionIndex = args.indexOf("--session");
 		assert.notEqual(sessionIndex, -1);
@@ -309,11 +305,10 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		assert.equal(result.isError, undefined);
 		const args = readAllCallArgs()[0] ?? [];
 		const taskArg = args.at(-1) ?? "";
-		if (process.platform === "darwin") {
-			assert.ok(isTaskFileArg(taskArg));
-		} else {
-			assert.ok(taskArg.startsWith("Task: \n\n## Acceptance Contract"));
-		}
+		assert.equal(taskArg, "Task: ");
+		const systemIndex = args.findIndex((arg) => arg === "--system-prompt" || arg === "--append-system-prompt");
+		assert.notEqual(systemIndex, -1);
+		assert.match(args[systemIndex + 1] ?? "", /## Acceptance Contract/);
 	});
 
 	it("fails pruned fork model auth before child spawn", async () => {
@@ -1315,11 +1310,10 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		assert.equal(result.isError, undefined);
 		const args = readAllCallArgs()[0] ?? [];
 		const taskArg = args.at(-1) ?? "";
-		if (process.platform === "darwin") {
-			assert.ok(isTaskFileArg(taskArg));
-		} else {
-			assert.ok(taskArg.startsWith(`Task: ${task}\n\n## Acceptance Contract`));
-		}
+		assert.equal(taskArg, `Task: ${task}`);
+		const systemIndex = args.findIndex((arg) => arg === "--system-prompt" || arg === "--append-system-prompt");
+		assert.notEqual(systemIndex, -1);
+		assert.match(args[systemIndex + 1] ?? "", /## Acceptance Contract/);
 		const modelIndex = args.indexOf("--model");
 		assert.notEqual(modelIndex, -1);
 		assert.equal(args[modelIndex + 1], "anthropic/claude-haiku-4-5");
@@ -1353,4 +1347,4 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			removeTempDir(tempHome);
 		}
 	});
-});
+});