pi-subagents 0.50.0 → 0.52.0

package/src/runs/background/async-status.ts

@@ -2,9 +2,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.ts";
 import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.ts";
-import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type CostSummary, type Details, type LaunchResolvedChildExtensionsV1, type RuntimeAcknowledgedChildExtensionsV1, type NestedRunSummary, type SteeringStatus, type SubagentRunMode, type TokenUsage, type TurnBudgetState, type UsageBudgetState, type ChainCheckpointState } from "../../shared/types.ts";
+import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type CostSummary, type Details, type LaunchResolvedChildExtensionsV1, type RuntimeAcknowledgedChildExtensionsV1, type NestedRunSummary, type SteeringStatus, type SubagentRunMode, type TokenUsage, type TurnBudgetState, type UsageBudgetState } from "../../shared/types.ts";
 import type { ResolvedSubagentCapabilityCeiling, SubagentCapabilityAudit } from "../shared/capability-ceiling.ts";
-import { pruneStatusCacheForAsyncRoot, readStatus } from "../../shared/utils.ts";
+import { readStatus } from "../../shared/utils.ts";
 import { attachRootChildrenToSteps, buildNestedRouteIndex, findNestedRouteForRootId, type NestedRoute, projectNestedEvents } from "../shared/nested-events.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.ts";
@@ -13,6 +13,8 @@ import { contextModeLabel, summarizeContextModes, type ContextMode, type Context
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.ts";
 import { ACTIVE_RUN_INDEX_DIR, DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS, activeRunMarkerAgeMs, isActiveAsyncState, readActiveRunIndex, releaseActiveRunIndex, updateActiveRunIndex } from "./active-run-index.ts";
+import { readRecentTerminalRunIndex, TERMINAL_RUN_INDEX_DIR } from "./terminal-run-index.ts";
+import { canScanAsyncRunPrefix } from "./run-id-query.ts";
 
 interface AsyncRunStepSummary {
 	index: number;
@@ -23,7 +25,6 @@ interface AsyncRunStepSummary {
 	phase?: string;
 	outputName?: string;
 	structured?: boolean;
-	checkpoint?: ChainCheckpointState;
 	status: AsyncJobStep["status"];
 	runner?: AsyncJobStep["runner"];
 	activityState?: ActivityState;
@@ -83,6 +84,7 @@ export interface AsyncRunSummary {
 	mode: SubagentRunMode;
 	context?: ContextSummary;
 	cwd?: string;
+	sessionRoot?: string;
 	startedAt: number;
 	lastUpdate?: number;
 	endedAt?: number;
@@ -98,7 +100,6 @@ export interface AsyncRunSummary {
 	pendingAppends?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	steps: AsyncRunStepSummary[];
-	checkpoint?: ChainCheckpointState;
 	sessionDir?: string;
 	outputFile?: string;
 	totalTokens?: TokenUsage;
@@ -122,14 +123,18 @@ interface AsyncRunListOptions {
 	states?: Array<AsyncRunSummary["state"]>;
 	sessionId?: string;
 	limit?: number;
-	/** Limits status-file reads after candidates are ordered by status mtime. */
+	/** Limits terminal candidates using the timestamp embedded in index marker names. */
 	entryLimit?: number;
 	resultsDir?: string;
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 	now?: () => number;
 	reconcile?: boolean;
 	runId?: string;
+	/** The caller already holds a canonical run id; never interpret a miss as a prefix. */
+	exactRunId?: boolean;
 	includeNested?: boolean;
+	/** Explicit repair/debug escape hatch. Normal runtime paths must not set this. */
+	repairScan?: boolean;
 }
 
 function getErrorMessage(error: unknown): string {
@@ -157,7 +162,7 @@ function isAsyncRunDir(root: string, entry: string): boolean {
 
 type TargetedAsyncRunResolution =
 	| { kind: "exact"; id: string }
-	| { kind: "scan" }
+	| { kind: "prefix" }
 	| { kind: "reject" };
 
 /**
@@ -165,13 +170,13 @@ type TargetedAsyncRunResolution =
  * accepting a path whose canonical location escaped the async root.
  */
 export function resolveTargetedAsyncRun(asyncDirRoot: string, id: string, sessionId?: string): TargetedAsyncRunResolution {
-	if (!id || id === "." || id === ".." || id === ACTIVE_RUN_INDEX_DIR || path.basename(id) !== id) return { kind: "reject" };
+	if (!id || id === "." || id === ".." || id === ACTIVE_RUN_INDEX_DIR || id === TERMINAL_RUN_INDEX_DIR || path.basename(id) !== id) return { kind: "reject" };
 	const asyncDir = path.join(asyncDirRoot, id);
 	let entryStat: fs.Stats;
 	try {
 		entryStat = fs.lstatSync(asyncDir);
 	} catch (error) {
-		if (isNotFoundError(error)) return { kind: "scan" };
+		if (isNotFoundError(error)) return canScanAsyncRunPrefix(id) ? { kind: "prefix" } : { kind: "reject" };
 		throw new Error(`Failed to inspect async run path '${asyncDir}': ${getErrorMessage(error)}`, {
 			cause: error instanceof Error ? error : undefined,
 		});
@@ -189,7 +194,7 @@ export function resolveTargetedAsyncRun(asyncDirRoot: string, id: string, sessio
 	}
 	if (sessionId !== undefined) {
 		const status = readStatus(asyncDir);
-		if (status?.sessionId !== sessionId) return { kind: "scan" };
+		if (status?.sessionId !== sessionId) return canScanAsyncRunPrefix(id) ? { kind: "prefix" } : { kind: "reject" };
 	}
 	return { kind: "exact", id };
 }
@@ -253,7 +258,6 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.phase ? { phase: step.phase } : {}),
 			...(step.outputName ? { outputName: step.outputName } : {}),
 			...(step.structured ? { structured: step.structured } : {}),
-			...(step.checkpoint ? { checkpoint: step.checkpoint } : {}),
 			status: step.status,
 			...(step.runner ? { runner: step.runner } : {}),
 			...(stepActivityState ? { activityState: stepActivityState } : {}),
@@ -315,6 +319,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		mode: status.mode,
 		...(summarizeContextModes(summarizedSteps.map((step) => step.context)) ? { context: summarizeContextModes(summarizedSteps.map((step) => step.context)) } : {}),
 		cwd: status.cwd,
+		...(status.sessionRoot ? { sessionRoot: status.sessionRoot } : {}),
 		startedAt: status.startedAt,
 		lastUpdate: status.lastUpdate,
 		endedAt: status.endedAt,
@@ -330,7 +335,6 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		...(status.pendingAppends !== undefined ? { pendingAppends: status.pendingAppends } : {}),
 		...(parallelGroups.length ? { parallelGroups } : {}),
 		steps: summarizedSteps,
-		...(status.checkpoint ? { checkpoint: status.checkpoint } : {}),
 		...(nestedChildren.length ? { nestedChildren } : {}),
 		...(nestedWarnings.length ? { nestedWarnings } : {}),
 		...(processTerminal ? { processTerminal } : {}),
@@ -379,35 +383,39 @@ function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
 
 export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions = {}): AsyncRunSummary[] {
 	let entries: string[];
-	let scannedCompleteRoot = false;
-	let usedActiveIndex = false;
-	const activeOnly = options.runId === undefined
-		&& options.entryLimit === undefined
-		&& options.states !== undefined
-		&& options.states.length > 0
-		&& options.states.every(isActiveAsyncState);
+	const activeEntries = new Set<string>();
+	const wantsActive = options.states === undefined || options.states.some(isActiveAsyncState);
+	const wantsTerminal = options.states === undefined || options.states.some((state) => !isActiveAsyncState(state));
 	const includeNested = options.includeNested !== false;
 	try {
 		if (options.runId !== undefined) {
 			const resolution = resolveTargetedAsyncRun(asyncDirRoot, options.runId, options.sessionId);
 			entries = resolution.kind === "exact"
 				? [resolution.id]
-				: resolution.kind === "scan"
+				: resolution.kind === "prefix" && options.exactRunId !== true
 					? fs.readdirSync(asyncDirRoot).filter((entry) =>
 						(entry === options.runId || entry.startsWith(options.runId!))
 						&& resolveTargetedAsyncRun(asyncDirRoot, entry, options.sessionId).kind === "exact"
 					)
 					: [];
-		} else if (activeOnly) {
-			entries = (readActiveRunIndex(asyncDirRoot) ?? []).filter((entry) => {
-				if (resolveTargetedAsyncRun(asyncDirRoot, entry).kind === "exact") return true;
-				updateActiveRunIndex(path.join(asyncDirRoot, entry), "failed");
-				return false;
-			});
-			usedActiveIndex = true;
+		} else if (options.repairScan === true) {
+			entries = fs.readdirSync(asyncDirRoot).filter((entry) => entry !== ACTIVE_RUN_INDEX_DIR && entry !== TERMINAL_RUN_INDEX_DIR && isAsyncRunDir(asyncDirRoot, entry));
 		} else {
-			entries = fs.readdirSync(asyncDirRoot).filter((entry) => entry !== ACTIVE_RUN_INDEX_DIR && isAsyncRunDir(asyncDirRoot, entry));
-			scannedCompleteRoot = true;
+			const indexed = new Set<string>();
+			if (wantsActive) {
+				for (const entry of readActiveRunIndex(asyncDirRoot) ?? []) {
+					if (resolveTargetedAsyncRun(asyncDirRoot, entry).kind === "exact") {
+						indexed.add(entry);
+						activeEntries.add(entry);
+					} else {
+						updateActiveRunIndex(path.join(asyncDirRoot, entry), "failed");
+					}
+				}
+			}
+			if (wantsTerminal) {
+				for (const entry of readRecentTerminalRunIndex(asyncDirRoot, { sessionId: options.sessionId, ...(options.entryLimit !== undefined ? { limit: options.entryLimit } : {}) })) indexed.add(entry);
+			}
+			entries = [...indexed];
 		}
 	} catch (error) {
 		if (isNotFoundError(error)) return [];
@@ -416,28 +424,6 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		});
 	}
 
-	if (options.entryLimit !== undefined) {
-		scannedCompleteRoot = false;
-		const limit = Math.max(0, Math.floor(options.entryLimit));
-		entries = entries
-			.map((entry) => {
-				try {
-					return { entry, mtimeMs: fs.statSync(path.join(asyncDirRoot, entry, "status.json")).mtimeMs };
-				} catch (error) {
-					if (isNotFoundError(error)) return undefined;
-					throw new Error(`Failed to inspect async status file for '${entry}': ${getErrorMessage(error)}`, {
-						cause: error instanceof Error ? error : undefined,
-					});
-				}
-			})
-			.filter((candidate): candidate is { entry: string; mtimeMs: number } => candidate !== undefined)
-			.sort((left, right) => right.mtimeMs - left.mtimeMs)
-			.slice(0, limit)
-			.map((candidate) => candidate.entry);
-	}
-
-	if (scannedCompleteRoot) pruneStatusCacheForAsyncRoot(asyncDirRoot, entries);
-
 	const allowedStates = options.states ? new Set(options.states) : undefined;
 	const runs: AsyncRunSummary[] = [];
 	// Route resolution for every run shares a single index built from the
@@ -448,7 +434,7 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 	let nestedRouteIndex: Map<string, NestedRoute> | undefined;
 	const resolveNestedRoute = (rootRunId: string): NestedRoute | undefined => {
 		if (!includeNested) return undefined;
-		if (usedActiveIndex) return findNestedRouteForRootId(rootRunId);
+		if (activeEntries.has(rootRunId)) return findNestedRouteForRootId(rootRunId);
 		if (!nestedRouteIndex) nestedRouteIndex = buildNestedRouteIndex();
 		return nestedRouteIndex.get(rootRunId);
 	};
@@ -459,10 +445,10 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 			: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
 		if (!status) {
-			if (usedActiveIndex) updateActiveRunIndex(asyncDir, "failed");
+			if (activeEntries.has(entry)) updateActiveRunIndex(asyncDir, "failed");
 			continue;
 		}
-		if (usedActiveIndex && !isActiveAsyncState(status.state)) {
+		if (activeEntries.has(entry) && !isActiveAsyncState(status.state)) {
 			const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId });
 			if (processTerminal?.state === "observed" || (activeRunMarkerAgeMs(asyncDir, options.now?.()) ?? 0) > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS) releaseActiveRunIndex(asyncDir);
 		}

package/src/runs/background/chain-append.ts

@@ -5,8 +5,8 @@ import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { appendJsonl } from "../../shared/artifacts.ts";
 import type { AsyncParallelGroupStatus, AsyncStatus, WorkflowGraphNode, WorkflowGraphSnapshot } from "../../shared/types.ts";
 import { PROMPT_REDACTED, readStatus } from "../../shared/utils.ts";
-import type { DynamicRunnerGroup, ParallelStepGroup, RunnerStep, RunnerSubagentStep, RunnerCheckpointStep } from "../shared/parallel-utils.ts";
-import { isCheckpointRunnerStep, isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
+import type { DynamicRunnerGroup, ParallelStepGroup, RunnerStep, RunnerSubagentStep } from "../shared/parallel-utils.ts";
+import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
 
 const APPEND_REQUESTS_DIR = "append-requests";
 
@@ -52,9 +52,7 @@ export function countPendingChainAppendRequests(asyncDir: string): number {
 export function runnerStepOutputNames(steps: RunnerStep[]): string[] {
 	const names: string[] = [];
 	for (const step of steps) {
-		if (isCheckpointRunnerStep(step)) {
-			continue;
-		} else if (isParallelGroup(step)) {
+		if (isParallelGroup(step)) {
 			names.push(...step.parallel.map((task) => task.outputName).filter((name): name is string => Boolean(name)));
 		} else if (isDynamicRunnerGroup(step)) {
 			if (step.collect.as) names.push(step.collect.as);
@@ -181,20 +179,7 @@ function statusStepForTask(task: RunnerSubagentStep): StatusStep {
 	};
 }
 
-function statusStepForCheckpoint(step: RunnerCheckpointStep, stepIndex: number): StatusStep {
-	return {
-		agent: `checkpoint:${step.checkpoint}`,
-		phase: step.phase,
-		label: step.label ?? step.checkpoint,
-		status: "pending",
-		checkpoint: { name: step.checkpoint, ...(step.message ? { message: step.message } : {}), status: "pending", stepIndex },
-		recentTools: [],
-		recentOutput: [],
-	};
-}
-
 function statusStepsForRunnerStep(step: RunnerStep, stepIndex: number): StatusStep[] {
-	if (isCheckpointRunnerStep(step)) return [statusStepForCheckpoint(step, stepIndex)];
 	if (isParallelGroup(step)) return step.parallel.map(statusStepForTask);
 	if (isDynamicRunnerGroup(step)) {
 		return [{
@@ -286,21 +271,6 @@ function graphNodeForDynamic(step: DynamicRunnerGroup, stepIndex: number): Workf
 
 function appendWorkflowNode(graph: WorkflowGraphSnapshot | undefined, step: RunnerStep, stepIndex: number, flatIndex: number): void {
 	if (!graph) return;
-	if (isCheckpointRunnerStep(step)) {
-		const node: WorkflowGraphNode = {
-			id: `step-${stepIndex}`,
-			kind: "checkpoint",
-			phase: step.phase,
-			label: step.label?.trim() || step.checkpoint,
-			status: "pending",
-			flatIndex,
-			stepIndex,
-			checkpoint: { name: step.checkpoint, ...(step.message ? { message: step.message } : {}), status: "pending", stepIndex },
-		};
-		graph.nodes.push(node);
-		pushPhase(graph, step.phase, node.id);
-		return;
-	}
 	if (isParallelGroup(step)) {
 		graph.nodes.push(graphNodeForParallel(step, stepIndex, flatIndex, graph));
 		return;

package/src/runs/background/completion-dedupe.ts

@@ -3,6 +3,7 @@ interface CompletionDataLike {
 	agent?: unknown;
 	timestamp?: unknown;
 	sessionId?: unknown;
+	state?: unknown;
 	taskIndex?: unknown;
 	totalTasks?: unknown;
 	success?: unknown;
@@ -22,7 +23,10 @@ function asFiniteNumber(value: unknown): number | undefined {
 export function buildCompletionKey(data: CompletionDataLike, fallback: string): string {
 	const sessionId = asNonEmptyString(data.sessionId) ?? "no-session";
 	const id = asNonEmptyString(data.id);
-	if (id) return `session:${sessionId}:id:${id}`;
+	const state = asNonEmptyString(data.state);
+	if (id) return state
+		? `session:${sessionId}:id:${id}:state:${state}`
+		: `session:${sessionId}:id:${id}`;
 	const agent = asNonEmptyString(data.agent) ?? "unknown";
 	const timestamp = asFiniteNumber(data.timestamp);
 	const taskIndex = asFiniteNumber(data.taskIndex);

package/src/runs/background/completion-replay.ts

@@ -14,6 +14,7 @@ const lastCleanupByResultsDir = new Map<string, number>();
 
 export interface CompletionArchiveEntry {
 	agent?: string;
+	resultIndex?: number;
 	source: "output-artifact" | "session" | "result-tail";
 	path?: string;
 	text?: string;
@@ -71,39 +72,45 @@ function outputArtifactPath(child: Record<string, unknown>): string | undefined
 /** Create a small archive that references saved child artifacts and retains only bounded fallback output text. */
 export function writeCompletionArchive(resultsDir: string, runId: string, data: Record<string, unknown>, createdAt: number): string {
 	const entries: CompletionArchiveEntry[] = [];
-	const fallback: string[] = [];
 	const results = Array.isArray(data.results) ? data.results : [];
-	for (const value of results) {
+	for (let resultIndex = 0; resultIndex < results.length; resultIndex++) {
+		const value = results[resultIndex];
 		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
 		const child = value as Record<string, unknown>;
 		const agent = nonEmptyString(child.agent);
 		const artifactPath = outputArtifactPath(child);
 		if (artifactPath) {
-			entries.push({ ...(agent ? { agent } : {}), source: "output-artifact", path: artifactPath });
+			entries.push({ ...(agent ? { agent } : {}), resultIndex, source: "output-artifact", path: artifactPath });
 			continue;
 		}
 		const sessionPath = existingFile(child.sessionFile);
 		if (sessionPath) {
-			entries.push({ ...(agent ? { agent } : {}), source: "session", path: sessionPath });
+			entries.push({ ...(agent ? { agent } : {}), resultIndex, source: "session", path: sessionPath });
 			continue;
 		}
 		const output = nonEmptyString(child.output);
 		const error = nonEmptyString(child.error);
 		if (output || error) {
-			fallback.push([agent ? `[${agent}]` : undefined, error ? `Error: ${error}` : undefined, output].filter(Boolean).join("\n"));
+			const bounded = utf8Tail([error ? `Error: ${error}` : undefined, output].filter(Boolean).join("\n"), ARCHIVE_TEXT_LIMIT_BYTES);
+			entries.push({
+				...(agent ? { agent } : {}),
+				resultIndex,
+				source: "result-tail",
+				text: bounded.text,
+				...(bounded.truncated ? { truncated: true } : {}),
+			});
 		}
 	}
 	if (results.length === 0) {
 		const sessionPath = existingFile(data.sessionFile);
 		if (sessionPath) entries.push({ source: "session", path: sessionPath });
 	}
-	if (entries.length === 0 && fallback.length === 0) {
+	if (entries.length === 0) {
 		const summary = nonEmptyString(data.summary);
-		if (summary) fallback.push(summary);
-	}
-	if (fallback.length > 0) {
-		const bounded = utf8Tail(fallback.join("\n\n"), ARCHIVE_TEXT_LIMIT_BYTES);
-		entries.push({ source: "result-tail", text: bounded.text, ...(bounded.truncated ? { truncated: true } : {}) });
+		if (summary) {
+			const bounded = utf8Tail(summary, ARCHIVE_TEXT_LIMIT_BYTES);
+			entries.push({ source: "result-tail", text: bounded.text, ...(bounded.truncated ? { truncated: true } : {}) });
+		}
 	}
 	const archive: CompletionArchive = { version: ARCHIVE_VERSION, runId, createdAt, entries };
 	const archivePath = completionArchivePath(resultsDir, runId);
@@ -165,6 +172,7 @@ function parseArchive(value: unknown): CompletionArchive | undefined {
 		if (entry.source !== "output-artifact" && entry.source !== "session" && entry.source !== "result-tail") return [];
 		return [{
 			...(typeof entry.agent === "string" ? { agent: entry.agent } : {}),
+			...(typeof entry.resultIndex === "number" && Number.isSafeInteger(entry.resultIndex) && entry.resultIndex >= 0 ? { resultIndex: entry.resultIndex } : {}),
 			source: entry.source,
 			...(typeof entry.path === "string" ? { path: entry.path } : {}),
 			...(typeof entry.text === "string" ? { text: entry.text } : {}),
@@ -228,7 +236,9 @@ export function readCompletionReplay(resultsDir: string, runId: string, options:
 
 export function readCompletionArchive(archivePath: string): CompletionArchive | undefined {
 	try {
-		return parseArchive(JSON.parse(fs.readFileSync(archivePath, "utf-8")));
+		const archive = parseArchive(JSON.parse(fs.readFileSync(archivePath, "utf-8")));
+		if (!archive) throw new Error("Completion archive is malformed.");
+		return archive;
 	} catch (error) {
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
 		throw error;

package/src/runs/background/control-channel.ts

@@ -18,6 +18,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { POLL_INTERVAL_MS } from "../../shared/types.ts";
+import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.ts";
 import { resolveWatchPath } from "../../shared/utils.ts";
 
 export type ControlChannelFs = Pick<typeof fs, "mkdirSync" | "existsSync" | "rmSync" | "watch" | "readdirSync" | "readFileSync" | "realpathSync">;
@@ -56,13 +57,6 @@ export interface StopRequest {
 	reason?: string;
 }
 
-export interface CheckpointDecisionRequest {
-	type: "approve-checkpoint" | "reject-checkpoint";
-	ts?: number;
-	source?: string;
-	reason?: string;
-}
-
 export type SteerDeliveryMode = "steer" | "follow_up" | "auto";
 export type SteerDeliveryStatus = "delivered" | "queued";
 
@@ -127,14 +121,6 @@ export function stopRequestPath(asyncDir: string): string {
 	return path.join(controlInboxDir(asyncDir), "stop.json");
 }
 
-export function approveCheckpointRequestPath(asyncDir: string): string {
-	return path.join(controlInboxDir(asyncDir), "approve-checkpoint.json");
-}
-
-export function rejectCheckpointRequestPath(asyncDir: string): string {
-	return path.join(controlInboxDir(asyncDir), "reject-checkpoint.json");
-}
-
 /** Directory of parent-to-runner steering requests. */
 export function steerRequestsDir(asyncDir: string): string {
 	return path.join(controlInboxDir(asyncDir), STEER_REQUESTS_DIR);
@@ -144,8 +130,8 @@ export function steerInboxClosedPath(asyncDir: string): string {
 	return path.join(controlInboxDir(asyncDir), STEER_INBOX_CLOSED_FILE);
 }
 
-export function closeSteerInbox(asyncDir: string, state: string): void {
-	writeAtomicJson(steerInboxClosedPath(asyncDir), { version: 1, closedAt: Date.now(), state });
+export function closeSteerInbox(asyncDir: string, state: string, write: (filePath: string, payload: object) => void = writeAtomicJson): void {
+	write(steerInboxClosedPath(asyncDir), { version: 1, closedAt: Date.now(), state });
 }
 
 /** Per-child inbox consumed by the child prompt runtime inside the Pi process. */
@@ -299,18 +285,6 @@ export function requestAsyncStop(
 	return requestPath;
 }
 
-export function requestAsyncCheckpointDecision(
-	asyncDir: string,
-	type: CheckpointDecisionRequest["type"],
-	payload: Omit<CheckpointDecisionRequest, "type"> = {},
-	deps: { now?: () => number } = {},
-): string {
-	const requestPath = type === "approve-checkpoint" ? approveCheckpointRequestPath(asyncDir) : rejectCheckpointRequestPath(asyncDir);
-	const request: CheckpointDecisionRequest = { ...payload, ts: payload.ts ?? deps.now?.() ?? Date.now(), type };
-	writeAtomicJson(requestPath, request);
-	return requestPath;
-}
-
 export function requestAsyncSteer(
 	asyncDir: string,
 	payload: { message: string; mode?: SteerDeliveryMode; targetIndex?: number; targetIndexes?: number[]; source?: string; id?: string; ts?: number },
@@ -559,21 +533,6 @@ export function consumeStopRequest(
 	return true;
 }
 
-export function consumeCheckpointDecisionRequest(
-	asyncDir: string,
-	fsImpl: Pick<typeof fs, "existsSync" | "rmSync"> = fs,
-): "approved" | "rejected" | undefined {
-	if (fsImpl.existsSync(rejectCheckpointRequestPath(asyncDir))) {
-		try { fsImpl.rmSync(rejectCheckpointRequestPath(asyncDir), { force: true, recursive: true }); } catch {}
-		return "rejected";
-	}
-	if (fsImpl.existsSync(approveCheckpointRequestPath(asyncDir))) {
-		try { fsImpl.rmSync(approveCheckpointRequestPath(asyncDir), { force: true, recursive: true }); } catch {}
-		return "approved";
-	}
-	return undefined;
-}
-
 /** Parent side: write the authoritative portable interrupt request. */
 export function deliverInterruptRequest(input: {
 	asyncDir: string;
@@ -605,21 +564,6 @@ export function deliverStopRequest(input: {
 	requestAsyncStop(input.asyncDir, input.source ? { source: input.source } : {}, { now: input.now });
 }
 
-export function deliverCheckpointDecisionRequest(input: {
-	asyncDir: string;
-	decision: "approved" | "rejected";
-	now?: () => number;
-	source?: string;
-	reason?: string;
-}): void {
-	requestAsyncCheckpointDecision(
-		input.asyncDir,
-		input.decision === "approved" ? "approve-checkpoint" : "reject-checkpoint",
-		{ ...(input.source ? { source: input.source } : {}), ...(input.reason ? { reason: input.reason } : {}) },
-		{ now: input.now },
-	);
-}
-
 /**
  * Runner side: watch the control inbox and route interrupt requests into
  * `onInterrupt`. Uses `fs.watch` when available and starts interval polling
@@ -633,11 +577,11 @@ export function watchAsyncControlInbox(
 		onTimeout?: () => void;
 		onStop?: () => void;
 		onSteer?: (request: SteerRequest) => void;
-		onCheckpointDecision?: (decision: "approved" | "rejected") => void;
 		onSteerCapability?: (capability: SteerCapability) => void;
 		onSteerAck?: (ack: SteerAck) => void;
 		pollIntervalMs?: number;
 		safetyPollIntervalMs?: number;
+		platform?: NodeJS.Platform;
 		fs?: ControlChannelFs;
 		timers?: ControlChannelTimers;
 	},
@@ -658,8 +602,6 @@ export function watchAsyncControlInbox(
 			if (consumeStopRequest(asyncDir, fsImpl)) opts.onStop?.();
 			if (consumeTimeoutRequest(asyncDir, fsImpl)) opts.onTimeout?.();
 			if (consumeInterruptRequest(asyncDir, fsImpl)) opts.onInterrupt();
-			const checkpointDecision = consumeCheckpointDecisionRequest(asyncDir, fsImpl);
-			if (checkpointDecision) opts.onCheckpointDecision?.(checkpointDecision);
 			for (const request of consumeSteerRequests(asyncDir, fsImpl)) opts.onSteer?.(request);
 			for (const capability of consumeSteerCapabilities(asyncDir, fsImpl)) opts.onSteerCapability?.(capability);
 			for (const ack of consumeSteerAcks(asyncDir, fsImpl)) opts.onSteerAck?.(ack);
@@ -707,12 +649,16 @@ export function watchAsyncControlInbox(
 		for (const entry of entries) watchDir(path.join(ackRoot, entry));
 	};
 	try {
-		watchDir(dir);
-		watchDir(steerRequestsDir(asyncDir), true);
-		watchDir(steerCapabilitiesDir(asyncDir), true);
-		watchDir(path.join(dir, STEER_ACKS_DIR), true);
-		watchExistingSteerAckDirs();
-		startSafetyPolling();
+		if (shouldUseNativeFsWatch("runner-control-inbox", opts.platform)) {
+			watchDir(dir);
+			watchDir(steerRequestsDir(asyncDir), true);
+			watchDir(steerCapabilitiesDir(asyncDir), true);
+			watchDir(path.join(dir, STEER_ACKS_DIR), true);
+			watchExistingSteerAckDirs();
+			startSafetyPolling();
+		} else {
+			startPolling();
+		}
 	} catch {
 		startPolling();
 	}

package/src/runs/background/fleet-view.ts

@@ -156,34 +156,83 @@ function stringifyJsonPreview(value: unknown, maxLength = 240): string {
 	return raw.length > maxLength ? `${raw.slice(0, maxLength)}…` : raw;
 }
 
-function contentText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content.map((part) => {
-		if (!part || typeof part !== "object") return "";
-		const entry = part as { type?: unknown; text?: unknown; name?: unknown; toolName?: unknown; args?: unknown; result?: unknown; content?: unknown };
-		if (typeof entry.text === "string") return entry.text;
+/** One structured content part of a session JSONL record. Shared by the prose transcript formatter and inspect RPC. */
+export interface SessionTranscriptMessage {
+	role: string;
+	kind: "text" | "toolCall" | "toolResult";
+	text: string;
+	name?: string;
+	isError?: boolean;
+	/** Ordinal of the session record this part came from, so consumers can
+	 *  regroup multi-part messages (one session record can yield several parts). */
+	recordIndex?: number;
+}
+
+function sessionMessageParts(record: unknown): SessionTranscriptMessage[] {
+	if (!record || typeof record !== "object") return [];
+	const outer = record as { message?: unknown; role?: unknown; content?: unknown; type?: unknown };
+	const message = outer.message && typeof outer.message === "object" ? outer.message as { role?: unknown; content?: unknown } : outer;
+	const role = typeof message.role === "string" ? message.role : undefined;
+	if (!role) return [];
+	const content = message.content;
+	if (typeof content === "string") return content.trim() ? [{ role, kind: "text", text: content }] : [];
+	if (!Array.isArray(content)) return [];
+	const parts: SessionTranscriptMessage[] = [];
+	for (const part of content) {
+		if (!part || typeof part !== "object") continue;
+		const entry = part as { type?: unknown; text?: unknown; name?: unknown; toolName?: unknown; args?: unknown; result?: unknown; content?: unknown; isError?: unknown };
+		if (typeof entry.text === "string") {
+			if (entry.text.trim()) parts.push({ role, kind: "text", text: entry.text });
+			continue;
+		}
 		if (entry.type === "toolCall" || entry.type === "tool_call") {
 			const name = typeof entry.name === "string" ? entry.name : typeof entry.toolName === "string" ? entry.toolName : "tool";
-			return `[tool: ${name}${entry.args === undefined ? "" : ` ${stringifyJsonPreview(entry.args)}`}]`;
+			parts.push({ role, kind: "toolCall", name, text: `[tool: ${name}${entry.args === undefined ? "" : ` ${stringifyJsonPreview(entry.args)}`}]` });
+			continue;
 		}
 		if (entry.type === "toolResult" || entry.type === "tool_result") {
-			return `[tool result${entry.result === undefined ? "" : `: ${stringifyJsonPreview(entry.result)}`}]`;
+			const name = typeof entry.name === "string" ? entry.name : typeof entry.toolName === "string" ? entry.toolName : undefined;
+			parts.push({ role, kind: "toolResult", ...(name ? { name } : {}), ...(entry.isError === true ? { isError: true } : {}), text: `[tool result${entry.result === undefined ? "" : `: ${stringifyJsonPreview(entry.result)}`}]` });
+			continue;
+		}
+		if (entry.content !== undefined) {
+			const preview = stringifyJsonPreview(entry.content);
+			if (preview.trim()) parts.push({ role, kind: "text", text: preview });
 		}
-		if (entry.content !== undefined) return stringifyJsonPreview(entry.content);
-		return "";
-	}).filter(Boolean).join("\n");
+	}
+	return parts;
 }
 
 function sessionMessageLine(record: unknown): string | undefined {
-	if (!record || typeof record !== "object") return undefined;
-	const outer = record as { message?: unknown; role?: unknown; content?: unknown; type?: unknown };
-	const message = outer.message && typeof outer.message === "object" ? outer.message as { role?: unknown; content?: unknown } : outer;
-	const role = typeof message.role === "string" ? message.role : undefined;
-	if (!role) return undefined;
-	const text = contentText(message.content).trim();
+	const parts = sessionMessageParts(record);
+	if (parts.length === 0) return undefined;
+	const text = parts.map((part) => part.text).join("\n").trim();
 	if (!text) return undefined;
-	return `${role}: ${text}`;
+	return `${parts[0]!.role}: ${text}`;
+}
+
+/** Structured session tail: parsed content parts, newest last, bounded by
+ *  maxMessages. Same trusted-root containment as the prose transcript tail. */
+export function readSessionMessagesTail(sessionFile: string, maxMessages: number, trustedRoots: string[]): { messages: SessionTranscriptMessage[]; warnings: string[]; truncated: boolean } {
+	const tail = readContainedTextTail(sessionFile, Math.max(maxMessages * 4, maxMessages), trustedRoots, "session");
+	const warnings: string[] = [];
+	if (tail.error) warnings.push(`Session read failed for ${sessionFile}: ${tail.error}`);
+	const parsedMessages: SessionTranscriptMessage[] = [];
+	let malformed = 0;
+	let recordIndex = 0;
+	for (const line of tail.lines) {
+		if (!line.trim()) continue;
+		try {
+			const parsed = JSON.parse(line) as unknown;
+			for (const part of sessionMessageParts(parsed)) parsedMessages.push({ ...part, recordIndex });
+		} catch {
+			malformed++;
+		}
+		recordIndex++;
+	}
+	if (malformed > 0) warnings.push(`Skipped ${malformed} malformed session tail line${malformed === 1 ? "" : "s"}.`);
+	const messages = parsedMessages.slice(-maxMessages);
+	return { messages, warnings, truncated: tail.truncated || parsedMessages.length > messages.length };
 }
 
 function readSessionTranscriptTail(sessionFile: string, maxLines: number, trustedRoots: string[]): { lines: string[]; warnings: string[] } {