@selesai/code 0.13.39 → 0.13.40

package/dist/extensions/pi-subagents/src/runs/shared/subagent-control.ts

@@ -187,8 +187,21 @@ export function shouldNotifyControlEvent(config: ResolvedControlConfig, event: C
 	return config.enabled && config.notifyOn.includes(event.type);
 }
 
+function controlNotificationChildKey(event: Pick<ControlEvent, "runId" | "index">, childIntercomTarget?: string): string {
+	return childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
+}
+
+/**
+ * Forget the de-duplication keys of one child's `needs_attention` notifications for `reason`, so the same problem can notify again
+ * after it was cleared and then recurs.
+ */
+export function forgetControlNotifications(seenKeys: Set<string>, target: Pick<ControlEvent, "runId" | "index">, reason: NonNullable<ControlEvent["reason"]>, childIntercomTarget?: string): void {
+	const prefix = `${controlNotificationChildKey(target, childIntercomTarget)}:needs_attention:${reason}:`;
+	for (const key of [...seenKeys]) if (key.startsWith(prefix)) seenKeys.delete(key);
+}
+
 export function controlNotificationKey(event: ControlEvent, childIntercomTarget?: string): string {
-	const childKey = childIntercomTarget ?? (event.index !== undefined ? `${event.runId}:${event.index}` : event.runId);
+	const childKey = controlNotificationChildKey(event, childIntercomTarget);
 	const contextHash = createHash("sha256").update(formatControlNudge(event)).digest("hex").slice(0, 8);
 	return `${childKey}:${event.type}:${event.reason ?? "idle"}:${contextHash}`;
 }

package/dist/extensions/pi-subagents/src/shared/owner-record.ts

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "./atomic-json.ts";
+import { currentCompletionOwnerId } from "./completion-owner.ts";
+import { processStartKey } from "./process-identity.ts";
+
+/**
+ * On-disk identity of one parent process, keyed by its `completionOwnerId`. Detached background runners outlive
+ * their parent, so a later process needs this record to prove the owner of a finished result is really gone.
+ * Records are deliberately NOT removed on shutdown: a cleanly exited parent is exactly the case where its
+ * runners finish later and a resumed process must take the results over.
+ */
+export interface OwnerRecord {
+	version: 1;
+	completionOwnerId: string;
+	pid: number;
+	startKey?: string;
+	hostname: string;
+	createdAt: number;
+}
+
+const MAX_ENCODED_SEGMENT_LENGTH = 200;
+
+/** Collision-free, traversal-safe file stem for an id that may come from an untrusted result file. */
+export function ownerFileStem(id: string): string | undefined {
+	if (typeof id !== "string" || !id) return undefined;
+	const encoded = encodeURIComponent(id);
+	if (encoded.length <= MAX_ENCODED_SEGMENT_LENGTH) return encoded;
+	return `h-${createHash("sha256").update(id).digest("hex")}`;
+}
+
+export function ownerRecordPath(ownersDir: string, completionOwnerId: string): string | undefined {
+	const stem = ownerFileStem(completionOwnerId);
+	return stem ? path.join(ownersDir, `${stem}.json`) : undefined;
+}
+
+export function parseOwnerRecord(value: unknown): OwnerRecord | undefined {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (record.version !== 1) return undefined;
+	if (typeof record.completionOwnerId !== "string" || !record.completionOwnerId) return undefined;
+	if (!Number.isSafeInteger(record.pid) || (record.pid as number) <= 0) return undefined;
+	if (typeof record.hostname !== "string" || !record.hostname) return undefined;
+	if (typeof record.createdAt !== "number" || !Number.isFinite(record.createdAt)) return undefined;
+	return {
+		version: 1,
+		completionOwnerId: record.completionOwnerId,
+		pid: record.pid as number,
+		...(typeof record.startKey === "string" && record.startKey ? { startKey: record.startKey } : {}),
+		hostname: record.hostname,
+		createdAt: record.createdAt,
+	};
+}
+
+/** Returns undefined for a missing, unreadable, or malformed record; callers must treat that as "unknown". */
+export function readOwnerRecord(ownersDir: string, completionOwnerId: string): OwnerRecord | undefined {
+	const file = ownerRecordPath(ownersDir, completionOwnerId);
+	if (!file) return undefined;
+	try {
+		const record = parseOwnerRecord(JSON.parse(fs.readFileSync(file, "utf-8")));
+		return record?.completionOwnerId === completionOwnerId ? record : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export interface EnsureOwnerRecordOptions {
+	ownersDir: string;
+	completionOwnerId?: string;
+	pid?: number;
+	hostname?: string;
+	startKey?: () => string | undefined;
+	now?: () => number;
+}
+
+/**
+ * Writes this process's owner record unless an identical one is already on disk (an extension reload in the same
+ * process shares the owner id and must not rewrite it). Returns true when a file was written.
+ */
+export function ensureOwnerRecord(options: EnsureOwnerRecordOptions): boolean {
+	const completionOwnerId = options.completionOwnerId ?? currentCompletionOwnerId();
+	const pid = options.pid ?? process.pid;
+	const hostname = options.hostname ?? os.hostname();
+	const file = ownerRecordPath(options.ownersDir, completionOwnerId);
+	if (!file) return false;
+	const existing = readOwnerRecord(options.ownersDir, completionOwnerId);
+	if (existing && existing.pid === pid && existing.hostname === hostname) return false;
+	const startKey = (options.startKey ?? (() => processStartKey(pid)))();
+	const record: OwnerRecord = {
+		version: 1,
+		completionOwnerId,
+		pid,
+		...(startKey ? { startKey } : {}),
+		hostname,
+		createdAt: (options.now ?? Date.now)(),
+	};
+	fs.mkdirSync(options.ownersDir, { recursive: true, mode: 0o700 });
+	try {
+		fs.chmodSync(options.ownersDir, 0o700);
+	} catch {
+		// Best effort (no-op on Windows); the records themselves are written 0600.
+	}
+	writePrivateAtomicJson(file, record);
+	return true;
+}

package/dist/extensions/pi-subagents/src/shared/process-identity.ts

@@ -0,0 +1,87 @@
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+
+export type ProcessLiveness = "alive" | "dead" | "unknown";
+
+type KillFn = (pid: number, signal: 0) => unknown;
+
+/**
+ * `kill(pid, 0)` probe. ESRCH proves the pid is gone, EPERM proves it exists (owned by someone else),
+ * anything else proves nothing. A live pid may still be a *reused* pid; pair with `processStartKey`.
+ */
+export function processLiveness(pid: number, kill: KillFn = process.kill): ProcessLiveness {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return "unknown";
+	try {
+		kill(pid, 0);
+		return "alive";
+	} catch (error) {
+		const code = typeof error === "object" && error !== null && "code" in error
+			? (error as NodeJS.ErrnoException).code
+			: undefined;
+		if (code === "ESRCH") return "dead";
+		if (code === "EPERM") return "alive";
+		return "unknown";
+	}
+}
+
+export function linuxProcessStartKey(pid: number): string | undefined {
+	try {
+		const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+		const tail = raw.slice(raw.lastIndexOf(")") + 2).trim().split(/\s+/);
+		return tail[19] ? `linux:${tail[19]}` : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function psProcessStartKey(pid: number): string | undefined {
+	try {
+		const raw = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 1000 }).trim();
+		return raw ? `ps:${raw}` : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function windowsProcessStartKey(pid: number): string | undefined {
+	try {
+		const raw = execFileSync("powershell.exe", ["-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter \"ProcessId=${pid}\").CreationDate`], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 1000, windowsHide: true }).trim();
+		return raw ? `win:${raw}` : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+type StartKeyResolvers = {
+	linux?: (pid: number) => string | undefined;
+	ps?: (pid: number) => string | undefined;
+	windows?: (pid: number) => string | undefined;
+};
+
+/**
+ * Resolves a start key without caching. Linux prefers `/proc` and falls back to `ps`; Windows uses CIM; every
+ * other unix (macOS, BSDs) uses `ps -o lstart=`. `undefined` means the identity could not be established.
+ */
+export function computeProcessStartKey(pid: number, platform: NodeJS.Platform = process.platform, resolvers: StartKeyResolvers = {}): string | undefined {
+	const linux = resolvers.linux ?? linuxProcessStartKey;
+	const ps = resolvers.ps ?? psProcessStartKey;
+	const windows = resolvers.windows ?? windowsProcessStartKey;
+	if (platform === "linux") return linux(pid) ?? ps(pid);
+	if (platform === "win32") return windows(pid);
+	return ps(pid);
+}
+
+let currentProcessKey: string | undefined | null = null;
+
+export function processStartKey(pid: number): string | undefined {
+	// Foreign PIDs can be reused while this process lives, so resolve them afresh.
+	if (pid !== process.pid) return computeProcessStartKey(pid);
+	if (currentProcessKey === null) currentProcessKey = computeProcessStartKey(pid);
+	return currentProcessKey;
+}
+
+/** Start keys are only comparable within one scheme (`linux:`, `ps:`, `win:`). */
+export function startKeyScheme(key: string): string {
+	const index = key.indexOf(":");
+	return index < 0 ? "" : key.slice(0, index);
+}

package/dist/extensions/pi-subagents/src/shared/types.ts

@@ -1986,6 +1986,10 @@ export type AsyncJobStep = Omit<NonNullable<AsyncStatus["steps"]>[number], "time
 };
 
 export interface AsyncJobState {
+	/** Native lifecycle evidence retained for read-only host observation. */
+	endedAt?: number;
+	error?: string;
+	processTerminal?: ProcessTerminal;
 	asyncId: string;
 	asyncDir: string;
 	/** Host tool-call id retained when it differs from the internal run id. */
@@ -2247,6 +2251,8 @@ export interface SubagentState {
 	liveAsyncSessionRoots?: Map<string, string>;
 	/** Foreground nested routes retained after their direct parent settles, keyed by root run id. */
 	retainedForegroundNestedRoutes?: Map<string, NestedRouteInfo>;
+	/** Observer cache seeded/refreshed only by the existing retained-route tracker. */
+	retainedForegroundNestedChildren?: Map<string, { sessionId: string; workflowId?: string; children: NestedRunSummary[] }>;
 	/** Last valid parent session model observed for this session; used when continuation contexts omit ctx.model. */
 	lastParentModel?: { provider: string; id: string };
 	subagentInProgress?: boolean;
@@ -2755,9 +2761,12 @@ export const RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
 export const ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
 export const CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
 export const TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
+/** Per-user process-owner records + result takeover claims; a sibling of the results dir, outside any project. */
+export const OWNERS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-owners");
 
 export const DIRS = {
 	results: RESULTS_DIR,
+	owners: OWNERS_DIR,
 	async: ASYNC_DIR,
 	chain: CHAIN_RUNS_DIR,
 	artifacts: TEMP_ARTIFACTS_DIR,

package/dist/extensions/pi-subagents/test/integration/async-attention-clearing.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Integration tests for decision D12: a background step's `needs_attention` flag clears when its cause resolves
+ * (the open tool ends, a failed steer is delivered, the failure streak is broken, activity resumes) and can be raised again,
+ * while stop/interrupt/terminal still clear it unconditionally.
+ *
+ * Requires pi packages to be importable. Skips gracefully if unavailable.
+ */
+
+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 { events, makeAgent } from "../support/helpers.ts";
+import { deliverStopRequest, requestAsyncSteer } from "../../src/runs/background/control-channel.ts";
+import type { AsyncStatusPayload } from "../support/async-execution-fixture.ts";
+import {
+	installAsyncExecutionHooks, available, isAsyncAvailable, executeAsyncSingle,
+	ASYNC_DIR, waitForAsyncResultFile, waitForAsyncState, tempDir, mockPi,
+} from "../support/async-execution-fixture.ts";
+
+const skip = !isAsyncAvailable() ? "jiti not available" : undefined;
+const flagged = (status: AsyncStatusPayload) => status.steps?.[0]?.activityState === "needs_attention" && status.activityState === "needs_attention";
+const unflagged = (status: AsyncStatusPayload) => status.steps?.[0]?.activityState !== "needs_attention" && status.activityState !== "needs_attention";
+
+type RecordedEvent = { type?: string; reason?: string; from?: string; to?: string | null; index?: number; event?: { type?: string; reason?: string } };
+function readEvents(id: string): RecordedEvent[] {
+	const eventsPath = path.join(ASYNC_DIR, id, "events.jsonl");
+	if (!fs.existsSync(eventsPath)) return [];
+	return fs.readFileSync(eventsPath, "utf-8").split("\n").filter(Boolean).map((line) => JSON.parse(line) as RecordedEvent);
+}
+const clearedEvents = (id: string, reason: string) => readEvents(id).filter((event) => event.type === "subagent.attention.cleared" && event.reason === reason);
+const attentionEvents = (id: string, reason: string) => readEvents(id).filter((event) => event.type === "subagent.control" && event.event?.type === "needs_attention" && event.event.reason === reason);
+
+/** An assistant turn that ends in a tool call, so the child keeps running (a `stop` turn would settle it). */
+function midTurnMessage(text: string): object {
+	const message = events.assistantMessage(text) as { message: { stopReason: string } };
+	message.message.stopReason = "toolUse";
+	return message;
+}
+
+function launch(id: string, controlConfig: Record<string, unknown>) {
+	return executeAsyncSingle(id, {
+		agent: "worker",
+		task: "Do the work",
+		agentConfig: makeAgent("worker"),
+		ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "session-1" },
+		artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+		shareEnabled: false,
+		sessionRoot: path.join(tempDir, "sessions"),
+		maxSubagentDepth: 2,
+		controlConfig: {
+			enabled: true,
+			needsAttentionAfterMs: 999_999,
+			activeNoticeAfterMs: 100,
+			failedToolAttemptsBeforeAttention: 3,
+			notifyOn: ["needs_attention"],
+			notifyChannels: ["event", "async", "intercom"],
+			...controlConfig,
+		},
+	});
+}
+
+describe("async needs_attention clearing (D12)", { skip: !available ? "pi packages not available" : undefined }, () => {
+	installAsyncExecutionHooks();
+
+	it("clears when the open tool ends and flags again for a second long tool", { timeout: 45_000, skip }, async () => {
+		const id = `async-attention-tool-${Date.now().toString(36)}`;
+		const release = [1, 2, 3].map((n) => path.join(tempDir, `${id}.${n}`));
+		const release3 = release[2]!;
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [{ type: "tool_execution_start", toolCallId: "bash-1", toolName: "bash", args: { command: "sleep 600" } }] },
+				{ waitForPath: release[0]!, jsonl: [{ type: "tool_execution_end", toolCallId: "bash-1", toolName: "bash" }, events.toolResult("bash", "first done")] },
+				{ waitForPath: release[1]!, jsonl: [{ type: "tool_execution_start", toolCallId: "bash-2", toolName: "bash", args: { command: "sleep 600" } }] },
+				{ waitForPath: release3, jsonl: [{ type: "tool_execution_end", toolCallId: "bash-2", toolName: "bash" }, events.toolResult("bash", "second done"), events.assistantMessage("Done")] },
+			],
+		});
+		launch(id, {});
+
+		await waitForAsyncState(id, flagged);
+		assert.equal(attentionEvents(id, "tool_open_threshold").length, 1);
+		assert.equal(clearedEvents(id, "tool_open_threshold").length, 0, "still flagged while the tool is open");
+
+		fs.writeFileSync(release[0]!, "");
+		const recovered = await waitForAsyncState(id, unflagged);
+		assert.notEqual(recovered.steps?.[0]?.activityState, "needs_attention");
+		assert.notEqual(recovered.activityState, "needs_attention");
+		const cleared = clearedEvents(id, "tool_open_threshold");
+		assert.equal(cleared.length, 1);
+		assert.equal(cleared[0]?.from, "needs_attention");
+		assert.equal(cleared[0]?.index, 0);
+
+		fs.writeFileSync(release[1]!, "");
+		await waitForAsyncState(id, flagged);
+		assert.equal(attentionEvents(id, "tool_open_threshold").length, 2, "a recurrence is flagged and notified again");
+
+		fs.writeFileSync(release3, "");
+		await waitForAsyncResultFile(id);
+		assert.equal(clearedEvents(id, "tool_open_threshold").length, 2);
+		const finalStatus = JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(finalStatus.activityState, undefined);
+		assert.notEqual(finalStatus.steps?.[0]?.activityState, "needs_attention");
+	});
+
+	it("still clears unconditionally on stop while the flag is raised", { timeout: 30_000, skip }, async () => {
+		const id = `async-attention-stop-${Date.now().toString(36)}`;
+		mockPi.onCall({ steps: [{ jsonl: [{ type: "tool_execution_start", toolCallId: "bash-1", toolName: "bash", args: { command: "sleep 600" } }] }, { waitForPath: path.join(tempDir, `${id}.never`), jsonl: [] }] });
+		launch(id, {});
+		await waitForAsyncState(id, flagged);
+		deliverStopRequest({ asyncDir: path.join(ASYNC_DIR, id), source: "test" });
+		const stopped = await waitForAsyncState(id, (status) => status.state === "stopped");
+		assert.equal(stopped.activityState, undefined);
+		assert.equal(stopped.steps?.[0]?.activityState, undefined);
+		assert.equal(clearedEvents(id, "tool_open_threshold").length, 0, "terminal handling does not announce a recovery");
+	});
+
+	it("clears steering attention once a steer is delivered, but not when one is merely queued", { timeout: 30_000, skip }, async () => {
+		const id = `async-attention-steer-${Date.now().toString(36)}`;
+		const release = path.join(tempDir, `${id}.release`);
+		mockPi.onCall({ failSteers: 1, steps: [{ waitForPath: release, jsonl: [events.assistantMessage("Done")] }] });
+		launch(id, {});
+		const asyncDir = path.join(ASYNC_DIR, id);
+		await waitForAsyncState(id, (status) => status.steps?.[0]?.status === "running");
+
+		requestAsyncSteer(asyncDir, { message: "Please focus on the tests.", targetIndex: 0, source: "test" });
+		await waitForAsyncState(id, flagged);
+		assert.equal(readEvents(id).filter((event) => event.type === "subagent.steer.failed").length, 1);
+
+		requestAsyncSteer(asyncDir, { message: "Queue this for later.", mode: "follow_up", targetIndex: 0, source: "test" });
+		await waitForAsyncState(id, () => readEvents(id).some((event) => event.type === "subagent.steer.queued"));
+		assert.equal(clearedEvents(id, "steering").length, 0, "a queued follow-up is not a delivery");
+		const stillFlagged = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8")) as AsyncStatusPayload;
+		assert.equal(stillFlagged.steps?.[0]?.activityState, "needs_attention");
+
+		requestAsyncSteer(asyncDir, { message: "Please focus on the tests, again.", targetIndex: 0, source: "test" });
+		await waitForAsyncState(id, unflagged);
+		const cleared = clearedEvents(id, "steering");
+		assert.equal(cleared.length, 1);
+		assert.equal(cleared[0]?.index, 0);
+
+		fs.writeFileSync(release, "");
+		await waitForAsyncResultFile(id);
+	});
+
+	it("clears a mutating-failure flag when a mutating tool succeeds again", { timeout: 30_000, skip }, async () => {
+		const id = `async-attention-failures-${Date.now().toString(36)}`;
+		const release = path.join(tempDir, `${id}.release`);
+		const failingEdit = (n: number) => [
+			{ type: "tool_execution_start", toolCallId: `edit-${n}`, toolName: "edit", args: { path: "src/a.ts" } },
+			{ type: "tool_execution_end", toolCallId: `edit-${n}`, toolName: "edit" },
+			events.toolResult("edit", "Error: could not find the text to replace", true),
+		];
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [...failingEdit(1), ...failingEdit(2), ...failingEdit(3)] },
+				{ waitForPath: release, jsonl: [
+					{ type: "tool_execution_start", toolCallId: "edit-4", toolName: "edit", args: { path: "src/a.ts" } },
+					{ type: "tool_execution_end", toolCallId: "edit-4", toolName: "edit" },
+					events.toolResult("edit", "Successfully replaced text in src/a.ts"),
+				] },
+				{ jsonl: [events.assistantMessage("Done")] },
+			],
+		});
+		launch(id, { activeNoticeAfterMs: 999_999 });
+		await waitForAsyncState(id, flagged);
+		assert.equal(attentionEvents(id, "tool_failures").length, 1);
+		fs.writeFileSync(release, "");
+		await waitForAsyncState(id, unflagged);
+		assert.equal(clearedEvents(id, "tool_failures").length, 1);
+		await waitForAsyncResultFile(id);
+	});
+
+	it("clears idle attention when the child becomes active again", { timeout: 45_000, skip }, async () => {
+		const id = `async-attention-idle-${Date.now().toString(36)}`;
+		const release = path.join(tempDir, `${id}.release`);
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [midTurnMessage("Thinking about it")] },
+				{ waitForPath: release, jsonl: [{ type: "tool_execution_start", toolCallId: "read-1", toolName: "read", args: { path: "README.md" } }, { type: "tool_execution_end", toolCallId: "read-1", toolName: "read" }] },
+				{ delay: 3_500, jsonl: [events.assistantMessage("Done")] },
+			],
+		});
+		launch(id, { needsAttentionAfterMs: 2_000, activeNoticeAfterMs: 999_999 });
+		await waitForAsyncState(id, flagged, 20_000);
+		assert.equal(attentionEvents(id, "idle").length, 1);
+		fs.writeFileSync(release, "");
+		await waitForAsyncState(id, unflagged, 20_000);
+		assert.equal(clearedEvents(id, "idle").length, 1);
+		await waitForAsyncResultFile(id, 30_000);
+	});
+});

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

@@ -983,6 +983,69 @@ describe("result watcher", () => {
 		}
 	});
 
+	it("takes over a dead previous owner's result after resume, exactly once, and leaves live and foreign-session results alone", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-takeover-"));
+		const ownersDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-owners-"));
+		try {
+			const record = (id: string, pid: number) => fs.writeFileSync(path.join(ownersDir, `${id}.json`), JSON.stringify({ version: 1, completionOwnerId: id, pid, hostname: "host-a", createdAt: 1 }));
+			record("owner-dead", 100);
+			record("owner-live", 200);
+			record("resumed-a", 301);
+			record("resumed-b", 302);
+			const liveness = (pid: number) => (pid === 100 ? "dead" as const : "alive" as const);
+			const takeoverDeps = { ownersDir, hostname: () => "host-a", processLiveness: liveness, processStartKey: () => undefined };
+			const resumed = (ownerId: string) => {
+				const state = createState();
+				state.currentSessionId = "resumed-session";
+				state.completionOwnerId = ownerId;
+				const delivered: string[] = [];
+				const events: string[] = [];
+				const watcher = createResultWatcher({ events: { on: () => () => {}, emit(name: string) { events.push(name); } } }, state, resultsDir, 60_000, {
+					deliverIntercomResults: false,
+					ownership: createResultDeliveryOwnership(state, takeoverDeps),
+					notifier: { async deliver(result) { delivered.push(result.id!); return true; } },
+				});
+				return { watcher, delivered, events };
+			};
+			const write = (id: string, owner: string, session = "resumed-session") => writeAsyncResultFile(path.join(resultsDir, `${id}.json`), { id, runId: id, sessionId: session, completionOwnerId: owner, success: true, summary: id });
+			write("orphan", "owner-dead");
+			write("busy", "owner-live");
+			write("no-record", "owner-ghost");
+			write("other-session", "owner-dead", "someone-elses-session");
+
+			// Two resumed processes race to prime the same session: exactly one delivers.
+			const a = resumed("resumed-a");
+			const b = resumed("resumed-b");
+			try {
+				a.watcher.startResultWatcher();
+				b.watcher.startResultWatcher();
+				a.watcher.primeExistingResults();
+				b.watcher.primeExistingResults();
+				assert.equal(await waitForPredicate(() => !fs.existsSync(path.join(resultsDir, "orphan.json"))), true);
+				await new Promise((resolve) => setTimeout(resolve, 100));
+				assert.equal(a.delivered.length + b.delivered.length, 1, "delivered exactly once across both processes");
+				assert.deepEqual([...a.delivered, ...b.delivered], ["orphan"]);
+				assert.equal(fs.existsSync(path.join(resultsDir, "busy.json")), true, "live owner keeps its result");
+				assert.equal(fs.existsSync(path.join(resultsDir, "no-record.json")), true, "missing owner record means no takeover");
+				assert.equal(fs.existsSync(path.join(resultsDir, "other-session.json")), true, "other sessions are never taken");
+				assert.equal(fs.existsSync(path.join(ownersDir, "claims", "orphan.json")), true);
+
+				// A result that appears later (the runner finished after the parent died) is picked up by the next scan.
+				const winner = a.delivered.length ? a : b;
+				write("late", "owner-dead");
+				winner.watcher.primeExistingResults();
+				assert.equal(await waitForPredicate(() => winner.delivered.includes("late")), true);
+				assert.equal(await waitForPredicate(() => !fs.existsSync(path.join(resultsDir, "late.json"))), true);
+			} finally {
+				a.watcher.stopResultWatcher();
+				b.watcher.stopResultWatcher();
+			}
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+			fs.rmSync(ownersDir, { recursive: true, force: true });
+		}
+	});
+
 	it("logs malformed result files instead of swallowing them silently", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-"));
 		try {

package/dist/extensions/pi-subagents/test/integration/stop-all-background.test.ts

@@ -0,0 +1,142 @@
+/**
+ * Integration tests for the `stop_all_background` kill switch against REAL detached runner processes (mock pi child):
+ * the stop request is only a file in the run's control inbox, the runner consumes it by itself, ends with status `stopped`
+ * and exits. Runs of other sessions are untouched.
+ *
+ * Requires pi packages to be importable. Skips gracefully if unavailable.
+ */
+
+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 { createEventBus } from "../../../../core/event-bus.ts";
+import { RpcReleaseBridge } from "../../../../modes/rpc/release-bridge.ts";
+import { registerSubagentRpcBridge } from "../../src/extension/rpc.ts";
+import { registerReleaseReadiness } from "../../src/extension/release-readiness.ts";
+import { makeAgent, events } from "../support/helpers.ts";
+import type { AsyncJobState, SubagentState } from "../../src/shared/types.ts";
+import type { ExtensionContext } from "@selesai/code";
+import {
+	installAsyncExecutionHooks, available, isAsyncAvailable, executeAsyncSingle,
+	ASYNC_DIR, RESULTS_DIR, waitForAsyncResultFile, waitForAsyncState, tempDir, mockPi,
+} from "../support/async-execution-fixture.ts";
+
+const skip = !isAsyncAvailable() ? "jiti not available" : undefined;
+const SESSION = "session-1";
+
+function launch(id: string, sessionId: string) {
+	const receipt = executeAsyncSingle(id, {
+		agent: "worker",
+		task: "Do the work",
+		agentConfig: makeAgent("worker"),
+		ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: sessionId },
+		artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+		shareEnabled: false,
+		sessionRoot: path.join(tempDir, "sessions"),
+		maxSubagentDepth: 2,
+	});
+	assert.equal(receipt.isError === true, false, "launch must succeed");
+}
+const readRunStatus = (id: string) => JSON.parse(fs.readFileSync(path.join(ASYNC_DIR, id, "status.json"), "utf-8")) as { state: string; pid?: number };
+const job = (id: string, sessionId: string, pid?: number): AsyncJobState => ({ asyncId: id, asyncDir: path.join(ASYNC_DIR, id), status: "running", startedAt: Date.now(), updatedAt: Date.now(), sessionId, pid } as AsyncJobState);
+const alive = (pid: number) => { try { process.kill(pid, 0); return true; } catch { return false; } };
+async function waitFor(check: () => boolean, ms: number, what: string): Promise<void> {
+	const until = Date.now() + ms;
+	while (!check()) {
+		if (Date.now() > until) assert.fail(`timed out waiting for ${what}`);
+		await new Promise((resolve) => setTimeout(resolve, 25));
+	}
+}
+
+describe("stop_all_background against real detached runners", { skip: !available ? "pi packages not available" : undefined }, () => {
+	installAsyncExecutionHooks();
+
+	it("stops this session's runner (status stopped, process gone) and leaves another session's runner running", { timeout: 60_000, skip }, async () => {
+		const mine = `stopall-mine-${Date.now().toString(36)}`;
+		const theirs = `stopall-theirs-${Date.now().toString(36)}`;
+		const releaseTheirs = path.join(tempDir, `${theirs}.release`);
+		const bash = (n: number) => ({ type: "tool_execution_start", toolCallId: `bash-${n}`, toolName: "bash", args: { command: "sleep 600" } });
+		mockPi.onCall({ steps: [{ jsonl: [bash(1)] }, { waitForPath: path.join(tempDir, `${mine}.never`), jsonl: [] }] });
+		launch(mine, SESSION);
+		await waitForAsyncState(mine, (status) => status.state === "running" && status.steps?.[0]?.status === "running");
+		mockPi.onCall({ steps: [{ waitForPath: releaseTheirs, jsonl: [events.assistantMessage("Done")] }] });
+		launch(theirs, "session-2");
+		await waitForAsyncState(theirs, (status) => status.state === "running" && status.steps?.[0]?.status === "running");
+		const minePid = readRunStatus(mine).pid!;
+		const theirsPid = readRunStatus(theirs).pid!;
+		assert.ok(alive(minePid) && alive(theirsPid));
+
+		// Session-1's extension state tracks its own run, and (adversarially) also lists session-2's run.
+		const state = { baseCwd: tempDir, currentSessionId: SESSION, supervisorOwnerSessionId: "host", asyncJobs: new Map([[mine, job(mine, SESSION, minePid)], [theirs, job(theirs, "session-2", theirsPid)]]), foregroundControls: new Map(), lastForegroundControlId: null } as unknown as SubagentState;
+		const bus = createEventBus();
+		const ctx = { sessionManager: { getSessionFile: () => SESSION, getSessionId: () => SESSION } } as unknown as ExtensionContext;
+		const rpc = registerSubagentRpcBridge({ events: bus, getContext: () => ctx, execute: async () => { throw new Error("unused"); }, asyncDirRoot: ASYNC_DIR, resultsDir: RESULTS_DIR, state });
+		registerReleaseReadiness({
+			events: bus,
+			getHostSessionId: () => "host",
+			subagents: { state, hasPendingDelivery: () => false, listUndeliveredResults: () => [], resultsDir: RESULTS_DIR },
+			scheduler: { armedSchedules: () => [], observedCompletionRunIds: () => [] },
+			stopAll: {
+				subagents: { state, resultsDir: RESULTS_DIR, asyncDirRoot: ASYNC_DIR, observedCompletionRunIds: () => [], stopRun: (target) => rpc.stopRun(target) },
+				scheduler: { disarmSessionSchedules: () => [] },
+			},
+		});
+
+		const bridge = new RpcReleaseBridge(bus, { version: 1, sessionId: "host", epoch: "e1" });
+		const reply = await bridge.stopAll({ type: "stop_all_background", version: 1 }, () => [], () => []);
+		assert.ok(reply.success && reply.command === "stop_all_background", JSON.stringify(reply));
+		assert.deepEqual(reply.data.stopped.map((item) => [item.source, item.kind, item.id, item.ok, item.error]), [
+			["subagents", "async_run", theirs, false, "foreign_session"],
+			["subagents", "async_run", mine, true, undefined],
+		]);
+
+		// The runner ended with status stopped (written by the detached runner itself) ...
+		assert.equal(readRunStatus(mine).state, "stopped");
+		const result = JSON.parse(fs.readFileSync(await waitForAsyncResultFile(mine), "utf-8")) as { state?: string; success?: boolean; stopped?: boolean };
+		assert.equal(result.state, "stopped");
+		assert.equal(result.success, false);
+		// ... and the process is gone, not merely idle.
+		await waitFor(() => !alive(minePid), 15_000, "the stopped runner process to exit");
+		// The other session's runner is untouched and still completes normally.
+		assert.equal(readRunStatus(theirs).state, "running");
+		assert.ok(alive(theirsPid));
+		assert.equal(reply.data.remaining.blockers.some((b) => b.id === mine && b.kind === "async_run"), false, "the stopped run is no longer an async_run blocker");
+
+		// Idempotent: the run is terminal now, nothing is stopped again (the foreign one is reported again, never touched).
+		const again = await bridge.stopAll({ type: "stop_all_background", version: 1 }, () => [], () => []);
+		assert.ok(again.success && again.command === "stop_all_background");
+		assert.deepEqual(again.data.stopped.map((item) => [item.id, item.ok]), [[theirs, false]]);
+
+		fs.writeFileSync(releaseTheirs, "");
+		const done = JSON.parse(fs.readFileSync(await waitForAsyncResultFile(theirs), "utf-8")) as { state?: string; success?: boolean };
+		assert.equal(done.success, true);
+	});
+
+	it("stops a run that is not tracked in memory but awaited by a scheduled run (scheduled_run_pending)", { timeout: 60_000, skip }, async () => {
+		const id = `stopall-sched-${Date.now().toString(36)}`;
+		mockPi.onCall({ steps: [{ jsonl: [{ type: "tool_execution_start", toolCallId: "bash-1", toolName: "bash", args: { command: "sleep 600" } }] }, { waitForPath: path.join(tempDir, `${id}.never`), jsonl: [] }] });
+		launch(id, SESSION);
+		await waitForAsyncState(id, (status) => status.state === "running" && status.steps?.[0]?.status === "running");
+		const pid = readRunStatus(id).pid!;
+		const state = { baseCwd: tempDir, currentSessionId: SESSION, supervisorOwnerSessionId: "host", asyncJobs: new Map(), foregroundControls: new Map(), lastForegroundControlId: null } as unknown as SubagentState;
+		const bus = createEventBus();
+		const ctx = { sessionManager: { getSessionFile: () => SESSION, getSessionId: () => SESSION } } as unknown as ExtensionContext;
+		const rpc = registerSubagentRpcBridge({ events: bus, getContext: () => ctx, execute: async () => { throw new Error("unused"); }, asyncDirRoot: ASYNC_DIR, resultsDir: RESULTS_DIR, state });
+		registerReleaseReadiness({
+			events: bus,
+			getHostSessionId: () => "host",
+			subagents: { state, hasPendingDelivery: () => false, listUndeliveredResults: () => [], resultsDir: RESULTS_DIR },
+			scheduler: { armedSchedules: () => [], observedCompletionRunIds: () => [id] },
+			stopAll: {
+				subagents: { state, resultsDir: RESULTS_DIR, asyncDirRoot: ASYNC_DIR, observedCompletionRunIds: () => [id], stopRun: (target) => rpc.stopRun(target) },
+				scheduler: { disarmSessionSchedules: () => [] },
+			},
+		});
+		const reply = await new RpcReleaseBridge(bus, { version: 1, sessionId: "host", epoch: "e1" }).stopAll({ type: "stop_all_background", version: 1 }, () => [], () => []);
+		assert.ok(reply.success && reply.command === "stop_all_background", JSON.stringify(reply));
+		assert.deepEqual(reply.data.stopped.map((item) => [item.kind, item.id, item.ok]), [["scheduled_run", id, true]]);
+		assert.equal(readRunStatus(id).state, "stopped");
+		await waitFor(() => !alive(pid), 15_000, "the stopped runner process to exit");
+	});
+});