@selesai/code 0.13.12 → 0.13.14

package/dist/extensions/pi-subagents/test/unit/process-terminal.test.ts

@@ -6,6 +6,7 @@ import test from "node:test";
 import { ACTIVE_RUN_INDEX_DIR, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import {
 	finalizeProcessTerminal,
+	initializeProcessTerminal,
 	processTerminalPath,
 	readProcessTerminal,
 	sanitizeProcessTerminal,
@@ -59,6 +60,27 @@ test("process-terminal proof requires the matching runner instance and writer cl
 	}
 });
 
+test("startup process-terminal candidate does not certify unobserved writers", () => {
+	const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-terminal-startup-"));
+	try {
+		initializeProcessTerminal(asyncDir, "run-startup", "runner-startup");
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "run-startup", state: "running", lifecycleArtifactVersion: 3, steps: [{ agent: "worker", status: "running" }] }));
+		fs.writeFileSync(path.join(asyncDir, "events.jsonl"), "");
+
+		const proof = finalizeProcessTerminal(asyncDir, "run-startup", {
+			processInstanceId: "runner-startup",
+			closeObservedAt: 20,
+			exitCode: 1,
+			signal: null,
+		});
+
+		assert.equal(proof.state, "unknown");
+		assert.equal(proof.reason, "writer-close-unverified");
+	} finally {
+		fs.rmSync(asyncDir, { recursive: true, force: true });
+	}
+});
+
 test("process-terminal rejects missing writer close evidence", () => {
 	const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-process-terminal-"));
 	try {

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

@@ -37,6 +37,7 @@ describe("profiles helpers", () => {
 		homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subprofiles-home-"));
 		process.env.HOME = homeDir;
 		process.env.USERPROFILE = homeDir;
+		process.env[SELESAI_SUBAGENT_SELESAI_BINARY_ENV] = path.join(homeDir, "pi-test-bin");
 	});
 
 	afterEach(() => {

package/dist/extensions/pi-subagents/test/unit/project-panes-public-api.test.ts

@@ -30,6 +30,8 @@ describe("public project-panes package export", () => {
 
 	it("runs the structured lifecycle and verifies pane ownership before idle close", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-"));
+		const previousPiBinary = process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
+		process.env.SELESAI_SUBAGENT_SELESAI_BINARY = path.join(root, "pi-bin");
 		try {
 			const projectRoot = fs.realpathSync(root);
 			const calls: string[][] = [];
@@ -76,6 +78,8 @@ describe("public project-panes package export", () => {
 			assert.ok(calls.some((args) => args.join(" ") === "tab focus tab-20"));
 			assert.ok(calls.some((args) => args.join(" ") === "pane close w1:p20"));
 		} finally {
+			if (previousPiBinary === undefined) delete process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
+			else process.env.SELESAI_SUBAGENT_SELESAI_BINARY = previousPiBinary;
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
@@ -131,6 +135,8 @@ describe("public project-panes package export", () => {
 
 	it("returns a structured error and closes the pane when binding persistence fails", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-public-project-pane-write-failure-"));
+		const previousPiBinary = process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
+		process.env.SELESAI_SUBAGENT_SELESAI_BINARY = path.join(root, "pi-bin");
 		try {
 			fs.mkdirSync(path.join(root, ".selesai"));
 			fs.writeFileSync(path.join(root, ".pi-subagents"), "directory collision");
@@ -152,6 +158,8 @@ describe("public project-panes package export", () => {
 			}
 			assert.ok(calls.some((args) => args.join(" ") === "pane close w1:p24"));
 		} finally {
+			if (previousPiBinary === undefined) delete process.env.SELESAI_SUBAGENT_SELESAI_BINARY;
+			else process.env.SELESAI_SUBAGENT_SELESAI_BINARY = previousPiBinary;
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});

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

@@ -33,37 +33,6 @@ function result(agent: string, output: string) {
 	};
 }
 
-function countedWorkflowJob(onNodesRead: () => void): AsyncJobState {
-	const nodes = [
-		{ id: "step-0", kind: "step", agent: "scout", label: "Scout", status: "completed", flatIndex: 0, stepIndex: 0 },
-		{ id: "step-1", kind: "step", agent: "reviewer", label: "Review", status: "running", flatIndex: 1, stepIndex: 1 },
-	] as const;
-	return {
-		asyncId: "workflow-run",
-		asyncDir: "/tmp/workflow-run",
-		status: "running",
-		mode: "workflow",
-		agents: ["scout", "reviewer"],
-		currentStep: 1,
-		startedAt: 0,
-		updatedAt: 1000,
-		steps: [
-			{ index: 0, agent: "scout", status: "completed", workflowKey: "step-0" },
-			{ index: 1, agent: "reviewer", status: "running", workflowKey: "step-1" },
-		],
-		workflowGraph: {
-			runId: "workflow-run",
-			mode: "workflow",
-			phases: [],
-			currentNodeId: "step-1",
-			get nodes() {
-				onNodesRead();
-				return nodes;
-			},
-		} as never,
-	};
-}
-
 test("row clips content to the available width", () => {
 	const rendered = row("abcdef", 6, theme as any);
 	assert.equal(visibleWidth(rendered), 6);
@@ -317,6 +286,133 @@ test("compact multi-result cards prefer bounded workflow labels over raw tasks",
 	assert.match(text, /Ctrl\+Alt\+F Fleet/);
 });
 
+test("workflow checklist does not map child-local result indexes onto graph nodes", () => {
+	const text = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "failed" }],
+			details: {
+			mode: "workflow",
+			results: [
+				{ ...result("scout", "ok"), index: 0 },
+				{ ...result("writer", "failed"), index: 0, exitCode: 1 },
+			],
+			workflowGraph: {
+				runId: "workflow-local-indexes",
+				mode: "workflow",
+				phases: [{ title: "inventory", nodeIds: ["inventory"] }, { title: "write", nodeIds: ["writer"] }],
+				nodes: [
+					{ id: "inventory", kind: "agent", agent: "scout", label: "Inventory", status: "completed", flatIndex: 0 },
+					{ id: "writer", kind: "agent", agent: "writer", label: "Writer", status: "failed", flatIndex: 1 },
+				],
+			},
+		},
+	}, { expanded: true }, theme as any));
+
+	assert.match(text, /Checklist 1\/2 done · 1 failed/);
+	assert.match(text, /✗ write 1 failed/);
+	assert.match(text, /✗ Writer · writer · failed/);
+});
+
+test("collapsed workflow widgets lead with checklist phases while expanded widgets keep child detail", () => {
+	const now = 50_000;
+	const workflowGraph = {
+		runId: "workflow-collapsed",
+		mode: "workflow" as const,
+		phases: [
+			{ title: "inventory", nodeIds: ["inventory"] },
+			{ title: "writers", nodeIds: ["writer-a", "writer-b"] },
+			{ title: "reviews", nodeIds: ["review"] },
+			{ title: "gates", nodeIds: ["gate"] },
+		],
+		nodes: [
+			{ id: "inventory", kind: "step" as const, label: "inventory", agent: "scout", status: "completed" as const, flatIndex: 0 },
+			{ id: "writer-a", kind: "agent" as const, label: "writer-a", agent: "writer", status: "running" as const, flatIndex: 1 },
+			{ id: "writer-b", kind: "agent" as const, label: "writer-b", agent: "writer", status: "pending" as const, flatIndex: 2 },
+			{ id: "review", kind: "step" as const, label: "review", agent: "reviewer", status: "pending" as const, flatIndex: 3 },
+			{ id: "gate", kind: "step" as const, label: "gate", agent: "reviewer", status: "pending" as const, flatIndex: 4 },
+		],
+	};
+	const job: AsyncJobState = {
+		asyncId: "workflow-collapsed",
+		asyncDir: "/tmp/workflow-collapsed",
+		cwd: "/tmp/workflow",
+		status: "running",
+		mode: "workflow",
+		agents: ["scout", "writer", "reviewer"],
+		stepsTotal: 5,
+		currentStep: 1,
+		toolCount: 38,
+		startedAt: 1_000,
+		updatedAt: now,
+		workflowGraph,
+		steps: [
+			{ index: 0, workflowKey: "inventory", agent: "scout", status: "complete", description: "Inspect the repository" },
+			{ index: 1, workflowKey: "writer-a", agent: "writer", status: "running", description: "Review auth flow", currentTool: "edit", currentToolStartedAt: now - 2_000, toolCount: 19, outputName: "review-a.md" },
+			{ index: 2, workflowKey: "writer-b", agent: "writer", status: "pending", description: "Review billing flow", outputName: "review-b.md" },
+		],
+	};
+
+	const collapsed = buildWidgetLines([job], theme, 240).join("\n");
+	assert.match(collapsed, /1\/5 done · 1 active · 3 queued/);
+	assert.match(collapsed, /✓ inventory/);
+	assert.match(collapsed, /writers 1 active · 1 queued/);
+	assert.match(collapsed, /◦ reviews 1 queued/);
+	assert.match(collapsed, /◦ gates 1 queued/);
+	assert.match(collapsed, /bottleneck/);
+	assert.match(collapsed, /Press configured-expand-key for live detail · Ctrl\+Alt\+F Fleet/);
+	assert.equal((collapsed.match(/1\/5 done · 1 active · 3 queued/g) ?? []).length, 1);
+	assert.doesNotMatch(collapsed, /Step \d\/\d|task:|workspace:|ref:|out(?:put)?:/i);
+
+	const expanded = buildWidgetLines([job], theme, 240, true).join("\n");
+	assert.match(expanded, /Stage 2\/5/);
+	assert.match(expanded, /task: .*Review auth flow/);
+	assert.match(expanded, /workspace:\/tmp\/workflow/);
+	assert.match(expanded, /out:review-a\.md/);
+	assert.match(expanded, /output: [\\/]tmp[\\/]workflow-collapsed[\\/]output-1\.log/);
+
+	const generic = buildWidgetLines([{
+		asyncId: "workflow-generic",
+		asyncDir: "/tmp/workflow-generic",
+		status: "running",
+		mode: "workflow",
+		agents: ["reviewer", "scout"],
+		stepsTotal: 2,
+		steps: [
+			{ index: 0, agent: "reviewer", status: "running" },
+			{ index: 1, agent: "scout", status: "running" },
+		],
+	} as AsyncJobState], theme, 240).join("\n");
+	assert.match(generic, /Workflow 2 active/);
+});
+
+test("compact foreground workflow results use checklist phases instead of child rows", () => {
+	const workflowGraph = {
+		runId: "foreground-workflow",
+		mode: "workflow" as const,
+		phases: [{ title: "inventory", nodeIds: ["inventory"] }, { title: "writers", nodeIds: ["writer"] }],
+		nodes: [
+			{ id: "inventory", kind: "step" as const, label: "inventory", agent: "scout", status: "completed" as const, flatIndex: 0 },
+			{ id: "writer", kind: "agent" as const, label: "writer", agent: "writer", status: "running" as const, flatIndex: 1 },
+		],
+	};
+	const text = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "running" }],
+		details: {
+			mode: "workflow",
+			results: [
+				{ ...result("scout", "done"), workflowKey: "inventory" },
+				{ ...result("writer", ""), workflowKey: "writer", task: "raw task that should stay in expanded detail", progress: { status: "running", index: 1, agent: "writer", toolCount: 7, tokens: 0, durationMs: 2_000 } },
+			],
+			workflowGraph,
+		},
+	} as never, { expanded: false }, theme as any));
+
+	assert.match(text, /1\/2 done · 1 active/);
+	assert.match(text, /✓ inventory/);
+	assert.match(text, /writers 1 active/);
+	assert.match(text, /Press configured-expand-key for live detail · Ctrl\+Alt\+F Fleet/);
+	assert.doesNotMatch(text, /Step \d\/\d|task:|workspace:|ref:|out(?:put)?:/i);
+});
+
 test("compact chain rendering uses workflow graph labels and parallel groups", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "done" }],
@@ -357,23 +453,6 @@ test("compact chain rendering uses workflow graph labels and parallel groups", (
 	assert.match(text, /Step 3\/3: Writer/);
 });
 
-test("widget rendering reuses one staged workflow projection", () => {
-	let nodeReads = 0;
-	const lines = buildWidgetLines([countedWorkflowJob(() => nodeReads++)], theme as any, 120, false, 0);
-
-	assert.equal(nodeReads, 1);
-	assert.match(lines.join("\n"), /staged lane · stage 2\/2 · Review · reviewer · running/);
-	assert.match(lines.join("\n"), /Stage 2\/2: Review/);
-});
-
-test("widget render keys reuse one staged workflow projection", () => {
-	let nodeReads = 0;
-
-	widgetRenderKey(countedWorkflowJob(() => nodeReads++));
-
-	assert.equal(nodeReads, 1);
-});
-
 test("compact chain rendering shows failed zero-child dynamic fanout groups", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "failed" }],

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

@@ -360,6 +360,70 @@ describe("async run status inspection", () => {
 		}
 	});
 
+	it("shows host steps in exact workflow status checklist", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-host-checklist-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-workflow-host");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId: "run-workflow-host",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 200,
+				workflowGraph: { runId: "run-workflow-host", mode: "workflow", phases: [], nodes: [{ id: "ci", kind: "host-step", label: "CI", status: "running", hostStep: { version: 1, kind: "host-step", monitorKind: "ci", id: "ci", label: "CI", state: "running", updatedAt: 200 } }] },
+			}, null, 2), "utf-8");
+
+			const result = inspectSubagentStatus({ id: "run-workflow-host" }, {
+				asyncDirRoot: asyncRoot,
+				resultsDir: path.join(root, "results"),
+				kill: () => true,
+				now: () => 250,
+			});
+
+			const text = textContent(result);
+			assert.equal(result.isError, undefined);
+			assert.match(text, /Workflow checklist: 0\/1 done · 1 active/);
+			assert.match(text, /CI 1 active/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps preflight as a plan hint outside the runtime checklist", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-preflight-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-workflow-preflight");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId: "run-workflow-preflight",
+				mode: "workflow",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 200,
+				preflight: { version: 1, lanes: [{ key: "pr14", mode: "review" }] },
+				steps: [{ agent: "reviewer", workflowKey: "pr14-quality", status: "running" }],
+			}, null, 2), "utf-8");
+
+			const result = inspectSubagentStatus({ id: "run-workflow-preflight" }, {
+				asyncDirRoot: asyncRoot,
+				resultsDir: path.join(root, "results"),
+				kill: () => true,
+				now: () => 250,
+			});
+
+			const text = textContent(result);
+			assert.equal(result.isError, undefined);
+			assert.match(text, /Plan: 1 lane · pr14/);
+			assert.match(text, /Workflow checklist: 0\/1 done · 1 active/);
+			assert.doesNotMatch(text, /1 queued/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("refuses to tail status outputFile paths outside the async directory", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-transcript-escape-"));
 		try {
@@ -1446,6 +1510,8 @@ describe("async run status inspection", () => {
 				results: [{
 					agent: "worker",
 					success: false,
+					structuredOutput: { payload: { ok: true } },
+					structuredOutputPath: "/runs/structured-output/output.json",
 					timeoutRecovery: {
 						termination: "timed-out",
 						changedFiles: ["input.md"],
@@ -1470,6 +1536,8 @@ describe("async run status inspection", () => {
 			assert.match(text, /Recovery needed: review the diff and artifacts before resuming or launching dependent stages\./);
 			assert.match(text, /requested report: missing/);
 			assert.match(text, /changed tracked files: input\.md/);
+			assert.match(text, /Structured output: \{"payload":\{"ok":true\}\}/);
+			assert.match(text, /Structured output path: \/runs\/structured-output\/output\.json/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}

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

@@ -123,6 +123,23 @@ describe("runtime agent registration", () => {
 		registration.dispose();
 	});
 
+	it("preserves excludeTools on runtime agents", () => {
+		const registration = registerAgent({
+			pi,
+			name: "runtime-exclude-helper",
+			definition: {
+				description: "Runtime exclude helper",
+				systemPrompt: "Help at runtime.",
+				tools: ["read", "write"],
+				excludeTools: ["write", "unknown_tool"],
+			},
+		});
+
+		const agent = mergeRuntimeAgents(pi, discoverAgents(tempProject, "both")).agents.find((candidate) => candidate.name === "runtime-exclude-helper");
+		assert.deepEqual(agent?.excludeTools, ["write", "unknown_tool"]);
+		registration.dispose();
+	});
+
 	it("registers through the owner runtime when consumer and owner API objects differ", () => {
 		const events = makeEventBus();
 		const ownerPi = makePiWithEvents(events);

package/dist/extensions/pi-subagents/test/unit/scheduled-runs.test.ts

@@ -97,6 +97,10 @@ function text(result: Awaited<ReturnType<ScheduledRunManager["handleToolCall"]>>
 	return result.content[0]?.type === "text" ? result.content[0].text : "";
 }
 
+function detailRecords(result: Awaited<ReturnType<ScheduledRunManager["handleToolCall"]>>): Array<Record<string, unknown>> {
+	return result.details?.schedules?.records as Array<Record<string, unknown>> ?? [];
+}
+
 async function flush(): Promise<void> {
 	for (let i = 0; i < 8; i++) await Promise.resolve();
 }
@@ -158,6 +162,85 @@ describe("project schedule management", () => {
 		assert.match(text(shown), /Night review/);
 	});
 
+	it("restores session-only schedules only in the creating session", async () => {
+		const owner = harness({ sessionId: "owner-session" });
+		const created = await owner.manager.handleToolCall({
+			action: "schedule.create",
+			id: "owner-only",
+			name: "Owner only",
+			every: "1h",
+			cwd: owner.ctx.cwd,
+			sessionOnly: true,
+			workflowScript: "return 1",
+		}, owner.ctx);
+		assert.equal(created.isError, undefined);
+		assert.equal(detailRecords(created)[0]?.sessionOnly, true);
+		assert.equal("ownerSessionFile" in detailRecords(created)[0]!, false);
+
+		const root = scheduledRunStorePath(owner.ctx.cwd, undefined, path.join(owner.root, "stores"));
+		const [record] = listScheduledRunSummaries(owner.ctx.cwd, path.join(owner.root, "stores"));
+		assert.equal(record?.sessionOnly, true);
+		assert.equal(record?.ownerSessionFile, owner.ctx.sessionManager.getSessionFile());
+
+		owner.manager.stop();
+		const otherTimers = new FakeTimers();
+		const otherLaunches: Launch[] = [];
+		const other = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(owner.root, "stores"),
+			now: () => owner.clock.now,
+			timers: otherTimers,
+			launch: (params, launchCtx) => new Promise((resolve) => otherLaunches.push({ params: params as Record<string, unknown>, ctx: launchCtx, resolve: resolve as Launch["resolve"] })) as never,
+		});
+		const otherContext = context(owner.ctx.cwd, "other-session");
+		other.bindSession(otherContext);
+		assert.equal(otherTimers.values.size, 0, "non-owner sessions must not arm session-only schedules");
+
+		const manual = await other.handleToolCall({ action: "schedule.run", id: "owner-only" }, otherContext);
+		assert.match(text(manual), /not its owner/);
+		assert.equal("ownerSessionFile" in detailRecords(manual)[0]!, false);
+		const shownToOther = await other.handleToolCall({ action: "schedule.show", id: "owner-only" }, otherContext);
+		assert.equal("ownerSessionFile" in detailRecords(shownToOther)[0]!, false);
+		const listedToOther = await other.handleToolCall({ action: "schedule.list" }, otherContext);
+		assert.equal("ownerSessionFile" in detailRecords(listedToOther)[0]!, false);
+		assert.equal(otherLaunches.length, 0);
+		assert.equal(listScheduledRunSummaries(owner.ctx.cwd, path.join(owner.root, "stores"))[0]?.ownerSessionFile, owner.ctx.sessionManager.getSessionFile());
+		assert.equal(fs.existsSync(path.join(root, "owner-only", "active.lock")), false);
+
+		const ownerTimers = new FakeTimers();
+		const ownerAgain = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(owner.root, "stores"),
+			now: () => owner.clock.now,
+			timers: ownerTimers,
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		ownerAgain.bindSession(context(owner.ctx.cwd, "owner-session"));
+		assert.equal(ownerTimers.values.size, 1, "the creating session must restore its schedule");
+	});
+
+	it("re-arms an owner timer after a non-owner context consumes it", async () => {
+		const h = harness({ sessionId: "owner-session" });
+		await h.manager.handleToolCall({ action: "schedule.create", id: "owner-only", cwd: h.ctx.cwd, every: "1h", sessionOnly: true, workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		const nextRunAt = listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores"))[0]?.trigger.nextRunAt;
+		h.manager.bindSession(context(h.ctx.cwd, "other-session"));
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 0, "a non-owner context must not launch the schedule");
+		assert.equal(h.timers.values.size, 0, "the consumed non-owner timer is not left spinning");
+		assert.equal(listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores"))[0]?.trigger.nextRunAt, nextRunAt, "a non-owner context must not advance the schedule");
+
+		h.manager.bindSession(h.ctx);
+		assert.equal(h.timers.values.size, 1, "rebinding the owner must restore the timer");
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 1);
+		assert.equal(h.launches[0]!.ctx.sessionManager.getSessionId(), "owner-session");
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "owner-async" } });
+		await flush();
+	});
+
 	it("does not let completed one-shot schedules consume maxPending capacity", async () => {
 		const h = harness({ config: { scheduledRuns: { enabled: true, maxPending: 1 } } });
 		await h.manager.handleToolCall({ action: "schedule.create", id: "completed", at: "+1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
@@ -668,6 +751,11 @@ describe("recurring schedule execution", () => {
 		const targetCtx = context(target, "target-session");
 		h.manager.bindSession(targetCtx);
 		h.manager.bindSession(h.ctx);
+		const sessionOnly = await h.manager.handleToolCall({ action: "schedule.create", id: "session-only-targeted", cwd: target, every: "1h", sessionOnly: true, workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		assert.equal(sessionOnly.isError, true);
+		assert.match(text(sessionOnly), /sessionOnly schedules cannot use an explicit cross-project cwd/);
+		assert.deepEqual(listScheduledRunSummaries(target, path.join(h.root, "stores")), [], "rejected session-only schedules must not dead-end in the target project");
+
 		await h.manager.handleToolCall({ action: "schedule.create", id: "targeted", cwd: target, every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
 		h.clock.now += 3_600_000;
 		h.timers.fireAll();

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

@@ -596,7 +596,10 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		const reviewedRecoveryBranch = acceptanceStringBranches.find((branch) => Array.isArray(branch.enum) && branch.enum.includes("reviewed"));
 		assert.deepEqual(reviewedRecoveryBranch?.enum, ["reviewed"]);
 		assert.equal(reviewedRecoveryBranch?.deprecated, true);
+		assert.equal(acceptanceStringBranches.some((branch) => branch.enum === undefined), true, "acceptance should tolerate JSON-encoded object strings");
 		assert.match(String(acceptanceSchema.description ?? ""), /reviewer\/read-only calls, omit acceptance/i);
+		assert.match(String(acceptanceSchema.description ?? ""), /prefer an inline JSON object/i);
+		assert.match(String(acceptanceSchema.description ?? ""), /JSON-encoded object strings are tolerated only during input normalization/i);
 		assert.match(String(acceptanceSchema.description ?? ""), /acceptance\.review\.required/);
 		const acceptanceObjectBranch = anyOfBranches(acceptanceSchema).find((branch) => branch.type === "object");
 		assert.ok(acceptanceObjectBranch, "acceptance should support object config");
@@ -621,11 +624,10 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 			{ action: "not-a-real-action" },
 			{ config: { name: "reviewer", description: "Review things" } },
 			{ config: JSON.stringify({ name: "reviewer", description: "Review things" }) },
+			{ agent: "worker", task: "Fix", acceptance: JSON.stringify({ level: "checked", evidence: ["commands-run"] }) },
 		];
 		const invalidValues = [
 			{ skill: 123 },
-			{ agent: "worker", task: "Fix", acceptance: "none" },
-			{ agent: "worker", task: "Fix", acceptance: "verified" },
 			{ skill: [123] },
 			{ output: 123 },
 			{ timeoutMs: 0 },

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

@@ -1429,28 +1429,28 @@ describe("scripted workflow runtime", () => {
 		);
 	});
 
-	it("passes per-child worktree controls through runs.run and runs.all", async () => {
-		const launches: Array<{ key: string; worktree: unknown }> = [];
+	it("passes per-child workflow controls through runs.run and runs.all", async () => {
+		const launches: Array<{ key: string; worktree: unknown; control: unknown }> = [];
 		await runWorkflowScript({
 			script: `
-				const one = await runs.run("one", { agent: "worker", task: "one", worktree: true });
+				const one = await runs.run("one", { agent: "worker", task: "one", worktree: true, control: { needsAttentionAfterMs: 111 } });
 				const rest = await runs.all([
-					{ key: "two", agent: "worker", task: "two", worktree: true },
-					{ key: "three", agent: "reviewer", task: "three", worktree: false }
+					{ key: "two", agent: "worker", task: "two", worktree: true, control: { activeNoticeAfterMs: 222 } },
+					{ key: "three", agent: "reviewer", task: "three", worktree: false, control: { enabled: false } }
 				]);
 				return [one.key, ...rest.map((entry) => entry.key)];
 			`,
 			timeoutMs: 2_000,
 			async launch(key, params) {
-				launches.push({ key, worktree: params.worktree });
+				launches.push({ key, worktree: params.worktree, control: params.control });
 				return { key, ok: true, output: key, artifactPaths: [], results: [] };
 			},
 			async status(key) { return { key, ok: true, output: "ok", artifactPaths: [] }; },
 		});
 		assert.deepEqual(launches, [
-			{ key: "one", worktree: true },
-			{ key: "two", worktree: true },
-			{ key: "three", worktree: false },
+			{ key: "one", worktree: true, control: { needsAttentionAfterMs: 111 } },
+			{ key: "two", worktree: true, control: { activeNoticeAfterMs: 222 } },
+			{ key: "three", worktree: false, control: { enabled: false } },
 		]);
 	});
 

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

@@ -139,7 +139,7 @@ describe("acknowledged steering action", () => {
 			assert.equal(result.isError, undefined);
 			assert.equal(result.details.steering?.state, "delivered");
 			assert.match(result.content[0]!.text, /Steering delivered/);
-			assert.match(result.content[0]!.text, /Message: "correct course"/);
+			assert.match(result.content[0]!.text, /Message sent:\n```text\ncorrect course\n```/);
 		} finally {
 			removeAsyncDir(asyncDir);
 		}
@@ -330,7 +330,7 @@ describe("acknowledged steering action", () => {
 			const result = await action;
 			assert.equal(result.isError, undefined);
 			assert.equal(result.details.steering?.state, "recovered");
-			assert.match(result.content[0]!.text, /Message: "correct course"/);
+			assert.match(result.content[0]!.text, /Message sent:\n```text\ncorrect course\n```/);
 			assert.equal(result.details.steering?.replacementRunId, "replacement");
 			assert.ok(result.details.steering?.targets[0]?.lateDeliveredAt);
 			const limits = receivedLimits as { timeoutMs: number; absoluteDeadlineAt: number; toolBudget: unknown };

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

@@ -3,17 +3,23 @@ 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 { actionResultFromSteeringStatus, claimSteeringRecovery, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, steeringMessagePreview, terminalSteeringNoticeState, updateSteeringTarget } from "../../src/runs/background/steering.ts";
+import { actionResultFromSteeringStatus, claimSteeringRecovery, createSteeringStatus, recordSteeringRequest, remainingSteeringRecoveryLimits, steeringMessagePreview, steeringReceipt, terminalSteeringNoticeState, updateSteeringTarget } from "../../src/runs/background/steering.ts";
 import { applySteeringRecoveryAgentConfig } from "../../src/runs/background/async-resume.ts";
 import type { AgentConfig } from "../../src/agents/agents.ts";
 
 describe("steering lifecycle ledger", () => {
-	it("redacts and bounds steering message previews", () => {
+	it("redacts, bounds, and separates steering message previews", () => {
 		const secret = "ghp_1234567890abcdef";
-		const preview = steeringMessagePreview(`Use ${secret}\n${"x".repeat(200)}`);
+		const message = `Use ${secret}\n${"x".repeat(200)}`;
+		const preview = steeringMessagePreview(message);
+		const receipt = steeringReceipt(message, "Steering delivered.");
 		assert.ok(preview.length <= 160);
 		assert.match(preview, /\[redacted\]/);
 		assert.doesNotMatch(preview, new RegExp(secret));
+		assert.match(receipt, /\[redacted\]/);
+		assert.doesNotMatch(receipt, new RegExp(secret));
+		assert.match(receipt, /^Steering delivered\.\n\nMessage sent:\n```text\n[\s\S]+\n```$/);
+		assert.match(steeringReceipt("review this:\n```\ntext\n```", "Steering queued."), /^Steering queued\.\n\nMessage sent:\n````text\n[\s\S]+\n````$/);
 	});
 
 	it("retains 20 recent requests while aggregate totals remain monotonic", () => {