@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/unit/active-async-capacity.test.ts

@@ -460,4 +460,55 @@ describe("active async capacity", () => {
 			}
 		}
 	});
-});
+
+	it("reclaims a terminal workflow only when every unresolved async child is an old failed run with a dead runner", () => {
+		type Child = { state: string; lastActivityAt?: number; pid?: "dead" | "alive"; sessionId?: string; runnerId?: unknown; pidNamespace?: string };
+		const abandoned: Child = { state: "failed", lastActivityAt: 0, pid: "dead" };
+		const cases: Array<{ name: string; children: Child[]; endedAt?: number; threshold?: number | false; releases: boolean }> = [
+			{ name: "abandoned children", children: [abandoned, abandoned], releases: true },
+			{ name: "later child still running", children: [abandoned, { state: "running" }], releases: false },
+			{ name: "workflow ended recently", children: [abandoned], endedAt: 9_500, releases: false },
+			{ name: "child active recently", children: [{ ...abandoned, lastActivityAt: 9_500 }], releases: false },
+			{ name: "unresolved complete child", children: [{ ...abandoned, state: "complete" }], releases: false },
+			{ name: "child runner alive", children: [{ ...abandoned, pid: "alive" }], releases: false },
+			{ name: "child runner in another PID namespace", children: [{ ...abandoned, pidNamespace: "pid:[2]" }], releases: false },
+			{ name: "child from another session", children: [{ ...abandoned, sessionId: "other-session" }], releases: false },
+			{ name: "malformed child runner identity", children: [{ ...abandoned, runnerId: 42 }], releases: false },
+			{ name: "strict mode", children: [abandoned], threshold: false, releases: false },
+		];
+		for (const testCase of cases) {
+			const rootDir = tempRoot();
+			const asyncRoot = path.join(rootDir, "runs");
+			const workflowDir = path.join(asyncRoot, "workflow");
+			const pids = new Map<number, "dead" | "alive">();
+			try {
+				const workflow = acquireActiveAsyncCapacity({ sessionId: "session-a", limit: 1, runId: "workflow", kind: "workflow", asyncDir: workflowDir }, { rootDir });
+				assert.ok(workflow);
+				workflow.markWorkflowStarted();
+				const steps = testCase.children.map((child, index) => {
+					const runId = `child-${index}`;
+					const pid = 50_000 + index;
+					pids.set(pid, child.pid ?? "alive");
+					writeJson(path.join(asyncRoot, runId, "status.json"), { runId, sessionId: child.sessionId ?? "session-a", mode: "single", state: child.state, pid, pidNamespaceScope: child.pidNamespace ?? "pid:[1]", startedAt: 0, lastActivityAt: child.lastActivityAt, processTerminal: { version: 1, state: "pending", runId, runnerProcessInstanceId: child.runnerId ?? `runner-${index}` } });
+					writeJson(path.join(asyncRoot, runId, "process-terminal.json"), { version: 1, state: "pending", runId, runnerProcessInstanceId: `runner-${index}` });
+					return { agent: "worker", workflowKey: runId, runId, async: true, status: child.state };
+				});
+				writeJson(path.join(workflowDir, "status.json"), { runId: "workflow", sessionId: "session-a", mode: "workflow", state: "failed", startedAt: 0, endedAt: testCase.endedAt ?? 0, steps });
+				const options = { rootDir, now: () => 10_000, pidLiveness: (pid: number) => pids.get(pid) ?? "unknown" as const, pidNamespaceScope: () => "pid:[1]", abandonedSlotReleaseAfterMs: testCase.threshold ?? 1_000 };
+
+				const inspection = inspectActiveAsyncCapacityOwner({ runId: "workflow", sessionId: "session-a" }, options);
+				assert.equal(inspection.release.state, testCase.releases ? "releasable" : "retained", testCase.name);
+				assert.deepEqual(getActiveAsyncCapacitySnapshot("session-a", 1, options), { used: testCase.releases ? 0 : 1, limit: 1 }, testCase.name);
+				if (testCase.releases) {
+					const event = JSON.parse(fs.readFileSync(path.join(workflowDir, "events.jsonl"), "utf-8"));
+					assert.equal(event.releasedBy, "abandoned-timeout");
+					assert.equal(event.processProof, "unknown");
+					assert.equal(event.controller, "unregistered");
+					assert.deepEqual(event.abandonedChildren.map((child: { runId: string }) => child.runId), ["child-0", "child-1"]);
+				}
+			} finally {
+				fs.rmSync(rootDir, { recursive: true, force: true });
+			}
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/advertised-agent-prompt.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { appendAdvertisedAgentPrompt, buildAdvertisedAgentPrompt } from "../../src/agents/advertised-agent-prompt.ts";
+import { buildAdvertisedAgentCatalog, buildAdvertisedAgentPrompt } from "../../src/agents/advertised-agent-prompt.ts";
 import type { AgentConfig } from "../../src/agents/agents.ts";
 
 function agent(name: string, overrides: Partial<AgentConfig> = {}): AgentConfig {
@@ -52,21 +52,8 @@ describe("advertised agent prompt", () => {
 		assert.match(prompt, /<omitted count="2" \/>/);
 	});
 
-	it("replaces an existing catalog instead of duplicating it", () => {
-		const first = buildAdvertisedAgentPrompt([agent("alpha", { advertise: true })]);
-		const second = buildAdvertisedAgentPrompt([agent("beta", { advertise: true })]);
-		assert.ok(first);
-		assert.ok(second);
-
-		const systemPrompt = appendAdvertisedAgentPrompt(appendAdvertisedAgentPrompt("base prompt", first), second);
-		assert.equal(systemPrompt.match(/<advertised_subagents>/gu)?.length, 1);
-		assert.doesNotMatch(systemPrompt, /<name>alpha<\/name>/);
-		assert.match(systemPrompt, /<name>beta<\/name>/);
-	});
-
 	it("returns no catalog when no agent opts in", () => {
 		assert.equal(buildAdvertisedAgentPrompt([agent("hidden")]), undefined);
-		assert.equal(appendAdvertisedAgentPrompt("base prompt\n\n", undefined), "base prompt\n\n");
 	});
 
 	it("admits an exact-budget canonical name and omits it one byte over", () => {
@@ -80,8 +67,25 @@ describe("advertised agent prompt", () => {
 		assert.match(over, /<omitted count="1"/);
 	});
 
-	it("withdraws a reused catalog when the last advertised agent disappears", () => {
-		const prior = appendAdvertisedAgentPrompt("base prompt", buildAdvertisedAgentPrompt([agent("alpha", { advertise: true })]));
-		assert.equal(appendAdvertisedAgentPrompt(prior, buildAdvertisedAgentPrompt([])), "base prompt");
+	it("builds a section body without the outer tag that Pi adds from the section key", () => {
+		const agents = [agent("alpha", { advertise: true }), agent("hidden")];
+		const body = buildAdvertisedAgentCatalog(agents)!;
+		assert.doesNotMatch(body, /advertised_subagents/);
+		assert.match(body, /<name>alpha<\/name>/);
+		assert.doesNotMatch(body, /hidden/);
+		assert.equal(buildAdvertisedAgentPrompt(agents), `<advertised_subagents>\n${body}\n</advertised_subagents>`);
+		assert.equal(buildAdvertisedAgentCatalog([agent("hidden")]), undefined);
+	});
+
+	it("bounds the section body by the same wrapped byte budget", () => {
+		const agents = Array.from({ length: 40 }, (_, index) => agent(`agent-${String(index).padStart(2, "0")}`, {
+			advertise: true,
+			description: "🦜界".repeat(200),
+		}));
+		const body = buildAdvertisedAgentCatalog(agents)!;
+		const wrapped = buildAdvertisedAgentPrompt(agents)!;
+		assert.equal(wrapped, `<advertised_subagents>\n${body}\n</advertised_subagents>`);
+		assert.ok(Buffer.byteLength(wrapped) <= 12_288);
+		assert.match(body, /<omitted count="\d+" \/>/);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/advertised-agent-refresh.test.ts

@@ -30,7 +30,7 @@ it("emits bounded file-only snapshots, refreshes through management, and perform
 				"---\nname: " + name + "\ndescription: " + description + "\nadvertise: " + advertise + "\n---\nAct narrowly.\n");
 			const handlers = new Map();
 			let tool;
-			let activeTools = ["subagent"];
+			const activeTools = ["subagent"];
 			const pi = new Proxy({
 				events: { on() { return () => {}; }, emit() {} },
 				on(event, handler) { handlers.set(event, [...(handlers.get(event) ?? []), handler]); },
@@ -39,15 +39,16 @@ it("emits bounded file-only snapshots, refreshes through management, and perform
 			}, { get(target, key) { return key in target ? target[key] : () => undefined; } });
 			register(pi);
 			const ctx = {
-				cwd, hasUI: false, model: { provider: "test", id: "test" },
+				cwd, isIdle() { return false; }, hasUI: false, model: { provider: "test", id: "test" },
 				modelRegistry: { getAvailable() { return []; }, getAll() { return []; } },
 				sessionManager: { getSessionId() { return "advertised-test"; }, getSessionFile() { return undefined; }, getBranch() { return []; } },
 			};
-			// Invoke the registered catalog lifecycle hook; unrelated host services are not started by this harness.
-			const refresh = (reason = "reload") => handlers.get("session_start").at(-1)({ reason }, ctx);
-			const emit = (systemPrompt = "base", selectedTools = activeTools) => {
-				const result = handlers.get("before_agent_start").at(-1)({ systemPrompt, systemPromptOptions: { selectedTools: selectedTools ?? undefined } }, ctx);
-				return result?.systemPrompt ?? systemPrompt;
+			// Invoke the catalog hooks directly; activation lifecycle is registered after them.
+			const refresh = (reason = "reload") => handlers.get("session_start").at(-2)({ reason }, ctx);
+			const emit = async (_previous = "base", selectedTools = activeTools) => {
+				const sections = {};
+				await handlers.get("before_agent_start").at(-2)({ systemPrompt: "base", systemPromptOptions: { selectedTools, sections } }, ctx);
+				return sections.advertised_subagents ?? "base";
 			};
 			const io = { statSync: 0, readdirSync: 0, readFileSync: 0 };
 			const originals = {};
@@ -56,67 +57,67 @@ it("emits bounded file-only snapshots, refreshes through management, and perform
 				fs[key] = (...args) => { io[key]++; return originals[key](...args); };
 			}
 			syncBuiltinESMExports();
-			const noIo = (fn) => {
+			const noIo = async (fn) => {
 				const before = { ...io };
-				const result = fn();
+				const result = await fn();
 				assert.deepEqual(io, before, "prompt emission must not stat, readdir, or read files");
 				return result;
 			};
 			refresh("startup");
-			noIo(() => { for (let i = 0; i < 20; i++) assert.equal(emit(), "base"); });
+			await emit();
+			await noIo(async () => { for (let i = 0; i < 20; i++) assert.equal(await emit(), "base"); });
 			for (let i = 0; i < 250; i++) write("hidden-" + i, "hidden-" + i, "hidden", false);
 			refresh();
-			noIo(() => { for (let i = 0; i < 20; i++) assert.equal(emit(), "base"); });
+			await emit();
+			await noIo(async () => { for (let i = 0; i < 20; i++) assert.equal(await emit(), "base"); });
 			write("specialist", "specialist", "Original specialist");
-			assert.equal(noIo(() => emit()), "base", "external edits wait for reload");
+			assert.equal(await noIo(() => emit()), "base", "external edits wait for reload");
 			refresh();
-			let prompt = noIo(() => emit());
+			await emit();
+			let prompt = await noIo(() => emit());
 			assert.match(prompt, /<name>specialist<\/name>/);
 			assert.doesNotMatch(prompt, /hidden-/);
 			assert.match(prompt, /Before execution.*action: "list", capabilities: true/);
-			assert.equal(noIo(() => emit(prompt, ["read"])), "base");
-			activeTools = ["read"];
-			assert.equal(noIo(() => emit(prompt, null)), "base");
-			activeTools = ["subagent"];
+			assert.equal(await noIo(() => emit(prompt, ["read"])), "base");
 			const ceiling = registerSubagentCapabilityCeiling({ sessionId: "advertised-test", source: "test", ceiling: { allowedAgents: [] } });
-			assert.equal(noIo(() => emit(prompt)), "base");
+			assert.equal(await noIo(() => emit(prompt)), "base");
 			ceiling.dispose();
-			assert.match(noIo(() => emit()), /Original specialist/);
+			assert.match(await noIo(() => emit()), /Original specialist/);
 			const manage = async (params) => tool.execute("manage", params, new AbortController().signal, undefined, ctx);
 			write("pending", "pending", "External change awaiting refresh");
 			await manage({ action: "get", agent: "specialist" });
-			assert.doesNotMatch(noIo(() => emit()), /<name>pending<\/name>/, "reads must not refresh");
+			assert.doesNotMatch(await noIo(() => emit()), /<name>pending<\/name>/, "reads must not refresh");
 			await assert.rejects(manage({ action: "update", agent: "specialist", config: { advertise: "invalid" } }), /config.advertise must be a boolean/);
-			assert.doesNotMatch(noIo(() => emit()), /<name>pending<\/name>/, "failed mutations must not refresh");
+			assert.doesNotMatch(await noIo(() => emit()), /<name>pending<\/name>/, "failed mutations must not refresh");
 			fs.unlinkSync(path.join(dir, "pending.md"));
 			let result = await manage({ action: "update", agent: "specialist", config: { description: "Updated specialist" } });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			assert.match(noIo(() => emit(prompt)), /Updated specialist/);
+			assert.match(await noIo(() => emit(prompt)), /Updated specialist/);
 			assert.match(fs.readFileSync(path.join(dir, "specialist.md"), "utf8"), /advertise: true/);
 			result = await manage({ action: "disable", agent: "specialist", agentScope: "user" });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			assert.equal(noIo(() => emit(prompt)), "base");
+			assert.equal(await noIo(() => emit(prompt)), "base");
 			result = await manage({ action: "enable", agent: "specialist", agentScope: "user" });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			prompt = noIo(() => emit());
+			prompt = await noIo(() => emit());
 			assert.match(prompt, /Updated specialist/);
 			result = await manage({ action: "delete", agent: "specialist", agentScope: "user" });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			assert.equal(noIo(() => emit(prompt)), "base");
+			assert.equal(await noIo(() => emit(prompt)), "base");
 			result = await manage({ action: "create", config: { name: "created", description: "Created specialist", systemPrompt: "Act narrowly.", scope: "user", advertise: true } });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			assert.match(noIo(() => emit()), /<name>created<\/name>/);
+			assert.match(await noIo(() => emit()), /<name>created<\/name>/);
 			result = await manage({ action: "update", agent: "created", config: { name: "renamed" } });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			prompt = noIo(() => emit());
+			prompt = await noIo(() => emit());
 			assert.match(prompt, /<name>renamed<\/name>/);
 			assert.doesNotMatch(prompt, /<name>created<\/name>/);
 			result = await manage({ action: "update", agent: "renamed", config: { advertise: false } });
 			assert.notEqual(result.isError, true, JSON.stringify(result));
-			assert.equal(noIo(() => emit(prompt)), "base");
+			assert.equal(await noIo(() => emit(prompt)), "base");
 			// Inject a refresh-only read failure after the management file write has succeeded.
 			await manage({ action: "update", agent: "renamed", config: { advertise: true } });
-			prompt = noIo(() => emit());
+			prompt = await noIo(() => emit());
 			assert.match(prompt, /<name>renamed<\/name>/);
 			const writeFile = fs.writeFileSync;
 			fs.writeFileSync = (file, ...args) => {
@@ -128,20 +129,23 @@ it("emits bounded file-only snapshots, refreshes through management, and perform
 			result = await manage({ action: "update", agent: "renamed", config: { description: "Persisted despite refresh failure" } });
 			assert.notEqual(result.isError, true, "refresh failure must not change the persisted mutation result");
 			assert.match(fs.readFileSync(path.join(dir, "renamed.md"), "utf8"), /advertise: true/);
-			assert.equal(noIo(() => emit(prompt)), "base", "failed refresh withdraws stale guidance");
-			assert.throws(() => refresh(), /Failed to parse settings file/, "reload discovery errors must reach the host");
+			assert.equal(await noIo(() => emit(prompt)), "base", "failed refresh withdraws stale guidance");
+			refresh();
+			await assert.rejects(emit(), /Failed to parse settings file/, "reload discovery errors must reach the host");
 			fs.writeFileSync = writeFile;
 			syncBuiltinESMExports();
 			fs.unlinkSync(path.join(home, "settings.json"));
 			refresh();
-			assert.match(noIo(() => emit()), /<name>renamed<\/name>/);
+			await emit();
+			assert.match(await noIo(() => emit()), /<name>renamed<\/name>/);
 			await manage({ action: "delete", agent: "renamed", agentScope: "user" });
 			write("huge", "a".repeat(100000), "huge name");
 			write("escaped-name", "b" + "&".repeat(4000), "escaped huge name");
 			for (let i = 0; i < 25; i++) write("opt-" + i, "pkg.opt-" + i, i % 2 ? '<>&"'.repeat(300) : "🦜界".repeat(300));
 			refresh();
-			prompt = noIo(() => { let result; for (let i = 0; i < 20; i++) result = emit(); return result; });
-			const catalog = prompt.slice(prompt.indexOf("<advertised_subagents>"));
+			await emit();
+			prompt = await noIo(async () => { let result; for (let i = 0; i < 20; i++) result = await emit(); return result; });
+			const catalog = prompt;
 			assert.ok(Buffer.byteLength(catalog) <= 12288);
 			assert.doesNotMatch(catalog, /<name>[ab]/);
 			assert.match(catalog, /&lt;&gt;&amp;&quot;/);
@@ -151,9 +155,10 @@ it("emits bounded file-only snapshots, refreshes through management, and perform
 			assert.match(catalog, /<name>pkg\.opt-\d+<\/name>/);
 			assert.match(catalog, /<omitted count="\d+"/);
 			for (const file of fs.readdirSync(dir)) fs.unlinkSync(path.join(dir, file));
-			assert.equal(noIo(() => emit()), prompt, "external removal waits for reload");
+			assert.equal(await noIo(() => emit()), prompt, "external removal waits for reload");
 			refresh();
-			assert.equal(noIo(() => emit(prompt)), "base");
+			await emit();
+			assert.equal(await noIo(() => emit(prompt)), "base");
 			process.stdout.write("prompt contracts passed; zero prompt-time stat/readdir/readFile calls at 0, 250, and 277 definitions");
 		`], { cwd: root, env, encoding: "utf8", timeout: 60_000 });
 		assert.match(output, /prompt contracts passed/);
@@ -161,3 +166,67 @@ it("emits bounded file-only snapshots, refreshes through management, and perform
 		fs.rmSync(home, { recursive: true, force: true });
 	}
 });
+
+it("delivers the catalog as a structured prompt section instead of replacing the system prompt", () => {
+	const home = fs.mkdtempSync(path.join(os.tmpdir(), "advertised-section-"));
+	const env = { ...process.env, SELESAI_CODING_AGENT_DIR: home };
+	delete env[SUBAGENT_CHILD_ENV];
+	try {
+		const output = execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", String.raw`
+			import assert from "node:assert/strict";
+			import fs from "node:fs";
+			import path from "node:path";
+			import register from "./src/extension/index.ts";
+			import { registerSubagentCapabilityCeiling } from "./src/runs/shared/capability-ceiling.ts";
+			const home = process.env.SELESAI_CODING_AGENT_DIR;
+			const cwd = path.join(home, "project");
+			fs.mkdirSync(path.join(cwd, ".selesai"), { recursive: true });
+			const dir = path.join(home, "agents");
+			fs.mkdirSync(dir);
+			fs.writeFileSync(path.join(dir, "specialist.md"), "---\nname: specialist\ndescription: Section specialist\nadvertise: true\n---\nAct narrowly.\n");
+			const handlers = new Map();
+			const pi = new Proxy({
+				events: { on() { return () => {}; }, emit() {} },
+				on(event, handler) { handlers.set(event, [...(handlers.get(event) ?? []), handler]); },
+				registerTool() {},
+				getActiveTools() { return ["subagent"]; },
+			}, { get(target, key) { return key in target ? target[key] : () => undefined; } });
+			register(pi);
+			const ctx = {
+				cwd, isIdle() { return false; }, hasUI: false, model: { provider: "test", id: "test" },
+				modelRegistry: { getAvailable() { return []; }, getAll() { return []; } },
+				sessionManager: { getSessionId() { return "section-test"; }, getSessionFile() { return undefined; }, getBranch() { return []; } },
+			};
+			handlers.get("session_start").at(-2)({ reason: "startup" }, ctx);
+			const before = handlers.get("before_agent_start").at(-2);
+			const emit = async (selectedTools, sections = {}) => {
+				const event = { systemPrompt: "base", systemPromptOptions: { selectedTools, sections } };
+				return { result: await before(event, ctx), sections: event.systemPromptOptions.sections };
+			};
+
+			let turn = await emit(["subagent"]);
+			assert.equal(turn.result, undefined, "the sections path must not return systemPrompt");
+			assert.match(turn.sections.advertised_subagents, /<name>specialist<\/name>/);
+			assert.match(turn.sections.advertised_subagents, /Section specialist/);
+			assert.doesNotMatch(turn.sections.advertised_subagents, /advertised_subagents/, "Pi adds the tag from the section key");
+
+			turn = await emit(["read"]);
+			assert.equal(turn.result, undefined);
+			assert.equal("advertised_subagents" in turn.sections, false, "no section when subagent is not selected");
+
+			const ceiling = registerSubagentCapabilityCeiling({ sessionId: "section-test", source: "test", ceiling: { allowedAgents: [] } });
+			turn = await emit(["subagent"]);
+			assert.equal(turn.result, undefined);
+			assert.equal("advertised_subagents" in turn.sections, false, "no section when the ceiling excludes every agent");
+			ceiling.dispose();
+
+			turn = await emit(["subagent"], { other: "kept" });
+			assert.equal(turn.sections.other, "kept", "other sections are untouched");
+			assert.match(turn.sections.advertised_subagents, /<name>specialist<\/name>/);
+			process.stdout.write("section delivery passed");
+		`], { cwd: root, env, encoding: "utf8", timeout: 60_000 });
+		assert.match(output, /section delivery passed/);
+	} finally {
+		fs.rmSync(home, { recursive: true, force: true });
+	}
+});

package/dist/extensions/pi-subagents/test/unit/advertisement-barrier.test.ts

@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { SUBAGENT_CHILD_ENV } from "../../src/runs/shared/child-runtime-config.ts";
+
+const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+it("session startup yields to the event loop and both first advertisements await the complete global catalog", () => {
+	const temp = fs.mkdtempSync(path.join(os.tmpdir(), "advertisement-barrier-"));
+	try {
+		const fixtureRoot = path.join(temp, "quote's & space");
+		const bin = path.join(fixtureRoot, "bin");
+		const globalRoot = path.join(fixtureRoot, "global", "node_modules");
+		const newerRoot = path.join(fixtureRoot, "newer", "node_modules");
+		const packageDir = path.join(globalRoot, "example");
+		const newerPackage = path.join(newerRoot, "example");
+		const localDir = path.join(fixtureRoot, "project", ".selesai", "agents");
+		fs.mkdirSync(bin, { recursive: true });
+		fs.mkdirSync(path.join(packageDir, "agents"), { recursive: true });
+		fs.mkdirSync(path.join(newerPackage, "agents"), { recursive: true });
+		fs.mkdirSync(localDir, { recursive: true });
+		fs.writeFileSync(path.join(packageDir, "package.json"), JSON.stringify({ name: "example", "pi-subagents": { agents: ["agents"] } }));
+		fs.writeFileSync(path.join(newerPackage, "package.json"), JSON.stringify({ name: "example", "pi-subagents": { agents: ["agents"] } }));
+		const agent = (name: string) => `---\nname: ${name}\ndescription: ${name}\nadvertise: true\n---\nWork.\n`;
+		fs.writeFileSync(path.join(packageDir, "agents", "global-specialist.md"), agent("global-specialist"));
+		fs.writeFileSync(path.join(newerPackage, "agents", "new-specialist.md"), agent("new-specialist"));
+		fs.writeFileSync(path.join(localDir, "local-specialist.md"), agent("local-specialist"));
+		const oldDone = path.join(temp, "old-lookup-finished");
+		fs.writeFileSync(path.join(bin, "fake-npm.cjs"), `
+const fs = require("node:fs");
+const phase = process.env.TEST_NPM_PHASE;
+if (phase === "failure") { console.error("private npm failure"); process.exit(1); }
+setTimeout(() => { if (phase === "old") fs.writeFileSync(${JSON.stringify(oldDone)}, "done"); if (phase !== "timeout") console.log(phase === "latest" ? ${JSON.stringify(newerRoot)} : ${JSON.stringify(globalRoot)}); }, phase === "timeout" ? 6000 : phase === "old" ? 2500 : phase === "seed" || phase === "latest" ? 150 : 300);
+`);
+		const npm = path.join(bin, process.platform === "win32" ? "npm.cmd" : "npm");
+		fs.writeFileSync(npm, process.platform === "win32"
+			? `@echo off\r\n"${process.execPath}" "%~dp0fake-npm.cjs" %*\r\n`
+			: `#!/bin/sh\nexec "${process.execPath}" "$(dirname "$0")/fake-npm.cjs" "$@"\n`);
+		if (process.platform !== "win32") fs.chmodSync(npm, 0o755);
+		const env = { ...process.env, PATH: `${bin}${path.delimiter}${process.env.PATH ?? ""}`, HOME: path.join(temp, "home"), USERPROFILE: path.join(temp, "home"), SELESAI_CODING_AGENT_DIR: path.join(temp, "home"), TEST_PROJECT: path.join(fixtureRoot, "project"), TEST_OLD_DONE: oldDone, TEST_NPM_PHASE: "initial", APPDATA: path.join(temp, "missing-appdata") };
+		delete env.PI_OFFLINE;
+		delete env[SUBAGENT_CHILD_ENV];
+		const output = execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", String.raw`
+			import assert from "node:assert/strict";
+			import fs from "node:fs";
+			import path from "node:path";
+			import register from "./src/extension/index.ts";
+			import { discoverAgents } from "./src/agents/agents.ts";
+			import { registerRuntimeAgent } from "./src/agents/runtime-agent-registry.ts";
+			const hooks = new Map();
+			const tools = new Map();
+			let active = ["subagents_enable"];
+			const pi = new Proxy({
+				events: { on() { return () => {}; }, emit() {} },
+				on(name, handler) { hooks.set(name, [...(hooks.get(name) ?? []), handler]); },
+				registerTool(tool) { tools.set(tool.name, tool); },
+				getAllTools() { return [...tools.values()].map(({ name }) => ({ name })); },
+				getActiveTools() { return active; },
+				setActiveTools(next) { active = next; },
+			}, { get(target, key) { return key in target ? target[key] : () => undefined; } });
+			register(pi);
+			const ctx = {
+				cwd: process.env.TEST_PROJECT, isIdle() { return false; }, hasUI: false, model: { provider: "test", id: "test" },
+				modelRegistry: { getAvailable() { return []; }, getAll() { return []; } },
+				sessionManager: { getSessionId() { return "barrier-test"; }, getSessionFile() { return undefined; }, getBranch() { return []; }, buildSessionContext() { return { messages: [] }; } },
+			};
+			const start = hooks.get("session_start").at(-2);
+			const before = hooks.get("before_agent_start").at(-2);
+			const advertise = async () => {
+				const event = { systemPrompt: "base", systemPromptOptions: { selectedTools: ["subagent"], sections: {} } };
+				await before(event, ctx);
+				return event.systemPromptOptions.sections.advertised_subagents;
+			};
+			start({ reason: "startup" }, ctx);
+			let tick = false;
+			setTimeout(() => { tick = true; }, 10);
+			const firstPrompt = advertise();
+			const enabled = tools.get("subagents_enable").execute("id", {}, new AbortController().signal, undefined, ctx);
+			const firstExecution = tools.get("subagent").execute("immediate", { agent: "global-specialist", task: "Probe", async: false }, new AbortController().signal, undefined, ctx)
+				.then((result) => JSON.stringify(result), (error) => error.message);
+			const firstList = tools.get("subagent").execute("list", { action: "list" }, new AbortController().signal, undefined, ctx);
+			await new Promise((resolve) => setTimeout(resolve, 50));
+			assert.equal(tick, true, "npm did not block event loop");
+			let complete = false;
+			void firstPrompt.then(() => { complete = true; });
+			assert.equal(complete, false, "first prompt returned before global lookup");
+			const [prompt, loader, firstRun, listed] = await Promise.all([firstPrompt, enabled, firstExecution, firstList]);
+			assert.match(firstRun, /global-specialist/);
+			assert.doesNotMatch(firstRun, /Unknown agent|not found/i);
+			assert.match(JSON.stringify(listed), /global-specialist/);
+			for (const text of [prompt, loader.content[0].text]) {
+				assert.match(text, /<name>global-specialist<\/name>/);
+				assert.match(text, /<name>local-specialist<\/name>/);
+			}
+			assert.match(loader.content[0].text, /If your tool list includes subagent \(possibly prefixed\), call subagent\(\{action:"list",capabilities:true\}\)\./);
+			assert.match(loader.content[0].text, /Otherwise, wait for the next user prompt; do not retry now\./);
+			assert.match(loader.content[0].text, /Start Pi with --exclude-tools subagents_enable to keep subagent always available\./);
+			process.env.TEST_NPM_PHASE = "seed";
+			assert.ok(discoverAgents(ctx.cwd, "both").agents.some((agent) => agent.name === "global-specialist"));
+			process.env.TEST_NPM_PHASE = "old";
+			start({ reason: "reload" }, ctx);
+			await new Promise((resolve) => setTimeout(resolve, 50));
+			const waitingOnOld = advertise();
+			const waitingLoader = tools.get("subagents_enable").execute("reload", {}, new AbortController().signal, undefined, ctx);
+			const registration = registerRuntimeAgent({ pi, name: "runtime-test", definition: { description: "Test", systemPrompt: "Test" } });
+			process.env.TEST_NPM_PHASE = "latest";
+			start({ reason: "reload" }, ctx);
+			const mergedExecution = tools.get("subagent").execute("merged-runtime", { agent: "new-specialist", task: "Probe", async: false }, new AbortController().signal, undefined, ctx)
+				.then((result) => JSON.stringify(result), (error) => error.message);
+			const [latest, reloadedLoader] = await Promise.all([waitingOnOld, waitingLoader]);
+			assert.equal(fs.existsSync(process.env.TEST_OLD_DONE), false, "old lookup held the new session's prompt");
+			assert.match(latest, /<name>new-specialist<\/name>/);
+			assert.match(reloadedLoader.content[0].text, /<name>new-specialist<\/name>/);
+			assert.doesNotMatch(latest, /<name>global-specialist<\/name>/);
+			const currentList = await tools.get("subagent").execute("list-b", { action: "list" }, new AbortController().signal, undefined, ctx);
+			assert.match(JSON.stringify(currentList), /new-specialist/);
+			assert.doesNotMatch(JSON.stringify(currentList), /global-specialist/);
+			const currentGet = await tools.get("subagent").execute("get-b", { action: "get", agent: "new-specialist" }, new AbortController().signal, undefined, ctx);
+			assert.match(JSON.stringify(currentGet), /new-specialist/);
+			const mergedRuntime = await mergedExecution;
+			assert.match(mergedRuntime, /new-specialist/, "runtime registry must retain the advertised package agent");
+			assert.doesNotMatch(mergedRuntime, /Unknown agent|not found/i);
+			registration.dispose();
+			const runtime = await tools.get("subagent").execute("runtime", { agent: "new-specialist", task: "Probe", async: false }, new AbortController().signal, undefined, ctx)
+				.then((result) => JSON.stringify(result), (error) => error.message);
+			assert.match(runtime, /new-specialist/, "execution must resolve the advertised agent");
+			assert.doesNotMatch(runtime, /Unknown agent|not found/i);
+			await new Promise((resolve) => setTimeout(resolve, 2600));
+			assert.equal(fs.existsSync(process.env.TEST_OLD_DONE), true, "old lookup completed");
+			const afterStale = await advertise();
+			assert.match(afterStale, /<name>new-specialist<\/name>/);
+			assert.doesNotMatch(afterStale, /<name>global-specialist<\/name>/);
+			process.env.TEST_NPM_PHASE = "failure";
+			start({ reason: "reload" }, ctx);
+			const local = await advertise();
+			assert.match(local, /<name>local-specialist<\/name>/);
+			assert.doesNotMatch(local, /<name>(global|new)-specialist<\/name>/);
+			fs.writeFileSync(path.join(process.env.SELESAI_CODING_AGENT_DIR, "settings.json"), "{");
+			start({ reason: "reload" }, ctx);
+			await assert.rejects(tools.get("subagent").execute("invalid", { action: "list" }, new AbortController().signal, undefined, ctx), /Failed to parse settings file/);
+			console.log("responsive session_start; complete first prompt and loader");
+		`], { cwd: repo, env, encoding: "utf8", timeout: 30_000 });
+		assert.match(output, /responsive session_start; complete first prompt and loader/);
+	} finally {
+		fs.rmSync(temp, { recursive: true, force: true });
+	}
+});

package/dist/extensions/pi-subagents/test/unit/agent-disabled.test.ts

@@ -195,7 +195,6 @@ describe("builtin agent disabling", () => {
 			},
 			{
 				model: undefined,
-				fallbackModels: undefined,
 				thinking: undefined,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -210,4 +209,4 @@ describe("builtin agent disabling", () => {
 
 		assert.deepEqual(override, { disabled: false });
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/agent-eject-disable.test.ts

@@ -288,7 +288,7 @@ describe("agent eject/disable/enable/reset management actions", () => {
 			assert.equal(discoverAgents(tempDir, "both").agents.find((a) => a.name === "reviewer")?.source, "builtin");
 		});
 
-		it("removes a settings override and restores the pristine builtin", () => {
+	it("removes a settings override and restores the pristine builtin", () => {
 			const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
 			handleManagementAction("disable", { agent: "reviewer" }, ctx);
 			assert.equal(discoverAgents(tempDir, "both").agents.find((a) => a.name === "reviewer"), undefined);
@@ -298,9 +298,39 @@ describe("agent eject/disable/enable/reset management actions", () => {
 			assert.match(readText(reset), /Removed user settings override/);
 			assert.ok(discoverAgents(tempDir, "both").agents.find((a) => a.name === "reviewer"));
 			assert.equal((readJson(userSettingsPath()) as { subagents?: unknown }).subagents, undefined);
+	});
+
+		it("retains machine placement while clearing other settings customization", () => {
+			const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+			writeJson(userSettingsPath(), {
+				subagents: { agentOverrides: { reviewer: { machine: "workmac", model: "openai/gpt-5.4", thinking: "high" } } },
+			});
+
+			const reset = handleManagementAction("reset", { agent: "reviewer" }, ctx);
+			assert.equal(reset.isError, false);
+			assert.match(readText(reset), /Retained machine placement/);
+			const settings = readJson(userSettingsPath()) as { subagents: { agentOverrides: { reviewer: unknown } } };
+			assert.deepEqual(settings.subagents.agentOverrides.reviewer, { machine: "workmac" });
+			assert.equal(discoverAgentsAll(tempDir).builtin.find((agent) => agent.name === "reviewer")?.machine, "workmac");
+		});
+
+		it("retains a false machine clear so an inherited placement does not reactivate", () => {
+			const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+			writeJson(userSettingsPath(), {
+				subagents: { agentOverrides: { "scout": { machine: "workmac" } } },
+			});
+			writeJson(projectSettingsPath(), {
+				subagents: { agentOverrides: { "scout": { machine: false, model: "openai/gpt-5.4" } } },
+			});
+
+			const reset = handleManagementAction("reset", { agent: "scout", agentScope: "project" }, ctx);
+			assert.equal(reset.isError, false);
+			const settings = readJson(projectSettingsPath()) as { subagents: { agentOverrides: { scout: unknown } } };
+			assert.deepEqual(settings.subagents.agentOverrides["scout"], { machine: false });
+			assert.equal(discoverAgentsAll(tempDir).builtin.find((agent) => agent.name === "scout")?.machine, undefined);
 		});
 
-		it("removes both a custom file and a settings override in one reset", () => {
+	it("removes both a custom file and a settings override in one reset", () => {
 			const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
 			handleManagementAction("eject", { agent: "reviewer" }, ctx);
 			handleManagementAction("disable", { agent: "reviewer" }, ctx);
@@ -340,4 +370,4 @@ describe("agent eject/disable/enable/reset management actions", () => {
 			assert.match(readText(reset), /not found/);
 		});
 	});
-});
+});