@selesai/code 0.5.20 → 0.5.21

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

@@ -0,0 +1,290 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { resolveWatchdogConfig, resolveWatchdogConfigStrict, writeUserWatchdogEnabled, writeWatchdogModelSettings } from "../../src/watchdog/settings.ts";
+
+let tempHome = "";
+let tempProject = "";
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalPiCodingAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+function userSettingsPath(): string {
+	return path.join(tempHome, ".selesai", "agent", "settings.json");
+}
+
+function projectSettingsPath(): string {
+	return path.join(tempProject, ".selesai", "settings.json");
+}
+
+describe("watchdog settings", () => {
+	beforeEach(() => {
+		tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-watchdog-home-"));
+		tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-watchdog-project-"));
+		process.env.HOME = tempHome;
+		process.env.USERPROFILE = tempHome;
+		delete process.env.SELESAI_CODING_AGENT_DIR;
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) delete process.env.HOME;
+		else process.env.HOME = originalHome;
+		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = originalUserProfile;
+		if (originalPiCodingAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = originalPiCodingAgentDir;
+		fs.rmSync(tempHome, { recursive: true, force: true });
+		fs.rmSync(tempProject, { recursive: true, force: true });
+	});
+
+	it("resolves a default-off config when no watchdog settings exist", () => {
+		const result = resolveWatchdogConfig(tempProject);
+
+		assert.equal(result.ok, true);
+		assert.equal(result.config.enabled, false);
+		assert.equal(result.config.main.enabled, false);
+		assert.equal(result.config.children.enabled, false);
+		assert.equal(result.config.asyncCompletion.enabled, false);
+		assert.equal(result.config.delivery, "held");
+		assert.equal(result.config.showDuringRun, false);
+		assert.equal(result.config.agentEndTimeoutMs, 30_000);
+		assert.equal(result.config.children.watchdogTailTimeoutMs, 120_000);
+		assert.equal(result.config.autoFollow.maxAttempts, 3);
+		assert.deepEqual(result.config.lsp, { enabled: true, timeoutMs: 3000, maxFiles: 20, maxDiagnostics: 50 });
+	});
+
+	it("lets root enabled opt the main watchdog in while children stay default-off", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					enabled: true,
+				},
+			},
+		});
+
+		const config = resolveWatchdogConfig(tempProject).config;
+
+		assert.equal(config.enabled, true);
+		assert.equal(config.main.enabled, true);
+		assert.equal(config.children.enabled, false);
+	});
+
+	it("merges user, project, and session overrides field by field", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					enabled: true,
+					autoFollow: { blockers: true, maxAttempts: 5 },
+					children: {
+						autoFollow: { maxAttempts: 4 },
+						overrides: {
+							worker: { enabled: true, model: "anthropic/claude-test" },
+						},
+					},
+					guidance: { systemPromptPath: "/tmp/user-watchdog.md" },
+				},
+			},
+		});
+		writeJson(projectSettingsPath(), {
+			subagents: {
+				watchdog: {
+					autoFollow: { stalemateRepeats: 2 },
+					lsp: { enabled: false, timeoutMs: 1500, maxFiles: 4, maxDiagnostics: 7 },
+					main: { model: "openai/gpt-test" },
+					children: {
+						autoFollow: { blockers: false },
+						overrides: {
+							worker: { thinking: "medium" },
+							reviewer: { enabled: false },
+						},
+					},
+				},
+			},
+		});
+
+		const result = resolveWatchdogConfig(tempProject, {
+			session: {
+				autoFollow: { maxAttempts: null },
+				children: {
+					overrides: {
+						worker: { enabled: false },
+					},
+				},
+			},
+		});
+
+		assert.equal(result.ok, true);
+		assert.equal(result.config.main.enabled, true);
+		assert.equal(result.config.main.model, "openai/gpt-test");
+		assert.deepEqual(result.config.autoFollow, { blockers: true, maxAttempts: null, stalemateRepeats: 2 });
+		assert.equal(result.config.guidance.systemPromptPath, "/tmp/user-watchdog.md");
+		assert.deepEqual(result.config.lsp, { enabled: false, timeoutMs: 1500, maxFiles: 4, maxDiagnostics: 7 });
+		assert.deepEqual(result.config.children.autoFollow, { blockers: false, maxAttempts: 4, stalemateRepeats: 3 });
+		assert.deepEqual(result.config.children.overrides.worker, {
+			enabled: false,
+			model: "anthropic/claude-test",
+			thinking: "medium",
+		});
+		assert.deepEqual(result.config.children.overrides.reviewer, { enabled: false });
+	});
+
+	it("returns exact validation errors at the watchdog boundary", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					enabled: "yes",
+				},
+			},
+		});
+
+		const result = resolveWatchdogConfig(tempProject);
+
+		assert.equal(result.ok, false);
+		assert.deepEqual(result.errors, [{
+			scope: "user",
+			path: userSettingsPath(),
+			message: `Watchdog settings in '${userSettingsPath()}' have invalid 'subagents.watchdog.enabled'; expected a boolean.`,
+		}]);
+		assert.equal(result.config.enabled, false);
+		assert.equal(result.config.main.enabled, false);
+	});
+
+	it("throws the same exact validation error in strict mode", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					children: { overrides: { worker: { mode: "fast" } } },
+				},
+			},
+		});
+
+		assert.throws(
+			() => resolveWatchdogConfigStrict(tempProject),
+			(error: unknown) => error instanceof Error
+				&& error.message === `Watchdog settings in '${userSettingsPath()}' have unknown field 'subagents.watchdog.children.overrides.worker.mode'.`,
+		);
+	});
+
+	it("rejects invalid LSP config at settings load", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					lsp: { timeoutMs: 0 },
+				},
+			},
+		});
+
+		const result = resolveWatchdogConfig(tempProject);
+
+		assert.equal(result.ok, false);
+		assert.equal(result.config.main.enabled, false);
+		assert.match(result.errors[0]?.message ?? "", /invalid 'subagents\.watchdog\.lsp\.timeoutMs'/);
+	});
+
+	it("rejects unsupported watchdog thinking values at settings load", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					main: { thinking: "maximum" },
+				},
+			},
+		});
+
+		const result = resolveWatchdogConfig(tempProject);
+
+		assert.equal(result.ok, false);
+		assert.equal(result.config.main.enabled, false);
+		assert.match(result.errors[0]?.message ?? "", /invalid 'subagents\.watchdog\.main\.thinking'/);
+		assert.match(result.errors[0]?.message ?? "", /'high'/);
+	});
+
+	it("writes watchdog model settings without toggling enablement", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					enabled: false,
+					main: { enabled: false },
+				},
+			},
+		});
+
+		writeWatchdogModelSettings({
+			scope: "user",
+			target: { kind: "main" },
+			model: "anthropic/claude-opus-4-8",
+			thinking: "high",
+		});
+
+		const settings = JSON.parse(fs.readFileSync(userSettingsPath(), "utf-8"));
+		assert.equal(settings.subagents.watchdog.enabled, false);
+		assert.equal(settings.subagents.watchdog.main.enabled, false);
+		assert.equal(settings.subagents.watchdog.main.model, "anthropic/claude-opus-4-8");
+		assert.equal(settings.subagents.watchdog.main.thinking, "high");
+	});
+
+	it("clears watchdog model and thinking overrides", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					main: { model: "openai-codex/gpt-5.5", thinking: "high" },
+				},
+			},
+		});
+
+		writeWatchdogModelSettings({
+			scope: "user",
+			target: { kind: "main" },
+			model: null,
+			thinking: null,
+		});
+
+		const settings = JSON.parse(fs.readFileSync(userSettingsPath(), "utf-8"));
+		assert.equal("model" in settings.subagents.watchdog.main, false);
+		assert.equal("thinking" in settings.subagents.watchdog.main, false);
+	});
+
+	it("preserves JSON.parse errors in boundary results", () => {
+		fs.mkdirSync(path.dirname(userSettingsPath()), { recursive: true });
+		fs.writeFileSync(userSettingsPath(), "{ bad", "utf-8");
+
+		const result = resolveWatchdogConfig(tempProject);
+
+		assert.equal(result.ok, false);
+		assert.equal(result.errors.length, 1);
+		assert.equal(result.errors[0]?.scope, "user");
+		assert.match(result.errors[0]?.message ?? "", new RegExp(`^Failed to parse settings file '${userSettingsPath().replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}': `));
+		assert.equal(result.config.main.enabled, false);
+	});
+
+	it("writes persistent on/off toggles to root and main enabled", () => {
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: {
+					enabled: false,
+					main: { enabled: false, model: "openai/watchdog" },
+				},
+			},
+		});
+
+		writeUserWatchdogEnabled(true);
+		let settings = JSON.parse(fs.readFileSync(userSettingsPath(), "utf-8"));
+		assert.equal(settings.subagents.watchdog.enabled, true);
+		assert.equal(settings.subagents.watchdog.main.enabled, true);
+		assert.equal(settings.subagents.watchdog.main.model, "openai/watchdog");
+		assert.equal(resolveWatchdogConfig(tempProject).config.main.enabled, true);
+
+		writeUserWatchdogEnabled(false);
+		settings = JSON.parse(fs.readFileSync(userSettingsPath(), "utf-8"));
+		assert.equal(settings.subagents.watchdog.enabled, false);
+		assert.equal(settings.subagents.watchdog.main.enabled, false);
+		assert.equal(settings.subagents.watchdog.main.model, "openai/watchdog");
+		assert.equal(resolveWatchdogConfig(tempProject).config.main.enabled, false);
+	});
+});

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

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { MainWatchdogRuntime } from "../../src/watchdog/runtime.ts";
+import { handleWatchdogToolAction } from "../../src/watchdog/tool-actions.ts";
+
+let tempHome = "";
+let tempProject = "";
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+const originalPiCodingAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+
+function createCtx(current: { provider: string; id: string }) {
+	const models = [
+		{ provider: "openai-codex", id: "gpt-5.5", reasoning: true },
+		{ provider: "anthropic", id: "claude-opus-4-8", reasoning: true },
+	];
+	return {
+		cwd: tempProject,
+		model: current,
+		modelRegistry: {
+			getAvailable: () => models,
+			find: (provider: string, id: string) => models.find((model) => model.provider === provider && model.id === id),
+			hasConfiguredAuth: (model: { provider: string; id: string }) => Boolean(model),
+		},
+		sessionManager: {
+			getSessionFile: () => null,
+			getSessionId: () => "session-test",
+		},
+	} as never;
+}
+
+function text(result: { content: Array<{ text?: string }> }): string {
+	return result.content.map((entry) => entry.text ?? "").join("\n");
+}
+
+describe("watchdog tool actions", () => {
+	beforeEach(() => {
+		tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-watchdog-tool-home-"));
+		tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "pi-watchdog-tool-project-"));
+		process.env.HOME = tempHome;
+		process.env.USERPROFILE = tempHome;
+		process.env.SELESAI_CODING_AGENT_DIR = path.join(tempHome, ".selesai", "agent");
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) delete process.env.HOME;
+		else process.env.HOME = originalHome;
+		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = originalUserProfile;
+		if (originalPiCodingAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+		else process.env.SELESAI_CODING_AGENT_DIR = originalPiCodingAgentDir;
+		fs.rmSync(tempHome, { recursive: true, force: true });
+		fs.rmSync(tempProject, { recursive: true, force: true });
+	});
+
+	it("configures the recommended model for the current session without writing settings", () => {
+		const runtime = new MainWatchdogRuntime({ cwd: tempProject });
+		const result = handleWatchdogToolAction("watchdog.configure", { model: "recommended" }, createCtx({ provider: "openai-codex", id: "gpt-5.5" }), runtime);
+
+		assert.equal(result.isError, undefined);
+		assert.match(text(result), /session model configured: anthropic\/claude-opus-4-8:high/);
+		assert.equal(fs.existsSync(path.join(tempHome, ".selesai", "agent", "settings.json")), false);
+		assert.equal(runtime.getSnapshot(tempProject).config.main.model, "anthropic/claude-opus-4-8");
+		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, "high");
+	});
+
+	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" });
+
+		handleWatchdogToolAction("watchdog.configure", { model: "recommended" }, ctx, runtime);
+		const result = handleWatchdogToolAction("watchdog.configure", { thinking: "low" }, ctx, runtime);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(runtime.getSnapshot(tempProject).config.main.model, "anthropic/claude-opus-4-8");
+		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, "low");
+	});
+
+	it("persists the recommended model when user scope is explicit", () => {
+		const runtime = new MainWatchdogRuntime({ cwd: tempProject });
+		const result = handleWatchdogToolAction("watchdog.configure", { scope: "user", model: "recommended" }, createCtx({ provider: "anthropic", id: "claude-opus-4-8" }), runtime);
+
+		assert.equal(result.isError, undefined);
+		const settings = JSON.parse(fs.readFileSync(path.join(tempHome, ".selesai", "agent", "settings.json"), "utf-8"));
+		assert.equal(settings.subagents.watchdog.main.model, "openai-codex/gpt-5.5");
+		assert.equal(settings.subagents.watchdog.main.thinking, "high");
+	});
+});

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

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { formatWatchdogReviewMessage, formatWatchdogTurnDelta } from "../../src/watchdog/turn-delta.ts";
+import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../src/watchdog/types.ts";
+
+describe("watchdog turn delta formatter", () => {
+	it("formats user prompt, assistant text, thinking, tool calls, and tool results", () => {
+		const delta = formatWatchdogTurnDelta({
+			includeUserPrompt: true,
+			userPrompt: "Implement the parser.",
+			messages: [
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "I will inspect the settings." },
+						{ type: "thinking", thinking: "The settings parser is the risky part." },
+						{ type: "toolCall", name: "bash", arguments: { command: "printf 'a\\nb'" } },
+					],
+				},
+			],
+			events: [
+				{
+					type: "tool_execution_end",
+					toolName: "bash",
+					result: { content: [{ type: "text", text: "a\nb" }] },
+					isError: false,
+				},
+			],
+		});
+
+		assert.match(delta, /User prompt:\nImplement the parser\./);
+		assert.match(delta, /Assistant:\nI will inspect the settings\./);
+		assert.match(delta, /Thinking:\nThe settings parser is the risky part\./);
+		assert.match(delta, /Tool call: bash\nArguments:\ncommand:/);
+		assert.match(delta, /printf 'a\\nb'/);
+		assert.match(delta, /Tool result: bash\nResult:\na\nb/);
+	});
+
+	it("uses a successful tool diff instead of noisy raw edit blobs", () => {
+		const delta = formatWatchdogTurnDelta({
+			messages: [
+				{
+					role: "assistant",
+					content: [{
+						type: "toolCall",
+						name: "edit",
+						arguments: {
+							path: "src/file.ts",
+							oldText: "huge old text",
+							newText: "huge new text",
+							edits: [{ oldText: "nested old text", newText: "nested new text" }],
+						},
+					}],
+				},
+				{
+					role: "toolResult",
+					toolName: "edit",
+					content: "oldText: huge\nnewText: huge",
+					details: { diff: "--- a/file.ts\n+++ b/file.ts\n@@\n-old\n+new" },
+					isError: false,
+				},
+			],
+		});
+
+		assert.match(delta, /Tool result: edit\nDiff:\n--- a\/file\.ts/);
+		assert.match(delta, /oldText: \[omitted 13 chars; use tool result diff\]/);
+		assert.match(delta, /newText: \[omitted 13 chars; use tool result diff\]/);
+		assert.match(delta, /oldText: \[omitted 15 chars; use tool result diff\]/);
+		assert.match(delta, /newText: \[omitted 15 chars; use tool result diff\]/);
+		assert.doesNotMatch(delta, /huge old text/);
+		assert.doesNotMatch(delta, /huge new text/);
+		assert.doesNotMatch(delta, /nested old text/);
+		assert.doesNotMatch(delta, /nested new text/);
+		assert.doesNotMatch(delta, /oldText: huge/);
+	});
+
+	it("marks failed tool results from isError and does not replace them with diffs", () => {
+		const delta = formatWatchdogTurnDelta({
+			messages: [{ role: "toolResult", toolName: "edit", isError: true, content: [{ type: "text", text: "edit failed" }], details: { diff: "should not render" } }],
+		});
+
+		assert.match(delta, /Tool result: edit\nError: tool reported an error\nOutput:\nedit failed/);
+		assert.doesNotMatch(delta, /should not render/);
+	});
+
+	it("formats turn_end events with assistant message and tool results", () => {
+		const delta = formatWatchdogTurnDelta({
+			events: [
+				{
+					 type: "turn_end",
+					 message: {
+						 role: "assistant",
+						 content: [
+							{ type: "text", text: "I will run a check." },
+							{ type: "toolCall", name: "bash", arguments: { command: "npm test" } },
+						 ],
+					 },
+					 toolResults: [
+						 { role: "toolResult", toolName: "bash", isError: true, content: [{ type: "text", text: "tests failed" }] },
+					 ],
+				},
+			],
+		});
+
+		assert.match(delta, /Assistant:\nI will run a check\./);
+		assert.match(delta, /Tool call: bash\nArguments:\ncommand: npm test/);
+		assert.match(delta, /Tool result: bash\nError: tool reported an error\nOutput:\ntests failed/);
+	});
+
+	it("filters watchdog warning custom messages from its own review stream", () => {
+		const warningMessage = {
+			role: "custom",
+			customType: SUBAGENT_WATCHDOG_WARNING_TYPE,
+			content: "prior watchdog warning",
+		};
+
+		assert.equal(formatWatchdogReviewMessage(warningMessage), undefined);
+		assert.equal(formatWatchdogTurnDelta({ messages: [warningMessage] }), "");
+	});
+
+	it("marks final assistant stop when represented", () => {
+		const delta = formatWatchdogTurnDelta({
+			messages: [{ role: "assistant", content: "Done.", stopReason: "stop" }],
+			finalAssistantStop: true,
+		});
+
+		assert.match(delta, /Assistant stop: stop/);
+		assert.match(delta, /Final assistant stop: stop without tool call/);
+	});
+});

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

@@ -41,11 +41,14 @@ describe("nested widget rendering", () => {
 	it("uses aggregate lines when collapsed and full child rows when expanded", () => {
 		const child = nested("nested-reviewer", "root-run", "running", { currentTool: "read" });
 		const collapsed = buildWidgetLines([job(child)], theme as any, 120, false).join("\n");
-		assert.match(collapsed, /↳ \+1 nested run \(1 running\)/);
+		assert.match(collapsed, /↳ \[\d{2}:\d{2}:\d{2}\] \+1 nested run \(1 running\)/);
 		assert.doesNotMatch(collapsed, /nested-reviewer · running/);
 
 		const expanded = buildWidgetLines([job(child)], theme as any, 120, true).join("\n");
-		assert.match(expanded, /↳ . nested-reviewer · running · read/);
+		assert.match(expanded, /↳ \[\d{2}:\d{2}:\d{2}\] . nested-reviewer · running · read/);
+
+		const epoch = buildWidgetLines([job(nested("epoch", "root-run", "running", { lastUpdate: 0, startedAt: 0 }))], theme as any, 120, false).join("\n");
+		assert.match(epoch, /↳ \[\d{2}:\d{2}:\d{2}\] \+1 nested run/);
 	});
 
 	it("collapses descendants beyond the nested depth budget", () => {
@@ -71,13 +74,38 @@ describe("nested widget rendering", () => {
 		state.steps![0]!.status = "complete";
 		const expanded = buildWidgetLines([state], theme as any, 120, true).join("\n");
 		assert.match(expanded, /✓ Step 1\/1: owner · complete/);
-		assert.match(expanded, /↳ . still-running · running/);
+		assert.match(expanded, /↳ \[\d{2}:\d{2}:\d{2}\] . still-running · running/);
 	});
 
 	it("degrades stale child summaries to id and state", () => {
 		const child = nested("missing-metadata", "root-run", "failed", { agent: undefined, error: "owner gone" });
 		const expanded = buildWidgetLines([job(child)], theme as any, 120, true).join("\n");
-		assert.match(expanded, /missing-metadata · failed · Failed · owner gone/);
+		assert.match(expanded, /\[\d{2}:\d{2}:\d{2}\] . missing-metadata · failed · Failed · owner gone/);
+	});
+
+	it("timestamps every nested lifecycle state and completed steps", () => {
+		const states: NestedRunSummary["state"][] = ["queued", "running", "complete", "failed", "paused", "stopped"];
+		const root = nested("matrix-root", "root-run", "running", {
+			steps: [{ agent: "completed-step", status: "completed", endedAt: 2_000 }],
+			children: states.map((state, index) => nested(`child-${state}`, "matrix-root", state, {
+				parentStepIndex: undefined,
+				startedAt: 1_000 + index,
+				...(state === "running" ? { lastActivityAt: 2_000 + index } : { endedAt: 2_000 + index }),
+			})),
+		});
+		const expanded = buildWidgetLines([job(root)], theme as any, 200, true).join("\n");
+		for (const state of states) {
+			assert.match(expanded, new RegExp(`\\[\\d{2}:\\d{2}:\\d{2}\\] . child-${state} · ${state}`));
+		}
+		assert.match(expanded, /\[\d{2}:\d{2}:\d{2}\] . completed-step · completed/);
+	});
+
+	it("keeps event-time timestamps stable instead of advancing with wall time", async () => {
+		const state = job(nested("nested-reviewer", "root-run", "running", { currentTool: "read", currentToolStartedAt: 0 }));
+		const first = buildWidgetLines([state], theme as any, 120, true);
+		await new Promise((resolve) => setTimeout(resolve, 20));
+		const second = buildWidgetLines([state], theme as any, 120, true);
+		assert.deepEqual(second, first);
 	});
 
 	it("rerenders when only nested state changes", () => {

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

@@ -246,8 +246,12 @@ describe("worktree", () => {
 			setup = createWorktrees(repoDir, "cleanup", 2);
 			const worktreePaths = setup.worktrees.map((worktree) => worktree.path);
 			const branches = setup.worktrees.map((worktree) => worktree.branch);
-			cleanupWorktrees(setup);
+			const cleanup = cleanupWorktrees(setup);
 			setup = undefined;
+			assert.equal(cleanup.state, "complete");
+			assert.equal(cleanup.pruned, true);
+			assert.equal(cleanup.tasks.length, 2);
+			assert.ok(cleanup.tasks.every((task) => task.worktreeRemoved && task.branchRemoved));
 
 			for (const worktreePath of worktreePaths) {
 				assert.equal(fs.existsSync(worktreePath), false, `worktree path still exists: ${worktreePath}`);

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

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+
+const readProjectFile = (file: string): string => readFileSync(join(process.cwd(), file), "utf-8");
+
+describe("writer budget guidance", () => {
+	it("keeps hard turn and tool caps off mutation-capable workers", () => {
+		const readme = readProjectFile("README.md");
+		const skill = readProjectFile("skills/pi-subagents/SKILL.md");
+		const reviewLoop = readProjectFile("prompts/review-loop.md");
+
+		for (const text of [readme, skill, reviewLoop]) {
+			assert.match(text, /As a conservative orchestration policy, do not (?:pass|set) `turnBudget` 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/);
+			assert.match(text, /changed files/);
+			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);
+	});
+
+	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`/);
+	});
+});

package/dist/extensions/question/batch.ts

@@ -0,0 +1,39 @@
+import { getOptionsFormatError, normalizeOptions } from "./helpers.ts";
+import { resolveShortcuts } from "./shortcuts.ts";
+import type { BatchedQuestion, RawBatchQuestion } from "./types.ts";
+
+export function prepareBatchQuestions(value: unknown): { questions: BatchedQuestion[] } | { error: string } {
+	if (!Array.isArray(value) || value.length === 0) return { error: "questions must contain at least one question." };
+
+	const ids = new Set<string>();
+	const questions: BatchedQuestion[] = [];
+	for (let index = 0; index < value.length; index++) {
+		const raw = value[index] as RawBatchQuestion;
+		const question = raw?.question?.trim();
+		if (!question) return { error: `Question ${index + 1} must include a non-empty question.` };
+
+		const optionsError = getOptionsFormatError(raw.options);
+		if (optionsError) return { error: `Question ${index + 1}: ${optionsError}` };
+		const options = normalizeOptions(raw.options);
+		const allowFreeform = raw.allowFreeform ?? options.length === 0;
+		if (options.length === 0 && !allowFreeform) {
+			return { error: `Question ${index + 1}: options are empty and allowFreeform is false.` };
+		}
+
+		const id = raw.id?.trim() || `q${index + 1}`;
+		if (ids.has(id)) return { error: `Question ids must be unique; duplicate id: ${id}` };
+		ids.add(id);
+		questions.push({
+			id,
+			label: raw.label?.trim() || `Q${index + 1}`,
+			question,
+			context: raw.context?.trim() || raw.title?.trim() || undefined,
+			options,
+			allowMultiple: raw.allowMultiple ?? false,
+			allowFreeform,
+			allowComment: raw.allowComment ?? false,
+			shortcuts: resolveShortcuts(raw.commentToggleKey, process.env.PI_QUESTION_COMMENT_TOGGLE_KEY),
+		});
+	}
+	return { questions };
+}