@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/test/integration/async-job-tracker.test.ts

@@ -2,6 +2,8 @@ import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { describe, it } from "node:test";
+import { getProjectArtifactsDir } from "../../src/shared/artifacts.ts";
+import { SubagentFleetComponent } from "../../src/tui/fleet.ts";
 import { createTempDir, removeTempDir, tryImport } from "../support/helpers.ts";
 
 interface AsyncJobTrackerModule {
@@ -13,6 +15,7 @@ interface AsyncJobTrackerModule {
 			completionRetentionMs?: number;
 			pollIntervalMs?: number;
 			resultsDir?: string;
+			widgetEnabled?: boolean;
 			kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 			now?: () => number;
 		},
@@ -33,6 +36,9 @@ function createState() {
 		baseCwd: "/repo",
 		currentSessionId: null,
 		asyncJobs: new Map(),
+		fleetJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
 		cleanupTimers: new Map(),
 		lastUiContext: null,
 		poller: null,
@@ -86,6 +92,7 @@ function createUiContext() {
 		ui: {
 			theme: {
 				fg: (_theme: string, text: string) => text,
+				bold: (text: string) => text,
 			},
 			setWidget: (_key: string, value: unknown) => {
 				widgets.push(value);
@@ -121,9 +128,11 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			tracker.handleComplete({ id: "run-1", success: true });
 
 			assert.equal(state.asyncJobs.size, 1);
+			assert.equal(state.fleetJobs.size, 1);
 			await new Promise((resolve) => setTimeout(resolve, 40));
 
 			assert.equal(state.asyncJobs.size, 0);
+			assert.equal(state.fleetJobs.get("run-1")?.status, "complete", "fleet history should outlive widget cleanup");
 			assert.ok(ui.renderRequests > 0, "expected widget cleanup to request a rerender");
 			assert.equal(ui.widgets.at(-1), undefined);
 		} finally {
@@ -131,16 +140,44 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("keeps the async widget cleared when it is disabled", () => {
+		const asyncRoot = createTempDir("pi-async-job-widget-disabled-");
+		try {
+			const state = createState();
+			const ui = createUiContext();
+			const recorder = createEventRecorder();
+			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+				widgetEnabled: false,
+			});
+			tracker.resetJobs(ui.ctx as never);
+			tracker.handleStarted({ id: "run-hidden", asyncDir: path.join(asyncRoot, "run-hidden"), agent: "worker" });
+
+			assert.equal(state.asyncJobs.size, 1, "disabled rendering must not disable lifecycle tracking");
+			assert.ok(ui.widgets.length > 0, "expected widget clear calls");
+			assert.ok(ui.widgets.every((widget) => widget === undefined), "disabled widget must stay cleared");
+			tracker.resetJobs(ui.ctx as never);
+			assert.equal(state.fleetJobs.size, 0, "session reset should clear fleet history");
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("restores active async runs into the widget after reset", async () => {
 		const asyncRoot = createTempDir("pi-async-job-restore-");
 		try {
 			const runDir = path.join(asyncRoot, "run-restored");
+			const customCwd = path.join(asyncRoot, "custom-cwd");
+			const artifactsRoot = getProjectArtifactsDir(customCwd);
+			const transcriptPath = path.join(artifactsRoot, "run-restored_reviewer_transcript.jsonl");
 			fs.mkdirSync(runDir, { recursive: true });
+			fs.mkdirSync(artifactsRoot, { recursive: true });
+			fs.writeFileSync(transcriptPath, `${JSON.stringify({ recordType: "message", role: "assistant", text: "Restored custom cwd transcript" })}\n`, "utf-8");
 			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
 				runId: "run-restored",
 				mode: "chain",
 				state: "running",
 				sessionId: "session-restored",
+				cwd: customCwd,
 				startedAt: 1000,
 				lastUpdate: 2000,
 				currentStep: 1,
@@ -148,7 +185,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				parallelGroups: [{ start: 1, count: 2, stepIndex: 1 }],
 				steps: [
 					{ agent: "scout", status: "complete" },
-					{ agent: "reviewer", status: "running", currentTool: "read" },
+					{ agent: "reviewer", status: "running", currentTool: "read", transcriptPath },
 					{ agent: "worker", status: "running" },
 					{ agent: "writer", status: "pending" },
 				],
@@ -180,6 +217,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			assert.ok(job);
 			assert.equal(job.status, "running");
 			assert.equal(job.sessionId, "session-restored");
+			assert.equal(job.cwd, customCwd);
 			assert.deepEqual(job.agents, ["reviewer", "worker"]);
 			assert.deepEqual(job.steps?.map((step: { index?: number }) => step.index), [1, 2]);
 			assert.equal(job.stepsTotal, 2);
@@ -190,6 +228,19 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			assert.ok(ui.renderRequests >= 2, "expected reset and restore to request widget renders");
 			assert.equal(typeof ui.widgets.at(-1), "function", "expected restored jobs to render the widget");
 
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				ui.ctx.ui.theme as never,
+				state as never,
+				() => {},
+				{ refreshMs: 60_000 },
+			);
+			try {
+				assert.ok(component.render(100).some((line) => line.includes("Restored custom cwd transcript")));
+			} finally {
+				component.dispose();
+			}
+
 			await new Promise((resolve) => setTimeout(resolve, 30));
 			assert.equal(recorder.events.length, 0, "historical control events should not be replayed during restore");
 		} finally {
@@ -303,6 +354,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			tracker.handleStarted({
 				id: "run-parallel-start",
 				asyncDir: path.join(asyncRoot, "run-parallel-start"),
+				cwd: path.join(asyncRoot, "custom-cwd"),
 				agent: "scout",
 				agents: ["scout", "reviewer", "worker", "writer"],
 				chain: ["[scout+reviewer+worker]", "writer"],
@@ -312,6 +364,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 
 			const job = state.asyncJobs.get("run-parallel-start");
 			assert.deepEqual(job?.agents, ["scout", "reviewer", "worker"]);
+			assert.equal(job?.cwd, path.join(asyncRoot, "custom-cwd"));
 			assert.equal(job?.chainStepCount, 2);
 			assert.deepEqual(job?.parallelGroups, [{ start: 0, count: 3, stepIndex: 0 }]);
 			assert.equal(job?.stepsTotal, 3);

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

@@ -53,6 +53,91 @@ describe("async status helpers", () => {
 		}
 	});
 
+	it("preserves agent contract projections on step summaries", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-contract-"));
+		try {
+			createAsyncDir(root, "run-contract", {
+				runId: "run-contract",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [{
+					agent: "worker",
+					status: "complete",
+					agentContract: { version: 1 },
+					execution: { status: "completed", success: true, exitCode: 0 },
+					acceptance: { status: "rejected", effectiveAcceptance: { level: "checked", explicit: true } },
+					review: { status: "not-requested" },
+					effects: { fileMutation: { status: "missing", expected: true, attempted: false } },
+				}],
+			});
+
+			const runs = listAsyncRuns(root, { states: ["complete"] });
+			const step = runs[0]?.steps[0];
+			assert.equal(step?.agentContract?.version, 1);
+			assert.deepEqual(step?.execution, { status: "completed", success: true, exitCode: 0 });
+			assert.equal(step?.acceptance?.status, "rejected");
+			assert.equal(step?.review?.status, "not-requested");
+			assert.equal(step?.effects?.fileMutation?.status, "missing");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves capability ceiling and audit projections on summaries", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-capability-"));
+		try {
+			const ceiling = { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["plan"] };
+			const audit = { ceiling, requestedTools: ["read", "write"], effectiveTools: ["read"], removedTools: ["write"], internalTools: [], extensionsDenied: true, removedExtensionCount: 1, requestedMcpToolCount: 0, effectiveMcpTools: [] };
+			createAsyncDir(root, "run-capability", {
+				runId: "run-capability",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				capabilityCeiling: ceiling,
+				capabilityAudit: audit,
+				steps: [{ agent: "worker", status: "complete", capabilityCeiling: ceiling, capabilityAudit: audit }],
+			});
+
+			const runs = listAsyncRuns(root, { states: ["complete"] });
+			assert.deepEqual(runs[0]?.capabilityCeiling, ceiling);
+			assert.deepEqual(runs[0]?.capabilityAudit, audit);
+			assert.deepEqual(runs[0]?.steps[0]?.capabilityCeiling, ceiling);
+			assert.deepEqual(runs[0]?.steps[0]?.capabilityAudit, audit);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("formats async run and step context labels", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-context-"));
+		try {
+			createAsyncDir(root, "run-context", {
+				runId: "run-context",
+				mode: "parallel",
+				state: "running",
+				startedAt: 100,
+				lastUpdate: 200,
+				steps: [
+					{ agent: "scout", context: "fresh", status: "running" },
+					{ agent: "worker", context: "fork", status: "running" },
+				],
+			});
+
+			const runs = listAsyncRuns(root, { states: ["running"] });
+			assert.equal(runs[0]?.context, "mixed");
+			assert.deepEqual(runs[0]?.steps.map((step) => step.context), ["fresh", "fork"]);
+			const text = formatAsyncRunList(runs);
+			assert.match(text, /run-context \| running .* \| parallel \[mixed\]/);
+			assert.match(text, /1\. scout \[fresh\] \| running/);
+			assert.match(text, /2\. worker \[fork\] \| running/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("formats model thinking in step summaries", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-model-thinking-"));
 		try {
@@ -107,6 +192,33 @@ describe("async status helpers", () => {
 		}
 	});
 
+	it("renders deferred turn-budget termination distinctly from a soft wrap-up request", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-turn-budget-deferred-"));
+		try {
+			createAsyncDir(root, "run-deferred", {
+				runId: "run-deferred",
+				mode: "single",
+				state: "running",
+				startedAt: Date.now() - 1_000,
+				lastUpdate: Date.now(),
+				wrapUpRequested: true,
+				turnBudget: { maxTurns: 2, graceTurns: 1, turnCount: 3, outcome: "termination-deferred", wrapUpRequestedAtTurn: 2, terminationDeferredAtTurn: 3 },
+				steps: [{
+					agent: "worker",
+					status: "running",
+					wrapUpRequested: true,
+					turnBudget: { maxTurns: 2, graceTurns: 1, turnCount: 3, outcome: "termination-deferred", wrapUpRequestedAtTurn: 2, terminationDeferredAtTurn: 3 },
+				}],
+			});
+
+			const text = formatAsyncRunList(listAsyncRuns(root, { states: ["running"] }));
+			assert.match(text, /turn-budget termination deferred 3\/2\+1/);
+			assert.doesNotMatch(text, /wrap-up requested/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("does not infer attention state when the runner has not persisted one", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-no-derived-attention-"));
 		try {

package/dist/extensions/pi-subagents/test/integration/chain-clarify.test.ts

@@ -8,7 +8,7 @@ interface ClarifyTestModel {
 	id: string;
 	fullId: string;
 	reasoning?: boolean;
-	thinkingLevelMap?: Partial<Record<"off" | "minimal" | "low" | "medium" | "high" | "xhigh", string | null>>;
+	thinkingLevelMap?: Partial<Record<"off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", string | null>>;
 }
 
 interface ClarifyTestComponent {
@@ -116,6 +116,38 @@ describe("chain clarify model display", { skip: !available ? "pi packages not av
 		assert.doesNotMatch(rendered, /minimal - Brief reasoning/);
 		assert.doesNotMatch(rendered, /low - Light reasoning/);
 		assert.doesNotMatch(rendered, /medium - Moderate reasoning/);
+		assert.doesNotMatch(rendered, /max - Maximum available reasoning/);
+	});
+
+	it("renders the max thinking option when the selected model exposes it", () => {
+		const component = new ChainClarifyComponent(
+			{ requestRender() {} },
+			{ fg(_key: string, text: string) { return text; } },
+			[{
+				name: "worker",
+				description: "",
+				systemPrompt: "",
+				systemPromptMode: "replace",
+				inheritProjectContext: false,
+				inheritSkills: false,
+				source: "user",
+				filePath: "worker.md",
+				model: "openai/gpt-5",
+			}],
+			["Task"],
+			"Task",
+			undefined,
+			[{ output: false, outputMode: "inline", reads: false, progress: false, skills: [], model: "openai/gpt-5" }],
+			[{ provider: "openai", id: "gpt-5", fullId: "openai/gpt-5", reasoning: true, thinkingLevelMap: { max: "max" } }],
+			"openai",
+			[],
+			() => {},
+			"single",
+		);
+		component.selectedStep = 0;
+		component.enterThinkingSelector();
+		const rendered = component.renderThinkingSelector().join("\n");
+		assert.match(rendered, /max - Maximum available reasoning/);
 	});
 
 	it("drops thinking when switching to a model that does not support it", () => {
@@ -271,4 +303,69 @@ describe("chain clarify model display", { skip: !available ? "pi packages not av
 
 		assert.equal(component.getEffectiveModel(0), "github-copilot/gpt-5:high");
 	});
+
+	it("labels every shortcut and keeps the clarify overlay within 84 columns", () => {
+		for (const mode of ["single", "parallel", "chain"] as const) {
+			const count = mode === "single" ? 1 : mode === "parallel" ? 2 : 4;
+			const component = new ChainClarifyComponent(
+				{ requestRender() {} },
+				{ fg(_key: string, text: string) { return `\u001b[31m${text}\u001b[0m`; } },
+				Array.from({ length: count }, (_, index) => ({
+					name: `agent-${index + 1}`,
+					description: "",
+					systemPrompt: "",
+					systemPromptMode: "replace",
+					inheritProjectContext: false,
+					inheritSkills: false,
+					source: "user",
+					filePath: `agent-${index + 1}.md`,
+				})),
+				Array.from({ length: count }, (_, index) => index === 0 ? "Task" : "Use {previous}"),
+				"Task",
+				undefined,
+				Array.from({ length: count }, () => ({
+					output: false,
+					outputMode: "inline",
+					reads: false,
+					progress: false,
+					skills: [],
+					model: undefined,
+				})),
+				[],
+				undefined,
+				[],
+				() => {},
+				mode,
+			);
+
+			const initialLines = component.render(84).map(stripAnsi);
+			const initial = initialLines.join("\n");
+			assert.match(initial, /\[e\]Task/);
+			assert.match(initial, /\[m\]Model/);
+			assert.match(initial, /\[t\]Think/);
+			assert.match(initial, /\[s\]Skills/);
+			assert.match(initial, /\[b\]Background:OFF/);
+			assert.doesNotMatch(initial, /• e m t/);
+			assert.match(initial, /\[Enter\] Run • \[Esc\] Cancel/);
+			if (mode === "single") {
+				assert.match(initial, /\[w\]Output/);
+				assert.doesNotMatch(initial, /\[↑↓\] Navigate/);
+			} else {
+				assert.match(initial, /\[↑↓\] Navigate/);
+			}
+			if (mode === "chain") {
+				assert.match(initial, /\[w\]Output/);
+				assert.match(initial, /\[r\]Reads/);
+				assert.match(initial, /\[p\]Prog/);
+			} else if (mode === "parallel") {
+				assert.doesNotMatch(initial, /\[w\]Output|\[r\]Reads|\[p\]Prog/);
+			}
+			for (const line of initialLines) {
+				assert.equal(visibleWidth(line), 84, `${mode} line did not match component width: ${line}`);
+			}
+
+			component.handleInput("b");
+			assert.match(component.render(84).map(stripAnsi).join("\n"), /\[b\]Background:ON/);
+		}
+	});
 });