@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/src/runs/background/async-status-snapshot.ts

@@ -227,12 +227,21 @@ function snapshotBytes(snapshot: AsyncStatusSnapshotV1): number {
 }
 
 function enforceByteLimit(snapshot: AsyncStatusSnapshotV1): void {
-	while (snapshot.runs.length > 0 && snapshotBytes(snapshot) > snapshot.caps.maxSerializedBytes) {
-		snapshot.runs.pop();
-		snapshot.omitted.runs += 1;
-		snapshot.omitted.byteLimitExceeded = true;
+	if (snapshotBytes(snapshot) <= snapshot.caps.maxSerializedBytes) return;
+	snapshot.omitted.byteLimitExceeded = true;
+	const runs = snapshot.runs;
+	const initialOmittedRuns = snapshot.omitted.runs;
+	let lower = 0;
+	let upper = Math.max(0, runs.length - 1);
+	while (lower < upper) {
+		const retained = Math.ceil((lower + upper) / 2);
+		snapshot.runs = runs.slice(0, retained);
+		snapshot.omitted.runs = initialOmittedRuns + runs.length - retained;
+		if (snapshotBytes(snapshot) <= snapshot.caps.maxSerializedBytes) lower = retained;
+		else upper = retained - 1;
 	}
-	if (snapshotBytes(snapshot) > snapshot.caps.maxSerializedBytes) snapshot.omitted.byteLimitExceeded = true;
+	snapshot.runs = runs.slice(0, lower);
+	snapshot.omitted.runs = initialOmittedRuns + runs.length - lower;
 }
 
 export function buildAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, options: AsyncStatusSnapshotOptions = {}): AsyncStatusSnapshotV1 {

package/dist/extensions/pi-subagents/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,17 +13,22 @@ 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";
+import { asyncStatusChildIdentity } from "../shared/child-identity.ts";
 
 interface AsyncRunStepSummary {
 	index: number;
+	childId?: string;
 	agent: string;
 	context?: ContextMode;
 	label?: string;
 	description?: string;
 	phase?: string;
+	workflowKey?: string;
+	runId?: string;
 	outputName?: string;
 	structured?: boolean;
-	checkpoint?: ChainCheckpointState;
 	status: AsyncJobStep["status"];
 	runner?: AsyncJobStep["runner"];
 	activityState?: ActivityState;
@@ -83,6 +88,7 @@ export interface AsyncRunSummary {
 	mode: SubagentRunMode;
 	context?: ContextSummary;
 	cwd?: string;
+	sessionRoot?: string;
 	startedAt: number;
 	lastUpdate?: number;
 	endedAt?: number;
@@ -98,7 +104,6 @@ export interface AsyncRunSummary {
 	pendingAppends?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	steps: AsyncRunStepSummary[];
-	checkpoint?: ChainCheckpointState;
 	sessionDir?: string;
 	outputFile?: string;
 	totalTokens?: TokenUsage;
@@ -121,17 +126,19 @@ export interface AsyncRunSummary {
 interface AsyncRunListOptions {
 	states?: Array<AsyncRunSummary["state"]>;
 	sessionId?: string;
-	/** Accept runs owned by any of these session identities (union). */
-	sessionIds?: 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 {
@@ -159,7 +166,7 @@ function isAsyncRunDir(root: string, entry: string): boolean {
 
 type TargetedAsyncRunResolution =
 	| { kind: "exact"; id: string }
-	| { kind: "scan" }
+	| { kind: "prefix" }
 	| { kind: "reject" };
 
 /**
@@ -167,13 +174,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,
 		});
@@ -191,7 +198,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 };
 }
@@ -248,14 +255,16 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		const stepLastActivityAt = step.lastActivityAt;
 		return {
 			index,
+			childId: asyncStatusChildIdentity(step, index),
 			agent: step.agent,
 			...(step.context ? { context: step.context } : {}),
 			...(step.label ? { label: step.label } : {}),
 			...(step.description ? { description: step.description } : {}),
 			...(step.phase ? { phase: step.phase } : {}),
+			...(step.workflowKey ? { workflowKey: step.workflowKey } : {}),
+			...(step.runId ? { runId: step.runId } : {}),
 			...(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 } : {}),
@@ -275,12 +284,15 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.skills ? { skills: step.skills } : {}),
 			...(step.model ? { model: step.model } : {}),
 			...(step.thinking ? { thinking: step.thinking } : {}),
+			...(step.thinkingCeiling ? { thinkingCeiling: step.thinkingCeiling } : {}),
 			...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
 			...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
 			...(step.transcriptPath ? { transcriptPath: step.transcriptPath } : {}),
 			...(step.error ? { error: step.error } : {}),
 			...(step.timedOut !== undefined ? { timedOut: step.timedOut } : {}),
 			...(step.stopped !== undefined ? { stopped: step.stopped } : {}),
+			...(step.stopRequested !== undefined ? { stopRequested: step.stopRequested } : {}),
+			...(step.stopRequestedAt !== undefined ? { stopRequestedAt: step.stopRequestedAt } : {}),
 			...(step.turnBudget ? { turnBudget: step.turnBudget } : {}),
 			...(step.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: step.turnBudgetExceeded } : {}),
 			...(step.wrapUpRequested !== undefined ? { wrapUpRequested: step.wrapUpRequested } : {}),
@@ -317,6 +329,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,
@@ -332,7 +345,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 } : {}),
@@ -381,35 +393,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 [];
@@ -418,28 +434,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
@@ -450,7 +444,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);
 	};
@@ -461,10 +455,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);
 		}
@@ -475,7 +469,6 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		// match.
 		if (allowedStates && !allowedStates.has(status.state)) continue;
 		if (options.sessionId && status.sessionId !== options.sessionId) continue;
-		if (options.sessionIds && (status.sessionId === undefined || !options.sessionIds.includes(status.sessionId))) continue;
 		const nestedWarnings: string[] = [];
 		let nestedRoute: NestedRoute | undefined;
 		if (options.reconcile !== false && includeNested) {

package/dist/extensions/pi-subagents/src/runs/background/auto-drain.ts

@@ -58,6 +58,7 @@ export async function drainOutstandingWork(deps: AutoDrainDeps): Promise<void> {
 				now,
 				stopOnAttention: false,
 				failOnFailedRuns: true,
+				failOnAttention: true,
 			},
 		);
 		if (waitResult.isError) {

package/dist/extensions/pi-subagents/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/dist/extensions/pi-subagents/src/runs/background/chain-root-attachment.ts

@@ -21,6 +21,7 @@ export interface ImportedAsyncRootResult {
 	model?: string;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
+	contextOverflow?: boolean;
 	totalCost?: CostSummary;
 	structuredOutput?: unknown;
 	structuredOutputPath?: string;
@@ -49,6 +50,7 @@ interface AsyncResultFile {
 		model?: string;
 		attemptedModels?: string[];
 		modelAttempts?: ModelAttempt[];
+		contextOverflow?: boolean;
 		totalCost?: CostSummary;
 		structuredOutput?: unknown;
 		structuredOutputPath?: string;
@@ -110,6 +112,7 @@ function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus,
 		...(step?.model ? { model: step.model } : {}),
 		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
 		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.contextOverflow ? { contextOverflow: true } : {}),
 		...(step?.totalCost ? { totalCost: step.totalCost } : {}),
 		...(step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
 		...(step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {}),
@@ -131,6 +134,7 @@ function outputFromTimeout(root: ImportedAsyncRoot, status: AsyncStatus | null,
 		...(step?.model ? { model: step.model } : {}),
 		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
 		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.contextOverflow ? { contextOverflow: true } : {}),
 		...(step?.totalCost ? { totalCost: step.totalCost } : {}),
 	};
 }
@@ -158,6 +162,7 @@ function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null
 		...(child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {}),
 		...(child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {}),
 		...(child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {}),
+		...(child?.contextOverflow || step?.contextOverflow ? { contextOverflow: true } : {}),
 		...(child?.totalCost ?? step?.totalCost ? { totalCost: child?.totalCost ?? step?.totalCost } : {}),
 		...(child?.structuredOutput !== undefined ? { structuredOutput: child.structuredOutput } : step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
 		...(child?.structuredOutputPath ?? step?.structuredOutputPath ? { structuredOutputPath: child?.structuredOutputPath ?? step?.structuredOutputPath } : {}),

package/dist/extensions/pi-subagents/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/dist/extensions/pi-subagents/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;