@selesai/code 0.5.27 → 0.5.29

package/dist/extensions/pi-subagents/test/unit/fleet-status.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { Editor, visibleWidth } from "@earendil-works/pi-tui";
+import { Editor, type EditorComponent, visibleWidth } from "@earendil-works/pi-tui";
 import type { ExtensionContext } from "@selesai/code";
 import type { SubagentState } from "../../src/shared/types.ts";
 import { collectFleetSnapshot } from "../../src/tui/fleet.ts";
@@ -10,6 +10,7 @@ import {
 	collectFleetStatusEntries,
 	formatFleetElapsed,
 	formatFleetTokens,
+	resolveFleetViewPlacement,
 } from "../../src/tui/fleet-status.ts";
 
 function stateForTest(): SubagentState {
@@ -45,6 +46,13 @@ describe("below-editor subagent FleetView", () => {
 		assert.equal(formatFleetTokens(1_250_000), "↓ 1.3M tokens");
 	});
 
+	it("resolves configured FleetView placement with a below-editor fallback", () => {
+		assert.equal(resolveFleetViewPlacement(undefined), "belowEditor");
+		assert.equal(resolveFleetViewPlacement("belowEditor"), "belowEditor");
+		assert.equal(resolveFleetViewPlacement("aboveEditor"), "aboveEditor");
+		assert.equal(resolveFleetViewPlacement("side"), "belowEditor");
+	});
+
 	it("renders main plus active children below the editor and bounds every line", () => {
 		const state = stateForTest();
 		const now = Date.now();
@@ -56,6 +64,7 @@ describe("below-editor subagent FleetView", () => {
 				updatedAt: now,
 				currentAgent: `worker-${index}`,
 				description: index === 0 ? "Inspect\nmodule 0" : `Inspect module ${index}`,
+				...(index === 0 ? { model: "anthropic/fable-5", thinking: "low" } : {}),
 				tokens: index === 0 ? 13_100 : index,
 			});
 		}
@@ -85,7 +94,7 @@ describe("below-editor subagent FleetView", () => {
 			const component = widgetFactory!({ requestRender() {} }, theme);
 			const lines = component.render(80);
 			assert.ok(lines.some((line) => line.includes("⏺ main")));
-			assert.ok(lines.some((line) => line.includes("worker-0") && line.includes("Inspect module 0")));
+			assert.ok(lines.some((line) => line.includes("worker-0 (fable-5 · thinking low)") && line.includes("Inspect module 0")));
 			assert.ok(lines.some((line) => line.includes("11s · ↓ 13.1k tokens")));
 			assert.ok(lines.some((line) => line.includes("↓ 2 more")));
 			for (const line of lines) assert.ok(visibleWidth(line) <= 80, `line exceeded width: ${line}`);
@@ -94,6 +103,143 @@ describe("below-editor subagent FleetView", () => {
 		}
 	});
 
+	it("registers above the editor when configured", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+		});
+		let placement: string | undefined;
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: unknown, options?: { placement?: string }) {
+					if (content) placement = options?.placement;
+				},
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000, placement: "aboveEditor" });
+		try {
+			fleet.setContext(ctx);
+			assert.equal(placement, "aboveEditor");
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("stops refreshing when the captured extension context becomes stale", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+		});
+		let stale = false;
+		let contextReads = 0;
+		let inputUnsubscribes = 0;
+		let widgetRemovals = 0;
+		const ctx = {
+			get hasUI() {
+				contextReads++;
+				if (stale) {
+					throw new Error("This extension ctx is stale after session replacement or reload.");
+				}
+				return true;
+			},
+			ui: {
+				setWidget(_key: string, content: unknown) {
+					if (content === undefined) widgetRemovals++;
+				},
+				onTerminalInput() { return () => { inputUnsubscribes++; }; },
+				getEditorText() { return ""; },
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		try {
+			fleet.setContext(ctx);
+			stale = true;
+			assert.doesNotThrow(() => fleet.refresh());
+			assert.equal(inputUnsubscribes, 1);
+			assert.equal(widgetRemovals, 1);
+			assert.equal((fleet as unknown as { timer?: unknown }).timer, undefined);
+			const readsAfterStaleRefresh = contextReads;
+			fleet.refresh();
+			assert.equal(contextReads, readsAfterStaleRefresh, "later refreshes must not reuse the stale context");
+		} finally {
+			fleet.dispose();
+		}
+	});
+
+	it("does not swallow unrelated widget cleanup errors", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+		});
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: unknown) {
+					if (content === undefined) throw new Error("widget cleanup failed");
+				},
+				onTerminalInput() { return () => {}; },
+				getEditorText() { return ""; },
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		fleet.setContext(ctx);
+		assert.throws(() => fleet.dispose(), /widget cleanup failed/);
+	});
+
+	it("preserves multiple unrelated UI cleanup errors", () => {
+		const state = stateForTest();
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			currentAgent: "worker",
+		});
+		const ctx = {
+			hasUI: true,
+			ui: {
+				setWidget(_key: string, content: unknown) {
+					if (content === undefined) throw new Error("widget cleanup failed");
+				},
+				onTerminalInput() {
+					return () => { throw new Error("input cleanup failed"); };
+				},
+				getEditorText() { return ""; },
+				notify() {},
+				theme,
+			},
+		} as unknown as ExtensionContext;
+		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
+		fleet.setContext(ctx);
+		assert.throws(
+			() => fleet.dispose(),
+			(error: unknown) => error instanceof AggregateError
+				&& error.errors.map(String).join("\n").includes("input cleanup failed")
+				&& error.errors.map(String).join("\n").includes("widget cleanup failed"),
+		);
+	});
+
 	it("keeps widget ownership through invalidation so an empty refresh removes it", () => {
 		const state = stateForTest();
 		state.foregroundControls.set("run-worker", {
@@ -268,8 +414,8 @@ describe("below-editor subagent FleetView", () => {
 			startedAt: 100,
 			updatedAt: 200,
 			steps: [
-				{ agent: "reviewer", index: 0, status: "running", startedAt: 120, tokens: { input: 4_000, output: 200, total: 4_200 } },
-				{ agent: "worker", index: 1, status: "complete", tokens: { input: 100, output: 20, total: 120 } },
+				{ agent: "reviewer", index: 0, status: "running", description: "Review only authentication", startedAt: 120, model: "openai/gpt-5", thinking: "medium", tokens: { input: 4_000, output: 200, total: 4_200 } },
+				{ agent: "worker", index: 1, status: "running", description: "Implement only billing", startedAt: 121, tokens: { input: 100, output: 20, total: 120 } },
 			],
 		});
 		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
@@ -288,9 +434,10 @@ describe("below-editor subagent FleetView", () => {
 		try {
 			fleet.setContext(ctx);
 			const lines = widgetFactory!({ requestRender() {} }, theme).render(100);
-			assert.ok(lines.some((line) => line.includes("reviewer") && line.includes("Review the authentication changes")));
+			assert.ok(lines.some((line) => line.includes("reviewer (gpt-5 · thinking medium)") && line.includes("Review only authentication")));
+			assert.ok(lines.some((line) => line.includes("worker") && line.includes("Implement only billing")));
+			assert.ok(lines.every((line) => !line.includes("Review the authentication changes")), "per-child descriptions should replace the run-level fallback when present");
 			assert.ok(lines.some((line) => line.includes("↓ 4.2k tokens")));
-			assert.ok(!lines.some((line) => line.includes("worker")), "completed async children should leave the status fleet");
 		} finally {
 			fleet.dispose();
 		}
@@ -331,11 +478,32 @@ describe("below-editor subagent FleetView", () => {
 
 			assert.equal(inputHandler!("\x1b[B"), undefined, "non-empty editor should retain Down");
 			editorText = "";
-			tui.focusedComponent = {} as Editor;
+			tui.focusedComponent = {
+				render() { return []; },
+				invalidate() {},
+				handleInput() {},
+			} as unknown as Editor;
 			assert.equal(inputHandler!("\x1b[B"), undefined, "non-editor focus should retain Down");
+
+			const crossModuleCustomEditor = {
+				render() { return []; },
+				invalidate() {},
+				handleInput() {},
+				getText() { return ""; },
+				setText() {},
+			} satisfies EditorComponent;
+			assert.equal(crossModuleCustomEditor instanceof Editor, false, "regression setup must cross the instanceof boundary");
+			tui.focusedComponent = crossModuleCustomEditor as unknown as Editor;
+			assert.equal(inputHandler!("j"), undefined, "inactive FleetView should retain printable navigation keys");
+			assert.equal(inputHandler!("k"), undefined, "inactive FleetView should retain printable navigation keys");
+			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true }, "custom editors should activate FleetView across jiti boundaries");
+			assert.deepEqual(inputHandler!("j"), { consume: true }, "active FleetView should navigate down with j");
+			assert.ok(component.render(100).some((line) => line.includes("⏺ worker")));
+			assert.deepEqual(inputHandler!("k"), { consume: true }, "active FleetView should navigate up with k");
+			assert.ok(component.render(100).some((line) => line.includes("⏺ main")));
+
 			tui.focusedComponent = Object.create(Editor.prototype) as Editor;
 			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true });
-			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true });
 			assert.ok(component.render(100).some((line) => line.includes("⏺ worker")));
 			assert.deepEqual(inputHandler!("\r"), { consume: true });
 			await Promise.resolve();

package/dist/extensions/pi-subagents/test/unit/fleet.test.ts

@@ -368,7 +368,7 @@ describe("native subagent fleet", () => {
 				currentIndex: 1,
 				description: "Review the active task",
 				activeChildren: new Map([
-					[0, { index: 0, agent: "worker", description: "Implement the active task", startedAt: now - 900, updatedAt: now - 100, tokens: 120 }],
+					[0, { index: 0, agent: "worker", description: "Implement the active task", startedAt: now - 900, updatedAt: now - 100, tokens: 120, model: "provider/live-model", thinking: "high" }],
 					[1, { index: 1, agent: "reviewer", description: "Review the active task", startedAt: now - 800, updatedAt: now, tokens: 240 }],
 				]),
 			});
@@ -388,6 +388,7 @@ describe("native subagent fleet", () => {
 				assert.ok(lines.some((line) => line.includes("worker")));
 				assert.ok(lines.some((line) => line.includes("reviewer")));
 				assert.ok(lines.some((line) => line.includes("foreground · live")));
+				assert.ok(lines.some((line) => line.includes("live-model · thinking high")));
 				assert.ok(lines.some((line) => line.includes("Task") && line.includes("Implement the active task")));
 				assert.ok(lines.some((line) => line.includes("Conversation") && line.includes("assistant response")));
 				assert.ok(lines.some((line) => line.includes("Worker live result")));
@@ -442,7 +443,7 @@ describe("native subagent fleet", () => {
 					cwd: baseCwd,
 					sessionId: "session-current",
 					updatedAt: 200,
-					children: [{ agent: "reviewer", index: 0, status: "completed", transcriptPath: recentTranscript }],
+					children: [{ agent: "reviewer", index: 0, status: "completed", transcriptPath: recentTranscript, model: "provider/recent-model", thinking: "xhigh" }],
 				});
 				state.asyncJobs.set(asyncId, {
 					asyncId,
@@ -469,7 +470,11 @@ describe("native subagent fleet", () => {
 						{ initialKey, refreshMs: 60_000, markdownTheme },
 					);
 					try {
-						assert.ok(component.render(100).some((line) => line.includes(expected)), `missing ${expected}`);
+						const lines = component.render(100);
+						assert.ok(lines.some((line) => line.includes(expected)), `missing ${expected}`);
+						if (initialKey.startsWith("foreground-recent:")) {
+							assert.ok(lines.some((line) => line.includes("recent-model · thinking xhigh")));
+						}
 					} finally {
 						component.dispose();
 					}
@@ -506,7 +511,7 @@ describe("native subagent fleet", () => {
 		assert.equal(state.fleetInspectorOpen, false);
 	});
 
-	it("opens the inspector with the FleetView-selected child focused", () => {
+	it("focuses the selected child and renders raw foreground model details", () => {
 		const state = stateForTest();
 		state.foregroundControls.set("run-worker", {
 			runId: "run-worker",
@@ -515,6 +520,8 @@ describe("native subagent fleet", () => {
 			updatedAt: 20,
 			currentAgent: "worker",
 			currentIndex: 0,
+			model: "provider/raw-model",
+			thinking: "medium",
 		});
 		state.foregroundControls.set("run-reviewer", {
 			runId: "run-reviewer",
@@ -524,6 +531,14 @@ describe("native subagent fleet", () => {
 			currentAgent: "reviewer",
 			currentIndex: 0,
 		});
+		state.foregroundRuns!.set("run-recent", {
+			runId: "run-recent",
+			mode: "single",
+			cwd: process.cwd(),
+			sessionId: "session-current",
+			updatedAt: 19,
+			children: [{ agent: "reviewer", index: 0, status: "completed", model: "provider/recent-raw-model", thinking: "xhigh" }],
+		});
 		const component = new SubagentFleetComponent(
 			{ terminal: { rows: 28, columns: 90 }, requestRender() {} } as never,
 			theme as never,
@@ -532,11 +547,148 @@ describe("native subagent fleet", () => {
 			{ initialKey: "foreground-active:run-worker:0", refreshMs: 60_000 },
 		);
 		try {
-			const selectedLine = component.render(90).find((line) => line.includes("›"));
+			const lines = component.render(90);
+			const selectedLine = lines.find((line) => line.includes("›"));
 			assert.ok(selectedLine?.includes("run-work"), `unexpected selected row: ${selectedLine}`);
+			assert.ok(lines.some((line) => line.includes("Model: raw-model · thinking medium")));
 		} finally {
 			component.dispose();
 		}
+
+		const recentComponent = new SubagentFleetComponent(
+			{ terminal: { rows: 28, columns: 90 }, requestRender() {} } as never,
+			theme as never,
+			state,
+			() => {},
+			{ initialKey: "foreground-recent:run-recent:0", refreshMs: 60_000 },
+		);
+		try {
+			assert.ok(recentComponent.render(90).some((line) => line.includes("Model: recent-raw-model · thinking xhigh")));
+		} finally {
+			recentComponent.dispose();
+		}
+	});
+
+	it("steers the selected async child with an inline message", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-steer-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-steer", agents: ["worker", "reviewer"] });
+			const state = stateForTest();
+			const calls: Array<{ runId: string; asyncDir: string; index?: number; message: string }> = [];
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					initialKey: "async:async-steer:0",
+					refreshMs: 60_000,
+					actions: {
+						async steer(input) {
+							calls.push(input);
+							return { text: "Steering queued." };
+						},
+						stop() {
+							return { text: "unused" };
+						},
+					},
+				},
+			);
+			try {
+				component.handleInput("s");
+				assert.ok(component.render(100).some((line) => line.includes("Steer message:")));
+				for (const char of "please continue") component.handleInput(char);
+				component.handleInput("\r");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [{ runId: "async-steer", asyncDir, index: 0, message: "please continue" }]);
+				assert.ok(component.render(100).some((line) => line.includes("Steering queued.")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("confirms stop for the selected async child before calling the action", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-stop-"));
+		try {
+			const asyncDir = writeAsyncRun(root, { id: "async-stop" });
+			const state = stateForTest();
+			const calls: Array<{ runId: string; asyncDir: string; index?: number }> = [];
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					refreshMs: 60_000,
+					actions: {
+						async steer() {
+							return { text: "unused" };
+						},
+						stop(input) {
+							calls.push(input);
+							return { text: "Stop requested." };
+						},
+					},
+				},
+			);
+			try {
+				component.handleInput("D");
+				assert.ok(component.render(100).some((line) => line.includes("Confirm stop for async run async-stop")));
+				component.handleInput("n");
+				assert.deepEqual(calls, []);
+				component.handleInput("D");
+				component.handleInput("y");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [{ runId: "async-stop", asyncDir, index: 0 }]);
+				assert.ok(component.render(100).some((line) => line.includes("Stop requested.")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("explains unavailable controls for completed async children", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-fleet-unavailable-"));
+		try {
+			writeAsyncRun(root, { id: "async-complete", state: "complete" });
+			const state = stateForTest();
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				theme as never,
+				state,
+				() => {},
+				{
+					asyncDirRoot: root,
+					resultsDir: path.join(root, "results"),
+					refreshMs: 60_000,
+					actions: {
+						async steer() {
+							return { text: "unused" };
+						},
+						stop() {
+							return { text: "unused" };
+						},
+					},
+				},
+			);
+			try {
+				component.handleInput("s");
+				assert.ok(component.render(100).some((line) => line.includes("Selected child is complete")));
+			} finally {
+				component.dispose();
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
 	});
 
 	it("refreshes the roster while the inspector remains open", async () => {
@@ -552,6 +704,12 @@ describe("native subagent fleet", () => {
 				() => {},
 				{ asyncDirRoot: root, resultsDir: path.join(root, "results"), refreshMs: 10 },
 			);
+			let invalidations = 0;
+			const originalInvalidate = component.invalidate.bind(component);
+			component.invalidate = () => {
+				invalidations++;
+				originalInvalidate();
+			};
 			try {
 				assert.ok(component.render(90).some((line) => line.includes("No tracked children")));
 				const initialOutput = Array.from({ length: 40 }, (_, index) => `output line ${index}`).join("\n");
@@ -565,6 +723,7 @@ describe("native subagent fleet", () => {
 				lines = component.render(90);
 				assert.ok(lines.some((line) => line.includes("LATEST LIVE OUTPUT")), "live transcript should keep following new output");
 				assert.ok(renderRequests > 0);
+				assert.ok(invalidations > 0, "live refresh must invalidate cached TUI frames before rendering");
 			} finally {
 				component.dispose();
 			}

package/dist/extensions/pi-subagents/test/unit/foreground-control.test.ts

@@ -1,7 +1,14 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import type { AgentProgress, ForegroundRunControl } from "../../src/shared/types.ts";
-import { beginForegroundChild, finishForegroundChild, updateForegroundChild } from "../../src/runs/foreground/foreground-control.ts";
+import {
+	beginForegroundChild,
+	finishForegroundChild,
+	foregroundSchedulingSettled,
+	retainForegroundSchedulingOwner,
+	settleForegroundSchedulingOwner,
+	updateForegroundChild,
+} from "../../src/runs/foreground/foreground-control.ts";
 
 function progress(index: number, agent: string, tokens: number): AgentProgress {
 	return {
@@ -13,6 +20,10 @@ function progress(index: number, agent: string, tokens: number): AgentProgress {
 		recentOutput: [],
 		toolCount: index + 1,
 		tokens,
+		model: "openai/gpt-5.6-terra:high",
+		thinking: "high",
+		inputTokens: tokens - 20,
+		outputTokens: 20,
 		durationMs: 10,
 	};
 }
@@ -28,11 +39,13 @@ describe("foreground child control", () => {
 		};
 		let firstInterrupts = 0;
 		let secondInterrupts = 0;
+		let firstDetaches = 0;
 		beginForegroundChild(control, {
 			index: 0,
 			agent: "reviewer",
 			description: "Review correctness",
 			interrupt: () => { firstInterrupts++; return true; },
+			detach: () => { firstDetaches++; return true; },
 		});
 		beginForegroundChild(control, {
 			index: 1,
@@ -46,10 +59,16 @@ describe("foreground child control", () => {
 		updateForegroundChild(control, 0, progress(0, "reviewer", 120));
 		assert.equal(control.currentIndex, 0);
 		assert.equal(control.tokens, 120);
+		assert.equal(control.inputTokens, 100);
+		assert.equal(control.outputTokens, 20);
+		assert.equal(control.model, "openai/gpt-5.6-terra:high");
+		assert.equal(control.thinking, "high");
 		assert.equal(control.activeChildren?.get(1)?.tokens, undefined);
 		assert.equal(control.interrupt?.(), true);
 		assert.equal(firstInterrupts, 1);
 		assert.equal(secondInterrupts, 0);
+		assert.equal(control.detach?.(), true);
+		assert.equal(firstDetaches, 1);
 
 		updateForegroundChild(control, 1, progress(1, "reviewer", 240));
 		finishForegroundChild(control, 1);
@@ -60,6 +79,27 @@ describe("foreground child control", () => {
 		finishForegroundChild(control, 0);
 		assert.equal(control.activeChildren?.size, 0);
 		assert.equal(control.currentIndex, undefined);
+		assert.equal(control.model, undefined);
+		assert.equal(control.inputTokens, undefined);
+		assert.equal(control.outputTokens, undefined);
 		assert.equal(control.interrupt, undefined);
+		assert.equal(control.detach, undefined);
+	});
+
+	it("settles scheduling only after every owner releases", () => {
+		const control: ForegroundRunControl = {
+			runId: "owned-run",
+			mode: "parallel",
+			startedAt: 1,
+			updatedAt: 1,
+			schedulingOwners: 1,
+		};
+
+		retainForegroundSchedulingOwner(control);
+		settleForegroundSchedulingOwner(control);
+		assert.equal(foregroundSchedulingSettled(control), false);
+		settleForegroundSchedulingOwner(control);
+		assert.equal(foregroundSchedulingSettled(control), true);
+		assert.equal(control.schedulingOwners, 0);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/index-child-registration.test.ts

@@ -60,7 +60,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -104,7 +104,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -155,7 +155,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -207,7 +207,7 @@ describe("subagent extension child mode", () => {
 			const output = execFileSync(
 				process.execPath,
 				[
-					"--experimental-transform-types",
+					"--experimental-strip-types",
 					"--import",
 					"./test/support/register-loader.mjs",
 					"--input-type=module",
@@ -328,7 +328,7 @@ describe("subagent extension child mode", () => {
 			env.SELESAI_CODING_AGENT_DIR = agentDir;
 			execFileSync(
 				process.execPath,
-				["--experimental-transform-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script],
+				["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script],
 				{ cwd: projectRoot, env, stdio: "pipe" },
 			);
 		} finally {
@@ -422,7 +422,7 @@ describe("subagent extension child mode", () => {
 			env.SELESAI_CODING_AGENT_DIR = agentDir;
 			execFileSync(
 				process.execPath,
-				["--experimental-transform-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script],
+				["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script],
 				{ cwd: projectRoot, env, stdio: "pipe" },
 			);
 		} finally {
@@ -458,7 +458,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -493,7 +493,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -529,7 +529,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -574,7 +574,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",
@@ -620,7 +620,7 @@ describe("subagent extension child mode", () => {
 		execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",