gentle-pi 3.2.1 → 3.3.0

package/scripts/maintainer/provider-relay-matrix.mjs

@@ -9,10 +9,11 @@
 // `pnpm test` never imports it; `pnpm run test:maintainer` runs the tests;
 // the CLI is the entry point the separate verifier uses for the real organic
 // positive journey after a user-visible forecast.
+import { randomUUID } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, resolve } from "node:path";
+import { fauxAssistantMessage, registerFauxProvider } from "@earendil-works/pi-ai/compat";
 import { REVIEW_HOST_RELAY_FAILURE, ReviewHostRelayError, classifyReviewHostRelayRefusal, resolveReviewHostRelaySubmission, runReviewHostRelaySlot } from "../../lib/review-host-relay.ts";
 import { GENTLE_PI_REVIEW_RELAY_CONTRACT, GENTLE_PI_REVIEW_RELAY_CONTRACT_ENV } from "../../lib/review-relay-contract.ts";
 export const DESCRIPTOR_SCHEMA = "gentle-pi.maintainer.provider-relay-descriptor/v1";
@@ -88,13 +89,17 @@ const exactKeys = (obj, allowed, label) => {
 // the completing form is provably bindable before any process launches.
 export function validateDescriptor(value) {
 	if (!isObj(value)) fail("descriptor must be a JSON object");
-	exactKeys(value, new Set(["schema", "gentleAiExecutable", "piExecutable", "cases"]), "descriptor");
+	exactKeys(value, new Set(["schema", "gentleAiExecutable", "reviewerSelection", "cases"]), "descriptor");
 	if (value.schema !== DESCRIPTOR_SCHEMA) fail(`descriptor.schema must be exactly "${DESCRIPTOR_SCHEMA}"`);
 	if (!isStr(value.gentleAiExecutable) || !isAbsolute(value.gentleAiExecutable)) fail("descriptor.gentleAiExecutable must be a non-empty absolute path; the runner never re-resolves the production binary");
-	if (!isStr(value.piExecutable)) fail("descriptor.piExecutable must be a non-empty string");
+	// gentle-pi#311 P4: the positive-lens journey used to need a declared real
+	// `pi` binary; lens captures now run in-process, so it instead needs a
+	// "provider/id" reviewer selection the armed run resolves through a
+	// scripted-but-real completion (never a fake pi child).
+	if (!isStr(value.reviewerSelection)) fail("descriptor.reviewerSelection must be a non-empty string");
 	if (!Array.isArray(value.cases) || value.cases.length === 0) fail("descriptor.cases must be a non-empty array");
 	const seen = new Set();
-	return { schema: value.schema, gentleAiExecutable: value.gentleAiExecutable, piExecutable: value.piExecutable, cases: value.cases.map((entry, index) => {
+	return { schema: value.schema, gentleAiExecutable: value.gentleAiExecutable, reviewerSelection: value.reviewerSelection, cases: value.cases.map((entry, index) => {
 			if (!isObj(entry)) fail(`descriptor.cases[${index}] must be an object`);
 			if (!isStr(entry.name)) fail(`descriptor.cases[${index}].name must be a non-empty string`);
 			if (seen.has(entry.name)) fail(`descriptor.cases[${index}].name "${entry.name}" is duplicated`);
@@ -205,13 +210,77 @@ export function resolveDeclaredExecutable(executable) {
 	return null;
 }
 const missingReason = (executable, label) => `${label} "${executable}" is not an existing executable; arm the descriptor with a real binary, or set GENTLE_PI_REQUIRE_MAINTAINER=1 to fail instead of block.`;
-// A guaranteed-nonexistent pi path inside a fresh private directory. mkdtemp
-// picks an unpredictable name and 0700 keeps it ours, so nothing can race a
-// file into the slot between the mkdtemp and the spawn.
-function unlaunchablePi() {
-	const directory = mkdtempSync(join(tmpdir(), "gentle-pi-maintainer-no-pi-"));
-	chmodSync(directory, 0o700);
-	return { directory, executable: join(directory, "pi-must-never-launch") };
+// A reviewer registry whose `find` always misses. Mirrors the pre-in-process
+// "unlaunchable pi" trick this replaced: the maintainer-declared `kind` is
+// not evidence that the declared gentle-ai binary is actually incapable, so
+// a `relay-unavailable` negative control against a mis-declared CAPABLE
+// binary must still never complete a reviewer or submit anything. Resolving
+// nothing guarantees a typed MODEL_NOT_FOUND refusal before any completion
+// or submission, so the control cannot become a hidden real mutation even
+// against a binary that turns out to be capable (gentle-pi#311 P4).
+function unresolvableReviewerRegistry() {
+	return {
+		find: () => undefined,
+		getApiKeyAndHeaders: async () => ({ ok: false, error: "the relay-unavailable negative control never resolves a reviewer" }),
+	};
+}
+// The armed, organic positive-lens journey needs the real gentle-ai binary's
+// materialize/submit protocol exercised end-to-end, but this harness cannot
+// assume a maintainer's real provider credentials. Instead of a fake pi
+// child, this registers pi-ai's own faux provider -- the SAME api-registry
+// the real `completeSimple` dispatches through in production -- so the real
+// `runInProcessReviewer` -> real `completeSimple` path runs with no network.
+// The scripted response reads the frozen prompt's `GENTLE_AI_REVIEW_BINDING`
+// line for the subject_hash and its `GENTLE_AI_REVIEW_CONTEXT` line for the
+// changed-path manifest, and answers with every field the reviewer result
+// contract requires -- subject_hash, a completed inspection over exactly the
+// frozen paths, findings, evidence -- so the real Go admission accepts it
+// (gentle-pi#311 P4). Not unregistered: each
+// call uses a fresh random api id, and this runs at most once per short-lived
+// process (the CLI's single `main()` or one test), so a leaked entry in the
+// process-global api-registry is harmless.
+// Reads the one-line JSON that follows a frozen prompt marker (the binding
+// and context lines Go writes at the top of every reviewer task). Returns
+// undefined when the marker is absent or its JSON is malformed, so the faux
+// reviewer answers with an incomplete result that real admission refuses
+// instead of throwing inside the provider and masking the contract drift.
+function frozenPromptMarkerJson(promptText, marker) {
+	const prefix = `${marker} `;
+	for (const line of promptText.split("\n")) {
+		if (!line.startsWith(prefix)) continue;
+		try { return JSON.parse(line.slice(prefix.length)); } catch { return undefined; }
+	}
+	return undefined;
+}
+function armedFauxReviewerRegistry(reviewerSelection) {
+	const separatorIndex = reviewerSelection.indexOf("/");
+	if (separatorIndex <= 0 || separatorIndex === reviewerSelection.length - 1) {
+		throw new DescriptorValidationError(`descriptor.reviewerSelection "${reviewerSelection}" must have the "provider/id" shape`);
+	}
+	const provider = reviewerSelection.slice(0, separatorIndex);
+	const modelId = reviewerSelection.slice(separatorIndex + 1);
+	const api = `gentle-pi-maintainer-faux-reviewer-${randomUUID()}`;
+	const faux = registerFauxProvider({ api, provider, models: [{ id: modelId }] });
+	faux.setResponses([(context) => {
+		const content = context.messages[0]?.content;
+		const textPart = Array.isArray(content) ? content.find((part) => part.type === "text") : undefined;
+		const promptText = textPart?.text ?? "";
+		const binding = frozenPromptMarkerJson(promptText, "GENTLE_AI_REVIEW_BINDING");
+		const frozenContext = frozenPromptMarkerJson(promptText, "GENTLE_AI_REVIEW_CONTEXT");
+		const manifest = Array.isArray(frozenContext?.changed_path_manifest) ? frozenContext.changed_path_manifest : [];
+		const paths = manifest.map((entry) => entry?.path).filter((path) => typeof path === "string" && path.length > 0);
+		return fauxAssistantMessage(JSON.stringify({
+			subject_hash: binding?.subject_hash,
+			inspection: { status: "completed", paths },
+			findings: [],
+			evidence: ["armed maintainer faux reviewer inspected every frozen candidate path"],
+		}));
+	}]);
+	const model = faux.getModel();
+	return {
+		find: () => model,
+		getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "faux-key" }),
+	};
 }
 function terminateRoleProcessTree(child) {
 	if (child.pid === undefined) return false;
@@ -317,39 +386,41 @@ export async function runMatrix(descriptor, options = {}) {
 			}
 			continue;
 		}
-		// The positive lens needs a real pi AND an explicit arm; the negative
-		// control never launches pi (fails closed at materialize). The precheck
-		// resolves the declared Pi executable ONCE and reuses that exact
-		// concrete path for launch; a bare declaration is never re-resolved
-		// between precheck and spawn, so the relay launches exactly the
-		// executable the harness checked (issue #324).
-		let piPath = null;
-		if (caseEntry.kind === "positive-lens") {
-			piPath = resolveDeclaredExecutable(descriptor.piExecutable);
-			if (piPath === null) {
-				verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "blocked", reason: missingReason(descriptor.piExecutable, "piExecutable"), command: POSITIVE_JOURNEY_COMMAND });
-				continue;
-			}
-			if (!positiveArmed) {
-				verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "blocked", reason: `positive-lens case is not explicitly armed; set ${ARM_POSITIVE_ENV}=1 with a real capable gentle-ai binary, a real pi, and a real review session (real binding tokens from \`gentle-ai review status --next-transition\`) to run the organic journey. The runner never synthesizes a provider result.`, command: POSITIVE_JOURNEY_COMMAND });
-				continue;
-			}
+		// The positive lens needs an explicit arm; the negative control never
+		// resolves a reviewer (fails closed at the reviewer stage or earlier).
+		if (caseEntry.kind === "positive-lens" && !positiveArmed) {
+			verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "blocked", reason: `positive-lens case is not explicitly armed; set ${ARM_POSITIVE_ENV}=1 with a real capable gentle-ai binary and a real review session (real binding tokens from \`gentle-ai review status --next-transition\`) to run the organic journey. The runner never synthesizes a provider result.`, command: POSITIVE_JOURNEY_COMMAND });
+			continue;
 		}
-		// `relay-unavailable` is a NEGATIVE CONTROL: it must never launch pi and
-		// never submit. The maintainer-declared `kind` is not evidence that the
-		// declared binary is actually incapable, so the arm gate cannot key off
-		// the declaration alone. Pointed at a mis-declared CAPABLE binary, a
-		// declaration-only gate materializes, runs a REAL pi model, and executes
-		// a REAL `capture-result --input=...` submission, and only then reports
-		// `fail` — the mutation already happened. So give the negative control a
-		// pi that cannot exist: an incapable binary still classifies
-		// relay-unavailable at materialize (the control stays genuine, since it
-		// never reached pi anyway), while a capable one fails closed at the pi
-		// stage as kind=pi-launch-failed stage=pi mutationOutcome=none, with
-		// zero pi launch and zero submission.
-		const negativeControl = caseEntry.kind === "relay-unavailable" ? unlaunchablePi() : null;
-		const request = { captureArgumentTokens: caseEntry.captureArgumentTokens, submission: caseEntry.submission, gentleAiExecutable: gentleAiPath, piExecutable: negativeControl === null ? piPath : negativeControl.executable, ...(options.signal === undefined ? {} : { signal: options.signal }) };
+		// `relay-unavailable` is a NEGATIVE CONTROL: it must never complete a
+		// reviewer and never submit. The maintainer-declared `kind` is not
+		// evidence that the declared binary is actually incapable, so the arm
+		// gate cannot key off the declaration alone. Pointed at a mis-declared
+		// CAPABLE binary, a declaration-only gate materializes, runs a REAL
+		// reviewer completion, and executes a REAL `capture-result --input=...`
+		// submission, and only then reports `fail` — the mutation already
+		// happened. So give the negative control a reviewer registry that can
+		// never resolve: an incapable binary still classifies relay-unavailable
+		// at materialize (the control stays genuine, since it never reached the
+		// reviewer stage anyway), while a capable one fails closed at the
+		// reviewer stage as kind=reviewer-model-not-found stage=pi
+		// mutationOutcome=none, with zero completion and zero submission
+		// (gentle-pi#311 P4, superseding the pre-in-process "unlaunchable pi").
 		try {
+			// A malformed `reviewerSelection` (caught here rather than at
+			// descriptor-validation time, since it is only ever exercised by an
+			// armed positive-lens case) must fail this case the same way a real
+			// relay error would, never crash the whole matrix.
+			const reviewerRegistry = caseEntry.kind === "relay-unavailable" ? unresolvableReviewerRegistry() : armedFauxReviewerRegistry(descriptor.reviewerSelection);
+			const request = {
+				captureArgumentTokens: caseEntry.captureArgumentTokens,
+				submission: caseEntry.submission,
+				gentleAiExecutable: gentleAiPath,
+				reviewerRegistry,
+				selection: descriptor.reviewerSelection,
+				routingKey: "review-relay-matrix",
+				...(options.signal === undefined ? {} : { signal: options.signal }),
+			};
 			const result = await relay(request);
 			if (caseEntry.kind === "relay-unavailable") {
 				verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "fail", reason: "expected relay-unavailable (runtime without --materialize) but the relay succeeded; the descriptor's binary is unexpectedly capable" });
@@ -357,7 +428,9 @@ export async function runMatrix(descriptor, options = {}) {
 				verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "pass", promptByteLength: result.promptByteLength, resultByteLength: result.resultByteLength, submissionByteLength: result.submission.length });
 			}
 		} catch (error) {
-			if (error instanceof ReviewHostRelayError) {
+			if (error instanceof DescriptorValidationError) {
+				verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "fail", reason: error.message });
+			} else if (error instanceof ReviewHostRelayError) {
 				if (caseEntry.kind === "relay-unavailable") {
 					if (error.kind === REVIEW_HOST_RELAY_FAILURE.RELAY_UNAVAILABLE && error.stage === "materialize" && error.mutationOutcome === "none") {
 						verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "pass", stage: error.stage, mutationOutcome: error.mutationOutcome, reason: REVIEW_HOST_RELAY_FAILURE.RELAY_UNAVAILABLE });
@@ -372,8 +445,6 @@ export async function runMatrix(descriptor, options = {}) {
 			} else {
 				verdicts.push({ name: caseEntry.name, kind: caseEntry.kind, verdict: "fail", reason: `unexpected non-relay error: ${error instanceof Error ? error.message : String(error)}` });
 			}
-		} finally {
-			if (negativeControl !== null) rmSync(negativeControl.directory, { recursive: true, force: true });
 		}
 	}
 	return verdicts;

package/scripts/verify-package-files.mjs

@@ -181,7 +181,7 @@ const contractHashes = {
   "contracts/review-integration/v2/schemas/start.schema.json": "2991e3fcca672d9257d61b6a336fb34e58b15a8e03f8a09a7adf892cae6a8085",
   "contracts/review-integration/v2/schemas/status.schema.json": "c4dcc736cfc6300560a3c4262d2d982368529d5c49d58d499552a3b0beef9212",
   "contracts/telemetry/runtime-aggregate-v1.schema.json": "eb0f2993d9271f55cb42eca343e6fbb601a733fb90bd40daeebc92ee60ae1ba9",
-  "docs/review-integration.md": "9868cd52ae8f15cc2e6a6757014d5b12ff0904e06725d1a4cf29e9bcc3a7bae2",
+  "docs/review-integration.md": "9b60fa2775129c468f7eb3510905014553cee5f3cbcb78a608f08baf8bbd7336",
 };
 
 requiredPaths.push(...Object.keys(contractHashes));
@@ -339,7 +339,7 @@ async function main() {
   });
 
   if (driftedContracts.length > 0) {
-    console.error("gentle-pi packaged review-integration/v1 and review-integration/v2 contract bytes drifted from the pinned v3.2.1 runtime's vendored Gentle AI contract artifacts:");
+    console.error("gentle-pi packaged review-integration/v1 and review-integration/v2 contract bytes drifted from the pinned v3.4.0 runtime's vendored Gentle AI contract artifacts:");
     for (const drift of driftedContracts) console.error(`- ${drift.relativePath}: expected ${drift.expected}, got ${drift.actual}`);
     process.exit(1);
   }
@@ -384,7 +384,7 @@ async function main() {
     process.exit(1);
   }
 
-  console.log(`gentle-pi package resource check passed (${requiredPaths.length} files; ${Object.keys(contractHashes).length} exact byte-pinned contract artifacts for the v3.2.1 runtime).`);
+  console.log(`gentle-pi package resource check passed (${requiredPaths.length} files; ${Object.keys(contractHashes).length} exact byte-pinned contract artifacts for the v3.4.0 runtime).`);
 }
 
 const isMainModule = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;

package/tests/agents-grouping.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { type TuiMouseEvent } from "@earendil-works/pi-tui";
 import { TASK_STATUS, TaskStore, type TaskRecord } from "../lib/agents-protocol.ts";
-import { AgentsView, SESSION_FINISHED_TTL_MS } from "../lib/agents-view.ts";
+import { AgentsView } from "../lib/agents-view.ts";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 
 const plainTheme = { fg: (_color: string, text: string) => text };
@@ -111,30 +111,25 @@ test("AgentsView keeps headings non-actionable and clears a hidden selected chil
 	view.dispose();
 });
 
-test("AgentsView removes terminal children immediately without deleting retained threads", () => {
+test("AgentsView keeps finished children listed as history instead of dropping them", () => {
 	let now = 10_000;
 	const { store, view } = harness(12, () => now);
 	store.add(task("live", "current-session-id", { agent: "retained" }));
 	store.add(task("other", "other-session", { agent: "excluded" }));
 	store.apply("live", { type: "text", text: "kept thread" }, now);
 	store.update("live", { status: TASK_STATUS.COMPLETED, endedAt: now });
-	for (const elapsed of [0, SESSION_FINISHED_TTL_MS - 1]) {
-		now = 10_000 + elapsed;
-		const output = view.render(100).map(stripAnsi).join("\n");
-		assert.doesNotMatch(output, /Subagent retained|kept thread/);
-		assert.equal(store.thread("live").items.length, 1, "retained thread remains available outside the panel");
-		assert.doesNotMatch(output, /excluded/);
-		assert.equal(view.selectedTask(), undefined);
-	}
-	now = 10_000 + SESSION_FINISHED_TTL_MS;
-	assert.doesNotMatch(view.render(100).join("\n"), /Subagent retained/);
-	assert.equal(view.selectedTask(), undefined);
+	now += 60_000;
+	const output = view.render(100).map(stripAnsi).join("\n");
+	assert.match(output, /Subagent retained/, "a finished task of this session stays listed, long after it ended");
+	assert.equal(store.thread("live").items.length, 1, "its retained thread remains available");
+	assert.doesNotMatch(output, /excluded/, "another session's task never shows");
+	now += 60_000;
 	store.add(task("archive", "current-session-id", { agent: "archived", status: TASK_STATUS.COMPLETED, endedAt: now }));
-	assert.doesNotMatch(view.render(100).join("\n"), /Subagent archived/, "absent groups lose implicit expansion");
+	assert.match(view.render(100).join("\n"), /Subagent archived/, "a later finished task joins the history too");
 	view.dispose();
 });
 
-test("AgentsView retains an idle open heading and explicit collapse after the final child finishes", () => {
+test("AgentsView keeps an explicit collapse across a finish, and reveals the finished child as history on re-expand", () => {
 	const { store, view } = harness();
 	store.add(task("live", "current-session-id", { agent: "hidden" }));
 	view.handleInput("a");
@@ -142,10 +137,12 @@ test("AgentsView retains an idle open heading and explicit collapse after the fi
 	view.handleInput("k");
 	view.handleInput("\x1b[D");
 	store.update("live", { status: TASK_STATUS.COMPLETED, endedAt: 10_000 });
-	assert.doesNotMatch(view.render(100).join("\n"), /Subagent hidden/);
+	assert.doesNotMatch(view.render(100).join("\n"), /Subagent hidden/, "an explicit collapse persists across the child finishing");
 	view.handleInput("\x1b[C");
-	assert.doesNotMatch(view.render(100).join("\n"), /Subagent hidden/);
-	assert.match(view.render(100).join("\n"), /Current orchestrator.*0/);
+	const revealed = view.render(100).join("\n");
+	assert.match(revealed, /Subagent hidden/, "re-expanding reveals the finished child as history, not nothing");
+	assert.match(revealed, /Current orchestrator · 1 Su/, "the group's own count now includes the finished child");
+	assert.match(revealed, /0 active · 1 finished/, "the panel header reflects the finished child too");
 	store.add(task("replacement", "current-session-id", { agent: "replacement" }));
 	assert.match(view.render(100).join("\n"), /Subagent replacement/);
 	view.dispose();
@@ -177,3 +174,63 @@ test("AgentsView keeps its selected listener stable while another listener recei
 	unsubscribe();
 	view.dispose();
 });
+
+// A1 (odd/tasks/usage-click-and-changes-attribution.md): finished subagents
+// stay listed as history instead of vanishing, ordered active first and then
+// newest-ended-first, with the panel header reading "N active . M finished",
+// and never cancellable or reorderable by later activity.
+
+test("AgentsView lists active children before finished ones, newest ended first", () => {
+	const { store, view } = harness();
+	store.add(task("old-finished", "current-session-id", { agent: "old-finished", status: TASK_STATUS.COMPLETED, endedAt: 1000, createdAt: 100 }));
+	store.add(task("new-finished", "current-session-id", { agent: "new-finished", status: TASK_STATUS.FAILED, endedAt: 3000, createdAt: 100 }));
+	store.add(task("active", "current-session-id", { agent: "active-one", createdAt: 50 }));
+	const output = view.render(100).join("\n");
+	const activeIndex = output.indexOf("Subagent active-one");
+	const newFinishedIndex = output.indexOf("Subagent new-finished");
+	const oldFinishedIndex = output.indexOf("Subagent old-finished");
+	assert.ok(activeIndex >= 0 && newFinishedIndex >= 0 && oldFinishedIndex >= 0, "every task is listed");
+	assert.ok(activeIndex < newFinishedIndex, "active tasks list before finished ones");
+	assert.ok(newFinishedIndex < oldFinishedIndex, "finished tasks order newest ended first, regardless of creation order");
+	view.dispose();
+});
+
+test("the panel header counts active and finished separately", () => {
+	const { store, view } = harness();
+	store.add(task("active-1", "current-session-id", { agent: "active-1" }));
+	store.add(task("done-1", "current-session-id", { agent: "done-1", status: TASK_STATUS.COMPLETED, endedAt: 1000 }));
+	store.add(task("done-2", "current-session-id", { agent: "done-2", status: TASK_STATUS.FAILED, endedAt: 2000 }));
+	assert.match(view.render(100).join("\n"), /❀ Agents · this session · 1 active · 2 finished/);
+	view.dispose();
+});
+
+test("a finished task's row offers no stop control and ignores the stop key", () => {
+	const { store, view } = harness();
+	store.add(task("done", "current-session-id", { agent: "done", status: TASK_STATUS.COMPLETED, endedAt: 1000 }));
+	let cancelled: string | undefined;
+	view.dispose();
+	const cancelView = new AgentsView({
+		theme: plainTheme,
+		rows: 12,
+		store,
+		sessionId: "current-session-id",
+		now: () => 10_000,
+		onCancel: (task) => { cancelled = task.id; },
+		onOpen: () => {},
+		onClose: () => {},
+		requestRender: () => {},
+	});
+	assert.doesNotMatch(cancelView.render(100).join("\n"), /Stop selected/, "the footer never offers to stop a finished task");
+	cancelView.handleInput("s");
+	assert.equal(cancelled, undefined, "the stop key is a no-op on a finished task's row");
+	cancelView.dispose();
+});
+
+test("history retention caps finished tasks at 200 per session", () => {
+	const { store, view } = harness();
+	for (let i = 0; i < 202; i += 1) {
+		store.add(task(`f${i}`, "current-session-id", { agent: `f${i}`, status: TASK_STATUS.COMPLETED, endedAt: i, createdAt: i }));
+	}
+	assert.match(view.render(100).join("\n"), /0 active · 200 finished/, "the oldest finished tasks beyond the cap are dropped");
+	view.dispose();
+});

package/tests/agents-view.test.ts

@@ -163,15 +163,15 @@ test("activating a visible child preserves the manual list offset through Back a
 	}
 });
 
-test("resizing a narrow child list to desktop keeps Fullscreen local and completion returns to the list", () => {
+test("a task finishing while its details are open in narrow mode keeps its thread visible instead of kicking back to the list", () => {
 	const { store, view, events } = harness(8);
 	store.add(task("a"));
 	view.render(40);
 	clickLabel(view, "Fullscreen", 80);
 	assert.deepEqual(events, []);
 	store.update("a", { status: TASK_STATUS.COMPLETED, endedAt: 5000 });
-	assert.equal(view.selectedTask(), undefined);
-	assert.doesNotMatch(view.render(80).join("\n"), /Back|Subagent explore/);
+	assert.equal(view.selectedTask()?.id, "a", "the finished task stays selected as history instead of disappearing");
+	assert.match(view.render(80).join("\n"), /Back|Subagent explore/, "narrow details mode stays open on the now-finished task");
 	assert.deepEqual(events, []);
 	view.dispose();
 });
@@ -254,11 +254,12 @@ test("AgentsView renders the frame with the task list and the selected thread's
 	for (const line of lines) assert.equal(visibleWidth(line), 90, `"${stripAnsi(line)}" is not 90 wide`);
 	const plain = lines.map(stripAnsi);
 	assert.equal(plain.length, 8);
-	assert.match(plain[0], /^╭─ ❀ Agents · this session · 1 active ─+ \[F Fullscreen\] \[× Close\]╮$/);
+	assert.match(plain[0], /^╭─ ❀ Agents · this session · 1 active · 1 finished ─+ \[F Fullscreen\] \[× Close\]╮$/);
 	assert.match(plain[1], /▸ └ ◐ Subagent explore.*explore · running · gpt-5\.6-terra · 34k · \$0\.27 · 1m00s/);
 	assert.match(plain[2], /line 3/, "the thread window follows the tail");
 	assert.match(plain[3], /line 4/);
-	assert.doesNotMatch(plain.join("\n"), /Subagent worker|orchestrator/i);
+	assert.match(plain.join("\n"), /Subagent worker/, "the session's own finished task now stays listed as history");
+	assert.doesNotMatch(plain.join("\n"), /orchestrator/i);
 	assert.match(plain[4], /line 5/);
 	assert.match(plain[6], /\[ Follow \].*\[ Open session \].*\[Stop\]/);
 	assert.match(plain[7], /^╰─+╯$/);
@@ -306,7 +307,7 @@ test("AgentsView subscribes only to the selected task and survives an empty stor
 	assert.equal(renders(), before + 1, "disposed views stay quiet");
 });
 
-test("live-only current panel exposes active children directly at desktop and narrow widths", () => {
+test("current panel exposes active children directly at desktop and narrow widths, and keeps its own finished history", () => {
 	for (const width of [40, 80]) {
 		const { store, view, events } = harness(12, "s");
 		try {
@@ -318,8 +319,12 @@ test("live-only current panel exposes active children directly at desktop and na
 			}
 			store.add(task("foreign", { agent: "foreign", parentSessionId: "other" }));
 			const frame = view.render(width).map(stripAnsi).join("\n");
-			assert.doesNotMatch(frame, /orchestrator|history_|foreign|finished/i);
+			assert.doesNotMatch(frame, /orchestrator|foreign/i);
 			for (const status of ["running", "queued", "waiting"]) assert.match(frame, new RegExp(`Subagent ${status}`));
+			// The narrow list column truncates each "history_<status>" label to a
+			// common "history_…" prefix, so count occurrences instead of matching
+			// each one by its full name.
+			assert.equal((frame.match(/Subagent history_/g) ?? []).length, 4, "all four finished tasks of this session stay listed as history");
 			assert.match(stripAnsi(view.render(width)[1]), /Subagent queued/, "equal creation times sort by ID, with no parent wrapper");
 			assert.equal(view.selectedTask()?.id, "running", "adding earlier-sorted children preserves the existing selection");
 			view.handleInput("k");
@@ -332,22 +337,27 @@ test("live-only current panel exposes active children directly at desktop and na
 			view.handleInput("s");
 			assert.deepEqual(events, [`cancel:${selected.id}`]);
 			store.update(selected.id, { status: TASK_STATUS.COMPLETED, endedAt: 61_000 });
-			assert.notEqual(view.selectedTask()?.id, selected.id, "completion removes the selected live row immediately");
+			assert.equal(view.selectedTask()?.id, selected.id, "completion keeps the task selected, now as finished history");
 		} finally {
 			view.dispose();
 		}
 	}
 });
 
-test("live-only current panel never promotes retained foreign or unknown tasks into open sessions", () => {
+test("current panel never promotes retained foreign or unknown tasks into open sessions, but keeps its own finished history", () => {
 	const { store, view } = harness(12, "s");
 	try {
 		store.add(task("foreign", { agent: "foreign", parentSessionId: "closed" }));
 		store.add(task("unknown", { agent: "unknown", parentSessionId: "" }));
 		store.add(task("finished", { agent: "finished", status: TASK_STATUS.COMPLETED, endedAt: 61_000 }));
-		assert.equal(view.selectedTask(), undefined);
+		assert.equal(view.selectedTask()?.id, "finished", "the session's own finished task is selectable even with nothing active");
 		view.handleInput("a");
-		assert.doesNotMatch(view.render(80).map(stripAnsi).join("\n"), /Subagent (foreign|unknown|finished)|Orchestrator closed|Unknown session/);
+		// The "Current orchestrator" heading starts collapsed here: it has no
+		// active task to auto-expand it, only finished history.
+		view.handleInput("\x1b[C");
+		const rendered = view.render(80).map(stripAnsi).join("\n");
+		assert.doesNotMatch(rendered, /Subagent (foreign|unknown)|Orchestrator closed|Unknown session/);
+		assert.match(rendered, /Subagent finished/, "the session's own finished task shows under all sessions too, once its heading is expanded");
 		assert.equal(store.list().length, 3, "panel filtering never deletes retained history");
 	} finally {
 		view.dispose();
@@ -553,7 +563,7 @@ test("AgentsView scrolls the task list so the selection stays visible when there
 	assert.match(listed()[2], /Subagent agent3/);
 });
 
-test("AgentsView scopes to live children and toggles only the open-session directory", () => {
+test("AgentsView scopes to this session's own children (active and finished) and toggles only the open-session directory", () => {
 	const { store, view } = harness(12, "s");
 	store.add(task("mine", { agent: "mine" }));
 	store.add(task("theirs", { agent: "theirs", parentSessionId: "other", createdAt: 900, lastActivityAt: 900 }));
@@ -561,19 +571,19 @@ test("AgentsView scopes to live children and toggles only the open-session direc
 	store.add(task("stale", { agent: "stale", status: TASK_STATUS.COMPLETED, endedAt: 61_000 - 16 * 60_000, createdAt: 800, lastActivityAt: 800 }));
 	const names = () => view.render(80).map(stripAnsi).filter((line) => /[◐✓] Subagent /.test(line)).map((line) => line.match(/[◐✓] Subagent (\w+)/)?.[1]);
 	let plain = view.render(80).map(stripAnsi);
-	assert.match(plain[0], /^╭─ ❀ Agents · this session · 1 active ─+ \[F Fullscreen\] \[× Close\]╮$/);
-	assert.deepEqual(names(), ["mine"], "all terminal tasks and foreign retained tasks stay out");
+	assert.match(plain[0], /^╭─ ❀ Agents · this session · 1 active · 2 finished ─+ \[F Fullscreen\] \[× Close\]╮$/);
+	assert.deepEqual(names(), ["mine", "fresh", "stale"], "the session's own history stays, newest ended first, after the active child; the foreign task stays out");
 	assert.match(plain.at(-2) ?? "", /\[Scope\]/);
 	view.handleInput("a");
 	plain = view.render(80).map(stripAnsi);
-	assert.match(plain[0], /^╭─ ❀ Agents · all sessions · 1 active ─+ \[F Fullscreen\] \[× Close\]╮$/);
-	assert.deepEqual(names(), ["mine"], "retained foreign tasks cannot manufacture open orchestrators");
+	assert.match(plain[0], /^╭─ ❀ Agents · all sessions · 1 active · 2 finished ─+ \[F Fullscreen\] \[× Close\]╮$/);
+	assert.deepEqual(names(), ["mine", "fresh", "stale"], "retained foreign tasks cannot manufacture open orchestrators");
 	assert.match(plain.at(-2) ?? "", /\[Scope\]/);
 	view.handleInput("j");
-	assert.equal(view.selectedTask()?.id, "mine", "navigation stops at the only live child");
+	assert.equal(view.selectedTask()?.id, "fresh", "navigation moves to the session's own next-newest history entry");
 	view.handleInput("a");
 	assert.equal(view.selectedTask()?.id, "mine", "a new scope reads from the top");
-	assert.deepEqual(names(), ["mine"]);
+	assert.deepEqual(names(), ["mine", "fresh", "stale"]);
 });
 
 test("AgentsView footer buttons follow, open only a session-backed selection, and clear stale geometry", () => {