@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/unit/watchdog-stable-host-layout.test.ts

@@ -0,0 +1,23 @@
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import test from "node:test";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("watchdog modules link on the stable host surface without newer pi-ai exports", () => {
+	const review = pathToFileURL(path.join(projectRoot, "src", "watchdog", "review.ts")).href;
+	const arbiter = pathToFileURL(path.join(projectRoot, "src", "watchdog", "permission-arbiter.ts")).href;
+	const loader = pathToFileURL(path.join(projectRoot, "test", "support", "watchdog-stable-host-loader.mjs")).href;
+	const script = `
+		const review = await import(${JSON.stringify(review)});
+		const arbiter = await import(${JSON.stringify(arbiter)});
+		if (typeof review.createMainWatchdogReview !== "function") throw new Error("review module did not load");
+		if (typeof arbiter.createWatchdogPermissionArbiter !== "function") throw new Error("permission arbiter module did not load");
+	`;
+
+	execFileSync(process.execPath, ["--experimental-strip-types", "--loader", loader, "--input-type=module", "--eval", script], {
+		cwd: projectRoot,
+		stdio: "pipe",
+	});
+});

package/dist/extensions/pi-subagents/test/unit/watchdog-tool-actions.test.ts

@@ -67,6 +67,36 @@ describe("watchdog tool actions", () => {
 		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, "high");
 	});
 
+	it("keeps session model overrides and their thinking in recommendations", () => {
+		const runtime = new MainWatchdogRuntime({ cwd: tempProject });
+		const ctx = createCtx({ provider: "openai-codex", id: "gpt-5.5" });
+		runtime.setSessionModel({ model: "openai-codex/gpt-5.5", thinking: false }, tempProject);
+		const recommendation = handleWatchdogToolAction("watchdog.recommend-model", {}, ctx, runtime);
+		assert.equal(recommendation.isError, undefined);
+		assert.match(text(recommendation), /Keep configured watchdog: openai-codex\/gpt-5.5:off/);
+		assert.doesNotMatch(text(recommendation), /strong independent watchdog/);
+		const applied = handleWatchdogToolAction("watchdog.configure", { model: "recommended" }, ctx, runtime);
+		assert.equal(applied.isError, undefined);
+		assert.equal(runtime.getSnapshot(tempProject).config.main.model, "openai-codex/gpt-5.5");
+		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, "off");
+		runtime.setSessionModel({ model: "openai-codex/gpt-5.5:low", thinking: false }, tempProject);
+		const suffixed = handleWatchdogToolAction("watchdog.configure", { model: "recommended" }, ctx, runtime);
+		assert.equal(suffixed.isError, undefined);
+		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, "low");
+		assert.equal(fs.existsSync(path.join(tempHome, ".selesai", "agent", "settings.json")), false);
+	});
+
+	it("does not replace an unavailable configured model with a strong recommendation", () => {
+		const runtime = new MainWatchdogRuntime({ cwd: tempProject });
+		const ctx = createCtx({ provider: "openai-codex", id: "gpt-5.5" });
+		runtime.setSessionModel({ model: "custom/unavailable", thinking: "low" }, tempProject);
+		const result = handleWatchdogToolAction("watchdog.configure", { model: "recommended", scope: "user" }, ctx, runtime);
+		assert.equal(result.isError, true);
+		assert.match(text(result), /was not found/);
+		assert.equal(runtime.getSnapshot(tempProject).config.main.model, "custom/unavailable");
+		assert.equal(fs.existsSync(path.join(tempHome, ".selesai", "agent", "settings.json")), false);
+	});
+
 	it("preserves omitted session model fields when configuring thinking", () => {
 		const runtime = new MainWatchdogRuntime({ cwd: tempProject });
 		const ctx = createCtx({ provider: "openai-codex", id: "gpt-5.5" });

package/dist/extensions/pi-subagents/test/unit/watchdog-turn-delta.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { formatWatchdogReviewMessage, formatWatchdogTurnDelta } from "../../src/watchdog/turn-delta.ts";
+import { formatWatchdogOrchestrationActivity, formatWatchdogReviewMessage, formatWatchdogTurnDelta } from "../../src/watchdog/turn-delta.ts";
 import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../src/watchdog/types.ts";
 
 describe("watchdog turn delta formatter", () => {
@@ -127,4 +127,41 @@ describe("watchdog turn delta formatter", () => {
 		assert.match(delta, /Assistant stop: stop/);
 		assert.match(delta, /Final assistant stop: stop without tool call/);
 	});
-});
+
+	it("distinguishes a validated structured terminal from an ordinary empty terminal", () => {
+		const messages = [{ role: "assistant", content: [], stopReason: "stop" }];
+		const ordinary = formatWatchdogTurnDelta({ messages, finalAssistantStop: true });
+		const structured = formatWatchdogTurnDelta({ messages, finalAssistantStop: true, structuredTerminal: true });
+
+		assert.match(ordinary, /Assistant: \(no text\)/);
+		assert.match(ordinary, /stop without tool call/);
+		assert.doesNotMatch(structured, /\(no text\)|stop without tool call/);
+		assert.match(structured, /validated structured output is the terminal response; no prose is required/);
+		assert.match(structured, /validated structured output completed the response/);
+	});
+
+	it("keeps independent tool evidence visible at a structured terminal", () => {
+		const delta = formatWatchdogTurnDelta({
+			structuredTerminal: true,
+			messages: [
+				{ role: "toolResult", toolName: "bash", isError: true, content: "tests failed" },
+				{ role: "assistant", content: [], stopReason: "stop" },
+			],
+		});
+
+		assert.match(delta, /Tool result: bash\nError: tool reported an error\nOutput:\ntests failed/);
+		assert.match(delta, /validated structured output is the terminal response/);
+	});
+
+	it("counts subagent workflow launches in every workflow form as orchestration activity", () => {
+		const calls = [{ workflow: true }, { workflow: "./ci/sweep.js" }, { workflow: "review" }, { workflowScript: "return 1" }]
+			.map((args, index) => ({ type: "toolCall", id: `call-${index}`, name: "subagent", arguments: args }));
+		const activity = formatWatchdogOrchestrationActivity({
+			type: "turn_end",
+			message: { content: calls },
+			toolResults: calls.map((call) => ({ role: "toolResult", toolCallId: call.id, toolName: "subagent", content: [{ type: "text", text: `launched ${call.id}` }] })),
+		});
+		for (const id of ["call-0", "call-1", "call-2"]) assert.match(activity, new RegExp(`launched ${id}`));
+		assert.doesNotMatch(activity, /launched call-3/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/widget-nested-render.test.ts

@@ -6,6 +6,7 @@ import type { AsyncJobState, NestedRunSummary } from "../../src/shared/types.ts"
 const theme = {
 	fg(_name: string, text: string): string { return text; },
 	bold(text: string): string { return text; },
+	getThinkingBorderColor(_level: string): (text: string) => string { return (text) => text; },
 };
 
 function withMockedDateNow<T>(now: number, fn: () => T): T {
@@ -168,4 +169,20 @@ describe("nested widget rendering", () => {
 		assert.notEqual(widgetRenderKey(first), widgetRenderKey(second));
 		assert.notEqual(widgetRenderKey(first), widgetRenderKey(renamed));
 	});
-});
+
+	it("colors running nested rows by the thinking level of the child each stands for", () => {
+		const toneTheme = {
+			fg: (name: string, text: string) => `⟦${name}⟧${text}⟦/⟧`,
+			bold: (text: string) => text,
+			getThinkingBorderColor: (level: string) => (text: string) => `⟦thinking:${level}⟧${text}⟦/⟧`,
+		};
+		const child = nested("leaf-run", "root-run", "running", {
+			thinking: "xhigh",
+			steps: [{ agent: "step-agent", status: "running", thinking: "minimal" }],
+		});
+		const lines = buildWidgetLines([job(child)], toneTheme as any, 160, true);
+		const glyphTone = (label: string) => lines.find((line) => line.includes(label))?.match(/⟦([^⟧]+)⟧[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏●]⟦\/⟧/)?.[1];
+		assert.equal(glyphTone("leaf-run"), "thinking:xhigh");
+		assert.equal(glyphTone("step-agent"), "thinking:minimal");
+	});
+});

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

@@ -9,6 +9,7 @@ import { renderSubagentResult } from "../../src/tui/render.ts";
 import { bindMissionWorkflowChildAsyncLaunch, createSubagentExecutor, foregroundResultIntercomStatus, missionWorkflowChildStatus, runMissionWorkflowChild, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
 import { encodeIndexSegment } from "../../src/runs/background/index-segment.ts";
 import { readMissionBinding } from "../../src/missions/lifecycle.ts";
+import { nestedRunScope } from "../../src/runs/shared/nested-events.ts";
 import { createMission, readMission } from "../../src/missions/store.ts";
 import { DIRS, type Details, type SingleResult, type SubagentState } from "../../src/shared/types.ts";
 
@@ -123,7 +124,8 @@ describe("workflow chat progress rendering", () => {
 				const result = await createExecutor().execute(
 					"wf-headless",
 					{
-						workflowScript: `return await runs.run("scout", { agent: "missing-agent", task: "scan" });`,
+						// A non-literal agent reaches launch-time resolution instead of pre-launch validation.
+						workflowScript: `const agent = "missing-agent"; return await runs.run("scout", { agent, task: "scan" });`,
 						async: false,
 						chatProgress: scenario === "explicit off" ? "off" : "auto",
 						...(other ? { cwd: other } : {}),
@@ -181,7 +183,7 @@ describe("workflow chat progress rendering", () => {
 			const updates: Array<{ details?: Details }> = [];
 			const result = await createExecutor().execute(
 				toolCallId,
-				{ workflowScript: `return await runs.run("scout", { agent: "missing-agent", task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
+				{ workflowScript: `const agent = "missing-agent"; return await runs.run("scout", { agent, task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
 				new AbortController().signal,
 				(update) => updates.push(update),
 				ctx(repo),
@@ -214,10 +216,10 @@ describe("workflow chat progress rendering", () => {
 		} as any), "running");
 	});
 
-	it("writes mission binding before async workflow child launch", () => {
+	for (const nestedRootRunId of [undefined, "binding-root"]) it(`writes mission binding at the actual async launch location (${nestedRootRunId ?? "top-level"})`, () => {
 		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);
+		const asyncDir = path.join(nestedRootRunId ? nestedRunScope(nestedRootRunId).asyncDirRoot : DIRS.async, asyncId);
 		try {
 			const location = {
 				projectRoot: root,
@@ -231,10 +233,12 @@ describe("workflow chat progress rendering", () => {
 				{ missionId: mission.id, location, autoCreated: false },
 				false,
 				asyncId,
+				nestedRootRunId,
 			);
 
 			assert.equal(params.workflowChildAsyncId, asyncId);
 			assert.equal(readMissionBinding(asyncDir)?.missionId, mission.id);
+			if (nestedRootRunId) assert.equal(fs.existsSync(path.join(DIRS.async, asyncId)), false);
 		} finally {
 			fs.rmSync(asyncDir, { recursive: true, force: true });
 			fs.rmSync(root, { recursive: true, force: true });

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

@@ -20,6 +20,16 @@ it("projects independent bounded snapshots by stable key and clears terminal act
 	assert.ok(workflowChildSummary({ ...input, inventoryComplete: true, workflowState: "failed", progress: snapshots }).children.every((row) => row.activity === undefined));
 });
 
+it("keeps launch receipts running when the workflow inventory closes successfully or with an error", () => {
+	for (const workflowState of ["completed", "failed", "stopped"] as const) {
+		const summary = workflowChildSummary({ ...input, workflowState, inventoryComplete: true,
+			children: [{ key: "a", state: "running", ok: false, runId: "child-a", output: "", artifactPaths: [] }],
+		});
+		assert.equal(summary.children.find((row) => row.childId === "a")?.state, "running");
+		assert.equal(summary.children.find((row) => row.childId === "b")?.state, workflowState === "stopped" ? "stopped" : "failed");
+	}
+});
+
 it("bounds UTF-8 and JSON bytes and rejects malformed activity strictly", () => {
 	assert.equal(workflowChildActivity({ currentTool: "界".repeat(86) }).currentTool, undefined);
 	assert.equal(workflowChildActivity({ currentTool: "界".repeat(85) }).currentTool?.length, 85);

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

@@ -145,7 +145,7 @@ describe("applyDetachedChildToPausedWorkflow", () => {
 });
 
 describe("reconcileDetachedWorkflowChildCompletion", () => {
-	it("publishes a terminal result when the paused result file is already gone", () => {
+	it("preserves quiet schedule attribution when the paused result file is already gone", () => {
 		const workflowRunId = "workflow-missing-result";
 		const asyncDir = path.join(DIRS.async, workflowRunId);
 		const childDir = path.join(DIRS.async, "child-1");
@@ -157,7 +157,8 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		fs.mkdirSync(DIRS.results, { recursive: true });
 		fs.writeFileSync(sessionFile, "", "utf-8");
 		fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({ runId: "child-1", mode: "single", state: "complete", startedAt: 1, lastUpdate: 2, sessionId: "session-1", steps: [{ agent: "worker", status: "complete", sessionFile }] }), "utf-8");
-		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
+		const scheduleOrigin = { id: "nightly", name: "Nightly", quiet: true as const };
+		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1", scheduleOrigin };
 		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
 		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({
 			workflowRunId,
@@ -185,7 +186,7 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 			events: { emit: (_name, payload) => { emitted = payload as CompletionNotification; } } as IntercomEventBus,
 			result: { index: 0, agent: "worker", task: `Write your findings to exactly this path: ${requestedPath}`, exitCode: 0, sessionFile, savedOutputPath: savedPath, usage: { input: 100, output: 50, cacheRead: 25, cacheWrite: 5, cost: 0.001, turns: 1 } },
 		}), true);
-		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; summary?: string; error?: string; sessionId?: string; workflowResolution?: string; recovery?: unknown[]; results?: Array<{ outputReference?: string; outputPathMapping?: unknown }>; workflowReceipt?: { receipt?: { state?: string; workflowResolution?: string; recovery?: unknown[]; entries?: Record<string, { resumability?: { state?: string; reason?: string } }> } } };
+		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; summary?: string; error?: string; sessionId?: string; scheduleOrigin?: typeof scheduleOrigin; workflowResolution?: string; recovery?: unknown[]; results?: Array<{ outputReference?: string; outputPathMapping?: unknown }>; workflowReceipt?: { receipt?: { state?: string; workflowResolution?: string; recovery?: unknown[]; entries?: Record<string, { resumability?: { state?: string; reason?: string } }> } } };
 		assert.equal(published.state, "failed");
 		assert.equal(published.success, false);
 		assert.match(published.error ?? "", /unsupported-continuation/);
@@ -199,11 +200,13 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		assert.deepEqual(publishedChild?.usage, { input: 100, output: 50, cacheRead: 25, cacheWrite: 5, cost: 0.001, turns: 1 });
 		assert.equal(publishedChild?.sessionFile, sessionFile);
 		assert.equal(published.sessionId, "session-1");
+		assert.deepEqual(published.scheduleOrigin, scheduleOrigin);
 		assert.equal(published.workflowReceipt?.receipt?.state, "failed");
 		assert.equal(published.workflowReceipt?.receipt?.workflowResolution, "settled-awaiting-resume");
 		assert.deepEqual(published.workflowReceipt?.receipt?.recovery, published.recovery);
 		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.state, "resumable");
 		assert.ok(emitted);
+		assert.deepEqual(emitted.scheduleOrigin, scheduleOrigin);
 		const notification = parseSubagentNotifyContent(formatSingleCompletion(buildCompletionDetails(emitted)));
 		const publishedPath = (published.workflowReceipt as { path: string }).path;
 		assert.equal(notification?.workflowReceiptPath, publishedPath);

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

@@ -1,9 +1,37 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { prepareWorkflowLaunchParams, promptAuditRedoParams, resolveRevivalControlConfig, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import { prepareWorkflowLaunchParams, promptAuditRedoParams, resolveRevivalControlConfig, resolveWorkflowChildLocalCwd, sanitizeRunPathSegment } from "../../src/runs/foreground/subagent-executor.ts";
 import { resolveControlConfig } from "../../src/runs/shared/subagent-control.ts";
 
 describe("workflow launch params", () => {
+	it("keeps remote workflow cwd out of local discovery for explicit and agent-pinned machines", () => {
+		const workflowCwd = "/local/workflow";
+		const discoverCalls: string[] = [];
+		const pinned: AgentConfig = {
+			name: "pinned",
+			description: "Pinned agent",
+			systemPrompt: "Run remotely.",
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritGlobalContext: false,
+			inheritSkills: false,
+			source: "project",
+			filePath: "/local/workflow/.selesai/agents/pinned.md",
+			machine: "workmac",
+		};
+		const discoverAgents = (cwd: string) => {
+			discoverCalls.push(cwd);
+			return { agents: [pinned] };
+		};
+		const shared = { workflowCwd, discoverAgents, agents: [] as AgentConfig[] };
+
+		assert.equal(resolveWorkflowChildLocalCwd({ ...shared, params: { agent: "worker", machine: "workmac", cwd: "/remote/repo" } }), workflowCwd);
+		assert.deepEqual(discoverCalls, []);
+		assert.equal(resolveWorkflowChildLocalCwd({ ...shared, params: { agent: "pinned", cwd: "/remote/repo" } }), workflowCwd);
+		assert.deepEqual(discoverCalls, [workflowCwd]);
+	});
+
 	it("preserves omitted workflow child async defaults and awaits background resolution", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
@@ -274,6 +302,21 @@ describe("workflow launch params", () => {
 		);
 	});
 
+	it("projects an object gate into a typed verify command", () => {
+		const gate = { command: "classify.sh --report r.md", output: "json", schema: { type: "object" }, timeoutMs: 5000 };
+		assert.deepEqual(
+			prepareWorkflowLaunchParams({}, { agent: "reviewer", task: "Review", gate }, "workflow-run", "typed"),
+			{
+				agent: "reviewer",
+				task: "Review",
+				workflowAwaitAsync: true,
+				workflowParentRunId: "workflow-run",
+				workflowKey: "typed",
+				acceptance: { level: "verified", verify: [{ id: "gate", command: "classify.sh --report r.md", output: "json", schema: { type: "object" }, timeoutMs: 5000 }] },
+			},
+		);
+	});
+
 	it("preserves a bridge override for retained workflow children", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(

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

@@ -79,6 +79,18 @@ describe("workflow receipts", () => {
 		assert.deepEqual(readWorkflowReceipt(asyncRoot, "workflow-resource").resource, resource);
 	});
 
+	it("round-trips the canonical workflow argument digest and rejects malformed digests", () => {
+		const asyncRoot = tempRoot();
+		const asyncDir = path.join(asyncRoot, "workflow-args");
+		fs.mkdirSync(asyncDir, { recursive: true });
+		const argsDigest = "a".repeat(64);
+		writeWorkflowReceipt(asyncDir, buildWorkflowReceipt({ workflowRunId: "workflow-args", state: "complete", children: [], argsDigest }));
+		assert.equal(readWorkflowReceipt(asyncRoot, "workflow-args").argsDigest, argsDigest);
+		assert.throws(() => buildWorkflowReceipt({ workflowRunId: "workflow-args", state: "complete", children: [], argsDigest: "invalid" }), /argsDigest/);
+		fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), JSON.stringify({ ...buildWorkflowReceipt({ workflowRunId: "workflow-args", state: "complete", children: [], argsDigest }), argsDigest: "invalid" }));
+		assert.throws(() => readWorkflowReceipt(asyncRoot, "workflow-args"), /argsDigest is invalid/);
+	});
+
 	it("round-trips bounded host CI/gate state in terminal receipts", () => {
 		const asyncRoot = tempRoot();
 		const asyncDir = path.join(asyncRoot, "workflow-host");
@@ -284,7 +296,12 @@ describe("workflow receipts", () => {
 		const runner = resolveExternalCliRunnerStatus({ command: "review-cli" });
 		const externalAdapter = externalCliReceiptMetadata({
 			runner,
-			externalProcess: { startedAt: 1, stdoutPath: "/tmp/stdout.log", stderrPath: "/tmp/stderr.log" },
+			externalProcess: {
+				startedAt: 1,
+				stdoutPath: "/tmp/stdout.log",
+				stderrPath: "/tmp/stderr.log",
+				machine: { provider: "herdr", id: "machine-1", label: "workmac", target: "host.example", cwd: "/srv/repo", remoteGit: { head: "abc123", branch: "main", dirty: true } },
+			},
 			outputReference: "/tmp/final.md",
 		});
 		const receipt = buildWorkflowReceipt({
@@ -298,9 +315,19 @@ describe("workflow receipts", () => {
 		assert.equal(receipt.entries.advisor?.externalAdapter?.capabilities.stop, true);
 		assert.equal(receipt.entries.advisor?.externalAdapter?.capabilities.supervisor, "unsupported");
 		assert.equal(receipt.entries.advisor?.externalAdapter?.handoff.mode, "fresh");
+		assert.deepEqual(receipt.entries.advisor?.externalAdapter?.machine, { provider: "herdr", id: "machine-1", label: "workmac", target: "host.example", cwd: "/srv/repo", remoteGit: { head: "abc123", branch: "main", dirty: true } });
 		assert.match(receipt.entries.advisor?.resumability.state === "not-resumable" ? receipt.entries.advisor.resumability.reason : "", /no durable external session identity/);
 		assert.doesNotMatch(serialized, /artifactPaths|rawOutput|handoffText|contact_supervisor/);
 		assert.ok(Buffer.byteLength(serialized) < 2_000, `external receipt metadata unexpectedly large: ${Buffer.byteLength(serialized)}`);
+		const asyncRoot = tempRoot();
+		const asyncDir = path.join(asyncRoot, "workflow-external");
+		fs.mkdirSync(asyncDir, { recursive: true });
+		writeWorkflowReceipt(asyncDir, receipt);
+		assert.deepEqual(readWorkflowReceipt(asyncRoot, "workflow-external").entries.advisor?.externalAdapter?.machine, externalAdapter.machine);
+		const malformed = JSON.parse(fs.readFileSync(path.join(asyncDir, "workflow-receipt.json"), "utf-8"));
+		malformed.entries.advisor.externalAdapter.machine.remoteGit.dirty = "true";
+		fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), JSON.stringify(malformed));
+		assert.throws(() => readWorkflowReceipt(asyncRoot, "workflow-external"), /machine\.remoteGit is invalid/);
 	});
 
 	it("fails closed for malformed external adapter receipt metadata", () => {

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

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { buildCompletionDetails, formatSingleCompletion } from "../../src/runs/background/notify.ts";
+import { buildWorkflowReceipt, resolveWorkflowReceiptResumeEntry, writeWorkflowReceipt } from "../../src/workflows/workflow-receipt.ts";
+import { formatWorkflowKeyRevival, projectWorkflowKeyRevival, recordWorkflowRevival, withWorkflowRevivals } from "../../src/workflows/workflow-revival.ts";
+import type { WorkflowScriptChildResult } from "../../src/workflows/scripted-workflow.ts";
+
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function setup(childState: string) {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-revival-"));
+	roots.push(root);
+	writeStatus(root, "child", { state: childState, parentWorkflowRunId: "wf", workflowKey: "memory" });
+	const child: WorkflowScriptChildResult = { key: "memory", ok: false, runId: "child", output: "429 rate limit", error: "429 rate limit", terminalOutcome: { state: "partial", reason: "timeout" }, outputReference: "/tmp/memory.md", structuredOutput: { partial: true }, resumability: { state: "resumable" }, artifactPaths: [] };
+	fs.mkdirSync(path.join(root, "wf"), { recursive: true });
+	writeWorkflowReceipt(path.join(root, "wf"), buildWorkflowReceipt({ workflowRunId: "wf", state: "complete", children: [child] }));
+	return { root, child };
+}
+
+function writeStatus(root: string, runId: string, fields: Record<string, unknown>): void {
+	fs.mkdirSync(path.join(root, runId), { recursive: true });
+	fs.writeFileSync(path.join(root, runId, "status.json"), JSON.stringify({ runId, mode: "single", startedAt: 1, ...fields }));
+}
+
+function keyedLatest(root: string): { latestRunId: string; runIds: string[] } {
+	const entry = resolveWorkflowReceiptResumeEntry({ reference: { workflowRunId: "wf", key: "memory", latest: true }, asyncDirRoot: root });
+	return { latestRunId: entry.latestRunId, runIds: entry.continuation.runIds };
+}
+
+describe("workflow child revival links", () => {
+	it("links only revivals of failed children", () => {
+		for (const state of ["complete", "paused", "stopped"]) {
+			const { root } = setup(state);
+			recordWorkflowRevival(root, "child", "revived");
+			assert.deepEqual(keyedLatest(root), { latestRunId: "child", runIds: ["child"] }, state);
+		}
+		const { root } = setup("failed");
+		recordWorkflowRevival(root, "child", "revived");
+		assert.deepEqual(keyedLatest(root), { latestRunId: "revived", runIds: ["child", "revived"] });
+		const corrupt = setup("failed").root;
+		fs.writeFileSync(path.join(corrupt, "child", "status.json"), "{");
+		assert.throws(() => recordWorkflowRevival(corrupt, "child", "revived"), /status/i, "an unreadable source status is reported, not skipped");
+		const blocked = setup("failed").root;
+		fs.mkdirSync(path.join(blocked, "child", "workflow-revival.json"));
+		assert.throws(() => recordWorkflowRevival(blocked, "child", "revived"));
+		assert.equal(fs.existsSync(path.join(blocked, "revived", "workflow-revival-origin.json")), false, "a failed link write leaves no origin that would pin the run");
+	});
+
+	it("refuses a revival past the chain bound, which readers always reach", () => {
+		const { root } = setup("failed");
+		let source = "child";
+		for (let depth = 1; depth <= 16; depth++) {
+			const revived = `revived-${depth}`;
+			recordWorkflowRevival(root, source, revived);
+			writeStatus(root, revived, { state: "failed" });
+			source = revived;
+		}
+		assert.throws(() => recordWorkflowRevival(root, source, "revived-17"), /already has 16 chained revivals/);
+		const revival = projectWorkflowKeyRevival(root, "wf", "memory", "child");
+		assert.equal(revival?.revivedRunIds.length, 16);
+		assert.equal(revival?.latestRunId, "revived-16");
+	});
+
+	it("adds revived lineage to a failed child's receipt and notice without rewriting its result", () => {
+		const { root, child } = setup("failed");
+		recordWorkflowRevival(root, "child", "revived");
+		writeStatus(root, "revived", { state: "complete" });
+		const [projected] = withWorkflowRevivals(root, "wf", [child]);
+		assert.deepEqual({ ...projected, continuation: undefined, revival: undefined }, { ...child, continuation: undefined, revival: undefined });
+		assert.deepEqual(projected!.continuation, { runIds: ["child", "revived"] });
+		assert.equal(buildWorkflowReceipt({ workflowRunId: "wf", state: "complete", children: [projected!] }).entries.memory!.latestRunId, "revived");
+
+		const notice = formatSingleCompletion(buildCompletionDetails({
+			id: "wf", runId: "wf", mode: "workflow", agent: "workflow", state: "complete", success: true, summary: "done",
+			results: [{ workflowKey: "memory", runId: "child", success: false, output: child.output, outputState: "present", revival: formatWorkflowKeyRevival(projected!.revival!) }],
+		}));
+		assert.match(notice, /key=memory run=child status=failed\n {2}Revived → revived: completed\n/);
+	});
+});

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

@@ -0,0 +1,177 @@
+import assert from "node:assert/strict";
+import * as os from "node:os";
+import { describe, it } from "node:test";
+import { Compile } from "typebox/compile";
+import { disabledFeatureUseError, resolveDisabledFeatureSurface } from "../../src/shared/disabled-features.ts";
+import { normalizePublicSubagentExecution } from "../../src/extension/public-execution.ts";
+import { createSubagentParamsSchema } from "../../src/extension/schemas.ts";
+import { SUBAGENT_RPC_PROTOCOL_VERSION, SUBAGENT_RPC_REQUEST_EVENT, registerSubagentRpcBridge, subagentRpcReplyEvent } from "../../src/extension/rpc.ts";
+import { buildSubagentToolDescription, buildSubagentToolPromptMetadata } from "../../src/extension/tool-description.ts";
+import { createSubagentExecutor, type SubagentParamsLike } from "../../src/runs/foreground/subagent-executor.ts";
+import { createChildSafeState } from "../../src/extension/fanout-child.ts";
+import { registerSlashCommands } from "../../src/slash/slash-commands.ts";
+import type { ExtensionConfig } from "../../src/shared/types.ts";
+import { createEventBus, makeMinimalCtx } from "../support/helpers.ts";
+
+const SETTING = `disabledFeatures "workflow-scripts"`;
+const DISABLED: ExtensionConfig = { disabledFeatures: ["workflow-scripts"] };
+const surface = resolveDisabledFeatureSurface(DISABLED);
+const LEGACY_ERROR = "Legacy top-level chain and parallel inputs were removed; use a workflow script (workflow: true or a workflow script path).";
+const SCRIPTS_DISABLED = `subagent workflow scripts are disabled by config ${SETTING}.`;
+
+function createExecutor(config: ExtensionConfig) {
+	return createSubagentExecutor({
+		pi: { events: { emit() {}, on() { return () => {}; } }, getSessionName() { return "parent"; } } as never,
+		state: createChildSafeState(),
+		config: { maxSubagentDepth: 2, control: {}, intercomBridge: {}, ...config } as never,
+		asyncByDefault: false,
+		tempArtifactsDir: os.tmpdir(),
+		getSubagentSessionRoot: () => os.tmpdir(),
+		expandTilde: (value) => value,
+		discoverAgents: () => ({ agents: [] as never[] }),
+	});
+}
+
+function ctx() {
+	return makeMinimalCtx(os.tmpdir()) as never;
+}
+
+function resultText(result: { content: Array<{ type: string; text?: string }> }): string {
+	return result.content.map((part) => part.text ?? "").join("\n");
+}
+
+function declarationLength(config: ExtensionConfig, toolDescriptionMode?: "full"): number {
+	const disabledFeatures = resolveDisabledFeatureSurface(config);
+	return JSON.stringify({
+		name: "subagent",
+		description: buildSubagentToolDescription({ toolDescriptionMode }, { disabledFeatures }),
+		parameters: createSubagentParamsSchema(disabledFeatures),
+	}).length;
+}
+
+describe("workflow-scripts tool surface", () => {
+	it("is smaller than the default declaration", () => {
+		for (const mode of [undefined, "full"] as const) {
+			const enabled = declarationLength({}, mode);
+			const disabled = declarationLength(DISABLED, mode);
+			assert.ok(disabled < enabled, `${mode ?? "default"} mode: disabled ${disabled} is not smaller than enabled ${enabled}`);
+		}
+	});
+
+	it("accepts chain and tasks shapes with a small schema", () => {
+		const schema = createSubagentParamsSchema(surface);
+		const validator = Compile(schema);
+		assert.equal(validator.Check({ task: "ship it", tasks: [{ agent: "scout", task: "a" }, { agent: "reviewer", task: "b" }] }), true);
+		assert.equal(validator.Check({ task: "ship it", chain: [{ agent: "scout", task: "{task}", as: "scan" }, { parallel: [{ agent: "reviewer", task: "{outputs.scan}" }] }, { agent: "writer" }] }), true);
+		assert.equal(validator.Check({ tasks: [{ agent: "scout" }] }), false, "tasks items require task");
+		assert.equal(validator.Check({ chain: [{ agent: "scout", model: "x" }] }), false, "chain steps reject other fields");
+		assert.equal(validator.Check({ chain: [] }), false, "chain needs a step");
+		const serialized = JSON.stringify({ tasks: schema.properties.tasks, chain: schema.properties.chain });
+		assert.ok(serialized.length <= 750, `chain/tasks schema is ${serialized.length} chars`);
+	});
+
+	it("replaces script guidance with chain/tasks guidance", () => {
+		for (const toolDescriptionMode of [undefined, "compact", "full"] as const) {
+			const description = buildSubagentToolDescription({ toolDescriptionMode }, { disabledFeatures: surface });
+			for (const script of ["```js workflow", "workflow:true", "runs.run", "runs.all", "runs.lanes", "runs.host", "Named resources", "validate", "args", "state.get", "Schedules take script inputs"]) {
+				assert.ok(!description.includes(script), `${toolDescriptionMode ?? "default"} description still mentions ${script}`);
+			}
+			for (const text of ["tasks:[{agent,task},...]", "chain:[{agent,task?,as?}", "{task}", "{previous}", "{outputs.name}", "SAFETY-CRITICAL SUBAGENT GUIDANCE", "exactly one top-level subagent chain or tasks call"]) {
+				assert.ok(description.includes(text), `${toolDescriptionMode ?? "default"} description lacks ${text}`);
+			}
+		}
+		// Selesai keeps the full description as default and emits no split prompt metadata.
+		assert.deepEqual(buildSubagentToolPromptMetadata({}, surface), {});
+	});
+});
+
+describe("workflow-scripts admission", () => {
+	it("attributes preflight to workflow-scripts in either config order", () => {
+		for (const disabledFeatures of [["preflight", "workflow-scripts"], ["workflow-scripts", "preflight"]] as const) {
+			const both = resolveDisabledFeatureSurface({ disabledFeatures: [...disabledFeatures] });
+			assert.equal(disabledFeatureUseError({ preflight: {} }, both), `subagent option 'preflight' is disabled by config ${SETTING}.`);
+		}
+	});
+
+	it("rejects every workflow form and raw scripts from public, delegated, and scheduled launches", async () => {
+		const executor = createExecutor(DISABLED);
+		for (const workflow of [true, "./flow.js", "review"]) {
+			const result = await executor.executePublic("workflow", { workflow } as SubagentParamsLike, new AbortController().signal, undefined, ctx());
+			assert.equal(resultText(result), `subagent option 'workflow' is disabled by config ${SETTING}.`);
+		}
+		const script = { workflowScript: "return 1;", async: true };
+		assert.equal(resultText(await executor.executePublic("public", script, new AbortController().signal, undefined, ctx())), SCRIPTS_DISABLED);
+		assert.equal(resultText(await executor.executeDelegated("delegated", script, new AbortController().signal, undefined, ctx())), SCRIPTS_DISABLED);
+		assert.equal(resultText(await executor.executeScheduled("scheduled", script, new AbortController().signal, ctx())), SCRIPTS_DISABLED);
+	});
+
+	it("rejects RPC spawn scripts before normalization", async () => {
+		const handlers: Array<(data: unknown) => void> = [];
+		const replies = new Map<string, unknown>();
+		registerSubagentRpcBridge({
+			events: {
+				on(event: string, handler: (data: unknown) => void) {
+					if (event === SUBAGENT_RPC_REQUEST_EVENT) handlers.push(handler);
+					return () => {};
+				},
+				emit(event: string, data: unknown) { replies.set(event, data); },
+			} as never,
+			getContext: () => ctx(),
+			execute: async () => assert.fail("disabled RPC spawn must not execute"),
+			disabledFeatures: surface,
+		});
+		const spawn = async (requestId: string, params: unknown) => {
+			for (const handler of handlers) await handler({ version: SUBAGENT_RPC_PROTOCOL_VERSION, requestId, method: "spawn", params });
+			return (replies.get(subagentRpcReplyEvent(requestId)) as { error?: { code: string; message: string } }).error;
+		};
+		assert.deepEqual(await spawn("script", { script: "return 1;" }), { code: "invalid_params", message: `RPC spawn workflow scripts are disabled by config ${SETTING}.` });
+		// Normalization would otherwise report "args requires workflow." and hide the setting.
+		assert.deepEqual(await spawn("args", { agent: "scout", task: "x", args: {} }), { code: "invalid_params", message: `RPC spawn option 'args' is disabled by config ${SETTING}.` });
+		assert.equal((await spawn("chain", { chain: [{ agent: "scout", task: "x" }] }))?.message, LEGACY_ERROR);
+	});
+
+	it("launches /run as a direct child", async () => {
+		const commands = new Map<string, { handler(args: string, ctx: unknown): Promise<void> }>();
+		const requested: unknown[] = [];
+		const events = createEventBus();
+		events.on("subagent:slash:request", (data) => {
+			const { requestId, params } = data as { requestId: string; params: unknown };
+			requested.push(params);
+			events.emit("subagent:slash:started", { requestId });
+			events.emit("subagent:slash:response", { requestId, result: { content: [{ type: "text", text: "done" }], details: { mode: "single", results: [] } }, isError: false });
+		});
+		const pi = { events, on() { return () => {}; }, registerTool() {}, registerCommand: (name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) => commands.set(name, spec), registerShortcut() {}, sendMessage() {} };
+		const disposer = registerSlashCommands(pi as never, { ...createChildSafeState(), baseCwd: process.cwd() }, { workflowScriptsDisabled: true });
+		try {
+			await commands.get("run")!.handler("scout Inspect this --bg", { ...makeMinimalCtx(process.cwd()), ui: { notify() {}, setStatus() {}, setToolsExpanded() {} } });
+			await new Promise<void>((resolve) => setImmediate(resolve));
+		} finally {
+			disposer.dispose();
+		}
+		assert.deepEqual(requested, [{ agent: "scout", task: "Inspect this", agentScope: "both", async: true }]);
+	});
+});
+
+describe("workflow-scripts chain/tasks normalization", () => {
+	it("keeps chain and tasks as legacy errors while workflow scripts are enabled", async () => {
+		for (const input of [{ chain: [{ agent: "scout", task: "x" }] }, { tasks: [{ agent: "scout", task: "x" }] }]) {
+			const result = await createExecutor({}).executePublic("enabled", input, new AbortController().signal, undefined, ctx());
+			assert.equal(resultText(result), LEGACY_ERROR);
+		}
+	});
+
+	it("accepts chain or tasks with the original request and rejects conflicts", () => {
+		const chain = [{ agent: "scout", task: "{task}" }];
+		const normalize = (input: Record<string, unknown>) => normalizePublicSubagentExecution(input, { structuredWorkflows: true });
+		assert.deepEqual(normalize({ task: "ship", chain, async: true }), { ok: true, params: { task: "ship", chain, async: true } });
+		const error = (input: Record<string, unknown>) => {
+			const normalized = normalize(input);
+			return normalized.ok ? undefined : normalized.error;
+		};
+		assert.equal(error({ chain, tasks: chain }), "Pass either tasks or chain, not both.");
+		assert.equal(error({ chain, agent: "scout" }), "chain cannot be combined with agent.");
+		assert.equal(error({ tasks: chain, action: "status" }), "tasks cannot be combined with action.");
+		assert.equal(error({ tasks: chain, step: {} }), "tasks cannot be combined with step.");
+		for (const legacy of [{ action: "chain", chain }, { action: "tasks", tasks: chain }, { chain, concurrency: 2 }, { chain, chainDir: "/tmp" }]) assert.equal(error(legacy), LEGACY_ERROR);
+	});
+});