@selesai/code 0.13.12 → 0.13.14

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

@@ -130,6 +130,19 @@ describe("builtin agent overrides", () => {
 		assert.equal(researcher?.mcpDirectTools, undefined);
 	});
 
+	it("applies excludeTools settings overrides to builtin agents", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					researcher: { excludeTools: ["write", "unknown_tool"] },
+				},
+			},
+		});
+
+		const researcher = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "researcher");
+		assert.deepEqual(researcher?.excludeTools, ["write", "unknown_tool"]);
+	});
+
 	it("surfaces invalid string tool override settings", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
 		writeJson(settingsPath, {
@@ -703,9 +716,10 @@ describe("builtin agent overrides", () => {
 		assert.equal(reviewer.override?.scope, "project");
 	});
 
-	it("frontmatter wins per-field over agentOverrides for a shadowing project agent", () => {
+	it("agentOverrides replace frontmatter for a shadowing project agent", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+
 			subagents: { agentOverrides: { reviewer: { model: "openai/gpt-5.4" } } },
 		});
 		writeProjectAgent(tempProject, "reviewer", `---\nname: reviewer\ndescription: Project reviewer\nmodel: google/gemini-3-pro\n---\n\nUse the project reviewer.\n`);
@@ -713,13 +727,14 @@ describe("builtin agent overrides", () => {
 		const reviewer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "reviewer");
 		assert.ok(reviewer);
 		assert.equal(reviewer.source, "project");
-		assert.equal(reviewer.model, "google/gemini-3-pro");
-		assert.equal(reviewer.override, undefined);
+		assert.equal(reviewer.model, "openai/gpt-5.4");
+		assert.equal(reviewer.override?.scope, "project");
 	});
 
-	it("fills in unset fields on a custom project agent from project agentOverrides", () => {
+	it("applies project agentOverrides to a custom project agent", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+
 			subagents: {
 				agentOverrides: {
 					implementer: {
@@ -769,8 +784,9 @@ describe("builtin agent overrides", () => {
 		assert.equal(implementer.override?.path, path.join(tempProject, ".selesai", "settings.json"));
 	});
 
-	it("fills in unset fields on a custom user agent from user agentOverrides", () => {
+	it("applies user agentOverrides to a custom user agent", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+
 			subagents: { agentOverrides: { implementer: { model: "anthropic/claude-sonnet-4-6" } } },
 		});
 		writeUserAgent(tempHome, "implementer", `---\nname: implementer\ndescription: TDD implementer\n---\n\nDrive the failing test first.\n`);
@@ -813,9 +829,10 @@ describe("builtin agent overrides", () => {
 		assert.equal(implementer.override?.scope, "project");
 	});
 
-	it("keeps explicit custom frontmatter fields over matching agentOverrides", () => {
+	it("agentOverrides replace explicit custom frontmatter fields", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+
 			subagents: {
 				agentOverrides: {
 					implementer: {
@@ -830,6 +847,7 @@ describe("builtin agent overrides", () => {
 						inheritProjectContext: true,
 						defaultContext: "fork",
 						acceptanceRole: "writer",
+						systemPrompt: "Override prompt",
 						completionGuard: true,
 					},
 				},
@@ -839,32 +857,34 @@ describe("builtin agent overrides", () => {
 
 		const implementer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "implementer");
 		assert.ok(implementer);
-		assert.equal(implementer.output, "artifacts/explicit.md");
-		assert.equal(implementer.outputMode, "inline");
-		assert.deepEqual(implementer.defaultReads, ["explicit.md"]);
-		assert.equal(implementer.model, "google/gemini-3-pro");
-		assert.equal(implementer.fast, false);
-		assert.equal(implementer.thinking, "medium");
-		assert.deepEqual(implementer.tools, ["read"]);
-		assert.deepEqual(implementer.mcpDirectTools, ["local_tool"]);
-		assert.deepEqual(implementer.skills, ["agent-skill"]);
-		assert.equal(implementer.inheritProjectContext, false);
-		assert.equal(implementer.defaultContext, "fresh");
-		assert.equal(implementer.acceptanceRole, "read-only");
-		assert.equal(implementer.completionGuard, false);
-		assert.equal(implementer.override, undefined);
+		assert.equal(implementer.output, "artifacts/override.md");
+		assert.equal(implementer.outputMode, "file-only");
+		assert.deepEqual(implementer.defaultReads, ["override.md"]);
+		assert.equal(implementer.model, "anthropic/claude-sonnet-4-6");
+		assert.equal(implementer.fast, true);
+		assert.equal(implementer.thinking, "high");
+		assert.deepEqual(implementer.tools, ["bash"]);
+		assert.equal(implementer.mcpDirectTools, undefined);
+		assert.deepEqual(implementer.skills, ["override-skill"]);
+		assert.equal(implementer.inheritProjectContext, true);
+		assert.equal(implementer.defaultContext, "fork");
+		assert.equal(implementer.acceptanceRole, "writer");
+		assert.equal(implementer.systemPrompt, "Override prompt");
+		assert.equal(implementer.completionGuard, true);
+		assert.equal(implementer.override?.scope, "project");
 	});
 
-	it("keeps explicit output and defaultReads frontmatter when overrides clear them", () => {
+	it("lets false overrides clear explicit output and defaultReads frontmatter", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+
 			subagents: { agentOverrides: { implementer: { output: false, defaultReads: false } } },
 		});
 		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\noutput: explicit.md\ndefaultReads: explicit.md\n---\n\nDrive the failing test first.\n`);
 
 		const implementer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "implementer");
-		assert.equal(implementer?.output, "explicit.md");
-		assert.deepEqual(implementer?.defaultReads, ["explicit.md"]);
+		assert.equal(implementer?.output, undefined);
+		assert.deepEqual(implementer?.defaultReads, undefined);
 	});
 
 	it("keeps an explicit empty defaultReads override distinct from false", () => {
@@ -1036,8 +1056,9 @@ describe("builtin agent overrides", () => {
 		const packageRoot = path.join(tempProject, "package-agents");
 		fs.mkdirSync(path.join(packageRoot, "agents"), { recursive: true });
 		writeJson(path.join(packageRoot, "package.json"), { "pi-subagents": { agents: ["agents"] } });
-		fs.writeFileSync(path.join(packageRoot, "agents", "package-scout.md"), `---\nname: package-scout\ndescription: Package scout\n---\n\nScout the package.\n`, "utf-8");
+		fs.writeFileSync(path.join(packageRoot, "agents", "package-scout.md"), `---\nname: package-scout\ndescription: Package scout\noutput: package-frontmatter.md\ndefaultReads: PACKAGE-FRONTMATTER.md\n---\n\nScout the package.\n`, "utf-8");
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+
 			packages: [packageRoot],
 			subagents: { agentOverrides: { "package-scout": { output: "package.md", defaultReads: ["PACKAGE.md"] } } },
 		});

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

@@ -0,0 +1,133 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { clearAgentDiscoveryCache, discoverAgents } from "../../src/agents/agents.ts";
+
+function tempDir(prefix: string): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), `agent-scan-${prefix}-`));
+}
+
+function writeAgent(dir: string, name: string, description = "scan dirs test"): void {
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(path.join(dir, `${name}.md`), `---\nname: ${name}\ndescription: ${description}\n---\nbody\n`, "utf-8");
+}
+
+describe("settings subagents.agentScanDirs", () => {
+	let agentDir: string;
+	let projectDir: string;
+	let scanRoot: string;
+	let previousAgentDir: string | undefined;
+
+	beforeEach(() => {
+		agentDir = tempDir("agent");
+		projectDir = tempDir("project");
+		scanRoot = tempDir("scan");
+		previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		fs.mkdirSync(path.join(agentDir, "agents"), { recursive: true });
+		fs.mkdirSync(path.join(projectDir, ".selesai"), { recursive: true });
+		clearAgentDiscoveryCache();
+	});
+
+	afterEach(() => {
+		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		for (const dir of [agentDir, projectDir, scanRoot]) fs.rmSync(dir, { recursive: true, force: true });
+		clearAgentDiscoveryCache();
+	});
+
+	function writeUserSettings(value: unknown): void {
+		fs.writeFileSync(path.join(agentDir, "settings.json"), JSON.stringify(value), "utf-8");
+	}
+
+	function writeProjectSettings(value: unknown): void {
+		fs.writeFileSync(path.join(projectDir, ".selesai", "settings.json"), JSON.stringify(value), "utf-8");
+	}
+
+	it("discovers agents from configured user scan directories", () => {
+		writeAgent(scanRoot, "scan-writer");
+		writeUserSettings({ subagents: { agentScanDirs: [scanRoot] } });
+
+		const result = discoverAgents(projectDir, "user");
+
+		const agent = result.agents.find((candidate) => candidate.name === "scan-writer");
+		assert.equal(agent?.source, "user");
+		assert.equal(agent?.filePath, path.join(scanRoot, "scan-writer.md"));
+	});
+
+	it("expands one wildcard directory segment and invalidates when children are added", () => {
+		writeUserSettings({ subagents: { agentScanDirs: [path.join(scanRoot, "*", "agents")] } });
+		assert.equal(discoverAgents(projectDir, "user").agents.some((agent) => agent.name === "late-writer"), false);
+
+		writeAgent(path.join(scanRoot, "template-a", "agents"), "late-writer");
+		const result = discoverAgents(projectDir, "user");
+
+		assert.equal(result.agents.some((agent) => agent.name === "late-writer"), true);
+	});
+
+	it("invalidates when an existing wildcard child receives its agents directory", () => {
+		fs.mkdirSync(path.join(scanRoot, "template-a"));
+		writeUserSettings({ subagents: { agentScanDirs: [path.join(scanRoot, "*", "agents")] } });
+		assert.equal(discoverAgents(projectDir, "user").agents.some((agent) => agent.name === "late-nested-writer"), false);
+
+		writeAgent(path.join(scanRoot, "template-a", "agents"), "late-nested-writer");
+		const result = discoverAgents(projectDir, "user");
+
+		assert.equal(result.agents.some((agent) => agent.name === "late-nested-writer"), true);
+	});
+
+	it("keeps user and project scan directories scoped", () => {
+		const userScanDir = path.join(scanRoot, "user-agents");
+		const projectScanDir = path.join(scanRoot, "project-agents");
+		writeAgent(userScanDir, "user-scan");
+		writeAgent(projectScanDir, "project-scan");
+		writeUserSettings({ subagents: { agentScanDirs: [userScanDir] } });
+		writeProjectSettings({ subagents: { agentScanDirs: [projectScanDir] } });
+
+		assert.equal(discoverAgents(projectDir, "user").agents.some((agent) => agent.name === "project-scan"), false);
+		assert.equal(discoverAgents(projectDir, "project").agents.some((agent) => agent.name === "user-scan"), false);
+		assert.equal(discoverAgents(projectDir, "both").agents.some((agent) => agent.name === "user-scan"), true);
+		assert.equal(discoverAgents(projectDir, "both").agents.some((agent) => agent.name === "project-scan"), true);
+	});
+
+	it("lets fixed user agents override same-name scan-dir agents", () => {
+		writeAgent(path.join(scanRoot, "template", "agents"), "writer", "from scan dir");
+		writeAgent(path.join(agentDir, "agents"), "writer", "from fixed user dir");
+		writeUserSettings({ subagents: { agentScanDirs: [path.join(scanRoot, "*", "agents")] } });
+
+		const agent = discoverAgents(projectDir, "both").agents.find((candidate) => candidate.name === "writer");
+
+		assert.equal(agent?.filePath, path.join(agentDir, "agents", "writer.md"));
+	});
+
+	it("accepts backslash-separated wildcard patterns", () => {
+		writeAgent(path.join(scanRoot, "template", "agents"), "backslash-scan");
+		writeUserSettings({ subagents: { agentScanDirs: [`${scanRoot}\\*\\agents`] } });
+
+		const result = discoverAgents(projectDir, "user");
+
+		assert.equal(result.agents.some((agent) => agent.name === "backslash-scan"), true);
+	});
+
+	it("does not treat constrained wildcard segments as broad directory scans", () => {
+		writeAgent(path.join(scanRoot, "flow-a", "agents"), "flow-scan");
+		writeAgent(path.join(scanRoot, "other", "agents"), "other-scan");
+		writeUserSettings({ subagents: { agentScanDirs: [path.join(scanRoot, "flow-*", "agents")] } });
+
+		const result = discoverAgents(projectDir, "user");
+
+		assert.equal(result.agents.some((agent) => agent.name === "flow-scan"), false);
+		assert.equal(result.agents.some((agent) => agent.name === "other-scan"), false);
+	});
+
+	it("rejects malformed scan directory settings", () => {
+		writeUserSettings({ subagents: { agentScanDirs: [path.join(scanRoot, "agents"), 42] } });
+
+		assert.throws(
+			() => discoverAgents(projectDir, "user"),
+			/Subagent settings .* invalid 'agentScanDirs'/,
+		);
+	});
+});

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

@@ -1,4 +1,6 @@
 import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import type { ExtensionAPI } from "@selesai/code";
@@ -62,6 +64,32 @@ describe("async runner execution", () => {
 		assert.doesNotMatch(result.error, /arbitrary \(project\)/);
 	});
 
+	it("loads launch rules from the resolved async step cwd", () => {
+		const repo = fs.mkdtempSync(path.join(os.tmpdir(), "async-step-rules-"));
+		const app = path.join(repo, "packages", "app");
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		process.env.SELESAI_CODING_AGENT_DIR = path.join(repo, "agent-home");
+		try {
+			fs.mkdirSync(path.join(app, ".selesai"), { recursive: true });
+			fs.writeFileSync(path.join(app, ".selesai", "settings.json"), JSON.stringify({ subagents: { watchdog: { rules: { action: "block", roleModels: { worker: { deny: ["mock/*"] } } } } } }, null, 2), "utf-8");
+			const result = buildAsyncRunnerSteps("async-step-rules", {
+				chain: [{ agent: "worker", task: "Do work", cwd: "packages/app" }],
+				agents: [{ ...agent("worker"), model: "mock/denied" }],
+				ctx: { ...ctx, cwd: repo },
+				cwd: repo,
+				asyncDir: path.join(repo, ".selesai", "subagents", "async-step-rules"),
+				maxSubagentDepth: 1,
+			});
+
+			assert.ok("error" in result);
+			assert.match(result.error, /Launch blocked by subagents\.watchdog\.rules: Agent 'worker' was launched with denied model 'mock\/denied'/);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+
 	it("formats interactive yield and headless auto-drain guidance separately", () => {
 		const interactive = formatAsyncStartedMessage("Async: worker [interactive]", true);
 		assert.match(interactive, /interactive session[\s\S]*return control/i);
@@ -70,14 +98,12 @@ describe("async runner execution", () => {
 		assert.match(interactive, /provider, detached, or other background work that lacks a native completion notification/i);
 		assert.doesNotMatch(interactive, /bg_wait\(\{ id:/i);
 		assert.doesNotMatch(interactive, /auto-drains current-session background work/i);
-		assert.doesNotMatch(interactive, /subagent_wait/);
 
 		const headless = formatAsyncStartedMessage("Async: worker [headless]", false);
 		assert.match(headless, /non-interactive run.*auto-drains current-session subagent work at agent_end/i);
 		assert.match(headless, /Use bg_wait only.*provider, detached, or other background-work results.*no native completion notification/i);
 		assert.doesNotMatch(headless, /nonBlocking: true/);
 		assert.doesNotMatch(headless, /By default, return control to the user/i);
-		assert.doesNotMatch(headless, /subagent_wait/);
 	});
 
 	it("places detached runner stdio logs in the async run directory", () => {

package/dist/extensions/pi-subagents/test/unit/async-interrupt-action.test.ts

@@ -216,7 +216,7 @@ describe("async interrupt action", () => {
 			assert.equal(result.details.steering?.state, "delivered");
 			assert.equal(result.details.steering?.sourceRunId, childRunId);
 			assert.equal(request.message, "Focus on the failing test.");
-			assert.match(text(result), /Message: "Focus on the failing test\."/);
+			assert.match(text(result), /Message sent:\n```text\nFocus on the failing test\.\n```/);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
 		}

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

@@ -98,6 +98,7 @@ describe("async resume lookup", () => {
 
 			const target = resolveAsyncResumeTarget({ id: "run-missing-cwd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
 			assert.equal(target.cwd, worktreeCwd);
+			assert.equal(target.managedWorktree, true);
 			fs.rmSync(worktreeCwd, { recursive: true });
 
 			assert.throws(
@@ -138,6 +139,7 @@ describe("async resume lookup", () => {
 
 			const target = resolveAsyncResumeTarget({ id: "run-nested-cwd" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
 			assert.equal(target.cwd, worktreeCwd);
+			assert.equal(target.managedWorktree, true);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}

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

@@ -100,7 +100,10 @@ describe("async retention cleanup", () => {
 			assert.equal(repaired.repairedRuns, 1);
 			assert.equal(repaired.deletedRuns, 0);
 			assert.equal(repaired.skipped.recent, 1);
-			assert.equal(JSON.parse(fs.readFileSync(path.join(runDir, "status.json"), "utf-8")).state, "failed");
+			const repairedStatusPath = path.join(runDir, "status.json");
+			assert.equal(JSON.parse(fs.readFileSync(repairedStatusPath, "utf-8")).state, "failed");
+			fs.utimesSync(repairedStatusPath, NOW / 1000, NOW / 1000);
+			fs.utimesSync(runDir, NOW / 1000, NOW / 1000);
 			assert.equal(fs.existsSync(path.join(roots.asyncDirRoot, ".active-runs", "dead-running")), false);
 			assert.equal(fs.existsSync(path.join(roots.resultsDir, "dead-running.json")), true);
 			assert.equal(JSON.parse(fs.readFileSync(path.join(protectedDir, "status.json"), "utf-8")).state, "running");

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

@@ -189,9 +189,9 @@ describe("async status projection", () => {
 		assert.deepEqual(rows, []);
 	});
 
-	it("projects stored preflight lanes as planned rows and merges launched facts", () => {
+	it("annotates authoritative children without projecting unmatched preflight lanes", () => {
 		const rows = projectAsyncWorkflowRows([
-			{ agent: "worker", workflowKey: "writer", label: "Writer", status: "running" },
+			{ agent: "worker", workflowKey: "writer.implementation", label: "Writer", status: "running" },
 		], {
 			version: 1,
 			coverage: "complete",
@@ -202,11 +202,25 @@ describe("async status projection", () => {
 		});
 
 		assert.deepEqual(rows.map((row) => ({ name: row.name, state: row.state, mode: row.preflight?.mode })), [
-			{ name: "writer · Writer (worker)", state: "running", mode: "mutation" },
-			{ name: "review", state: "planned", mode: "review" },
+			{ name: "writer.implementation · Writer (worker)", state: "running", mode: "mutation" },
 		]);
 	});
 
+	it("prefers a specific preflight lane over an earlier broad phase alias", () => {
+		const rows = projectAsyncWorkflowRows([
+			{ agent: "reviewer", workflowKey: "writer.quality.deep", phase: "writer", status: "running" },
+		], {
+			version: 1,
+			coverage: "partial",
+			lanes: [
+				{ key: "writer", mode: "mutation" },
+				{ key: "writer.quality", mode: "review" },
+			],
+		});
+
+		assert.equal(rows[0]?.preflight?.mode, "review");
+	});
+
 	it("projects known runs.lanes stages from the workflow graph, including pending stages", () => {
 		const rows = projectAsyncWorkflowRows([{
 			agent: "scout",

package/dist/extensions/pi-subagents/test/unit/atomic-json.test.ts

@@ -160,6 +160,22 @@ describe("writeAtomicJson", () => {
 		assert.throws(() => writeAtomicJson(path.join("/tmp", "status.json"), { state: "running" }), /ENOSPC/);
 	});
 
+	it("can ignore cleanup failures after the target is atomically published", () => {
+		const fakeFs = new FakeFs();
+		fakeFs.failCleanup = true;
+		const writeAtomicJson = createAtomicJsonWriter({
+			fs: fakeFs as any,
+			now: () => 12345,
+			pid: 678,
+			random: () => 0.5,
+			ignoreCleanupErrorAfterSuccess: true,
+		});
+		const targetPath = path.join("/tmp", "runner-startup-proceed.json");
+
+		assert.doesNotThrow(() => writeAtomicJson(targetPath, { action: "proceed", token: "runner" }));
+		assert.equal(fakeFs.files.get(targetPath), JSON.stringify({ action: "proceed", token: "runner" }, null, 2));
+	});
+
 	it("cleans up the temp file after retryable failures are exhausted", () => {
 		const fakeFs = new FakeFs();
 		fakeFs.failRenameCodes = ["EPERM", "EPERM", "EPERM", "EPERM"];

package/dist/extensions/pi-subagents/test/unit/completion-guard.test.ts

@@ -425,9 +425,47 @@ test("review-only, research, and framework output instructions do not expect mut
 	);
 });
 
+test("escaped line separators do not hide read-only prohibitions", () => {
+	const task = [
+		"This is a read-only skill compliance scenario, not an implementation assignment.",
+		"Read the supplied skill and write the exact user-facing response.",
+		"Do not edit files.",
+		"Use a scenario that discusses selection for an implementation task or closeout of an implementation assignment.",
+	].join("\\n");
+
+	assert.deepEqual(evaluateCompletionMutationGuard({
+		agent: "delegate",
+		task,
+		messages: [assistantText("The exact user-facing response")],
+		tools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+	}), {
+		expectedMutation: false,
+		attemptedMutation: false,
+		triggered: false,
+		blocked: false,
+	});
+});
+
+test("output instructions after blanket no-edit prohibitions stay read-only", () => {
+	assert.deepEqual(evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Do not modify files\\nIn your final output, implement the fix.",
+		messages: [assistantText("Here is the explanation.")],
+		tools: ["read", "grep", "find", "ls", "bash", "edit", "write"],
+	}), {
+		expectedMutation: false,
+		attemptedMutation: false,
+		triggered: false,
+		blocked: false,
+	});
+	assert.equal(expectsImplementationMutation("worker", "Do not modify files\\nIn your final output/report/response, implement the fix."), false);
+});
+
 test("worker implementation verbs win over investigative wording and scoped prohibitions", () => {
 	assert.equal(expectsImplementationMutation("worker", "Investigate why the worker did not edit files and fix it"), true);
 	assert.equal(expectsImplementationMutation("worker", "Do not modify tests; implement the fix"), true);
+	assert.equal(expectsImplementationMutation("worker", "Do not modify files\\nin output/; implement the fix"), true);
+	assert.equal(expectsImplementationMutation("worker", "Do not modify files\\nin report/; implement the fix"), true);
 	assert.equal(expectsImplementationMutation("worker", "Do not modify tests — implement the fix"), true);
 	assert.equal(expectsImplementationMutation("worker", "Research the current code path and patch the bug"), true);
 	assert.equal(expectsImplementationMutation("worker", "Fix the bug where no edits were made"), true);

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

@@ -117,7 +117,7 @@ describe("subagents.defaultExtensions", () => {
 		);
 		assert.deepEqual(
 			agents.find((agent) => agent.name === "explicit")?.extensions,
-			[path.join(tempProject, ".selesai", "agents", "frontmatter.ts")],
+			["./ignored.ts"],
 		);
 	});
 
@@ -216,4 +216,4 @@ describe("subagents.defaultExtensions", () => {
 			);
 		}
 	});
-});
+});

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

@@ -1006,6 +1006,27 @@ describe("below-editor subagent FleetView", () => {
 		assert.deepEqual(workflow?.workflowRows?.map((row) => row.name), ["review (reviewer)"]);
 	});
 
+	it("keeps advisory preflight declarations out of Fleet runtime rows and counts", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-preflight", {
+			asyncId: "workflow-preflight",
+			asyncDir: "/tmp/workflow-preflight",
+			status: "running",
+			mode: "workflow",
+			startedAt: 10,
+			updatedAt: 20,
+			preflight: { version: 1, coverage: "partial", lanes: [{ key: "pr14", mode: "review" }] },
+			steps: [{ agent: "reviewer", workflowKey: "pr14-quality", status: "running" }],
+		});
+
+		const workflow = collectFleetStatusEntries(state).find((entry) => entry.key === "async:workflow-preflight");
+		assert.deepEqual(workflow?.workflowRows?.map((row) => [row.name, row.state]), [["pr14-quality (reviewer)", "running"]]);
+		assert.deepEqual(
+			workflow?.workflowChecklist && { total: workflow.workflowChecklist.total, running: workflow.workflowChecklist.running, queued: workflow.workflowChecklist.queued },
+			{ total: 1, running: 1, queued: 0 },
+		);
+	});
+
 	it("renders bounded workflow progress rows under the workflow parent", () => {
 		const state = stateForTest();
 		const workflowJob = {

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

@@ -729,6 +729,7 @@ describe("native subagent fleet", () => {
 			writeAsyncRun(root, { id: "older", lastUpdate: 200 });
 			const state = stateForTest();
 			let closed = false;
+			let inspectCalls = 0;
 			const component = new SubagentFleetComponent(
 				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
 				theme as never,
@@ -739,7 +740,7 @@ describe("native subagent fleet", () => {
 					resultsDir: path.join(root, "results"),
 					refreshMs: 60_000,
 					fleetKeybindings: {
-						selectDown: ["n"],
+						selectDown: ["return"],
 						selectUp: ["p"],
 						steer: ["m"],
 						close: ["z"],
@@ -747,6 +748,7 @@ describe("native subagent fleet", () => {
 					actions: {
 						async steer() { return { text: "unused" }; },
 						stop() { return { text: "unused" }; },
+						async inspect() { inspectCalls++; return { text: "unexpected" }; },
 					},
 				},
 			);
@@ -755,8 +757,9 @@ describe("native subagent fleet", () => {
 				assert.match(selectedLine(), /newer/);
 				component.handleInput("j");
 				assert.match(selectedLine(), /newer/, "default j should not move when selectDown is overridden");
-				component.handleInput("\x1b[110;1u");
-				assert.match(selectedLine(), /older/, "custom selectDown should accept Kitty CSI-u input");
+				component.handleInput("\r");
+				assert.match(selectedLine(), /older/, "custom Enter binding should move instead of opening Herdr");
+				assert.equal(inspectCalls, 0);
 				component.handleInput("p");
 				assert.match(selectedLine(), /newer/);
 				component.handleInput("m");
@@ -1605,9 +1608,15 @@ describe("native subagent fleet", () => {
 				},
 			);
 			try {
-				component.handleInput("H");
+				component.handleInput("\r");
 				await new Promise((resolve) => setImmediate(resolve));
 				assert.deepEqual(calls, [{ runId: "async-herdr", asyncDir, index: 0 }]);
+				component.handleInput("H");
+				await new Promise((resolve) => setImmediate(resolve));
+				assert.deepEqual(calls, [
+					{ runId: "async-herdr", asyncDir, index: 0 },
+					{ runId: "async-herdr", asyncDir, index: 0 },
+				]);
 				assert.ok(component.render(100).some((line) => line.includes("Inspector opened.")));
 			} finally {
 				component.dispose();
@@ -1623,6 +1632,7 @@ describe("native subagent fleet", () => {
 			const asyncDir = writeAsyncRun(root, { id: "async-stop" });
 			const state = stateForTest();
 			const calls: Array<{ runId: string; asyncDir: string; index?: number }> = [];
+			let inspectCalls = 0;
 			const component = new SubagentFleetComponent(
 				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
 				theme as never,
@@ -1632,6 +1642,7 @@ describe("native subagent fleet", () => {
 					asyncDirRoot: root,
 					resultsDir: path.join(root, "results"),
 					refreshMs: 60_000,
+					fleetKeybindings: { stop: ["return"] },
 					actions: {
 						async steer() {
 							return { text: "unused" };
@@ -1640,15 +1651,17 @@ describe("native subagent fleet", () => {
 							calls.push(input);
 							return { text: "Stop requested." };
 						},
+						async inspect() { inspectCalls++; return { text: "unexpected" }; },
 					},
 				},
 			);
 			try {
-				component.handleInput("D");
+				component.handleInput("\r");
 				assert.ok(component.render(100).some((line) => line.includes("Confirm stop for async run async-stop")));
+				assert.equal(inspectCalls, 0);
 				component.handleInput("n");
 				assert.deepEqual(calls, []);
-				component.handleInput("D");
+				component.handleInput("\r");
 				component.handleInput("y");
 				await new Promise((resolve) => setImmediate(resolve));
 				assert.deepEqual(calls, [{ runId: "async-stop", asyncDir, index: 0 }]);

package/dist/extensions/pi-subagents/test/unit/get-final-output.test.ts

@@ -17,6 +17,32 @@ describe("getFinalOutput", () => {
 		assert.equal(getFinalOutput(messages), "Summary");
 	});
 
+	it("removes a trailing Pi turn-timing footer from final output", () => {
+		const report = "## Review\n\nVERDICT: FINDINGS";
+		const timingFooter = "\x1b[38;2;136;136;136m✻ Turn took 5m 54s (Total time 5m 54s · 2 turns)\x1b[0m";
+		const messages = [assistantContent([
+			{ type: "text", text: `${report}\n\n${timingFooter}` },
+		])];
+
+		assert.equal(getFinalOutput(messages), report);
+	});
+
+	it("ignores a separate Pi turn-timing footer text part", () => {
+		const report = "## Review\n\nVERDICT: CLEAN";
+		const timingFooter = "\x1b[38;2;136;136;136m✻ Turn took 2m 19s (Total time 2m 18s · 1 turn)\x1b[0m";
+		const messages = [assistantContent([
+			{ type: "text", text: report },
+			{ type: "text", text: timingFooter },
+		])];
+
+		assert.equal(getFinalOutput(messages), report);
+	});
+
+	it("preserves ordinary timing prose", () => {
+		const text = "The benchmark turn took 5m 54s.";
+		assert.equal(getFinalOutput([assistantContent([{ type: "text", text }])]), text);
+	});
+
 	it("prefers final text over progress text in a multi-part assistant message", () => {
 		const messages = [assistantContent([
 			{ type: "text", text: "Working on the fix..." },