@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/pi-subagents/test/unit/orca-progress-tabs.test.ts

@@ -0,0 +1,348 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { afterEach, test } from "node:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createOrcaProgressTab, resolveOrcaCommand, resolvePiSessionId } from "../../src/runs/shared/orca-progress-tabs.ts";
+import { TEMP_ROOT_DIR } from "../../src/shared/types.ts";
+import { writeNodeCommand } from "../support/node-command.ts";
+
+const tempDirs: string[] = [];
+
+function removeProgressFiles(prefix: string): void {
+	const root = path.join(TEMP_ROOT_DIR, "orca-progress");
+	if (!fs.existsSync(root)) return;
+	for (const name of fs.readdirSync(root)) {
+		if (name.startsWith(prefix)) fs.rmSync(path.join(root, name), { force: true });
+	}
+}
+
+afterEach(() => {
+	const progressRoot = path.join(TEMP_ROOT_DIR, "orca-progress");
+	for (const dir of tempDirs.splice(0)) {
+		const key = createHash("sha256").update(path.resolve(dir)).digest("hex").slice(0, 20);
+		fs.rmSync(path.join(progressRoot, `counter-${key}`), { force: true });
+		fs.rmSync(path.join(progressRoot, `counter-${key}.lock`), { recursive: true, force: true });
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+	removeProgressFiles("progress-");
+	removeProgressFiles("disabled-run-");
+	removeProgressFiles("standalone-pi-");
+});
+
+function tempDir(): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-orca-tabs-test-"));
+	tempDirs.push(dir);
+	return dir;
+}
+
+async function waitForFile(file: string): Promise<void> {
+	const deadline = Date.now() + 5_000;
+	while (!fs.existsSync(file)) {
+		if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${file}`);
+		await new Promise((resolve) => setTimeout(resolve, 20));
+	}
+}
+
+function progressFile(prefix: string, suffix: ".log" | ".done"): string {
+	const root = path.join(TEMP_ROOT_DIR, "orca-progress");
+	const name = fs.readdirSync(root).find((candidate) => candidate.startsWith(prefix) && candidate.endsWith(suffix));
+	assert.ok(name, `Expected ${suffix} file for ${prefix}`);
+	return path.join(root, name);
+}
+
+function captureCommand(command: string, cwd: string): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
+		let output = "";
+		child.stdout.setEncoding("utf-8");
+		child.stdout.on("data", (chunk: string) => { output += chunk; });
+		child.once("error", reject);
+		child.once("close", (code) => code === 0 ? resolve(output) : reject(new Error(`Viewer exited ${code}: ${output}`)));
+	});
+}
+
+function writeCaptureOrca(dir: string): string {
+	return writeNodeCommand(dir, "orca", "require('fs').writeFileSync(process.env.ORCA_TEST_CAPTURE, JSON.stringify(process.argv.slice(2)))");
+}
+
+test("Orca progress tabs are disabled on Windows", { skip: process.platform === "win32" ? undefined : "Windows-only platform boundary" }, () => {
+	const dir = tempDir();
+	assert.equal(createOrcaProgressTab({
+		cwd: dir,
+		runId: "windows-disabled",
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: process.execPath,
+	}), undefined);
+});
+
+test("resolveOrcaCommand only returns executable commands", () => {
+	const dir = tempDir();
+	const executable = writeNodeCommand(dir, "orca", "process.exit(0)");
+	assert.equal(resolveOrcaCommand({ PATH: dir, PATHEXT: ".CMD" }), executable);
+	assert.equal(resolveOrcaCommand({ PATH: "", SELESAI_SUBAGENT_ORCA_BINARY: path.join(dir, "missing") }), undefined);
+});
+
+test("an unavailable Orca command leaves native execution untouched", () => {
+	const dir = tempDir();
+	assert.equal(createOrcaProgressTab({
+		cwd: dir,
+		runId: "missing-orca",
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		env: { PATH: "", SELESAI_SUBAGENT_ORCA_BINARY: path.join(dir, "missing") },
+	}), undefined);
+});
+
+test("standalone Pi executables use PATH Node for the watchdog and viewer", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const fakePi = path.join(dir, "pi");
+	const originalExecPath = process.execPath;
+	try {
+		process.execPath = fakePi;
+		const tab = createOrcaProgressTab({
+			cwd: dir,
+			runId: "standalone-pi",
+			agent: "worker",
+			index: 0,
+			config: { enabled: true },
+			command: fakeOrca,
+			env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+		});
+		assert.ok(tab);
+		tab.finish("failed");
+		await waitForFile(capture);
+		const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+		const viewer = args[args.indexOf("--command") + 1]!;
+		assert.match(viewer, /^'node' '-e' /);
+		assert.equal(viewer.includes(fakePi), false);
+		assert.match(await captureCommand(viewer, dir), /failed/);
+	} finally {
+		process.execPath = originalExecPath;
+	}
+});
+
+test("hung Orca terminal creation does not delay the owning process", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const fakeOrca = writeNodeCommand(dir, "orca", "require('fs').writeFileSync(process.env.ORCA_TEST_PID, String(process.pid));setInterval(()=>{},1000)");
+	const pidFile = path.join(dir, "orca.pid");
+	const moduleUrl = new URL("../../src/runs/shared/orca-progress-tabs.ts", import.meta.url).href;
+	const ownerScript = `import {createOrcaProgressTab} from ${JSON.stringify(moduleUrl)};const tab=createOrcaProgressTab({cwd:${JSON.stringify(dir)},runId:'progress-hung-owner',agent:'worker',index:0,config:{enabled:true},command:${JSON.stringify(fakeOrca)},env:{...process.env,ORCA_TEST_PID:${JSON.stringify(pidFile)}}});if(!tab)throw new Error('tab unavailable');`;
+	const startedAt = Date.now();
+	const owner = spawn(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", ownerScript], { cwd: dir, stdio: "ignore" });
+	const ownerClosed = new Promise<number | null>((resolve, reject) => {
+		owner.once("error", reject);
+		owner.once("close", resolve);
+	});
+	let fakePid: number | undefined;
+	try {
+		assert.equal(await ownerClosed, 0);
+		assert.ok(Date.now() - startedAt < 2_000, "the Orca observer delayed runner completion");
+		await waitForFile(pidFile);
+		fakePid = Number.parseInt(fs.readFileSync(pidFile, "utf-8"), 10);
+		process.kill(fakePid, 0);
+	} finally {
+		if (fakePid !== undefined) {
+			try { process.kill(fakePid, "SIGKILL"); } catch { /* already stopped */ }
+		}
+		if (owner.exitCode === null) owner.kill("SIGKILL");
+	}
+});
+
+test("malformed optional observer metadata cannot break child execution", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId: undefined,
+		agent: undefined,
+		index: undefined,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	} as never);
+	assert.ok(tab);
+	tab.finish("completed");
+	await waitForFile(capture);
+	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+	assert.equal(args[args.indexOf("--title") + 1], "subagent · subagent · 1");
+	removeProgressFiles("run-0-");
+});
+
+test("disabled Orca progress tabs do not invoke Orca", async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId: "disabled-run",
+		agent: "worker",
+		index: 0,
+		config: { enabled: false },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.equal(tab, undefined);
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	assert.equal(fs.existsSync(capture), false);
+});
+
+test("enabled tabs use a worktree sequence and successful Pi sessions get cleanup guidance", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const secondCapture = path.join(dir, "capture-2.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	fs.mkdirSync(path.join(dir, ".git"));
+	const runId = `progress-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 2,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	tab.append("starting\n");
+	tab.event({ type: "tool_execution_start", toolName: "read", args: { path: "README.md" } });
+	tab.event({ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "done output" }] } as never });
+	const sessionId = "019ffd40-4859-7015-94e4-7d15c31885ef";
+	const sessionFile = path.join(dir, `session file's ${sessionId}.jsonl`);
+	fs.writeFileSync(sessionFile, `${JSON.stringify({ type: "session", version: 3, id: sessionId })}\n`);
+	assert.equal(resolvePiSessionId(sessionFile), sessionId);
+	assert.equal(resolvePiSessionId(path.join(dir, `missing_${sessionId}.jsonl`)), undefined);
+	tab.finish("completed", sessionFile);
+
+	await waitForFile(capture);
+	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+	assert.deepEqual(args.slice(0, 2), ["terminal", "create"]);
+	assert.equal(args[args.indexOf("--worktree") + 1], `path:${path.resolve(dir)}`);
+	assert.equal(args[args.indexOf("--title") + 1], "subagent · worker · 1");
+	const viewer = args[args.indexOf("--command") + 1];
+	assert.ok(viewer.includes(process.execPath));
+	assert.doesNotMatch(viewer, /(?:^|;)\s*exec\s/);
+	assert.doesNotMatch(viewer, /(?:&|;)\s*exit(?:\s|$)/);
+
+	const progressDir = path.join(TEMP_ROOT_DIR, "orca-progress");
+	const log = fs.readdirSync(progressDir).find((name) => name.startsWith(`${runId}-2-`) && name.endsWith(".log"));
+	assert.ok(log);
+	const text = fs.readFileSync(path.join(progressDir, log), "utf-8");
+	assert.match(text, /starting/);
+	assert.match(text, /› read: README\.md/);
+	assert.match(text, /done output/);
+	const quotedSessionFile = `'${fs.realpathSync(sessionFile).replace(/'/g, `'"'"'`)}'`;
+	assert.ok(text.includes(`completed. To remove the Pi session of this subagent, run rm -- ${quotedSessionFile}`));
+	assert.doesNotMatch(text, /find ~\/\.pi\/agent\/sessions/);
+
+	const nestedCwd = path.join(dir, "packages", "app");
+	fs.mkdirSync(nestedCwd, { recursive: true });
+	const secondTab = createOrcaProgressTab({
+		cwd: nestedCwd,
+		runId: `${runId}-second`,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: secondCapture },
+	});
+	assert.ok(secondTab);
+	secondTab.finish("failed", sessionFile);
+	await waitForFile(secondCapture);
+	const secondArgs = JSON.parse(fs.readFileSync(secondCapture, "utf-8")) as string[];
+	assert.equal(secondArgs[secondArgs.indexOf("--title") + 1], "subagent · worker · 2");
+	const secondLog = fs.readdirSync(progressDir).find((name) => name.startsWith(`${runId}-second-0-`) && name.endsWith(".log"));
+	assert.ok(secondLog);
+	const secondText = fs.readFileSync(path.join(progressDir, secondLog), "utf-8");
+	assert.match(secondText, /failed/);
+	assert.doesNotMatch(secondText, /To remove the Pi session/);
+});
+
+test("viewer strips split terminal control sequences across poll ticks", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const runId = `progress-sanitize-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	await waitForFile(capture);
+	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+	const viewer = args[args.indexOf("--command") + 1]!;
+	const outputPromise = captureCommand(viewer, dir);
+	await new Promise((resolve) => setTimeout(resolve, 200));
+	tab.append("safe CSI \u001b[");
+	await new Promise((resolve) => setTimeout(resolve, 200));
+	tab.append("31mred OSC \u001b]0;secret");
+	await new Promise((resolve) => setTimeout(resolve, 200));
+	tab.append(" title\u0007visible\u0000\u0001\r\t\u007f\n");
+	tab.finish("failed");
+	const output = await outputPromise;
+	assert.match(output, /safe CSI red OSC visible\n/);
+	assert.doesNotMatch(output, /\u001b|31m|secret|title|\u0000|\u0001|\r|\t|\u007f/);
+});
+
+test("mirror output keeps small writes that hit stream backpressure before the byte limit", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const runId = `progress-backpressure-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	for (let index = 0; index < 2_000; index++) tab.append(`line-${index.toString().padStart(4, "0")} ${"x".repeat(80)}\n`);
+	tab.finish("completed");
+	const log = progressFile(`${runId}-0-`, ".log");
+	await waitForFile(log.replace(/\.log$/, ".done"));
+	const text = fs.readFileSync(log, "utf-8");
+	assert.match(text, /line-1999/);
+	assert.doesNotMatch(text, /progress mirror truncated/);
+});
+
+test("mirror output truncates at a finite byte bound", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const runId = `progress-bounded-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	tab.append("x".repeat(2 * 1024 * 1024));
+	tab.append("must be dropped");
+	tab.finish("completed");
+	const log = progressFile(`${runId}-0-`, ".log");
+	await waitForFile(log.replace(/\.log$/, ".done"));
+	assert.ok(fs.statSync(log).size <= 1024 * 1024);
+	const text = fs.readFileSync(log, "utf-8");
+	assert.match(text, /progress mirror truncated at 1048576 bytes/);
+	assert.doesNotMatch(text, /must be dropped/);
+});

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

@@ -69,8 +69,11 @@ test("published extension APIs use supported package entrypoints", async () => {
 	assert.equal(backgroundWork.BACKGROUND_WORK_PROTOCOL_VERSION, 1);
 	assert.equal(backgroundWork.BACKGROUND_WORK_REGISTRY_KEY, "pi-subagents.background-work.v1");
 	const externalRuns = await import("pi-subagents/external-runs");
-	assert.equal(externalRuns.EXTERNAL_RUN_REGISTRY_VERSION, 1);
-	assert.equal(typeof externalRuns.registerExternalRunProvider, "function");
+	assert.equal(externalRuns.EXTERNAL_RUN_REGISTRY_VERSION, 2);
+	assert.equal(typeof externalRuns.registerExternalRun, "function");
+	assert.equal(typeof externalRuns.updateExternalRun, "function");
+	assert.equal(typeof externalRuns.snapshotExternalRuns, "function");
+	assert.equal(typeof externalRuns.unregisterExternalRun, "function");
 	const capability = await import("pi-subagents/capability-ceiling");
 	assert.equal(capability.SUBAGENT_CAPABILITY_CEILING_VERSION, 1);
 	assert.equal(capability.SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY, "pi-subagents.capability-ceiling.v1");

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

@@ -825,7 +825,7 @@ describe("buildPiArgs system prompt mode wiring", () => {
 			tools: reviewer.tools,
 		});
 
-		assert.equal(args[args.indexOf("--tools") + 1], "read,grep,find,ls,intercom");
+		assert.equal(args[args.indexOf("--tools") + 1], "read,grep,find,ls");
 		assert.doesNotMatch(args[args.indexOf("--tools") + 1] ?? "", /\b(?:bash|edit|write)\b/);
 	});
 

package/dist/extensions/pi-subagents/test/unit/pi-coding-agent-dir.test.ts

@@ -214,6 +214,7 @@ Package skill content.
 	it("resolves configured artifact directory preferences", () => {
 		const sessionFile = path.join(agentDir, "sessions", "session-1", "session.jsonl");
 
+		// Selesai fork default: project-scoped .pi-subagents artifacts.
 		assert.equal(getArtifactsDir(sessionFile, cwd), getProjectArtifactsDir(cwd));
 		assert.equal(getArtifactsDir(sessionFile, cwd, "project"), getProjectArtifactsDir(cwd));
 		assert.equal(getArtifactsDir(sessionFile, cwd, "session"), path.join(path.dirname(sessionFile), "subagent-artifacts"));
@@ -241,6 +242,39 @@ Package skill content.
 		assert.throws(() => updateConfig((config) => config), /config\.fleetKeybindings\.pageUp entries must be non-empty strings/);
 	});
 
+	it("loads and validates the foreground detach shortcut", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ foregroundDetachShortcut: "ctrl+b" }));
+		assert.equal(loadConfig().foregroundDetachShortcut, "ctrl+b");
+
+		writeFile(configPath, JSON.stringify({ foregroundDetachShortcut: "banana" }));
+		assert.throws(() => updateConfig((config) => config), /config\.foregroundDetachShortcut must be a valid keybinding string/);
+	});
+
+	it("loads and validates main-window renderer density config", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ mainWindowRenderer: { horizontalSpacing: 0, compactResultMaxLines: 4 } }));
+		assert.deepEqual(loadConfig().mainWindowRenderer, { horizontalSpacing: 0, compactResultMaxLines: 4 });
+
+		writeFile(configPath, JSON.stringify({ mainWindowRenderer: { horizontalSpacing: -1 } }));
+		assert.throws(() => updateConfig((config) => config), /config\.mainWindowRenderer\.horizontalSpacing must be an integer from 0 to 4/);
+
+		writeFile(configPath, JSON.stringify({ mainWindowRenderer: { compactResultMaxLines: 0 } }));
+		assert.throws(() => updateConfig((config) => config), /config\.mainWindowRenderer\.compactResultMaxLines must be a positive integer/);
+	});
+
+	it("loads and validates experimental Orca progress-tab config", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ orcaProgressTabs: { enabled: true } }));
+		assert.deepEqual(loadConfig().orcaProgressTabs, { enabled: true });
+
+		writeFile(configPath, JSON.stringify({ orcaProgressTabs: { enabled: "yes" } }));
+		assert.throws(() => updateConfig((config) => config), /config\.orcaProgressTabs\.enabled must be a boolean/);
+
+		writeFile(configPath, JSON.stringify({ orcaProgressTabs: { enabled: true, focus: true } }));
+		assert.throws(() => updateConfig((config) => config), /config\.orcaProgressTabs\.focus is not supported/);
+	});
+
 	it("hardens and redacts existing run history while recording", () => {
 		const historyPath = path.join(agentDir, "run-history.jsonl");
 		fs.mkdirSync(agentDir, { recursive: true, mode: 0o755 });

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -5,7 +5,12 @@ import { normalizePublicSubagentExecution } from "../../src/extension/public-exe
 describe("public subagent execution normalization", () => {
 	it("accepts all four execution modes, management, and direct-field schedules", () => {
 		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1" }), { ok: true, params: { workflowScript: "return 1" } });
-		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", task: "work" }), { ok: true, params: { agent: "worker", task: "work" } });
+		const single = normalizePublicSubagentExecution({ agent: "worker", task: "work" });
+		assert.equal(single.ok, true);
+		if (single.ok) {
+			assert.equal(typeof (single.params as { workflowScript?: unknown }).workflowScript, "string");
+			assert.match((single.params as { workflowScript: string }).workflowScript, /runs\.run\("main", \{"agent":"worker","task":"work","output":true\}\)/);
+		}
 		assert.deepEqual(normalizePublicSubagentExecution({ tasks: [{ agent: "worker" }] }), { ok: true, params: { tasks: [{ agent: "worker" }] } });
 		assert.deepEqual(normalizePublicSubagentExecution({ chain: [{ agent: "worker" }] }), { ok: true, params: { chain: [{ agent: "worker" }] } });
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });

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

@@ -80,6 +80,50 @@ test("multiline rendering omits two-column graphemes at one-column width", () =>
 	}
 });
 
+test("running single-subagent cards show the configured detach shortcut", () => {
+	const running = {
+		...result("reviewer", ""),
+		progress: { status: "running", index: 0, agent: "reviewer", toolCount: 0, tokens: 0, durationMs: 0 },
+	};
+	const toolResult = {
+		content: [{ type: "text", text: "running" }],
+		details: { mode: "single", results: [running] },
+	};
+
+	const configured = componentText(renderSubagentResult(
+		toolResult as never,
+		{ expanded: false },
+		theme as any,
+		undefined,
+		undefined,
+		"ctrl+b",
+	));
+	assert.match(configured, /Ctrl\+B to run in background/);
+
+	const unconfigured = componentText(renderSubagentResult(toolResult as never, { expanded: false }, theme as any));
+	assert.doesNotMatch(unconfigured, /run in background/);
+
+	const alreadyBackground = componentText(renderSubagentResult(
+		{ ...toolResult, details: { ...toolResult.details, asyncId: "async-123" } } as never,
+		{ expanded: false },
+		theme as any,
+		undefined,
+		undefined,
+		"ctrl+b",
+	));
+	assert.doesNotMatch(alreadyBackground, /run in background/);
+
+	const pendingBackground = componentText(renderSubagentResult(
+		{ ...toolResult, details: { ...toolResult.details, background: true } } as never,
+		{ expanded: false },
+		theme as any,
+		undefined,
+		undefined,
+		"ctrl+b",
+	));
+	assert.doesNotMatch(pendingBackground, /run in background/);
+});
+
 test("compact chain rendering uses workflow graph spans for dynamic fanout results", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "done" }],
@@ -238,3 +282,51 @@ test("static sequential and static parallel chain rendering keep existing labels
 	assert.match(parallel, /Agent 2\/2: auditor/);
 	assert.match(parallel, /Step 3: writer/);
 });
+
+test("main-window renderer config removes compact result indentation without changing status glyphs", () => {
+	const component = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [result("scout", "a"), { ...result("reviewer", ""), exitCode: 1, error: "failed" }],
+		},
+	}, { expanded: false }, theme as any, undefined, { horizontalSpacing: 0 });
+
+	const text = componentText(component);
+	assert.match(text, /^✗ parallel/m);
+	assert.match(text, /^✓ Agent 1\/2: scout/m);
+	assert.match(text, /^✗ Agent 2\/2: reviewer/m);
+	assert.match(text, /^⎿  Error: failed/m);
+});
+
+test("main-window renderer config caps only collapsed rich result rows", () => {
+	const rendered = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [
+				result("scout", "a"),
+				result("reviewer", "b"),
+				result("writer", "c"),
+			],
+		},
+	}, { expanded: false }, theme as any, undefined, { compactResultMaxLines: 3 }).render(120);
+
+	assert.equal(rendered.length, 3);
+	assert.match(rendered[2]!, /rows hidden/);
+
+	const expanded = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [
+				result("scout", "a"),
+				result("reviewer", "b"),
+				result("writer", "c"),
+			],
+		},
+	}, { expanded: true }, theme as any, undefined, { compactResultMaxLines: 3 }).render(120);
+
+	assert.ok(expanded.length > 3);
+	assert.doesNotMatch(expanded.join("\n"), /rows hidden/);
+});