gentle-pi 3.2.0 → 3.3.0

package/scripts/mirror-odd-routing.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+// ODD routing drift ratchet — canonical fixture regeneration.
+//
+// gentle-pi hand-mirrors the always-on ODD routing block rendered by gentle-ai
+// `internal/components/agentguidance/routing.go` (RenderRouting). There is no
+// automated sync, so a canonical change leaves the pi mirror stale with nothing
+// catching it. This script renders the canonical block from a LOCAL gentle-ai
+// checkout and vendors it into `fixtures/odd-routing-canonical.md` with managed
+// provenance, where `tests/odd-routing-canonical-ratchet.test.ts` turns drift
+// into a failing test.
+//
+// This script NEVER fetches anything from the network (GOPROXY=off), NEVER
+// modifies the gentle-ai checkout beyond a transient temporary Go entrypoint
+// that it always deletes, and NEVER touches the installer release pin
+// (scripts/gentle-ai-installer.mjs INSTALLER_VERSION). Regeneration writes ONLY
+// the fixture; it never auto-rewrites the pi mirror assets.
+//
+// Usage:
+//   node scripts/mirror-odd-routing.mjs [--gentle-ai <path to local checkout>]
+
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const ODD_ROUTING_FIXTURE_RELATIVE = "fixtures/odd-routing-canonical.md";
+export const ODD_ROUTING_SOURCE_REPO = "https://github.com/Gentleman-Programming/gentle-ai";
+export const ODD_ROUTING_SOURCE_PATH = "internal/components/agentguidance/routing.go";
+export const ODD_ROUTING_HEADER_OPEN = "<!-- gentle-pi:managed-odd-routing-canonical\n";
+export const ODD_ROUTING_HEADER_CLOSE = "\n-->\n";
+export const ODD_ROUTING_TEMP_DIR = "tmp-odd-routing-dump";
+export const ODD_ROUTING_BLOCK_PREFIX = "## Implementation Routing";
+
+const GO_ENTRYPOINT = `package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/gentleman-programming/gentle-ai/v3/internal/components/agentguidance"
+	"github.com/gentleman-programming/gentle-ai/v3/internal/model"
+)
+
+func main() {
+	rendered, err := agentguidance.RenderRouting(model.AgentPi)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	fmt.Print(rendered)
+}
+`;
+
+export function sha256Hex(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+
+export function parseOddRoutingFixture(raw) {
+	if (!raw.startsWith(ODD_ROUTING_HEADER_OPEN)) {
+		throw new Error(`fixture does not start with the managed header ${JSON.stringify(ODD_ROUTING_HEADER_OPEN)}`);
+	}
+	const headerEnd = raw.indexOf(ODD_ROUTING_HEADER_CLOSE, ODD_ROUTING_HEADER_OPEN.length);
+	if (headerEnd === -1) {
+		throw new Error(`fixture managed header is not terminated by ${JSON.stringify(ODD_ROUTING_HEADER_CLOSE)}`);
+	}
+	const headerText = raw.slice(ODD_ROUTING_HEADER_OPEN.length, headerEnd);
+	const body = raw.slice(headerEnd + ODD_ROUTING_HEADER_CLOSE.length);
+	const header = {};
+	for (const line of headerText.split("\n")) {
+		const separator = line.indexOf(": ");
+		if (separator === -1) continue;
+		header[line.slice(0, separator)] = line.slice(separator + 2);
+	}
+	return { header, body };
+}
+
+export function renderOddRoutingFixture(block, { sourceCommit, generatedAt }) {
+	const body = block.endsWith("\n") ? block : `${block}\n`;
+	const header = [
+		ODD_ROUTING_HEADER_OPEN.trimEnd(),
+		`source_repo: ${ODD_ROUTING_SOURCE_REPO}`,
+		`source_path: ${ODD_ROUTING_SOURCE_PATH}`,
+		`source_commit: ${sourceCommit}`,
+		`generated_at: ${generatedAt}`,
+		`block_sha256: ${sha256Hex(body)}`,
+		"-->",
+	].join("\n");
+	return `${header}\n${body}`;
+}
+
+// `git status --porcelain --untracked-files=no` emits one `XY PATH` line per
+// modified tracked file. Extract just the repository-relative path so the
+// fail-closed error can name what would make provenance unverifiable.
+export function parsePorcelainPaths(porcelainOutput) {
+	return porcelainOutput
+		.split("\n")
+		.map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line))
+		.filter((line) => line.length > 0)
+		.map((line) => line.slice(3).trim())
+		.filter((path) => path.length > 0);
+}
+
+// Fail closed when the checkout carries uncommitted changes to tracked files.
+// The fixture header asserts the rendered block came from the committed tree;
+// rendering a dirty tree under that claim would make the provenance a lie.
+// Untracked files never reach this guard because the git call excludes them.
+export function assertCleanGentleAiCheckout(porcelainOutput) {
+	const dirtyPaths = parsePorcelainPaths(porcelainOutput);
+	if (dirtyPaths.length > 0) {
+		throw new Error(
+			`gentle-ai checkout is dirty; provenance would be unverifiable: ${dirtyPaths.join(", ")}. Commit or stash first.`,
+		);
+	}
+}
+
+function parseArguments(argv) {
+	const values = { gentleAi: undefined };
+	for (let index = 0; index < argv.length; index += 2) {
+		const flag = argv[index];
+		const value = argv[index + 1];
+		if (flag !== "--gentle-ai" || value === undefined) {
+			throw new Error("usage: node scripts/mirror-odd-routing.mjs [--gentle-ai <path to local checkout>]");
+		}
+		if (values.gentleAi !== undefined) throw new Error("duplicate --gentle-ai argument");
+		values.gentleAi = value;
+	}
+	return values;
+}
+
+function requireGentleAiCheckout(gentleAiRoot) {
+	if (!existsSync(gentleAiRoot)) {
+		throw new Error(
+			`no gentle-ai checkout at ${gentleAiRoot}; pass --gentle-ai <path> or clone ${ODD_ROUTING_SOURCE_REPO} as a sibling of gentle-pi`,
+		);
+	}
+	const routingPath = join(gentleAiRoot, ...ODD_ROUTING_SOURCE_PATH.split("/"));
+	if (!existsSync(routingPath)) {
+		throw new Error(`not a gentle-ai checkout: missing ${routingPath}`);
+	}
+}
+
+export function renderCanonicalRouting(gentleAiRoot) {
+	const tempRoot = join(gentleAiRoot, ODD_ROUTING_TEMP_DIR);
+	// Clear any stale temp entrypoint from a previous crash so the render is clean.
+	rmSync(tempRoot, { recursive: true, force: true });
+	mkdirSync(tempRoot, { recursive: true });
+	try {
+		writeFileSync(join(tempRoot, "main.go"), GO_ENTRYPOINT, { encoding: "utf8" });
+		const rendered = execFileSync("go", ["run", `./${ODD_ROUTING_TEMP_DIR}`], {
+			cwd: gentleAiRoot,
+			encoding: "utf8",
+			// GOPROXY=off fails closed instead of downloading: this script must
+			// never touch the network.
+			env: { ...process.env, GOPROXY: "off" },
+			stdio: ["ignore", "pipe", "inherit"],
+		});
+		if (!rendered.startsWith(ODD_ROUTING_BLOCK_PREFIX)) {
+			throw new Error(
+				`RenderRouting(model.AgentPi) did not return the expected routing block (starts with ${JSON.stringify(ODD_ROUTING_BLOCK_PREFIX)})`,
+			);
+		}
+		return rendered;
+	} finally {
+		rmSync(tempRoot, { recursive: true, force: true });
+	}
+}
+
+// Resolve fixture provenance from the committed gentle-ai tree. `generatedAt`
+// is the committer date, not wall-clock time, so rendering the same commit
+// twice yields byte-identical fixture files. `execGit` is injectable for tests.
+export function resolveOddRoutingProvenance(gentleAiRoot, execGit) {
+	const git = execGit ?? ((args) => execFileSync("git", args, { cwd: gentleAiRoot, encoding: "utf8" }));
+	assertCleanGentleAiCheckout(git(["status", "--porcelain", "--untracked-files=no"]));
+	return {
+		sourceCommit: git(["rev-parse", "HEAD"]).trim(),
+		generatedAt: git(["show", "-s", "--format=%cI", "HEAD"]).trim(),
+	};
+}
+
+export function mirrorOddRouting(packageRoot, gentleAiRoot) {
+	requireGentleAiCheckout(gentleAiRoot);
+	// Resolve (and fail closed on dirty) provenance BEFORE rendering: the
+	// transient Go entrypoint must not run against a tree whose commit hash the
+	// fixture would misrepresent.
+	const provenance = resolveOddRoutingProvenance(gentleAiRoot);
+	const block = renderCanonicalRouting(gentleAiRoot);
+	const contents = renderOddRoutingFixture(block, provenance);
+
+	const fixturePath = join(resolve(packageRoot), ...ODD_ROUTING_FIXTURE_RELATIVE.split("/"));
+	const previous = readPreviousFixture(fixturePath);
+	mkdirSync(dirname(fixturePath), { recursive: true });
+
+	// Atomic overwrite: write a sibling temp file, then rename it into place.
+	const stagingPath = `${fixturePath}.tmp`;
+	try {
+		writeFileSync(stagingPath, contents, { encoding: "utf8" });
+		renameSync(stagingPath, fixturePath);
+	} finally {
+		rmSync(stagingPath, { force: true });
+	}
+
+	const next = parseOddRoutingFixture(contents);
+	return {
+		fixturePath,
+		sourceCommit: next.header.source_commit,
+		blockSha256: next.header.block_sha256,
+		changed: previous === undefined || previous.body !== next.body || previous.header.source_commit !== next.header.source_commit,
+		previous,
+	};
+}
+
+function readPreviousFixture(fixturePath) {
+	if (!existsSync(fixturePath)) return undefined;
+	const raw = readFileSync(fixturePath, "utf8");
+	// Verify the existing fixture before clobbering it: an unparseable file is a
+	// signal to inspect, not to silently overwrite.
+	const parsed = parseOddRoutingFixture(raw);
+	const recorded = parsed.header.block_sha256;
+	const actual = sha256Hex(parsed.body);
+	if (recorded !== undefined && recorded !== actual) {
+		console.warn(`warning: existing fixture body does not match its recorded digest (${recorded}); regenerating from canonical`);
+	}
+	return parsed;
+}
+
+async function main() {
+	const packageRoot = join(fileURLToPath(new URL("..", import.meta.url)));
+	const { gentleAi } = parseArguments(process.argv.slice(2));
+	const gentleAiRoot = resolve(gentleAi ?? join(packageRoot, "..", "gentle-ai"));
+	const result = mirrorOddRouting(packageRoot, gentleAiRoot);
+	console.log(`${result.changed ? "Wrote" : "Refreshed"} ${result.fixturePath}`);
+	console.log(`source commit ${result.sourceCommit}; block sha256 ${result.blockSha256}`);
+	if (result.previous !== undefined) {
+		console.log(`previous commit ${result.previous.header.source_commit}; previous block sha256 ${result.previous.header.block_sha256}`);
+	}
+}
+
+const isMainModule = process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMainModule) {
+	await main();
+}

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": "95a3df92785bc4d9f3b99e702aaf817ae0440bd16c83218d2c3f2aca67c280fb",
+  "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.1.0 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.1.0 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", () => {