@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/unit/workflow-chat-progress.test.ts

@@ -6,8 +6,10 @@ import * as path from "node:path";
 import { describe, it } from "node:test";
 import { isSameGitRepository, resolveWorkflowChatProgress } from "../../src/workflows/chat-progress.ts";
 import { renderSubagentResult } from "../../src/tui/render.ts";
-import { createSubagentExecutor, foregroundResultIntercomStatus, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
-import type { Details, SingleResult, SubagentState } from "../../src/shared/types.ts";
+import { bindMissionWorkflowChildAsyncLaunch, createSubagentExecutor, foregroundResultIntercomStatus, missionWorkflowChildStatus, runMissionWorkflowChild, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
+import { readMissionBinding } from "../../src/missions/lifecycle.ts";
+import { createMission, readMission } from "../../src/missions/store.ts";
+import { DIRS, type Details, type SingleResult, type SubagentState } from "../../src/shared/types.ts";
 
 const theme = {
 	fg(_name: string, text: string): string { return text; },
@@ -96,6 +98,7 @@ describe("workflow chat progress policy", () => {
 			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: worktree, background: true }).projection?.mode, "milestones");
 			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: other, background: false }).projection?.mode, "terminal");
 			assert.match(resolveWorkflowChatProgress({ requested: "live-card", parentCwd: repo, workflowCwd: other, background: false }).error ?? "", /same Git repository/i);
+			assert.match(resolveWorkflowChatProgress({ requested: "terminal", parentCwd: repo, workflowCwd: repo, background: false }).projection?.mode ?? "", /terminal/);
 		} finally {
 			try { git(repo, ["worktree", "remove", "--force", worktree]); } catch {}
 			fs.rmSync(repo, { recursive: true, force: true });
@@ -112,7 +115,7 @@ describe("workflow chat progress rendering", () => {
 			const updates: Array<{ details?: Details }> = [];
 			const result = await createExecutor().execute(
 				"wf-live",
-				{ workflowScript: `return await runs.run("explorer", { agent: "missing-agent", task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
+				{ workflowScript: `return await runs.run("scout", { agent: "missing-agent", task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
 				new AbortController().signal,
 				(update) => updates.push(update),
 				ctx(repo),
@@ -120,14 +123,85 @@ describe("workflow chat progress rendering", () => {
 			assert.equal(result.isError, true);
 			const liveUpdate = updates.find((update) => update.details?.chatProgress?.mode === "live-card");
 			assert.ok(liveUpdate, "expected a live-card update");
-			assert.equal(liveUpdate.details?.workflow?.trace[0]?.key, "explorer");
+			assert.equal(liveUpdate.details?.workflow?.trace[0]?.key, "scout");
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.phase, "Validation");
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.label, "Find renderer seam");
+			const ledgerChild = result.details.mission?.workflowChildren[0];
+			assert.equal(ledgerChild?.key, "scout");
+			assert.equal(ledgerChild?.workflowRunId, "wf-live");
+			assert.equal(ledgerChild?.agent, "missing-agent");
+			assert.equal(ledgerChild?.phase, "Validation");
+			assert.equal(ledgerChild?.status, "failed");
+			assert.equal(ledgerChild?.heartbeat?.status, "failed");
 		} finally {
 			fs.rmSync(repo, { recursive: true, force: true });
 		}
 	});
 
+	it("keeps async workflow launch receipts running in the mission ledger", () => {
+		assert.equal(missionWorkflowChildStatus({
+			content: [{ type: "text", text: "Async: worker [run-1]" }],
+			details: { mode: "single", runId: "run-1", asyncId: "run-1", asyncDir: "/tmp/run-1", results: [] },
+		} as any), "running");
+	});
+
+	it("writes mission binding before async workflow child launch", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-child-binding-"));
+		const asyncId = `workflow-child-${process.pid}-${Date.now()}`;
+		const asyncDir = path.join(DIRS.async, asyncId);
+		try {
+			const location = {
+				projectRoot: root,
+				missionDir: path.join(root, ".pi-subagents", "missions"),
+				globalIndexDir: path.join(root, ".pi-subagents", "mission-index"),
+				writeGlobalIndex: false,
+			};
+			const mission = createMission(location, { title: "Workflow", objective: "Track child" });
+			const params = bindMissionWorkflowChildAsyncLaunch(
+				{ agent: "worker", task: "run", async: true },
+				{ missionId: mission.id, location, autoCreated: false },
+				false,
+				asyncId,
+			);
+
+			assert.equal(params.workflowChildAsyncId, asyncId);
+			assert.equal(readMissionBinding(asyncDir)?.missionId, mission.id);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("marks workflow launch preparation failures as failed mission children", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-prep-failure-"));
+		try {
+			const location = {
+				projectRoot: root,
+				missionDir: path.join(root, ".pi-subagents", "missions"),
+				globalIndexDir: path.join(root, ".pi-subagents", "mission-index"),
+				writeGlobalIndex: false,
+			};
+			const mission = createMission(location, { title: "Workflow", objective: "Track child" });
+
+			await assert.rejects(
+				() => runMissionWorkflowChild({ missionId: mission.id, location, autoCreated: false }, "wf-prep-failure", "resume", "Prep", async () => {
+					throw new Error("gate is not supported with retained resume");
+				}),
+				/gate is not supported with retained resume/,
+			);
+			const ledgerChild = readMission(location, mission.id).workflowChildren[0];
+
+			assert.equal(ledgerChild?.key, "resume");
+			assert.equal(ledgerChild?.status, "failed");
+			assert.equal(ledgerChild?.heartbeat?.status, "failed");
+			assert.equal(ledgerChild?.heartbeat?.phase, "Prep");
+			assert.match(ledgerChild?.heartbeat?.message ?? "", /gate is not supported with retained resume/);
+			assert.ok(ledgerChild?.completedAt);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("renders stable rows keyed by workflow trace entries", () => {
 		const text = componentText(renderSubagentResult({
 			content: [{ type: "text", text: "Workflow running." }],
@@ -138,7 +212,7 @@ describe("workflow chat progress rendering", () => {
 				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
 				workflow: {
 					trace: [
-						{ operation: "run", key: "explorer", state: "completed", runId: "run-explorer", phase: "Validation", label: "Found renderer seam", durationMs: 12 },
+						{ operation: "run", key: "scout", state: "completed", runId: "run-scout", phase: "Validation", label: "Found renderer seam", durationMs: 12 },
 						{ operation: "run", key: "tests", state: "started", phase: "Validation", label: "focused integration suite" },
 						{ operation: "run", key: "review", state: "failed", phase: "Validation", label: "fresh-context UX review", error: "needs fixes" },
 					],
@@ -151,15 +225,68 @@ describe("workflow chat progress rendering", () => {
 		assert.match(text, /workflow wf_8f3a12345 .* same repo .* failed/);
 		assert.match(text, /Repo   pi-subagents/);
 		assert.match(text, /Phase  Validation/);
-		assert.match(text, /complete\s+explorer Found renderer seam/);
+		assert.match(text, /complete\s+scout Found renderer seam/);
 		assert.match(text, /running\s+tests focused integration suite/);
 		assert.match(text, /failed\s+review fresh-context UX review .* needs fixes/);
 	});
 
+	it("bounds workflow live-card rows and keeps old failed children visible", () => {
+		const trace = Array.from({ length: 10 }, (_, index) => ({
+			operation: "run" as const,
+			key: `step-${index}`,
+			state: index === 0 ? "failed" as const : "started" as const,
+			label: `review ${index}`,
+			...(index === 0 ? { error: "Failed\n\nOutput:\nI will read the required plan first.\nI will inspect the exact head.\nI will read agent default application path." } : {}),
+		}));
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow running." }],
+			details: {
+				mode: "workflow",
+				runId: "wf_noisy",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: { trace, emits: [], console: [] },
+			},
+		}, { expanded: false }, theme as any));
+
+		assert.match(text, /2 older workflow rows hidden/);
+		assert.match(text, /failed\s+step-0 review 0 .* Failed · latest: read agent default application path/);
+		assert.match(text, /running\s+step-9 review 9/);
+		assert.doesNotMatch(text, /step-1/);
+		assert.doesNotMatch(text, /Output:/);
+	});
+
+	it("keeps mixed workflow child error output visible", () => {
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow running." }],
+			details: {
+				mode: "workflow",
+				runId: "wf_mixed_error",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: {
+					trace: [{
+						operation: "run",
+						key: "gate-monitor",
+						state: "failed",
+						label: "bot gate",
+						error: "Failed\n\nOutput:\nerror: failed to fetch review threads\nI will inspect the retry path.",
+					}],
+					emits: [],
+					console: [],
+				},
+			},
+		}, { expanded: false }, theme as any));
+
+		assert.match(text, /Failed · error: failed to fetch review threads I will inspect the retry path/);
+		assert.doesNotMatch(text, /latest: inspect the retry path/);
+		assert.doesNotMatch(text, /Output:/);
+	});
+
 	it("suppresses only successful routine child result intercom for live-card workflows", () => {
-		const completed = { agent: "explorer", exitCode: 0, outputState: "present" } as SingleResult;
-		const failed = { agent: "explorer", exitCode: 1, outputState: "present" } as SingleResult;
-		const rejected = { agent: "explorer", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
+		const completed = { agent: "delegate", exitCode: 0, outputState: "present" } as SingleResult;
+		const failed = { agent: "delegate", exitCode: 1, outputState: "present" } as SingleResult;
+		const rejected = { agent: "delegate", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
 
 		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [completed] }), true);
 		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [failed] }), false);
@@ -168,7 +295,7 @@ describe("workflow chat progress rendering", () => {
 	});
 
 	it("marks acceptance-rejected foreground intercom results as failed", () => {
-		const rejected = { agent: "explorer", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
+		const rejected = { agent: "delegate", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
 
 		assert.equal(foregroundResultIntercomStatus(rejected), "failed");
 	});
@@ -183,7 +310,7 @@ describe("workflow chat progress rendering", () => {
 				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
 				workflow: {
 					value: "final answer",
-					trace: [{ operation: "run", key: "explorer", state: "completed", runId: "run-explorer" }],
+					trace: [{ operation: "run", key: "scout", state: "completed", runId: "run-scout" }],
 					emits: [],
 					console: [],
 				},

package/dist/extensions/pi-subagents/test/unit/workflow-graph.test.ts

@@ -7,7 +7,7 @@ describe("workflow graph snapshots", () => {
 		const graph = buildWorkflowGraphSnapshot({
 			runId: "run-1",
 			steps: [
-				{ agent: "explorer", task: "Scan", phase: "Research", label: "Find context", as: "context" },
+				{ agent: "scout", task: "Scan", phase: "Research", label: "Find context", as: "context" },
 				{ agent: "writer", task: "Use {outputs.context}", phase: "Synthesis", outputSchema: { type: "object" } },
 			],
 			results: [{ exitCode: 0 }, { exitCode: 1, error: "bad output" }],
@@ -25,9 +25,9 @@ describe("workflow graph snapshots", () => {
 		]);
 	});
 
-	it("maps a long alternating builder and commentator chain without losing indexes", () => {
+	it("maps a long alternating worker and reviewer chain without losing indexes", () => {
 		const steps = Array.from({ length: 40 }, (_, index) => ({
-			agent: index % 2 === 0 ? "builder" : "commentator",
+			agent: index % 2 === 0 ? "worker" : "reviewer",
 			task: index === 0 ? "Start" : "{previous}",
 		}));
 		const results = steps.map(() => ({ exitCode: 0 }));
@@ -43,10 +43,10 @@ describe("workflow graph snapshots", () => {
 		assert.equal(graph.nodes[0]?.id, "step-0");
 		assert.equal(graph.nodes[0]?.flatIndex, 0);
 		assert.equal(graph.nodes[37]?.id, "step-37");
-		assert.equal(graph.nodes[37]?.agent, "commentator");
+		assert.equal(graph.nodes[37]?.agent, "reviewer");
 		assert.equal(graph.nodes[37]?.flatIndex, 37);
 		assert.equal(graph.nodes[39]?.id, "step-39");
-		assert.equal(graph.nodes[39]?.agent, "commentator");
+		assert.equal(graph.nodes[39]?.agent, "reviewer");
 		assert.equal(graph.nodes[39]?.flatIndex, 39);
 		assert.equal(graph.currentNodeId, "step-37");
 	});
@@ -58,7 +58,7 @@ describe("workflow graph snapshots", () => {
 				{ agent: "setup", task: "Setup" },
 				{
 					parallel: [
-						{ agent: "commentator", label: "Correctness", phase: "Review", as: "correctness" },
+						{ agent: "reviewer", label: "Correctness", phase: "Review", as: "correctness" },
 						{ agent: "security", label: "Security", phase: "Review", as: "security" },
 					],
 				},
@@ -107,7 +107,7 @@ describe("workflow graph snapshots", () => {
 	it("uses dynamic group status overrides for empty or aggregate-failure fanout states", () => {
 		const steps = [{
 			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {item}" },
+			parallel: { agent: "reviewer", task: "Review {item}" },
 			collect: { as: "reviews" },
 		}];
 
@@ -123,7 +123,7 @@ describe("workflow graph snapshots", () => {
 		const collectFailure = buildWorkflowGraphSnapshot({
 			runId: "run-dynamic-collect-fail",
 			steps,
-			dynamicChildren: { 0: [{ agent: "commentator", flatIndex: 0, itemKey: "a" }] },
+			dynamicChildren: { 0: [{ agent: "reviewer", flatIndex: 0, itemKey: "a" }] },
 			results: [{ exitCode: 0 }],
 			dynamicGroupStatuses: { 0: { status: "failed", error: "Collected output validation failed" } },
 		});

package/dist/extensions/pi-subagents/test/unit/workflow-launch-params.test.ts

@@ -0,0 +1,113 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { prepareWorkflowLaunchParams } from "../../src/runs/foreground/subagent-executor.ts";
+
+describe("workflow launch params", () => {
+	it("keeps omitted workflow child async foreground", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ agent: "worker", task: "Run" },
+				"workflow-run",
+				"run",
+			),
+			{
+				agent: "worker",
+				task: "Run",
+				async: false,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "run",
+			},
+		);
+	});
+
+	it("preserves explicit async workflow children", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ agent: "worker", task: "Run", async: true },
+				"workflow-run",
+				"run",
+			),
+			{
+				agent: "worker",
+				task: "Run",
+				async: true,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "run",
+			},
+		);
+	});
+
+	it("places workflow child gates inside managed worktree tasks", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{},
+				{ agent: "worker", task: "Implement", worktree: true, gate: "npm test" },
+				"workflow-run",
+				"gated",
+			),
+			{
+				worktree: true,
+				async: false,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "gated",
+				tasks: [{
+					agent: "worker",
+					task: "Implement",
+					acceptance: { level: "verified", verify: [{ id: "gate", command: "npm test" }] },
+				}],
+			},
+		);
+	});
+
+	it("rejects gate defaults on retained resume items", () => {
+		assert.throws(
+			() => prepareWorkflowLaunchParams(
+				{ gate: "npm test" },
+				{ resume: "retained-run", task: "Continue" },
+				"workflow-run",
+				"continue",
+			),
+			/gate is not supported with retained resume/,
+		);
+		assert.throws(
+			() => prepareWorkflowLaunchParams(
+				{},
+				{ resume: "retained-run", task: "Continue", gate: "npm test" },
+				"workflow-run",
+				"continue",
+			),
+			/gate is not supported with retained resume/,
+		);
+	});
+
+	it("preserves execution limits when routing retained resume items", () => {
+		assert.deepEqual(
+			prepareWorkflowLaunchParams(
+				{ turnBudget: { maxTurns: 8 }, toolBudget: { hard: 12, block: ["read"] } },
+				{
+					resume: " retained-run ",
+					task: "Continue carefully",
+					maxRuntimeMs: 5_000,
+					turnBudget: { maxTurns: 3, graceTurns: 1 },
+					toolBudget: { soft: 2, hard: 4, block: "*" },
+				},
+				"workflow-run",
+				"continue",
+				{ missionDetached: true },
+			),
+			{
+				action: "resume",
+				id: "retained-run",
+				message: "Continue carefully",
+				workflowParentRunId: "workflow-run",
+				workflowKey: "continue",
+				mission: false,
+				timeoutMs: 5_000,
+				turnBudget: { maxTurns: 3, graceTurns: 1 },
+				toolBudget: { soft: 2, hard: 4, block: "*" },
+			},
+		);
+	});
+});

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

@@ -125,6 +125,67 @@ describe("worktree", () => {
 		}
 	});
 
+	it("rejects worktree base directories inside Selesai extensions", () => {
+		const repoDir = createRepo("selesai-worktree-extension-dir-");
+		const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-worktree-home-"));
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		const previousHome = process.env.HOME;
+		const previousUserProfile = process.env.USERPROFILE;
+		const extensionsDir = path.join(tempHome, ".selesai", "agent", "extensions");
+		try {
+			process.env.HOME = tempHome;
+			process.env.USERPROFILE = tempHome;
+			delete process.env.SELESAI_CODING_AGENT_DIR;
+			assert.throws(
+				() => createWorktrees(repoDir, "extension-dir", 1, { baseDir: extensionsDir }),
+				/worktree base directory cannot be inside Pi extensions directory/i,
+			);
+			assert.throws(
+				() => createWorktrees(repoDir, "extension-subdir", 1, { baseDir: path.join(extensionsDir, "checkout") }),
+				/worktree base directory cannot be inside Pi extensions directory/i,
+			);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+			if (previousHome === undefined) delete process.env.HOME;
+			else process.env.HOME = previousHome;
+			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+			else process.env.USERPROFILE = previousUserProfile;
+			cleanupRepo(repoDir);
+			fs.rmSync(tempHome, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects symlinked worktree base directories inside Selesai extensions", () => {
+		const repoDir = createRepo("selesai-worktree-extension-symlink-");
+		const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-worktree-home-"));
+		const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		const previousHome = process.env.HOME;
+		const previousUserProfile = process.env.USERPROFILE;
+		const extensionsDir = path.join(tempHome, ".selesai", "agent", "extensions");
+		const aliasDir = path.join(tempHome, "extension-alias");
+		try {
+			process.env.HOME = tempHome;
+			process.env.USERPROFILE = tempHome;
+			delete process.env.SELESAI_CODING_AGENT_DIR;
+			fs.mkdirSync(extensionsDir, { recursive: true });
+			fs.symlinkSync(extensionsDir, aliasDir, process.platform === "win32" ? "junction" : "dir");
+			assert.throws(
+				() => createWorktrees(repoDir, "extension-symlink", 1, { baseDir: path.join(aliasDir, "checkout") }),
+				/worktree base directory cannot be inside Pi extensions directory/i,
+			);
+		} finally {
+			if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+			if (previousHome === undefined) delete process.env.HOME;
+			else process.env.HOME = previousHome;
+			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+			else process.env.USERPROFILE = previousUserProfile;
+			cleanupRepo(repoDir);
+			fs.rmSync(tempHome, { recursive: true, force: true });
+		}
+	});
+
 	it("uses SELESAI_SUBAGENTS_WORKTREE_DIR when no base directory is configured", () => {
 		const repoDir = createRepo("pi-worktree-env-base-dir-");
 		const previous = process.env.SELESAI_SUBAGENTS_WORKTREE_DIR;
@@ -178,8 +239,8 @@ describe("worktree", () => {
 		assert.equal(
 			findWorktreeTaskCwdConflict(
 				[
-					{ agent: "builder-a" },
-					{ agent: "builder-b", cwd: sharedCwd },
+					{ agent: "worker-a" },
+					{ agent: "worker-b", cwd: sharedCwd },
 				],
 				sharedCwd,
 			),
@@ -191,7 +252,7 @@ describe("worktree", () => {
 		const sharedCwd = path.join("/tmp", "repo");
 		assert.equal(
 			findWorktreeTaskCwdConflict(
-				[{ agent: "builder-a", cwd: "." }],
+				[{ agent: "worker-a", cwd: "." }],
 				sharedCwd,
 			),
 			undefined,
@@ -202,14 +263,14 @@ describe("worktree", () => {
 		const sharedCwd = path.join("/tmp", "repo");
 		const conflict = findWorktreeTaskCwdConflict(
 			[
-				{ agent: "builder-a", cwd: sharedCwd },
-				{ agent: "builder-b", cwd: path.join(sharedCwd, "packages", "app") },
+				{ agent: "worker-a", cwd: sharedCwd },
+				{ agent: "worker-b", cwd: path.join(sharedCwd, "packages", "app") },
 			],
 			sharedCwd,
 		);
 		assert.deepEqual(conflict, {
 			index: 1,
-			agent: "builder-b",
+			agent: "worker-b",
 			cwd: path.join(sharedCwd, "packages", "app"),
 		});
 	});
@@ -338,7 +399,7 @@ describe("worktree", () => {
 			setup = createWorktrees(repoDir, "captured", 1);
 			const worktreePath = setup.worktrees[0]!.path;
 			fs.writeFileSync(path.join(worktreePath, "tracked.txt"), "captured\n", "utf-8");
-			const diffs = diffWorktrees(setup, ["builder"], path.join(repoDir, "artifacts", "captured"));
+			const diffs = diffWorktrees(setup, ["worker"], path.join(repoDir, "artifacts", "captured"));
 			assert.equal(diffs[0]?.error, undefined);
 			assert.ok(fs.statSync(diffs[0]!.patchPath).size > 0);
 

package/dist/extensions/pi-subagents/test/unit/writer-budget-guidance.test.ts

@@ -7,11 +7,11 @@ const readProjectFile = (file: string): string => readFileSync(join(process.cwd(
 
 describe("writer budget guidance", () => {
 	it("keeps hard turn and tool caps off mutation-capable workers", () => {
-		const readme = readProjectFile("README.md");
+		const toolReference = readProjectFile("docs/tool-reference.md");
 		const skill = readProjectFile("skills/pi-subagents/SKILL.md");
 		const reviewLoop = readProjectFile("prompts/review-loop.md");
 
-		for (const text of [readme, skill, reviewLoop]) {
+		for (const text of [toolReference, skill, reviewLoop]) {
 			assert.match(text, /As a conservative orchestration policy, do not (?:pass|set) `turnBudget`(?:, a hard `toolBudget`, or a tight `usageBudget`| or a hard `toolBudget`)/);
 			assert.match(text, /default tool budget blocks read\/search tools rather than mutation tools/i);
 			assert.match(text, /checkpoint after the current tool returns/);
@@ -19,12 +19,12 @@ describe("writer budget guidance", () => {
 			assert.match(text, /build\/test state/);
 			assert.match(text, /commit or PR state/);
 		}
-		assert.match(readme, /elapsed timeout is not a mutation-safe boundary/i);
+		assert.match(toolReference, /elapsed timeout is not a mutation-safe boundary/i);
 	});
 
 	it("documents deferred hard-limit termination at tool-using boundaries", () => {
-		const readme = readProjectFile("README.md");
-		assert.match(readme, /termination occurs at the next assistant boundary/);
-		assert.match(readme, /`termination-deferred`/);
+		const toolReference = readProjectFile("docs/tool-reference.md");
+		assert.match(toolReference, /termination occurs at the next assistant boundary/);
+		assert.match(toolReference, /`termination-deferred`/);
 	});
 });

package/dist/extensions/workflow/extension.ts

@@ -1,24 +1,26 @@
-// ponytail: single pi extension that mounts every workflow mode. One load
-// resolves a single writer tool + N start/end tool pairs. Avoids the per-mode
-// load conflict (multiple extension modules would each try to register the
-// shared writer).
+// ponytail: thin shell. Registers the four /workflow-* commands and launches
+// each mode's scripted workflow through pi-subagents' launchSlashSubagent.
 
 import type { ExtensionAPI } from "@selesai/code";
-import { __resetWorkflowRegistryForTests, createWorkflowExtension } from "./adapter.ts";
-import { prototypeMode } from "./modes/prototype.ts";
-import { quicktypeMode } from "./modes/quicktype.ts";
-import { taskMode } from "./modes/task.ts";
-import { loopMode } from "./modes/loop.ts";
-
-export { __resetWorkflowRegistryForTests };
-
-const MODES = [prototypeMode, quicktypeMode, taskMode, loopMode] as const;
+import { launchSlashSubagent } from "../pi-subagents/src/slash/slash-commands.ts";
+import { buildLoopScript, buildPrototypeScript, buildQuicktypeScript, buildTaskScript } from "./modes.ts";
 
 export default function workflowModesExtension(pi: ExtensionAPI): void {
-  for (const mode of MODES) {
-    createWorkflowExtension(mode.config, {
-      commandName: mode.commandName,
-      commandDescription: mode.commandDescription,
-    })(pi);
-  }
+  const register = (name: string, description: string, build: (goal: string) => string) =>
+    pi.registerCommand(name, {
+      description,
+      handler: async (args, ctx) => {
+        const goal = args.trim();
+        if (!goal) {
+          ctx.ui.notify(`${description}\nUsage: /${name} <goal>`, "info");
+          return;
+        }
+        launchSlashSubagent(pi, ctx, { workflowScript: build(goal), async: true, agentScope: "both" });
+      },
+    });
+
+  register("workflow-task", "Run the task workflow (plan → reuse → handoff → auto build↔review loop) as a scripted workflow.", buildTaskScript);
+  register("workflow-prototype", "Run the full prototype workflow (research → plan → reuse → handoff → auto loop → audit) as a scripted workflow.", buildPrototypeScript);
+  register("workflow-quicktype", "Run the quicker prototype workflow without research (plan → reuse → handoff → auto loop → audit) as a scripted workflow.", buildQuicktypeScript);
+  register("workflow-loop", "Run a direct auto build↔review loop for an already-agreed plan as a scripted workflow.", buildLoopScript);
 }

package/dist/extensions/workflow/modes.ts

@@ -0,0 +1,65 @@
+// ponytail: four workflow modes as pi-subagents workflowScript builders.
+// One-shot-and-sleep: phases run as runs.run steps and the loop auto-repeats
+// until the reviewer reports clean. A workflowScript has no checkpoints, so
+// there are no human gates.
+
+function js(value: string): string {
+  return JSON.stringify(value);
+}
+
+const AUTO_LOOP = String.raw`
+const autoLoop = async (goal, context) => {
+  let round = 1;
+  while (true) {
+    const build = await runs.run('build-' + round, {
+      agent: 'builder',
+      task: 'Implement the approved work in the workspace and run relevant checks.\n\nSource of truth (handoff/plan):\n' + context + '\n\nGoal:\n' + goal + (round > 1 ? '\n\nAddress the previous review feedback first.' : ''),
+    });
+    const review = await runs.run('review-' + round, {
+      agent: 'commentator',
+      task: 'Independently review the uncommitted diff and report concrete evidence (what you inspected and what you ran). Do not modify the workspace.\n\nAcceptance criteria (source of truth):\n' + context + '\n\nBuilder completion summary:\n' + build.output + '\n\nEnd with exactly one line: WORKFLOW_REVIEW_STATUS: clean OR WORKFLOW_REVIEW_STATUS: blocking.',
+    });
+    if (/WORKFLOW_REVIEW_STATUS\s*:\s*clean/i.test(review.output)) {
+      return { result: 'clean', rounds: round };
+    }
+    round += 1;
+  }
+};`;
+
+export function buildLoopScript(goal: string): string {
+  return String.raw`const goal = ${js(goal)};
+${AUTO_LOOP}
+return await autoLoop(goal, goal);`;
+}
+
+export function buildTaskScript(goal: string): string {
+  return String.raw`const goal = ${js(goal)};
+const plan = await runs.run('plan', { agent: 'architect', task: 'Produce a concrete implementation plan for: ' + goal + '. Cover what to build, how, in what order, which files and components, and the finished result. Return inline.' });
+const reuse = await runs.run('reuse', { agent: 'explorer', task: 'Explore the codebase for reusable patterns relevant to: ' + plan.output + '. Point at relevant areas and dependencies; skip cleanly if wholly new. Return inline.' });
+const handoff = await runs.run('handoff', { agent: 'recapper', task: 'Compile a self-contained handoff from the plan and reuse findings so fresh agents understand the goal, constraints, and acceptance criteria without re-planning.\n\nPlan:\n' + plan.output + '\n\nReuse findings:\n' + reuse.output + '\n\nReturn inline.' });
+${AUTO_LOOP}
+return await autoLoop(goal, handoff.output);`;
+}
+
+export function buildPrototypeScript(goal: string): string {
+  return String.raw`const goal = ${js(goal)};
+const research = await runs.run('research', { agent: 'researcher', task: 'Research the external, fast-changing knowledge this task depends on (libraries, SDKs, APIs, unfamiliar alternatives). Task: ' + goal + '. Synthesize actionable findings with sources. Return inline.' });
+const plan = await runs.run('plan', { agent: 'architect', task: 'Produce a concrete build plan from the research findings.\n\nResearch:\n' + research.output + '\n\nRequest:\n' + goal + '\n\nReturn inline.' });
+const reuse = await runs.run('reuse', { agent: 'explorer', task: 'Explore the codebase for reusable patterns relevant to: ' + plan.output + '. Return inline.' });
+const handoff = await runs.run('handoff', { agent: 'recapper', task: 'Compile a self-contained handoff from the plan and reuse findings.\n\nPlan:\n' + plan.output + '\n\nReuse:\n' + reuse.output + '\n\nReturn inline.' });
+${AUTO_LOOP}
+const loop = await autoLoop(goal, handoff.output);
+const audit = await runs.run('audit', { agent: 'commentator', task: 'Final audit of the uncommitted changes for correctness, plan adherence, and over-engineering (cut bloat, dead flexibility, reinvented stdlib). Plan:\n' + plan.output + '\n\nReport concrete evidence. Do not modify the workspace.' });
+return { ...loop, audited: true };`;
+}
+
+export function buildQuicktypeScript(goal: string): string {
+  return String.raw`const goal = ${js(goal)};
+const plan = await runs.run('plan', { agent: 'architect', task: 'Produce a concrete build plan for: ' + goal + '. Cover what to build, how, in what order, which components, and the finished result. Return inline.' });
+const reuse = await runs.run('reuse', { agent: 'explorer', task: 'Explore the codebase for reusable patterns relevant to: ' + plan.output + '. Return inline.' });
+const handoff = await runs.run('handoff', { agent: 'recapper', task: 'Compile a self-contained handoff from the plan and reuse findings.\n\nPlan:\n' + plan.output + '\n\nReuse:\n' + reuse.output + '\n\nReturn inline.' });
+${AUTO_LOOP}
+const loop = await autoLoop(goal, handoff.output);
+const audit = await runs.run('audit', { agent: 'commentator', task: 'Final audit of the uncommitted changes for correctness, plan adherence, and over-engineering (cut bloat, dead flexibility, reinvented stdlib). Plan:\n' + plan.output + '\n\nReport concrete evidence. Do not modify the workspace.' });
+return { ...loop, audited: true };`;
+}

package/dist/modes/interactive/interactive-mode.d.ts

@@ -398,6 +398,7 @@ export declare class InteractiveMode {
     private notifyAuthDialog;
     private loginProvider;
     private showLoginDialog;
+    private handleSettingsFactoryReset;
     private handleReloadCommand;
     private handleExportCommand;
     private getPathCommandArgument;