@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-subagents/test/unit/abort-recovery.test.ts

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { Message } from "@earendil-works/pi-ai";
+import { ABORT_RECOVERY_PROMPT, planAbortRecovery } from "../../src/runs/shared/abort-recovery.ts";
+
+function messages(...entries: unknown[]): Message[] {
+	return entries as Message[];
+}
+
+const progress = {
+	role: "assistant",
+	content: [{ type: "text", text: "Implemented the helper and running validation." }],
+	usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+};
+const aborted = {
+	role: "assistant",
+	content: [],
+	stopReason: "aborted",
+	usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+};
+
+function base(overrides: Partial<Parameters<typeof planAbortRecovery>[0]> = {}) {
+	return {
+		messages: messages(progress, aborted),
+		processSignal: undefined,
+		sessionAvailable: true,
+		alreadyResumed: false,
+		...overrides,
+	};
+}
+
+describe("planAbortRecovery", () => {
+	it("does not recover an abort without verified compaction settlement", () => {
+		assert.deepEqual(planAbortRecovery(base()), { action: "settle", reason: "compaction settlement not verified" });
+	});
+
+	it("plans the same retained-session continuation for a compaction-induced abort", () => {
+		assert.deepEqual(planAbortRecovery(base({ afterCompactionSettlement: true, processSignal: "SIGTERM" })), { action: "resume", prompt: ABORT_RECOVERY_PROMPT });
+	});
+
+	it("accepts a completed tool result as useful progress", () => {
+		const toolProgress = messages(
+			{ role: "assistant", content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: {} }], usage: { output: 1 } },
+			{ role: "toolResult", toolCallId: "call-1", isError: false, content: [{ type: "text", text: "tests passed" }] },
+			aborted,
+		);
+		assert.equal(planAbortRecovery(base({ messages: toolProgress, afterCompactionSettlement: true })).action, "resume");
+	});
+
+	it("fails closed without progress, a retained session, or a first-attempt permit", () => {
+		assert.equal(planAbortRecovery(base({ messages: messages(aborted) })).action, "settle");
+		assert.equal(planAbortRecovery(base({ sessionAvailable: false })).action, "settle");
+		assert.equal(planAbortRecovery(base({ alreadyResumed: true })).action, "settle");
+	});
+
+	it("does not reinterpret an ordinary empty completion as an abort", () => {
+		const emptyStop = { ...aborted, stopReason: "stop" };
+		assert.equal(planAbortRecovery(base({ messages: messages(progress, emptyStop), processSignal: undefined })).action, "settle");
+	});
+
+	it("does not treat a process signal alone as provider abort evidence", () => {
+		const emptyStop = { ...aborted, stopReason: "stop" };
+		assert.equal(planAbortRecovery(base({ messages: messages(progress, emptyStop), processSignal: "SIGKILL" })).action, "settle");
+	});
+
+	it("does not resume when a process signal accompanies abort evidence", () => {
+		assert.deepEqual(planAbortRecovery(base({ processSignal: "SIGTERM" })), { action: "settle", reason: "process terminated by signal" });
+		assert.deepEqual(planAbortRecovery(base({
+			messages: messages(progress),
+			error: "Connection reset by provider transport",
+			processSignal: "SIGKILL",
+		})), { action: "settle", reason: "process terminated by signal" });
+	});
+
+	it("excludes operator control, timeouts, budgets, schema and acceptance failures", () => {
+		for (const excluded of [
+			{ stopped: true },
+			{ interrupted: true },
+			{ timedOut: true },
+			{ toolBudgetExhausted: true },
+			{ usageBudgetExhausted: true },
+			{ structuredOutputFailed: true },
+			{ acceptanceFailed: true },
+		]) {
+			assert.equal(planAbortRecovery(base(excluded)).action, "settle");
+		}
+	});
+
+	it("fails closed while a tool call is unresolved", () => {
+		const inFlight = messages(
+			{ role: "assistant", content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: {} }], usage: { output: 1 } },
+			aborted,
+		);
+		assert.deepEqual(planAbortRecovery(base({ messages: inFlight, currentTool: "bash" })), { action: "settle", reason: "active tool 'bash' remains in flight" });
+		assert.deepEqual(planAbortRecovery(base({ messages: inFlight, currentTool: undefined })), { action: "settle", reason: "unresolved tool call remains in transcript" });
+	});
+
+	it("names the exact blocker when compaction abort recovery is unsafe", () => {
+		assert.deepEqual(planAbortRecovery(base({ sessionAvailable: false, afterCompactionSettlement: true })), {
+			action: "settle",
+			reason: "retained session unavailable",
+			diagnostic: "Compaction-induced child abort could not be resumed safely: retained session unavailable.",
+		});
+		assert.deepEqual(planAbortRecovery(base({ currentTool: "bash", afterCompactionSettlement: true })), {
+			action: "settle",
+			reason: "active tool 'bash' remains in flight",
+			diagnostic: "Compaction-induced child abort could not be resumed safely: active tool 'bash' remains in flight.",
+		});
+	});
+
+	it("requires terminal assistant abort evidence for compaction recovery", () => {
+		assert.deepEqual(planAbortRecovery(base({
+			messages: messages(progress),
+			processSignal: undefined,
+			error: "Connection reset by provider transport",
+		})), { action: "settle", reason: "compaction settlement not verified" });
+		assert.deepEqual(planAbortRecovery(base({
+			messages: messages(progress),
+			processSignal: undefined,
+			error: "Connection reset by provider transport",
+			afterCompactionSettlement: true,
+		})), { action: "settle", reason: "terminal assistant abort evidence not verified" });
+		assert.equal(planAbortRecovery(base({
+			messages: messages(progress, { ...aborted, stopReason: "error", errorMessage: "This operation was aborted" }),
+			processSignal: undefined,
+			error: "This operation was aborted",
+			afterCompactionSettlement: true,
+		})).action, "resume");
+	});
+
+	it("does not recover a generic transport abort after a normally settled compaction", () => {
+		const settled = {
+			role: "assistant",
+			content: [{ type: "text", text: "Compaction completed and the child settled normally." }],
+			stopReason: "stop",
+			usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+		};
+		assert.deepEqual(planAbortRecovery(base({
+			messages: messages(progress, settled),
+			error: "Connection reset by provider transport",
+			afterCompactionSettlement: true,
+		})), { action: "settle", reason: "terminal assistant abort evidence not verified" });
+	});
+
+	it("does not reinterpret a network-flavored task tool failure as a provider abort", () => {
+		assert.equal(planAbortRecovery(base({
+			messages: messages(progress),
+			processSignal: undefined,
+			error: "bash failed (exit 1): request connection error",
+		})).action, "settle");
+	});
+});

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

@@ -364,4 +364,52 @@ describe("active async capacity", () => {
 			fs.rmSync(rootDir, { recursive: true, force: true });
 		}
 	});
+
+	it("reclaims only old failed runs with dead runners under the abandoned-timeout policy", () => {
+		const cases = [
+			{ name: "dead old", state: "failed", pidLiveness: "dead" as const, lastActivityAt: 0, threshold: 1_000, releases: true },
+			{ name: "dead recent", state: "failed", pidLiveness: "dead" as const, lastActivityAt: 9_500, threshold: 1_000, releases: false },
+			{ name: "alive old", state: "failed", pidLiveness: "alive" as const, lastActivityAt: 0, threshold: 1_000, releases: false },
+			{ name: "unknown old", state: "failed", pidLiveness: "unknown" as const, lastActivityAt: 0, threshold: 1_000, releases: false },
+			{ name: "strict mode", state: "failed", pidLiveness: "dead" as const, lastActivityAt: 0, threshold: false as const, releases: false },
+			{ name: "successful old", state: "complete", pidLiveness: "dead" as const, lastActivityAt: 0, threshold: 1_000, releases: false },
+		];
+		for (const [index, testCase] of cases.entries()) {
+			const rootDir = tempRoot();
+			const asyncDir = path.join(rootDir, "runs", `run-${index}`);
+			try {
+				const handle = acquireActiveAsyncCapacity({ sessionId: "session-policy", limit: 1, runId: `run-${index}`, kind: "runner", asyncDir }, { rootDir });
+				assert.ok(handle);
+				handle.markStarted(`runner-${index}`);
+				writeJson(path.join(asyncDir, "status.json"), {
+					runId: `run-${index}`,
+					sessionId: "session-policy",
+					mode: "single",
+					state: testCase.state,
+					pid: 50_000 + index,
+					startedAt: 0,
+					lastActivityAt: testCase.lastActivityAt,
+					processTerminal: { version: 1, state: "unknown", runId: `run-${index}`, runnerProcessInstanceId: `runner-${index}`, reason: "stale-repair" },
+				});
+				const options = {
+					rootDir,
+					now: () => 10_000,
+					pidLiveness: () => testCase.pidLiveness,
+					abandonedSlotReleaseAfterMs: testCase.threshold,
+				};
+				const inspection = inspectActiveAsyncCapacityOwner({ runId: `run-${index}`, sessionId: "session-policy", asyncDir }, options);
+				assert.equal(inspection.release.state, testCase.releases ? "releasable" : "retained", testCase.name);
+				if (testCase.releases) {
+					assert.match(inspection.release.reason, /abandoned-timeout/);
+					assert.match(inspection.release.reason, /process proof unknown/);
+					assert.deepEqual(getActiveAsyncCapacitySnapshot("session-policy", 1, options), { used: 0, limit: 1 });
+					assert.match(fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8"), /"releasedBy":"abandoned-timeout"/);
+				} else {
+					assert.deepEqual(getActiveAsyncCapacitySnapshot("session-policy", 1, options), { used: 1, limit: 1 });
+				}
+			} finally {
+				fs.rmSync(rootDir, { recursive: true, force: true });
+			}
+		}
+	});
 });

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

@@ -7,7 +7,7 @@ import { afterEach, describe, it } from "node:test";
 import { handleManagementAction } from "../../src/agents/agent-management.ts";
 import { serializeAgent } from "../../src/agents/agent-serializer.ts";
 import { parseChain, serializeChain } from "../../src/agents/chain-serializer.ts";
-import { discoverAgents, discoverAgentsAll, type AgentConfig } from "../../src/agents/agents.ts";
+import { discoverAgents, discoverAgentsAll, inspectAgentDefinitionDirectory, type AgentConfig } from "../../src/agents/agents.ts";
 import { parseFrontmatter } from "../../src/agents/frontmatter.ts";
 import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
 import { THINKING_LEVELS } from "../../src/shared/model-info.ts";
@@ -101,6 +101,38 @@ afterEach(() => {
 	}
 });
 
+describe("agent definition directory inspection", () => {
+	it("distinguishes absent, empty, candidates, unreadable, and non-directory paths", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-inspection-"));
+		tempDirs.push(root);
+		const empty = path.join(root, "empty");
+		const candidates = path.join(root, "candidates");
+		const file = path.join(root, "not-directory");
+		fs.mkdirSync(empty);
+		fs.mkdirSync(candidates);
+		fs.writeFileSync(path.join(candidates, "worker.md"), "---\nname: worker\ndescription: Worker\n---\n", "utf-8");
+		fs.writeFileSync(file, "not a directory", "utf-8");
+		assert.equal(inspectAgentDefinitionDirectory(path.join(root, "absent")).state, "absent");
+		assert.equal(inspectAgentDefinitionDirectory(empty).state, "empty");
+		assert.deepEqual(inspectAgentDefinitionDirectory(candidates), { state: "candidates", files: [path.join(candidates, "worker.md")] });
+		assert.equal(inspectAgentDefinitionDirectory(file).state, "not-directory");
+		assert.equal(inspectAgentDefinitionDirectory(path.join(root, "blocked"), {
+			existsSync: () => true,
+			statSync: () => ({ isDirectory: () => true }),
+			readdirSync: () => { throw new Error("permission denied"); },
+		}).state, "unreadable");
+	});
+
+	it("reports cached builtin and configured project definition paths without synthesizing a root", () => withTempHome(() => {
+		const project = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-report-"));
+		tempDirs.push(project);
+		writeJson(path.join(project, ".selesai", "settings.json"), { subagents: { projectRootResolution: "nearest" } });
+		const discovered = discoverAgents(project, "project");
+		assert.ok(discovered.directories.some((entry) => entry.source === "builtin"));
+		assert.deepEqual(discovered.directories.filter((entry) => entry.source === "project").map((entry) => entry.path), [path.join(project, ".agents"), path.join(project, ".selesai", "agents")]);
+	}));
+});
+
 describe("folded frontmatter blocks", () => {
 	it("folds ordinary lines and paragraph breaks for > and >-", () => {
 		const expected = "first line second line\nthird line";
@@ -215,6 +247,28 @@ Review carefully.`.replace(" description:", "description:"));
 		assert.deepEqual(discoverAgents(project, "project").agents.find((agent) => agent.name === "external")?.runner, external.runner);
 	}));
 
+	it("keeps external-cli stop code-owned while refusing capability widening", () => withTempHome(() => {
+		const project = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-runner-capabilities-"));
+		tempDirs.push(project);
+		const agentPath = path.join(project, ".selesai", "agents", "external.md");
+		writeAgent(agentPath, `---\nname: external\ndescription: External runner\nrunner:\n  type: external-cli\n  command: node\n  capabilities:\n    steer: false\n---\nReview.`);
+		assert.deepEqual(discoverAgents(project, "project").agents.find((agent) => agent.name === "external")?.runner, {
+			type: "external-cli",
+			command: "node",
+			capabilities: { steer: false },
+		});
+
+		writeAgent(agentPath, `---\nname: external\ndescription: External runner\nrunner:\n  type: external-cli\n  command: node\n  capabilities:\n    stop: false\n---\nReview.`);
+		const narrowedStop = discoverAgents(project, "project");
+		assert.equal(narrowedStop.agents.some((agent) => agent.name === "external"), false);
+		assert.match(narrowedStop.agentDiagnostics?.[0]?.error ?? "", /capabilities has unsupported fields: stop/);
+
+		writeAgent(agentPath, `---\nname: external\ndescription: External runner\nrunner:\n  type: external-cli\n  command: node\n  capabilities:\n    steer: true\n---\nReview.`);
+		const widened = discoverAgents(project, "project");
+		assert.equal(widened.agents.some((agent) => agent.name === "external"), false);
+		assert.match(widened.agentDiagnostics?.[0]?.error ?? "", /steer may only be false; user config cannot widen code-owned external adapter capabilities/);
+	}));
+
 	it("parses and serializes an external-job runner", () => withTempHome(() => {
 		const project = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-external-job-agent-"));
 		tempDirs.push(project);
@@ -270,6 +324,25 @@ Review carefully.`);
 		assert.equal(discovered.agentDiagnostics?.[0]?.name, "broken");
 	}));
 
+	it("follows symlinked agent directories once without hiding diagnostics", () => withTempHome(() => {
+		const project = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-symlinked-agent-dir-"));
+		tempDirs.push(project);
+		const legacyAgentsRoot = path.join(project, ".agents");
+		const sharedAgents = path.join(project, "shared-agents");
+		const linkedAgents = path.join(legacyAgentsRoot, "agents");
+		fs.mkdirSync(legacyAgentsRoot, { recursive: true });
+		fs.mkdirSync(sharedAgents, { recursive: true });
+		writeAgent(path.join(sharedAgents, "linked.md"), "---\nname: linked\ndescription: Linked agent\n---\nBody");
+		writeAgent(path.join(sharedAgents, "broken.md"), "---\nname: broken\ndescription: Broken\nrunner:\n  type: unknown\n---\nBody");
+		fs.symlinkSync(sharedAgents, linkedAgents, process.platform === "win32" ? "junction" : "dir");
+		fs.symlinkSync(path.join(sharedAgents, "missing"), path.join(sharedAgents, "dangling"), process.platform === "win32" ? "junction" : "dir");
+		if (process.platform !== "win32") fs.symlinkSync(sharedAgents, path.join(sharedAgents, "loop"), "dir");
+
+		const discovered = discoverAgents(project, "project");
+		assert.equal(discovered.agents.find((agent) => agent.name === "linked")?.filePath, path.join(linkedAgents, "linked.md"));
+		assert.equal(discovered.agentDiagnostics?.find((diagnostic) => diagnostic.name === "broken")?.filePath, path.join(linkedAgents, "broken.md"));
+	}));
+
 	it("keeps a lower-priority agent available when a project override is malformed", () => withTempHome(() => {
 		const project = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-invalid-agent-shadow-"));
 		tempDirs.push(project);
@@ -622,7 +695,6 @@ Do work
 			defaultAsync: false,
 			defaultTimeoutMs: 90_000,
 			defaultToolTimeoutMs: 600_000,
-			defaultTurnBudget: { maxTurns: 12, graceTurns: 2 },
 			defaultAcceptance: { level: "none", reason: "lightweight lookup" },
 		};
 
@@ -630,7 +702,6 @@ Do work
 		assert.match(serialized, /^async: false$/m);
 		assert.match(serialized, /^timeoutMs: 90000$/m);
 		assert.match(serialized, /^toolTimeoutMs: 600000$/m);
-		assert.match(serialized, /^turnBudget: \{"maxTurns":12,"graceTurns":2\}$/m);
 		assert.match(serialized, /^acceptance: \{"level":"none","reason":"lightweight lookup"\}$/m);
 		writeAgent(filePath, serialized);
 
@@ -638,7 +709,6 @@ Do work
 		assert.equal(worker?.defaultAsync, false);
 		assert.equal(worker?.defaultTimeoutMs, 90_000);
 		assert.equal(worker?.defaultToolTimeoutMs, 600_000);
-		assert.deepEqual(worker?.defaultTurnBudget, { maxTurns: 12, graceTurns: 2 });
 		assert.deepEqual(worker?.defaultAcceptance, { level: "none", reason: "lightweight lookup" });
 	});
 
@@ -867,6 +937,59 @@ Plan the work.
 		assert.equal(agent.source, "package");
 	}));
 
+	it("loads bare HTTPS git packages from project Pi settings", () => withTempHome(() => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-settings-bare-git-package-"));
+		tempDirs.push(dir);
+		const packageRoot = path.join(dir, ".selesai", "git", "github.com", "user", "repo");
+		writeJson(path.join(dir, ".selesai", "settings.json"), {
+			packages: ["https://github.com/user/repo.git"],
+		});
+		writeJson(path.join(packageRoot, "package.json"), {
+			name: "bare-git-workflow",
+			"pi-subagents": { agents: ["./agents"] },
+		});
+		writeAgent(path.join(packageRoot, "agents", "planner.md"), `---
+name: planner
+package: bare-git-workflow
+description: Plan from a bare HTTPS git package.
+---
+
+Plan the work.
+`);
+
+		const agent = discoverAgents(dir, "both").agents.find((candidate) => candidate.name === "bare-git-workflow.planner");
+		assert.ok(agent);
+		assert.equal(agent.source, "package");
+		assert.equal(agent.packageSourceRoot, packageRoot);
+	}));
+
+	it("loads bare HTTP git packages from user Pi settings", () => withTempHome((home) => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-user-settings-bare-git-package-"));
+		tempDirs.push(dir);
+		const agentDir = path.join(home, ".selesai", "agent");
+		const packageRoot = path.join(agentDir, "git", "git.example.com", "team", "repo");
+		writeJson(path.join(agentDir, "settings.json"), {
+			packages: ["http://git.example.com/team/repo.git"],
+		});
+		writeJson(path.join(packageRoot, "package.json"), {
+			name: "user-bare-git-workflow",
+			"pi-subagents": { agents: ["./agents"] },
+		});
+		writeAgent(path.join(packageRoot, "agents", "reviewer.md"), `---
+name: reviewer
+package: user-bare-git-workflow
+description: Review from a bare HTTP git package.
+---
+
+Review the work.
+`);
+
+		const agent = discoverAgents(dir, "both").agents.find((candidate) => candidate.name === "user-bare-git-workflow.reviewer");
+		assert.ok(agent);
+		assert.equal(agent.source, "package");
+		assert.equal(agent.packageSourceRoot, packageRoot);
+	}));
+
 	it("discovers project package agents when cwd is nested below the project root", () => withTempHome(() => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-nested-package-discovery-"));
 		tempDirs.push(dir);
@@ -1313,6 +1436,39 @@ Inspect code
 	});
 });
 
+describe("agent frontmatter allowNestedSubagents", () => {
+	it("serializes and parses explicit nested fanout authorization", () => {
+		const agent: AgentConfig = {
+			name: "delegator",
+			description: "Delegator",
+			systemPrompt: "Delegate focused work",
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			source: "project",
+			filePath: "/tmp/delegator.md",
+			allowNestedSubagents: true,
+		};
+		assert.match(serializeAgent(agent), /allowNestedSubagents: true/);
+
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-nested-fanout-"));
+		tempDirs.push(dir);
+		const agentsDir = path.join(dir, ".selesai", "agents");
+		fs.mkdirSync(agentsDir, { recursive: true });
+		fs.writeFileSync(path.join(agentsDir, "delegator.md"), `---
+name: delegator
+description: Delegator
+allowNestedSubagents: true
+---
+
+Delegate focused work
+`, "utf-8");
+		const discovered = discoverAgents(dir, "project").agents.find((candidate) => candidate.name === "delegator");
+		assert.equal(discovered?.allowNestedSubagents, true);
+		assert.equal(discovered?.extraFields?.allowNestedSubagents, undefined);
+	});
+});
+
 describe("agent frontmatter thinking", () => {
 	it("coerces frontmatter false strings to disabled thinking", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-thinking-false-"));
@@ -1463,6 +1619,7 @@ describe("agent frontmatter prompt inheritance flags", () => {
 			systemPrompt: "Do work",
 			systemPromptMode: "replace",
 			inheritProjectContext: true,
+			inheritGlobalContext: true,
 			inheritSkills: true,
 			source: "project",
 			filePath: "/tmp/worker.md",
@@ -1470,6 +1627,7 @@ describe("agent frontmatter prompt inheritance flags", () => {
 
 		const serialized = serializeAgent(agent);
 		assert.match(serialized, /inheritProjectContext: true/);
+		assert.match(serialized, /inheritGlobalContext: true/);
 		assert.match(serialized, /inheritSkills: true/);
 	});
 
@@ -1482,6 +1640,7 @@ describe("agent frontmatter prompt inheritance flags", () => {
 name: worker
 description: Worker
 inheritProjectContext: true
+inheritGlobalContext: true
 inheritSkills: true
 ---
 
@@ -1491,8 +1650,27 @@ Do work
 		const result = discoverAgents(dir, "project");
 		const worker = result.agents.find((agent) => agent.name === "worker");
 		assert.equal(worker?.inheritProjectContext, true);
+		assert.equal(worker?.inheritGlobalContext, true);
 		assert.equal(worker?.inheritSkills, true);
 	});
+
+	it("defaults inheritGlobalContext to false when frontmatter omits it", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-prompt-inheritance-frontmatter-"));
+		tempDirs.push(dir);
+		const agentsDir = path.join(dir, ".selesai", "agents");
+		fs.mkdirSync(agentsDir, { recursive: true });
+		fs.writeFileSync(path.join(agentsDir, "worker.md"), `---
+name: worker
+description: Worker
+---
+
+Do work
+`, "utf-8");
+
+		const result = discoverAgents(dir, "project");
+		const worker = result.agents.find((agent) => agent.name === "worker");
+		assert.equal(worker?.inheritGlobalContext, false);
+	});
 });
 
 describe("agent frontmatter subagentOnlyExtensions", () => {
@@ -2044,7 +2222,7 @@ Canonical prompt
 		assert.equal(result.projectDir, path.join(dir, ".selesai", "agents"));
 	});
 
-	it("discovers project chains from .pi/chains", () => {
+	it("discovers project chains from .selesai/chains", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-project-chain-dirs-"));
 		tempDirs.push(dir);
 		fs.mkdirSync(path.join(dir, ".selesai", "agents"), { recursive: true });
@@ -2075,7 +2253,7 @@ Inspect canonical
 		assert.equal(result.projectChainDir, path.join(dir, ".selesai", "chains"));
 	});
 
-	it("prefers project .pi/chains over user chains on name collisions", () => {
+	it("prefers project .selesai/chains over user chains on name collisions", () => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-project-chain-collision-"));
 		const home = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-user-chain-home-"));
 		tempDirs.push(dir, home);

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

@@ -60,6 +60,55 @@ describe("agent management config parsing", () => {
 		assert.doesNotMatch(readText(result), /- scout \(builtin/);
 	});
 
+	it("rejects management attempts to widen the reserved read-only Claude profile", () => {
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		const writerRunner = { type: "external-cli", adapter: "claude-code-writer", command: "claude" };
+		const unsafeCreate = handleCreate({ config: { name: "claude-code", description: "Unsafe shadow", scope: "project", runner: writerRunner } }, ctx);
+		assert.equal(unsafeCreate.isError, true);
+		assert.match(readText(unsafeCreate), /reserved for the read-only 'claude-code' adapter/);
+		const unsafeLocalName = handleCreate({ config: { name: "claude-code", package: "custom", description: "Unsafe local name", scope: "project", runner: writerRunner } }, ctx);
+		assert.equal(unsafeLocalName.isError, true);
+		assert.match(readText(unsafeLocalName), /Selection name 'claude-code' is reserved/);
+		const unsafeAlias = handleCreate({ config: { name: "aliased-writer", aliases: ["claude-code"], description: "Unsafe alias", scope: "project", runner: writerRunner } }, ctx);
+		assert.equal(unsafeAlias.isError, true);
+		assert.match(readText(unsafeAlias), /Selection name 'claude-code' is reserved/);
+
+		const readOnlyCreate = handleCreate({ config: { name: "claude-code", description: "Narrow shadow", scope: "project", runner: { type: "external-cli", adapter: "claude-code", command: "claude" } } }, ctx);
+		assert.equal(readOnlyCreate.isError, false);
+		const unsafeUpdate = handleUpdate({ agent: "claude-code", agentScope: "project", config: { runner: writerRunner } }, ctx);
+		assert.equal(unsafeUpdate.isError, true);
+		assert.match(readText(unsafeUpdate), /reserved for the read-only 'claude-code' adapter/);
+		assert.match(fs.readFileSync(path.join(tempDir, ".selesai", "agents", "claude-code.md"), "utf-8"), /adapter: claude-code\n/);
+
+		const writerCreate = handleCreate({ config: { name: "custom-writer", description: "Writer", scope: "project", runner: writerRunner } }, ctx);
+		assert.equal(writerCreate.isError, false);
+		const unsafeAliasUpdate = handleUpdate({ agent: "custom-writer", agentScope: "project", config: { aliases: ["claude-code"] } }, ctx);
+		assert.equal(unsafeAliasUpdate.isError, true);
+		assert.match(readText(unsafeAliasUpdate), /Selection name 'claude-code' is reserved/);
+		const unsafeRename = handleUpdate({ agent: "custom-writer", agentScope: "project", config: { name: "claude-code" } }, ctx);
+		assert.equal(unsafeRename.isError, true);
+		assert.match(readText(unsafeRename), /reserved for the read-only 'claude-code' adapter/);
+	});
+
+	it("rejects create, update, alias, and rename widening for Codex and Cursor", () => {
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		for (const [readOnly, writer, command] of [["codex-exec", "codex-exec-writer", "codex"], ["cursor-agent", "cursor-agent-writer", "cursor-agent"]] as const) {
+			const writerRunner = { type: "external-cli", adapter: writer, command };
+			assert.equal(handleCreate({ config: { name: readOnly, description: "Unsafe shadow", scope: "project", runner: writerRunner } }, ctx).isError, true);
+			assert.equal(handleCreate({ config: { name: readOnly, package: `custom-${readOnly}`, description: "Unsafe local name", scope: "project", runner: writerRunner } }, ctx).isError, true);
+			assert.equal(handleCreate({ config: { name: `${readOnly}-alias`, aliases: [readOnly], description: "Unsafe alias", scope: "project", runner: writerRunner } }, ctx).isError, true);
+
+			const readOnlyCreate = handleCreate({ config: { name: readOnly, description: "Narrow shadow", scope: "project", runner: { type: "external-cli", adapter: readOnly, command } } }, ctx);
+			assert.equal(readOnlyCreate.isError, false);
+			assert.equal(handleUpdate({ agent: readOnly, agentScope: "project", config: { runner: writerRunner } }, ctx).isError, true);
+
+			const customName = `custom-${writer}`;
+			assert.equal(handleCreate({ config: { name: customName, description: "Writer", scope: "project", runner: writerRunner } }, ctx).isError, false);
+			assert.equal(handleUpdate({ agent: customName, agentScope: "project", config: { aliases: [readOnly] } }, ctx).isError, true);
+			assert.equal(handleUpdate({ agent: customName, agentScope: "project", config: { name: readOnly } }, ctx).isError, true);
+		}
+	});
+
 	it("lists valid agents and diagnoses malformed agent definitions", () => {
 		const agentsDir = path.join(tempDir, ".selesai", "agents");
 		fs.mkdirSync(agentsDir, { recursive: true });
@@ -499,7 +548,6 @@ Advise only.
 					scope: "project",
 					async: false,
 					timeoutMs: 120_000,
-					turnBudget: { maxTurns: 8, graceTurns: 2 },
 					acceptance: { level: "none", reason: "lightweight reviewer" },
 					outputMode: "file-only",
 				},
@@ -512,7 +560,6 @@ Advise only.
 		let content = fs.readFileSync(filePath, "utf-8");
 		assert.match(content, /^async: false$/m);
 		assert.match(content, /^timeoutMs: 120000$/m);
-		assert.match(content, /^turnBudget: \{"maxTurns":8,"graceTurns":2\}$/m);
 		assert.match(content, /^acceptance: \{"level":"none","reason":"lightweight reviewer"\}$/m);
 		assert.match(content, /^outputMode: file-only$/m);
 
@@ -520,19 +567,17 @@ Advise only.
 		assert.equal(got.isError, false);
 		assert.match(readText(got), /Async: false/);
 		assert.match(readText(got), /Timeout: 120000ms/);
-		assert.match(readText(got), /Turn budget: \{"maxTurns":8,"graceTurns":2\}/);
 		assert.match(readText(got), /Acceptance: \{"level":"none","reason":"lightweight reviewer"\}/);
 		assert.match(readText(got), /Output mode: file-only/);
 
 		const updated = handleUpdate(
-			{ agent: "background-reviewer", config: { async: true, timeoutMs: false, turnBudget: false, acceptance: "", outputMode: "inline" } },
+			{ agent: "background-reviewer", config: { async: true, timeoutMs: false, acceptance: "", outputMode: "inline" } },
 			ctx,
 		);
 		assert.equal(updated.isError, false);
 		content = fs.readFileSync(filePath, "utf-8");
 		assert.match(content, /^async: true$/m);
 		assert.doesNotMatch(content, /^timeoutMs:/m);
-		assert.doesNotMatch(content, /^turnBudget:/m);
 		assert.doesNotMatch(content, /^acceptance:/m);
 		assert.match(content, /^outputMode: inline$/m);
 
@@ -958,11 +1003,26 @@ Drive the failing test first.
 		assert.match(text, /^Builtin subagent models/m);
 		assert.match(text, /Current session model:\n  openai\/gpt-5-mini/);
 		assert.match(text, /(?:^|\n)scout\n  model:\n    openai\/gpt-5-mini\n  source: inherits current session model(?:\n|$)/);
+		assert.match(text, /(?:^|\n)advisor\n  model:\n    openai\/gpt-5-mini\n  source: inherits current session model(?:\n|$)/);
+		assert.doesNotMatch(text, /advisor\n  model:\n    \(builtin definition not found\)/);
 		assert.match(text, /Available models in this session's registry/);
 		assert.match(text, /  anthropic\/claude-sonnet-4\n  openai\/gpt-5-mini/);
 		assert.match(text, /Use an exact provider\/id from this list when you pass model/);
 	});
 
+	it("resolves the advisor builtin alias in a filtered model mapping", () => {
+		const result = handleManagementAction("models", { agent: "advisor" }, {
+			cwd: tempDir,
+			modelRegistry: { getAvailable: () => [{ provider: "openai", id: "gpt-5-mini" }] },
+			model: { provider: "openai", id: "gpt-5-mini" },
+		});
+		const text = readText(result);
+		assert.equal(result.isError, false);
+		assert.match(text, /Agent: advisor/);
+		assert.match(text, /Effective model:\n  openai\/gpt-5-mini/);
+		assert.doesNotMatch(text, /Builtin agent 'advisor' not found|source: missing/);
+	});
+
 	it("reports override source and disabled builtin state in runtime model mappings", () => {
 		const projectSettingsPath = path.join(tempDir, ".selesai", "settings.json");
 		fs.mkdirSync(path.dirname(projectSettingsPath), { recursive: true });
@@ -994,7 +1054,7 @@ Drive the failing test first.
 		assert.match(text, /Source: project override/);
 		assert.match(text, /Requested model setting:\n  claude-sonnet-4/);
 		assert.match(text, /Disabled: true/);
-		assert.match(text.replaceAll("\\", "/"), /Override file:\n  .*\.pi\/settings\.json/);
+		assert.match(text.replaceAll("\\", "/"), /Override file:\n  .*\.selesai[\\/]settings\.json/);
 	});
 
 	it("rejects unknown builtin filters for runtime model mappings", () => {