@oh-my-pi/pi-coding-agent 17.1.0 → 17.1.2

package/src/debug/raw-sse-buffer.ts

@@ -3,6 +3,13 @@ import type { Model, ProviderResponseMetadata, RawSseEvent } from "@oh-my-pi/pi-
 const MAX_RAW_SSE_EVENTS = 1_000;
 const MAX_RAW_SSE_CHARS = 512_000;
 const MAX_RAW_SSE_EVENT_CHARS = 64_000;
+// Reserve room for the `: omp-debug-truncated` / `: omp-debug-elided` marker
+// lines so a trimmed event stays within MAX_RAW_SSE_EVENT_CHARS overall.
+const TRIM_MARKER_RESERVE = 200;
+// Caps applied to individual tool entries when compacting a `tools` array
+// inside an oversized `data:` payload.
+const MAX_TOOL_SCHEMA_CHARS = 200;
+const MAX_TOOL_DESCRIPTION_CHARS = 200;
 
 export type RawSseDebugRecord =
 	| {
@@ -45,42 +52,162 @@ export interface RawSseDebugSnapshot {
 // path. The parallel array keeps records as plain monomorphic objects.
 type TrimResult = { raw: string[]; truncated: boolean; originalChars: number; chars: number };
 
-// Single-pass trim. Returns the final `chars` count using the historical
-// formula `reduce(line.length + 1, init = 1)` so the new accounting matches
-// the previous `countRecordChars` byte-for-byte (the trailing +1 covers the
-// record-level newline that `rawRecordText` appends in `toRawText`).
-//
-// When the event fits within budget the input `raw` array is returned
-// **by reference** — see the ownership contract documented at
-// `RawSseDebugBuffer.recordEvent` below.
-function trimRawLines(raw: string[]): TrimResult {
-	let originalChars = 0;
-	for (let i = 0; i < raw.length; i++) originalChars += raw[i].length + 1;
+// `chars` uses the historical formula `reduce(line.length + 1, init = 1)` so
+// the accounting matches the previous `countRecordChars` byte-for-byte (the
+// trailing +1 covers the record-level newline that `rawRecordText` appends in
+// `toRawText`).
+function countLines(lines: readonly string[]): number {
+	let chars = 0;
+	for (let i = 0; i < lines.length; i++) chars += lines[i].length + 1;
+	return chars;
+}
+
+function elideText(text: string, max: number): string {
+	if (text.length <= max) return text;
+	return `${text.slice(0, max)}… (+${text.length - max} chars)`;
+}
+
+// Shrinks one tool definition in place: schemas (`parameters` for OpenAI
+// shapes, `input_schema` for Anthropic) become elided JSON strings and long
+// descriptions are cut, while `name`/`type` survive untouched. Chat-completions
+// nests the payload under `function`.
+function compactToolEntry(tool: unknown): boolean {
+	if (typeof tool !== "object" || tool === null) return false;
+	const obj = tool as Record<string, unknown>;
+	let changed = false;
+	if (typeof obj.function === "object" && obj.function !== null) {
+		changed = compactToolEntry(obj.function);
+	}
+	for (const key of ["parameters", "input_schema"]) {
+		const schema = obj[key];
+		if (schema === undefined || schema === null) continue;
+		const text = typeof schema === "string" ? schema : JSON.stringify(schema);
+		if (text.length <= MAX_TOOL_SCHEMA_CHARS) continue;
+		obj[key] = elideText(text, MAX_TOOL_SCHEMA_CHARS);
+		changed = true;
+	}
+	if (typeof obj.description === "string" && obj.description.length > MAX_TOOL_DESCRIPTION_CHARS) {
+		obj.description = elideText(obj.description, MAX_TOOL_DESCRIPTION_CHARS);
+		changed = true;
+	}
+	return changed;
+}
+
+// Walks a parsed SSE payload and compacts every `tools` array it finds
+// (e.g. `response.tools` echoed back by the Responses API). Mutates `node`.
+function compactToolsDeep(node: unknown): boolean {
+	if (Array.isArray(node)) {
+		let changed = false;
+		for (const item of node) changed = compactToolsDeep(item) || changed;
+		return changed;
+	}
+	if (typeof node !== "object" || node === null) return false;
+	let changed = false;
+	const obj = node as Record<string, unknown>;
+	for (const key in obj) {
+		const value = obj[key];
+		if (key === "tools" && Array.isArray(value)) {
+			for (const tool of value) changed = compactToolEntry(tool) || changed;
+		} else {
+			changed = compactToolsDeep(value) || changed;
+		}
+	}
+	return changed;
+}
 
+// Rewrites oversized `data:` lines with tool schemas compacted. Returns null
+// when nothing changed (unparseable payloads or no tools to shrink). Only
+// invoked on events that already blew the budget, so the JSON round-trip is
+// off the streaming hot path.
+function compactToolLines(raw: readonly string[]): string[] | null {
+	let changed = false;
+	const out = raw.map(line => {
+		if (!line.startsWith("data:") || line.length <= MAX_TOOL_SCHEMA_CHARS) return line;
+		const start = line.charCodeAt(5) === 32 ? 6 : 5;
+		try {
+			const parsed = JSON.parse(line.slice(start));
+			if (!compactToolsDeep(parsed)) return line;
+			changed = true;
+			return `data: ${JSON.stringify(parsed)}`;
+		} catch {
+			return line;
+		}
+	});
+	return changed ? out : null;
+}
+
+// Keeps the first and last portions of an over-budget event and drops the
+// middle, so leading fields (id/model/status) AND trailing fields
+// (usage/finish_reason) both stay visible. A `: omp-debug-elided` comment
+// marks the cut; split lines carry `…` at the cut edge.
+function headTailTrim(lines: string[], budget: number, elidedTotal: number): string[] {
+	const headBudget = budget >> 1;
+	const tailBudget = budget - headBudget;
+
+	let i = 0;
+	let headRemaining = headBudget;
+	const out: string[] = [];
+	while (i < lines.length && lines[i].length + 1 <= headRemaining) {
+		headRemaining -= lines[i].length + 1;
+		out.push(lines[i]);
+		i++;
+	}
+
+	let j = lines.length - 1;
+	let tailRemaining = tailBudget;
+	const tail: string[] = [];
+	while (j >= i && lines[j].length + 1 <= tailRemaining) {
+		tailRemaining -= lines[j].length + 1;
+		tail.push(lines[j]);
+		j--;
+	}
+	tail.reverse();
+
+	let elided = elidedTotal - countLines(out) - countLines(tail);
+	if (i <= j) {
+		// lines[i..j] straddle the cut: keep a head slice of the first and a
+		// tail slice of the last (the same line when i === j).
+		const headSlice = lines[i].slice(0, Math.max(0, headRemaining - 2));
+		const tailStart =
+			i === j
+				? Math.max(headSlice.length, lines[j].length - tailRemaining + 2)
+				: Math.max(0, lines[j].length - tailRemaining + 2);
+		const tailSlice = lines[j].slice(tailStart);
+		elided -= headSlice.length + tailSlice.length;
+		if (headSlice.length > 0) out.push(`${headSlice}…`);
+		out.push(`: omp-debug-elided chars=${Math.max(0, elided)}`);
+		if (tailSlice.length > 0) out.push(`…${tailSlice}`);
+	} else if (elided > 0) {
+		out.push(`: omp-debug-elided chars=${elided}`);
+	}
+	out.push(...tail);
+	return out;
+}
+
+// Trim pipeline for one SSE event:
+//   1. fits → return `raw` **by reference** (ownership contract at
+//      `RawSseDebugBuffer.recordEvent` below).
+//   2. over budget → compact tool schemas inside `data:` JSON payloads;
+//      if that alone fits, the payload stays parseable JSON.
+//   3. still over → head+tail trim (middle elided).
+// Any trimmed result ends with the `: omp-debug-truncated` marker carrying
+// the original size.
+function trimRawLines(raw: string[]): TrimResult {
+	const originalChars = countLines(raw);
 	if (originalChars <= MAX_RAW_SSE_EVENT_CHARS) {
 		return { raw, truncated: false, originalChars, chars: originalChars + 1 };
 	}
 
-	const trimmed: string[] = [];
-	let remaining = MAX_RAW_SSE_EVENT_CHARS;
-	let chars = 1; // matches reduce(.., init = 1)
-	for (const line of raw) {
-		if (remaining <= 0) break;
-		if (line.length + 1 <= remaining) {
-			trimmed.push(line);
-			chars += line.length + 1;
-			remaining -= line.length + 1;
-			continue;
-		}
-		const slice = line.slice(0, Math.max(0, remaining));
-		trimmed.push(slice);
-		chars += slice.length + 1;
-		remaining = 0;
+	const budget = MAX_RAW_SSE_EVENT_CHARS - TRIM_MARKER_RESERVE;
+	let lines = compactToolLines(raw) ?? raw;
+	const compactedChars = lines === raw ? originalChars : countLines(lines);
+	if (compactedChars > budget) {
+		lines = headTailTrim(lines, budget, compactedChars);
+	} else if (lines === raw) {
+		lines = raw.slice();
 	}
-	const tail = `: omp-debug-truncated originalChars=${originalChars}`;
-	trimmed.push(tail);
-	chars += tail.length + 1;
-	return { raw: trimmed, truncated: true, originalChars, chars };
+	lines.push(`: omp-debug-truncated originalChars=${originalChars}`);
+	return { raw: lines, truncated: true, originalChars, chars: countLines(lines) + 1 };
 }
 
 export function formatRawSseIsoTime(timestamp: number): string {

package/src/eval/executor-base.ts

@@ -497,6 +497,7 @@ export async function executeWithKernelBase<
 		logger.error(`${errorLogLabel} execution failed`, { error: error.message });
 		throw error;
 	} finally {
+		await sink.dispose();
 		unregisterBridge?.();
 		abortShield.dispose?.();
 	}

package/src/eval/js/executor.ts

@@ -169,5 +169,7 @@ export async function executeJs(code: string, options: JsExecutorOptions): Promi
 			outputBytes: summary.outputBytes,
 			displayOutputs,
 		};
+	} finally {
+		await outputSink.dispose();
 	}
 }

package/src/exec/bash-executor.ts

@@ -581,6 +581,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		resetSession = true;
 		throw err;
 	} finally {
+		await sink.dispose();
 		if (timeoutTimer) {
 			clearTimeout(timeoutTimer);
 		}

package/src/export/share.ts

@@ -400,8 +400,9 @@ function redactShareMessage(
 			};
 		case "assistant":
 			// Drop opaque provider-replay state (encrypted reasoning / native history) the viewer
-			// never reads and we cannot redact field-by-field: `providerPayload` and any
-			// `redactedThinking` blocks.
+			// never reads and we cannot redact field-by-field: `providerPayload`, any
+			// `redactedThinking` blocks, and native Anthropic server-tool blocks
+			// (`server_tool_use` input / `web_search_tool_result` encrypted_content).
 			return {
 				...message,
 				providerPayload: undefined,
@@ -410,7 +411,7 @@ function redactShareMessage(
 						? undefined
 						: o.obfuscate(message.errorMessage, sharedRegexSecretValues),
 				content: message.content.flatMap((block): AssistantMessage["content"] => {
-					if (block.type === "redactedThinking") return [];
+					if (block.type === "redactedThinking" || block.type === "anthropicServerTool") return [];
 					if (block.type === "text") return [{ ...block, text: o.obfuscate(block.text, sharedRegexSecretValues) }];
 					if (block.type === "thinking") {
 						return [{ ...block, thinking: o.obfuscate(block.thinking, sharedRegexSecretValues) }];

package/src/extensibility/extensions/wrapper.ts

@@ -8,10 +8,11 @@ import type {
 	AgentToolUpdateCallback,
 	ToolLoadMode,
 } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
+import type { ComputerSafetyCheck, ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
-import { type ApprovalMode, formatApprovalPrompt, resolveApproval } from "../../tools/approval";
+import { type ApprovalMode, formatApprovalPrompt, resolveApproval, truncateForPrompt } from "../../tools/approval";
 import { defaultLoadModeForToolName } from "../../tools/essential-tools";
 import { normalizeToolEventInput, resolveToolEventInput } from "../tool-event-input";
 import { applyToolProxy } from "../tool-proxy";
@@ -83,6 +84,42 @@ export function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: E
 	return registeredTools.map(rt => wrapRegisteredTool(rt, runner));
 }
 
+function computerSafetyChecks(context: AgentToolContext | undefined): ComputerSafetyCheck[] {
+	const metadata = context?.toolCall?.providerMetadata;
+	return metadata?.type === "computer" ? metadata.pendingSafetyChecks : [];
+}
+
+function approvalArgs(params: unknown, context: AgentToolContext | undefined): unknown {
+	const metadata = context?.toolCall?.providerMetadata;
+	return metadata?.type === "computer" ? { actions: metadata.actions } : params;
+}
+
+function toolEventArgs(params: unknown, context: AgentToolContext | undefined): Record<string, unknown> {
+	const metadata = context?.toolCall?.providerMetadata;
+	if (metadata?.type === "computer") {
+		return {
+			actions: metadata.actions,
+			pendingSafetyChecks: metadata.pendingSafetyChecks,
+		};
+	}
+	return params as Record<string, unknown>;
+}
+
+function approvalData(value: string): string {
+	const sanitized = sanitizeText(value)
+		.replace(/[\r\n\t]+/g, " ")
+		.trim();
+	const truncated = truncateForPrompt(sanitized, 500);
+	return truncated.replace(/([\\`*_{}[\]()<>#+\-.!|])/g, "\\$1");
+}
+
+function safetyCheckLines(checks: readonly ComputerSafetyCheck[]): string[] {
+	return checks.map((check, index) => {
+		const value = check.message || check.code || check.id;
+		return `${index + 1}. ${approvalData(value)}`;
+	});
+}
+
 /**
  * Wraps a tool with extension callbacks for interception.
  * - Emits tool_call event before execution (can block)
@@ -128,19 +165,25 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		const configuredMode = (settings?.get("tools.approvalMode") ?? "yolo") as ApprovalMode;
 		const approvalMode: ApprovalMode = cliAutoApprove ? "yolo" : configuredMode;
 		const userPolicies = (settings?.get("tools.approval") ?? {}) as Record<string, unknown>;
-		const resolved = resolveApproval(this.tool, params, approvalMode, userPolicies);
+		const resolvedArgs = approvalArgs(params, context);
+		const resolved = resolveApproval(this.tool, resolvedArgs, approvalMode, userPolicies);
 		if (resolved.policy === "deny") {
 			throw new Error(
 				`Tool "${this.tool.name}" is blocked by user policy.\n` +
 					`To allow: remove "tools.approval.${this.tool.name}: deny" from config.`,
 			);
 		}
+		const pendingSafetyChecks = computerSafetyChecks(context);
 		// An xd:// device dispatch already cleared the write tool's outer gate at
 		// this tool's tier — re-prompting would double-ask for one action. Explicit
 		// per-tool "prompt" policies and tool-demanded overrides still prompt.
+		// Provider safety checks are stronger: yolo, per-tool allow, and xdev approval
+		// never acknowledge them on the user's behalf.
 		const explicitPrompt = resolved.override || Object.hasOwn(userPolicies, this.tool.name);
 		const approvalCheck = {
-			required: resolved.policy === "prompt" && (explicitPrompt || context?.xdevApproved !== true),
+			required:
+				pendingSafetyChecks.length > 0 ||
+				(resolved.policy === "prompt" && (explicitPrompt || context?.xdevApproved !== true)),
 			reason: resolved.reason,
 		};
 
@@ -171,10 +214,16 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				});
 			};
 
-			// Check if UI is available
+			// Provider safety checks fail closed without an interactive prompt. Unlike
+			// ordinary tier approval, no setting or yolo mode may bypass this gate.
 			if (!this.runner.hasUI()) {
 				const reason = "no interactive UI available";
 				await resolveApproval(false, reason);
+				if (pendingSafetyChecks.length > 0) {
+					throw new Error(
+						`Tool "${this.tool.name}" has pending provider safety checks but no interactive UI is available.`,
+					);
+				}
 				throw new Error(
 					`Tool "${this.tool.name}" requires approval but no interactive UI available.\n` +
 						`Options:\n` +
@@ -185,12 +234,14 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 			}
 
 			const uiContext = this.runner.getUIContext();
+			const basePrompt = formatApprovalPrompt(this.tool, resolvedArgs, approvalCheck.reason);
+			const safetyPrompt =
+				pendingSafetyChecks.length > 0
+					? `${basePrompt}\nProvider safety checks:\n${safetyCheckLines(pendingSafetyChecks).join("\n")}`
+					: basePrompt;
 			let choice: string | undefined;
 			try {
-				choice = await uiContext.select(formatApprovalPrompt(this.tool, params, approvalCheck.reason), [
-					"Approve",
-					"Deny",
-				]);
+				choice = await uiContext.select(safetyPrompt, ["Approve", "Deny"]);
 			} catch (err) {
 				await resolveApproval(false, err instanceof Error ? err.message : "approval aborted");
 				throw err;
@@ -200,6 +251,10 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 			if (!approved) {
 				throw new Error(`Tool call denied by user: ${this.tool.name}`);
 			}
+			if (pendingSafetyChecks.length > 0) {
+				if (!context) throw new Error("Provider safety approval context is unavailable");
+				context.providerSafetyApproved = true;
+			}
 		}
 
 		// 2. Emit tool_call event - extensions can block execution
@@ -211,7 +266,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 					toolCallId,
 					input: normalizeToolEventInput(
 						this.tool.name,
-						resolveToolEventInput(this.tool, params as Record<string, unknown>),
+						resolveToolEventInput(this.tool, toolEventArgs(params, context)),
 					),
 				})) as ToolCallEventResult | undefined;
 
@@ -228,7 +283,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		}
 
 		// Execute the actual tool
-		let result: { content: any; details?: TDetails };
+		let result: AgentToolResult<TDetails, TParameters>;
 		let executionError: Error | undefined;
 
 		try {
@@ -249,7 +304,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				toolCallId,
 				input: normalizeToolEventInput(
 					this.tool.name,
-					resolveToolEventInput(this.tool, params as Record<string, unknown>),
+					resolveToolEventInput(this.tool, toolEventArgs(params, context)),
 				),
 				content: result.content,
 				details: result.details,
@@ -275,6 +330,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				return {
 					content: modifiedContent,
 					details: modifiedDetails,
+					providerMetadata: result.providerMetadata,
 					...(effectiveError ? { isError: true } : {}),
 				};
 			}

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -17,7 +17,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type AuthCredential, SqliteAuthCredentialStore, type TSchema } from "@oh-my-pi/pi-ai";
-import { Text } from "@oh-my-pi/pi-tui";
+import { getKeybindings, type Keybinding, Text } from "@oh-my-pi/pi-tui";
 import {
 	getAgentDbPath,
 	getAgentDir,
@@ -26,6 +26,7 @@ import {
 	parseFrontmatter as parseOmpFrontmatter,
 } from "@oh-my-pi/pi-utils";
 import { getPackageDir as getOmpPackageDir } from "../config";
+import { formatKeyHints } from "../config/keybindings";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { type SettingPath, Settings } from "../config/settings";
 import { EditTool } from "../edit";
@@ -373,6 +374,11 @@ async function executeLegacyBashOperations(
 	}
 }
 
+/** Format the active shortcut for legacy extensions that render keybinding hints. */
+export function keyText(action: Keybinding): string {
+	return formatKeyHints(getKeybindings().getKeys(action));
+}
+
 /** Parse frontmatter using the historical Pi package-root helper. */
 export interface ParsedFrontmatter<T extends Record<string, unknown> = Record<string, unknown>> {
 	frontmatter: T;

package/src/launch/broker-list-order.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { TempDir } from "@oh-my-pi/pi-utils";
+import { createDaemonBrokerClient, type DaemonBrokerClient } from "./client";
+import type { DaemonSnapshot, DaemonSpec } from "./protocol";
+
+const TERMINAL_HISTORY_LIMIT = 10;
+
+function spec(name: string, cwd: string): DaemonSpec {
+	return {
+		name,
+		application: process.execPath,
+		args: [],
+		env: {},
+		cwd,
+		pty: false,
+		restart: "no",
+		persist: false,
+		detached: false,
+	};
+}
+
+function terminalSnapshot(index: number): DaemonSnapshot {
+	const name = `exited-${index}`;
+	return {
+		name,
+		id: name,
+		state: index % 2 === 0 ? "exited" : "failed",
+		createdAt: index * 10,
+		startedAt: index * 10,
+		exitedAt: index * 10 + 1,
+		exitReason: `historical exit ${index}`,
+		restartCount: 0,
+		outputBytes: 0,
+		persist: false,
+		detached: false,
+	};
+}
+
+async function seedTerminalRecord(runtimeDir: string, cwd: string, snapshot: DaemonSnapshot): Promise<void> {
+	const metaPath = path.join(runtimeDir, "daemons", snapshot.name, "meta.json");
+	await Bun.write(metaPath, JSON.stringify({ daemon: snapshot, spec: spec(snapshot.name, cwd) }));
+}
+
+async function shutdown(client: DaemonBrokerClient, activeName: string): Promise<void> {
+	await client.request({ op: "stop", name: activeName, timeoutMs: 2_000 }).catch(() => undefined);
+	await client.request({ op: "shutdown" }).catch(() => undefined);
+	client.close();
+}
+
+describe("broker list", () => {
+	it("returns active daemons first and caps recovered terminal history by real exit time", async () => {
+		using tempDir = TempDir.createSync("@omp-launch-list-");
+		const projectDir = path.join(tempDir.path(), "project");
+		const runtimeDir = path.join(tempDir.path(), "runtime");
+		await fs.mkdir(projectDir);
+
+		for (let index = 0; index < TERMINAL_HISTORY_LIMIT + 5; index++) {
+			await seedTerminalRecord(runtimeDir, projectDir, terminalSnapshot(index));
+		}
+
+		const client = await createDaemonBrokerClient(projectDir, { runtimeDir, idleGraceMs: 5_000 });
+		const activeName = "active-server";
+		try {
+			const started = await client.request({
+				op: "start",
+				spec: {
+					...spec(activeName, projectDir),
+					args: ["-e", "process.stdin.resume()"],
+				},
+			});
+			expect(started.op).toBe("start");
+
+			const listed = await client.request({ op: "list" });
+			expect(listed.op).toBe("list");
+			if (listed.op !== "list") throw new Error(`Unexpected broker result: ${listed.op}`);
+
+			expect(listed.daemons.map(daemon => daemon.name)).toEqual([
+				activeName,
+				...Array.from({ length: TERMINAL_HISTORY_LIMIT }, (_, offset) => `exited-${14 - offset}`),
+			]);
+			expect(listed.daemons[0]?.state).toBe("running");
+			expect(listed.daemons.at(-1)?.exitedAt).toBe(51);
+		} finally {
+			await shutdown(client, activeName);
+		}
+	}, 20_000);
+});

package/src/launch/broker.ts

@@ -33,6 +33,12 @@ const MAX_LOG_BYTES = 25 * 1024 * 1024;
 const LOG_READ_BYTES = 2 * 1024 * 1024;
 const READINESS_BUFFER_CHARS = 64 * 1024;
 const RESTART_MAX_DELAY_MS = 30_000;
+/**
+ * Cap on terminal (exited/failed) daemons surfaced by `list`. Active daemons
+ * are always shown in full; older history is truncated so the response stays
+ * bounded over a long-lived project (issue #6517).
+ */
+const MAX_TERMINAL_DAEMONS_LISTED = 10;
 const TOKEN_FILE = "broker.token";
 const PID_FILE = "broker.pid";
 const META_FILE = "meta.json";
@@ -95,6 +101,41 @@ function terminalState(state: DaemonSnapshot["state"]): boolean {
 	return state === "exited" || state === "failed";
 }
 
+/**
+ * Order daemons for the `list` response: non-terminal (active) daemons first,
+ * oldest to newest, so the process the user is acting on is immediately visible
+ * instead of buried behind exited history; then the most recently exited/failed
+ * ones, capped at {@link MAX_TERMINAL_DAEMONS_LISTED} to keep the response from
+ * growing without bound. Truncated terminal records stay addressable by name
+ * via `describe`/`logs`/`restart`.
+ */
+function orderDaemonsForListing(snapshots: DaemonSnapshot[]): DaemonSnapshot[] {
+	const active: DaemonSnapshot[] = [];
+	const terminal: DaemonSnapshot[] = [];
+	for (const snapshot of snapshots) {
+		(terminalState(snapshot.state) ? terminal : active).push(snapshot);
+	}
+	active.sort((left, right) => left.createdAt - right.createdAt);
+	terminal.sort((left, right) => (right.exitedAt ?? right.createdAt) - (left.exitedAt ?? left.createdAt));
+	return [...active, ...terminal.slice(0, MAX_TERMINAL_DAEMONS_LISTED)];
+}
+
+/**
+ * Reap a recovered non-detached daemon snapshot in place. Already-terminal
+ * records are left untouched so `list` keeps their real {@link DaemonSnapshot.exitedAt}
+ * for recency ranking; records that were still alive when the previous broker
+ * exited are marked `exited` at `now`, since their process died with that broker
+ * (issue #6517). Returns whether the record was reaped.
+ */
+function reapRecoveredSnapshot(snapshot: DaemonSnapshot, now: number): boolean {
+	if (terminalState(snapshot.state)) return false;
+	snapshot.pid = undefined;
+	snapshot.state = "exited";
+	snapshot.exitedAt = now;
+	snapshot.exitReason = "previous broker exited";
+	return true;
+}
+
 /** Mirror per-condition readiness progress into the snapshot so clients can see which condition is unmet. */
 function syncReadyPending(record: ManagedDaemon): void {
 	if (record.snapshot.state !== "starting") {
@@ -402,9 +443,7 @@ class DaemonBroker {
 				await Promise.all([...this.#records.values()].map(record => this.#refreshDetached(record)));
 				return {
 					op: "list",
-					daemons: [...this.#records.values()]
-						.sort((left, right) => left.snapshot.createdAt - right.snapshot.createdAt)
-						.map(record => record.snapshot),
+					daemons: orderDaemonsForListing([...this.#records.values()].map(record => record.snapshot)),
 				};
 			}
 			case "logs":
@@ -973,11 +1012,13 @@ class DaemonBroker {
 					snapshot.state !== "stopping" &&
 					processRef?.status() === "running";
 				if (!detached) {
-					if (processRef) await processRef.terminate({ group: true, gracefulMs: 500, timeoutMs: 2_000 });
-					snapshot.pid = undefined;
-					snapshot.state = "exited";
-					snapshot.exitedAt = Date.now();
-					snapshot.exitReason = "previous broker exited";
+					// Reap only records that were still alive when the previous broker
+					// exited; already-terminal records keep their real exit time so
+					// `list` ranks exited history by true recency (issue #6517).
+					if (!terminalState(snapshot.state) && processRef) {
+						await processRef.terminate({ group: true, gracefulMs: 500, timeoutMs: 2_000 });
+					}
+					reapRecoveredSnapshot(snapshot, Date.now());
 				} else if (snapshot.state === "restarting") {
 					snapshot.state = spec.ready ? "starting" : "running";
 				}