@selesai/code 0.13.6 → 0.13.8

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

@@ -241,7 +241,8 @@ describe("async status helpers", () => {
 					nodes: [{ id: "bad", kind: "host-step", label: "bad", status: "running" }],
 				},
 			});
-			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false }), /host step.*expected an object/);
+			fs.rmSync(path.join(root, ACTIVE_RUN_INDEX_DIR, "workflow-host-invalid"));
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false, repairScan: true }), /host step.*expected an object/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -285,7 +286,8 @@ describe("async status helpers", () => {
 				startedAt: 100,
 				steps: [{ agent: "worker", workflowKey: "writer", lane: { version: 1, key: "other" }, status: "running" }],
 			});
-			assert.throws(() => listAsyncRuns(root, { states: ["running"] }), /does not match workflow key/);
+			fs.rmSync(path.join(root, ACTIVE_RUN_INDEX_DIR, "run-lane-invalid"));
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], repairScan: true }), /does not match workflow key/);
 			assert.equal(fs.existsSync(path.join(runDir, "status.json")), true);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
@@ -621,9 +623,10 @@ describe("async status helpers", () => {
 				startedAt: 100,
 				steps: [{ agent: "worker", status: "running" }],
 			});
+			fs.rmSync(path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-session"));
 
 			assert.throws(
-				() => listAsyncRuns(root),
+				() => listAsyncRuns(root, { repairScan: true }),
 				/sessionId must be a string/,
 			);
 		} finally {
@@ -869,6 +872,322 @@ describe("async status helpers", () => {
 		}
 	});
 
+	it("isolates corrupt active status while restoring valid runs and releases an aged marker", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-corrupt-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const corruptDir = path.join(root, "bad-run");
+			const corruptStatusPath = path.join(corruptDir, "status.json");
+			fs.mkdirSync(corruptDir, { recursive: true });
+			fs.writeFileSync(corruptStatusPath, Buffer.from([0, 0, 0]));
+			fs.writeFileSync(path.join(corruptDir, "runner.stderr.log"), "runner stopped unexpectedly\n", "utf-8");
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-run");
+			fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+			fs.writeFileSync(markerPath, "", "utf-8");
+			fs.utimesSync(markerPath, new Date(1_000), new Date(1_000));
+
+			const runs = listAsyncRuns(root, {
+				states: ["running"],
+				reconcile: false,
+				now: () => 1_000 + DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS + 1,
+			});
+
+			assert.deepEqual(runs.map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(corruptDir), true);
+			assert.deepEqual(fs.readFileSync(corruptStatusPath), Buffer.from([0, 0, 0]));
+			assert.equal(fs.readFileSync(path.join(corruptDir, "runner.stderr.log"), "utf-8"), "runner stopped unexpectedly\n");
+			assert.equal(fs.existsSync(markerPath), false);
+			assert.ok(diagnostics.some((message) => message.includes("bad-run") && message.includes(corruptStatusPath) && message.includes("Failed to parse async status file")));
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active status validation failures while preserving ordinary validation errors", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-validation", {
+				runId: "bad-validation",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", workflowKey: "writer", lane: { version: 1, key: "other" }, status: "running" }],
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-validation");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-validation") && message.includes("Failed to validate async status file")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false, repairScan: true }), /Failed to validate async status file/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active reconciliation validation failures while preserving ordinary failures", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-reconcile-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-reconcile", {
+				runId: "bad-reconcile",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", model: 123, status: "running" }],
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-reconcile");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"] }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-reconcile") && message.includes("steps[0].model must be a string")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], repairScan: true }), /steps\[0\]\.model must be a string/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active status summary projection failures while preserving ordinary projection errors", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-summary-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-summary", {
+				runId: "bad-summary",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+				workflowChildren: {
+					version: 1,
+					parentToolCallId: "call_123",
+					workflowRunId: "other-run",
+					inventoryComplete: true,
+					workflowState: "running",
+					children: [],
+				},
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-summary");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-summary") && message.includes("workflowChildren.workflowRunId does not match")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false, repairScan: true }), /workflowChildren\.workflowRunId does not match/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active workflowChildren identifier projection failures while preserving ordinary failures", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-child-id-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-child-id", {
+				runId: "bad-child-id",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+				workflowChildren: {
+					version: 1,
+					parentToolCallId: "   ",
+					workflowRunId: "bad-child-id",
+					inventoryComplete: true,
+					workflowState: "running",
+					children: [],
+				},
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-child-id");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-child-id") && message.includes("workflowChildren.parentToolCallId must be a non-empty identifier")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false, repairScan: true }), /workflowChildren\.parentToolCallId must be a non-empty identifier/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active output file projection failures while preserving ordinary failures", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-output-file-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-output-file", {
+				runId: "bad-output-file",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				outputFile: { path: "output.txt" },
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-output-file");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-output-file") && message.includes("outputFile must be a string")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false, repairScan: true }), /outputFile must be a string/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active workflowGraph host-step projection failures while preserving ordinary failures", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-host-step-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-host-step", {
+				runId: "bad-host-step",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+				workflowGraph: {
+					runId: "bad-host-step",
+					mode: "workflow",
+					phases: [],
+					nodes: [{ id: "gate", kind: "host-step", label: "gate", status: "running" }],
+				},
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-host-step");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-host-step") && message.includes("hostStep': expected an object")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], reconcile: false, repairScan: true }), /hostStep': expected an object/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("isolates active workflowGraph container validation failures while preserving ordinary failures", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-workflow-graph-invalid-active-"));
+		const originalError = console.error;
+		const diagnostics: string[] = [];
+		try {
+			console.error = (...args: unknown[]) => diagnostics.push(args.map(String).join(" "));
+			createAsyncDir(root, "good-run", {
+				runId: "good-run",
+				mode: "single",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			const invalidDir = createAsyncDir(root, "bad-workflow-graph", {
+				runId: "bad-workflow-graph",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+				workflowGraph: {
+					runId: "bad-workflow-graph",
+					mode: "workflow",
+					phases: [],
+					nodes: null,
+				},
+			});
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "bad-workflow-graph");
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"] }).map((run) => run.id), ["good-run"]);
+			assert.equal(fs.existsSync(invalidDir), true);
+			assert.equal(fs.existsSync(markerPath), true);
+			assert.ok(diagnostics.some((message) => message.includes("bad-workflow-graph") && message.includes("workflowGraph': nodes must be an array")));
+
+			fs.rmSync(markerPath);
+			assert.throws(() => listAsyncRuns(root, { states: ["running"], repairScan: true }), /workflowGraph': nodes must be an array/);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("lists recent terminal runs from time-sortable session markers", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-terminal-index-"));
 		try {
@@ -978,4 +1297,4 @@ describe("async status helpers", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/claude-code-smoke.test.ts

@@ -6,11 +6,11 @@ import test from "node:test";
 import { resolveClaudeCodeLaunch } from "../../src/runs/shared/claude-code-adapter.ts";
 import { runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
 
-const enabled = process.env.PI_SUBAGENTS_CLAUDE_CODE_SMOKE === "1";
+const enabled = process.env.SELESAI_SUBAGENTS_CLAUDE_CODE_SMOKE === "1";
 
-test("maintainer Claude Code no-tools smoke", { skip: enabled ? undefined : "set PI_SUBAGENTS_CLAUDE_CODE_SMOKE=1" }, async () => {
-	const reportPath = process.env.PI_SUBAGENTS_CLAUDE_CODE_SMOKE_REPORT;
-	assert.ok(reportPath, "PI_SUBAGENTS_CLAUDE_CODE_SMOKE_REPORT is required");
+test("maintainer Claude Code no-tools smoke", { skip: enabled ? undefined : "set SELESAI_SUBAGENTS_CLAUDE_CODE_SMOKE=1" }, async () => {
+	const reportPath = process.env.SELESAI_SUBAGENTS_CLAUDE_CODE_SMOKE_REPORT;
+	assert.ok(reportPath, "SELESAI_SUBAGENTS_CLAUDE_CODE_SMOKE_REPORT is required");
 	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-claude-smoke-"));
 	const canaryPath = path.join(dir, "write-canary.txt");
 	try {
@@ -49,4 +49,4 @@ test("maintainer Claude Code no-tools smoke", { skip: enabled ? undefined : "set
 	} finally {
 		fs.rmSync(dir, { recursive: true, force: true });
 	}
-});
+});

package/dist/extensions/pi-subagents/test/integration/claude-code-writer-smoke.test.ts

@@ -6,11 +6,11 @@ import test from "node:test";
 import { CLAUDE_CODE_WRITER_TOOLS, resolveClaudeCodeLaunch } from "../../src/runs/shared/claude-code-adapter.ts";
 import { runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
 
-const enabled = process.env.PI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE === "1";
+const enabled = process.env.SELESAI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE === "1";
 
-test("maintainer Claude Code writer smoke", { skip: enabled ? undefined : "set PI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE=1" }, async () => {
-	const reportPath = process.env.PI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE_REPORT;
-	assert.ok(reportPath, "PI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE_REPORT is required");
+test("maintainer Claude Code writer smoke", { skip: enabled ? undefined : "set SELESAI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE=1" }, async () => {
+	const reportPath = process.env.SELESAI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE_REPORT;
+	assert.ok(reportPath, "SELESAI_SUBAGENTS_CLAUDE_CODE_WRITER_SMOKE_REPORT is required");
 	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-claude-writer-smoke-"));
 	const canaryPath = path.join(dir, "write-canary.txt");
 	try {
@@ -52,4 +52,4 @@ test("maintainer Claude Code writer smoke", { skip: enabled ? undefined : "set P
 	} finally {
 		fs.rmSync(dir, { recursive: true, force: true });
 	}
-});
+});

package/dist/extensions/pi-subagents/test/integration/codex-exec-smoke.test.ts

@@ -6,11 +6,11 @@ import test from "node:test";
 import { resolveCodexExecLaunch } from "../../src/runs/shared/codex-exec-adapter.ts";
 import { runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
 
-const enabled = process.env.PI_SUBAGENTS_CODEX_EXEC_SMOKE === "1";
+const enabled = process.env.SELESAI_SUBAGENTS_CODEX_EXEC_SMOKE === "1";
 
-test("maintainer Codex exec read-only smoke", { skip: enabled ? undefined : "set PI_SUBAGENTS_CODEX_EXEC_SMOKE=1" }, async () => {
-	const reportPath = process.env.PI_SUBAGENTS_CODEX_EXEC_SMOKE_REPORT;
-	assert.ok(reportPath, "PI_SUBAGENTS_CODEX_EXEC_SMOKE_REPORT is required");
+test("maintainer Codex exec read-only smoke", { skip: enabled ? undefined : "set SELESAI_SUBAGENTS_CODEX_EXEC_SMOKE=1" }, async () => {
+	const reportPath = process.env.SELESAI_SUBAGENTS_CODEX_EXEC_SMOKE_REPORT;
+	assert.ok(reportPath, "SELESAI_SUBAGENTS_CODEX_EXEC_SMOKE_REPORT is required");
 	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-codex-smoke-"));
 	const canaryPath = path.join(dir, "write-canary.txt");
 	const promptMarker = "CODEX_READ_PRIVATE_PROMPT_MARKER";
@@ -50,4 +50,4 @@ test("maintainer Codex exec read-only smoke", { skip: enabled ? undefined : "set
 	} finally {
 		fs.rmSync(dir, { recursive: true, force: true });
 	}
-});
+});

package/dist/extensions/pi-subagents/test/integration/codex-exec-writer-smoke.test.ts

@@ -6,11 +6,11 @@ import test from "node:test";
 import { resolveCodexExecLaunch } from "../../src/runs/shared/codex-exec-adapter.ts";
 import { runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
 
-const enabled = process.env.PI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE === "1";
+const enabled = process.env.SELESAI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE === "1";
 
-test("maintainer Codex exec workspace writer smoke", { skip: enabled ? undefined : "set PI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE=1" }, async () => {
-	const reportPath = process.env.PI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE_REPORT;
-	assert.ok(reportPath, "PI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE_REPORT is required");
+test("maintainer Codex exec workspace writer smoke", { skip: enabled ? undefined : "set SELESAI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE=1" }, async () => {
+	const reportPath = process.env.SELESAI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE_REPORT;
+	assert.ok(reportPath, "SELESAI_SUBAGENTS_CODEX_EXEC_WRITER_SMOKE_REPORT is required");
 	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-codex-writer-smoke-"));
 	const canaryPath = path.join(dir, "write-canary.txt");
 	const promptMarker = "CODEX_WRITER_PRIVATE_PROMPT_MARKER";
@@ -54,4 +54,4 @@ test("maintainer Codex exec workspace writer smoke", { skip: enabled ? undefined
 	} finally {
 		fs.rmSync(dir, { recursive: true, force: true });
 	}
-});
+});

package/dist/extensions/pi-subagents/test/integration/cursor-agent-smoke.test.ts

@@ -5,11 +5,11 @@ import { resolveCursorAgentLaunch } from "../../src/runs/shared/cursor-agent-ada
 import { runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
 import { cursorSmokeInputs } from "../support/cursor-smoke-inputs.ts";
 
-const enabled = process.env.PI_SUBAGENTS_CURSOR_AGENT_SMOKE === "1";
+const enabled = process.env.SELESAI_SUBAGENTS_CURSOR_AGENT_SMOKE === "1";
 
-test("maintainer Cursor Agent prompt-file read-only smoke", { skip: enabled ? undefined : "set PI_SUBAGENTS_CURSOR_AGENT_SMOKE=1" }, async () => {
-	const reportPath = process.env.PI_SUBAGENTS_CURSOR_AGENT_SMOKE_REPORT;
-	assert.ok(reportPath, "PI_SUBAGENTS_CURSOR_AGENT_SMOKE_REPORT is required");
+test("maintainer Cursor Agent prompt-file read-only smoke", { skip: enabled ? undefined : "set SELESAI_SUBAGENTS_CURSOR_AGENT_SMOKE=1" }, async () => {
+	const reportPath = process.env.SELESAI_SUBAGENTS_CURSOR_AGENT_SMOKE_REPORT;
+	assert.ok(reportPath, "SELESAI_SUBAGENTS_CURSOR_AGENT_SMOKE_REPORT is required");
 	const { workspace, stateRoot, canaryPath, promptDirectory } = cursorSmokeInputs(process.env);
 	const promptMarker = "CURSOR_READ_PRIVATE_PROMPT_MARKER";
 	try {
@@ -56,4 +56,4 @@ test("maintainer Cursor Agent prompt-file read-only smoke", { skip: enabled ? un
 	} finally {
 		fs.rmSync(canaryPath, { force: true });
 	}
-});
+});

package/dist/extensions/pi-subagents/test/integration/cursor-agent-writer-smoke.test.ts

@@ -5,11 +5,11 @@ import { resolveCursorAgentLaunch } from "../../src/runs/shared/cursor-agent-ada
 import { runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
 import { cursorSmokeInputs } from "../support/cursor-smoke-inputs.ts";
 
-const enabled = process.env.PI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE === "1";
+const enabled = process.env.SELESAI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE === "1";
 
-test("maintainer Cursor Agent prompt-file writer smoke", { skip: enabled ? undefined : "set PI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE=1" }, async () => {
-	const reportPath = process.env.PI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE_REPORT;
-	assert.ok(reportPath, "PI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE_REPORT is required");
+test("maintainer Cursor Agent prompt-file writer smoke", { skip: enabled ? undefined : "set SELESAI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE=1" }, async () => {
+	const reportPath = process.env.SELESAI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE_REPORT;
+	assert.ok(reportPath, "SELESAI_SUBAGENTS_CURSOR_AGENT_WRITER_SMOKE_REPORT is required");
 	const { workspace, stateRoot, canaryPath, promptDirectory } = cursorSmokeInputs(process.env);
 	const promptMarker = "CURSOR_WRITER_PRIVATE_PROMPT_MARKER";
 	try {
@@ -59,4 +59,4 @@ test("maintainer Cursor Agent prompt-file writer smoke", { skip: enabled ? undef
 	} finally {
 		fs.rmSync(canaryPath, { force: true });
 	}
-});
+});

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

@@ -246,4 +246,4 @@ describe("detectSubagentError", { skip: !available ? "utils not importable" : un
 		assert.equal(result.hasError, false,
 			"complete review with trailing EISDIR must not be flagged as failure");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/doctor-executor.test.ts

@@ -125,4 +125,4 @@ describe("doctor action executor routing", { skip: !createSubagentExecutor ? "ex
 		assert.match(text, /- session manager: failed — Error: session unavailable/);
 		assert.match(text, /- current session file: not available/);
 	});
-});
+});

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

@@ -278,4 +278,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/external-cli-runner.test.ts

@@ -164,4 +164,4 @@ describe("external CLI async lifecycle", () => {
 		assert.equal(args[args.indexOf("--worktree") + 1], `path:${path.resolve(dir)}`);
 		assert.match(args[args.indexOf("--title") + 1], /subagents · external/);
 	});
-});
+});

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

@@ -185,4 +185,4 @@ describe("foreground result payload compaction", { skip: !available ? "subagent
 		const payloadSize = JSON.stringify(result).length;
 		assert.ok(payloadSize < 80_000, `expected compact foreground payload, got ${payloadSize} bytes`);
 	});
-});
+});

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

@@ -527,6 +527,57 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		assert.equal(entries[3].thinkingLevel, "off");
 	});
 
+	it("uses an explicit Anthropic model for fork thinking preparation", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const childSessionFile = path.join(tempDir, "fork-explicit-anthropic.jsonl");
+		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => parentSessionFile,
+			getLeafId: () => "assistant-1",
+			openSession: () => ({
+				createBranchedSession: () => {
+					fs.writeFileSync(childSessionFile, [
+						{ type: "session", version: 1, id: "child", timestamp: "2026-04-16T00:00:00.000Z", cwd: "/tmp", parentSession: parentSessionFile },
+						{ type: "message", id: "assistant-1", parentId: null, timestamp: "2026-04-16T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude-sonnet-4-5", content: [{ type: "thinking", thinking: "private chain", thinkingSignature: "signed" }, { type: "text", text: "answer" }] } },
+					].map((entry) => JSON.stringify(entry)).join("\n") + "\n", "utf-8");
+					return childSessionFile;
+				},
+			}),
+		};
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork", model: "openai/gpt-5-mini:high", thinking: "high" },
+			],
+			projectAgentsDir: null,
+		}));
+		const ctx = {
+			...makeCtx(manager),
+			modelRegistry: {
+				getAvailable: () => [
+					{ provider: "openai", id: "gpt-5-mini", api: "openai-responses", reasoning: true },
+					{ provider: "anthropic", id: "claude-sonnet-4-5", api: "anthropic-messages", reasoning: true },
+				],
+			},
+		};
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "worker", task: "test", model: "anthropic/claude-sonnet-4-5:high" },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		);
+
+		assert.equal(result.isError, undefined);
+		const args = readCallArgs();
+		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:off");
+		const entries = fs.readFileSync(childSessionFile, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+		assert.deepEqual(entries[1].message.content, [{ type: "text", text: "answer" }]);
+		assert.equal(entries[2].type, "thinking_level_change");
+		assert.equal(entries[2].thinkingLevel, "off");
+	});
+
 	it("forces every foreground fallback attempt off after sanitizing inherited signed thinking", async () => {
 		mockPi.reset();
 		mockPi.onCall({
@@ -1298,4 +1349,4 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 			removeTempDir(tempHome);
 		}
 	});
-});
+});

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

@@ -985,7 +985,8 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			assert.equal(result.isError, undefined);
 			assert.match(result.content[0]?.text ?? "", /Revived async subagent from/);
 			assert.match(result.content[0]?.text ?? "", /Do not run sleep timers or polling loops/);
-			assert.match(result.content[0]?.text ?? "", /call subagent_wait\(\)/);
+			assert.match(result.content[0]?.text ?? "", /Use bg_wait only/);
+			assert.doesNotMatch(result.content[0]?.text ?? "", /subagent_wait/);
 			assert.match(result.content[0]?.text ?? "", /Status if needed: subagent\(\{ action: "status"/);
 			assert.doesNotMatch(result.content[0]?.text ?? "", /Follow:/);
 			const revivedId = result.details?.asyncId;
@@ -1494,7 +1495,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		const runId = original.details?.runId;
 		assert.ok(runId, "expected foreground run id");
 		assert.equal(original.details?.results?.[0]?.acceptance?.status, "pending");
-		assert.match(original.content[0]?.text ?? "", /subagent_wait\(\{ id:/);
+		assert.match(original.content[0]?.text ?? "", /bg_wait\(\{ id:/);
 		const metadataPath = original.details?.results?.[0]?.artifactPaths?.metadataPath;
 		assert.ok(metadataPath);
 		const pendingMetadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8")) as { acceptance?: { status?: string } };
@@ -1943,4 +1944,4 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.match(message, /process failed · output absent/);
 		assert.doesNotMatch(message, /Inspect that output before retrying/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/orca-progress-tabs.test.ts

@@ -211,4 +211,4 @@ describe("Orca progress-tab observer", () => {
 		const createdOrder = fs.readFileSync(orderFile, "utf-8").trim().split("\n");
 		assert.deepEqual(createdOrder, titles);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/render-fork-badge.test.ts

@@ -1405,4 +1405,4 @@ describe("renderSubagentResult fork indicator", () => {
 		}
 	});
 
-});
+});