pi-subagents 0.28.0 → 0.30.0

package/src/runs/shared/chain-outputs.ts

@@ -8,6 +8,11 @@ const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 export class ChainOutputValidationError extends Error {}
 
+export interface ChainOutputValidationContext {
+	priorOutputNames?: Iterable<string>;
+	startStepIndex?: number;
+}
+
 function outputNamesForStep(step: ChainStep): string[] {
 	if (isParallelStep(step)) return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
 	if (isDynamicParallelStep(step)) return [step.collect.as];
@@ -22,27 +27,37 @@ function taskTemplatesForStep(step: ChainStep): string[] {
 }
 
 export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutConfig: DynamicFanoutConfig = {}): void {
-	const available = new Set<string>();
-	const seen = new Set<string>();
+	validateChainOutputBindingsWithContext(steps, dynamicFanoutConfig);
+}
+
+export function validateChainOutputBindingsWithContext(
+	steps: ChainStep[],
+	dynamicFanoutConfig: DynamicFanoutConfig = {},
+	context: ChainOutputValidationContext = {},
+): void {
+	const priorOutputNames = [...(context.priorOutputNames ?? [])];
+	const available = new Set<string>(priorOutputNames);
+	const seen = new Set<string>(priorOutputNames);
 	for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+		const displayStepIndex = (context.startStepIndex ?? 0) + stepIndex + 1;
 		const step = steps[stepIndex]!;
 		if (hasDynamicFanoutFields(step)) {
 			if (!isDynamicParallelStep(step)) {
-				throw new ChainOutputValidationError(`Dynamic chain step ${stepIndex + 1} requires expand, a single parallel template object, and collect; dynamic expand/collect cannot be mixed with static parallel arrays.`);
+				throw new ChainOutputValidationError(`Dynamic chain step ${displayStepIndex} requires expand, a single parallel template object, and collect; dynamic expand/collect cannot be mixed with static parallel arrays.`);
 			}
 			try {
-				validateDynamicStepShape(step, stepIndex, dynamicFanoutConfig);
+				validateDynamicStepShape(step, displayStepIndex - 1, dynamicFanoutConfig);
 			} catch (error) {
 				if (error instanceof DynamicFanoutError) throw new ChainOutputValidationError(error.message);
 				throw error;
 			}
 			if (!available.has(step.expand.from.output)) {
-				throw new ChainOutputValidationError(`Dynamic chain step ${stepIndex + 1} references unknown output '${step.expand.from.output}'. Named outputs are only available after producing step/group completes.`);
+				throw new ChainOutputValidationError(`Dynamic chain step ${displayStepIndex} references unknown output '${step.expand.from.output}'. Named outputs are only available after producing step/group completes.`);
 			}
 		}
 		for (const name of outputNamesForStep(step)) {
 			if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-				throw new ChainOutputValidationError(`Invalid chain output name '${name}' at step ${stepIndex + 1}. Use /^[A-Za-z_][A-Za-z0-9_]*$/.`);
+				throw new ChainOutputValidationError(`Invalid chain output name '${name}' at step ${displayStepIndex}. Use /^[A-Za-z_][A-Za-z0-9_]*$/.`);
 			}
 			if (seen.has(name)) {
 				throw new ChainOutputValidationError(`Duplicate chain output name '${name}'. Each as name must be unique.`);
@@ -54,10 +69,10 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 				const rawReference = match[0];
 				const name = match[1]!;
 				if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-					throw new ChainOutputValidationError(`Invalid chain output reference '${rawReference}' at step ${stepIndex + 1}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`);
+					throw new ChainOutputValidationError(`Invalid chain output reference '${rawReference}' at step ${displayStepIndex}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`);
 				}
 				if (!available.has(name)) {
-					throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}' at step ${stepIndex + 1}. Named outputs are only available after producing step/group completes.`);
+					throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}' at step ${displayStepIndex}. Named outputs are only available after producing step/group completes.`);
 				}
 			}
 		}

package/src/runs/shared/completion-guard.ts

@@ -66,17 +66,6 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"contact_supervisor",
 ]);
 
-export type CompletionPolicy = "none" | "mutation-guard" | "acceptance-contract";
-
-interface CompletionPolicyInput {
-	agent: string;
-	task: string;
-	completionGuardEnabled: boolean;
-	usesAcceptanceContract: boolean;
-	tools?: string[];
-	mcpDirectTools?: string[];
-}
-
 interface CompletionMutationGuardInput {
 	agent: string;
 	task: string;
@@ -145,22 +134,10 @@ export function hasMutationToolCall(messages: Message[]): boolean {
 	return false;
 }
 
-export function resolveCompletionPolicy(input: CompletionPolicyInput): CompletionPolicy {
-	if (input.usesAcceptanceContract) return "acceptance-contract";
-	if (!input.completionGuardEnabled) return "none";
-	if (declaresOnlyReadOnlyTools(input.tools, input.mcpDirectTools)) return "none";
-	return expectsImplementationMutation(input.agent, input.task) ? "mutation-guard" : "none";
-}
-
 export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
-	const expectedMutation = resolveCompletionPolicy({
-		agent: input.agent,
-		task: input.task,
-		completionGuardEnabled: true,
-		usesAcceptanceContract: false,
-		tools: input.tools,
-		mcpDirectTools: input.mcpDirectTools,
-	}) === "mutation-guard";
+	const expectedMutation = declaresOnlyReadOnlyTools(input.tools, input.mcpDirectTools)
+		? false
+		: expectsImplementationMutation(input.agent, input.task);
 	const attemptedMutation = hasMutationToolCall(input.messages);
 	return {
 		expectedMutation,

package/src/runs/shared/dynamic-fanout.ts

@@ -48,7 +48,7 @@ const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outpu
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
 	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "maxSubagentDepth",
-	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "mcpDirectTools", "completionGuard", "systemPrompt",
+	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "completionGuard", "systemPrompt",
 	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);

package/src/runs/shared/model-fallback.ts

@@ -20,6 +20,44 @@ export function splitThinkingSuffix(model: string): { baseModel: string; thinkin
 	};
 }
 
+/** Sentinel model value requesting that a subagent inherit the parent session's model. */
+export const INHERIT_MODEL = "inherit";
+
+/** Minimal shape of the parent session's in-memory model (`ctx.model`). */
+export interface ParentModel {
+	provider: string;
+	id: string;
+}
+
+/**
+ * Resolve the `--model` override passed to a spawned subagent.
+ *
+ * When no model is requested (`undefined`, `false`, empty, or the `"inherit"`
+ * sentinel), the child must inherit the parent session's *in-memory* model
+ * (`provider/id`) instead of being left to resolve its own model. Without an
+ * explicit `provider/id`, the child falls back to the global
+ * `~/.pi/agent/settings.json` default, which is shared across every open PI
+ * session — so a different session that last changed its model in the TUI would
+ * silently contaminate this session's subagents (see issue #266). Passing an
+ * explicit `provider/id` keeps each session's children isolated to that
+ * session's model.
+ *
+ * An explicitly requested model string is resolved via {@link resolveModelCandidate}.
+ */
+export function resolveSubagentModelOverride(
+	requestedModel: string | boolean | undefined,
+	parentModel: ParentModel | undefined,
+	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
+): string | undefined {
+	const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
+	const explicit = trimmed && trimmed !== INHERIT_MODEL ? trimmed : undefined;
+	if (explicit === undefined) {
+		return parentModel ? `${parentModel.provider}/${parentModel.id}` : undefined;
+	}
+	return resolveModelCandidate(explicit, availableModels, preferredProvider);
+}
+
 export function resolveModelCandidate(
 	model: string | undefined,
 	availableModels: AvailableModelInfo[] | undefined,

package/src/runs/shared/parallel-utils.ts

@@ -1,9 +1,12 @@
-import type { DynamicCollectSpec, DynamicExpandSpec } from "../../shared/settings.ts";
-import type { JsonSchemaObject, ResolvedAcceptanceConfig } from "../../shared/types.ts";
-
 export interface RunnerSubagentStep {
 	agent: string;
 	task: string;
+	importAsyncRoot?: {
+		runId: string;
+		asyncDir: string;
+		resultPath: string;
+		index: number;
+	};
 	phase?: string;
 	label?: string;
 	outputName?: string;
@@ -14,6 +17,7 @@ export interface RunnerSubagentStep {
 	modelCandidates?: string[];
 	tools?: string[];
 	extensions?: string[];
+	subagentOnlyExtensions?: string[];
 	mcpDirectTools?: string[];
 	completionGuard?: boolean;
 	systemPrompt?: string | null;
@@ -25,15 +29,13 @@ export interface RunnerSubagentStep {
 	outputMode?: "inline" | "file-only";
 	sessionFile?: string;
 	maxSubagentDepth?: number;
-	maxExecutionTimeMs?: number;
-	maxTokens?: number;
 	structuredOutput?: {
-		schema: JsonSchemaObject;
+		schema: import("../../shared/types.ts").JsonSchemaObject;
 		schemaPath: string;
 		outputPath: string;
 	};
-	structuredOutputSchema?: JsonSchemaObject;
-	effectiveAcceptance?: ResolvedAcceptanceConfig;
+	structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
+	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 }
 
 export interface ParallelStepGroup {
@@ -44,13 +46,14 @@ export interface ParallelStepGroup {
 }
 
 export interface DynamicRunnerGroup {
-	expand: DynamicExpandSpec;
+	expand: import("../../shared/settings.ts").DynamicExpandSpec;
 	parallel: RunnerSubagentStep;
-	collect: DynamicCollectSpec;
+	collect: import("../../shared/settings.ts").DynamicCollectSpec;
 	concurrency?: number;
 	failFast?: boolean;
 	phase?: string;
 	label?: string;
+	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 }
 
 export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;

package/src/runs/shared/pi-args.ts

@@ -39,6 +39,7 @@ interface BuildPiArgsInput {
 	inheritSkills: boolean;
 	tools?: string[];
 	extensions?: string[];
+	subagentOnlyExtensions?: string[];
 	systemPrompt?: string | null;
 	mcpDirectTools?: string[];
 	cwd?: string;
@@ -120,11 +121,11 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		: [PROMPT_RUNTIME_EXTENSION_PATH];
 	if (input.extensions !== undefined) {
 		args.push("--no-extensions");
-		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths, ...input.extensions])]) {
+		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths, ...input.extensions, ...(input.subagentOnlyExtensions ?? [])])]) {
 			args.push("--extension", extPath);
 		}
 	} else {
-		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths])]) {
+		for (const extPath of [...new Set([...runtimeExtensions, ...toolExtensionPaths, ...(input.subagentOnlyExtensions ?? [])])]) {
 			args.push("--extension", extPath);
 		}
 	}

package/src/runs/shared/subagent-control.ts

@@ -173,9 +173,8 @@ export function formatControlNoticeMessage(event: ControlEvent, childIntercomTar
 		].filter((line): line is string => Boolean(line)).join("\n");
 	}
 
-	const nudgeCommand = childIntercomTarget
-		? `intercom({ action: "send", to: "${childIntercomTarget}", message: "What are you blocked on? Reply with the smallest next step or ask for a decision." })`
-		: undefined;
+	const nudgeMessage = "What are you blocked on? Reply with the smallest next step or ask for a decision.";
+	const nudgeCommand = `subagent({ action: "resume", id: "${runTarget}", ${event.index !== undefined ? `index: ${event.index}, ` : ""}message: "${nudgeMessage}" })`;
 	if (event.type === "active_long_running") {
 		const facts = formatLongRunningFacts(event);
 		return [
@@ -183,10 +182,9 @@ export function formatControlNoticeMessage(event: ControlEvent, childIntercomTar
 			`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
 			`Signal: ${event.message}`,
 			facts ? `Facts: ${facts}` : undefined,
-			"Hint: Inspect status, then nudge if the work seems stuck.",
-			childIntercomTarget
-				? `Nudge: ${nudgeCommand}`
-				: "Nudge: no child message route registered",
+			"Hint: Inspect status, then nudge if the work seems stuck. Live async nudges interrupt the child before sending the follow-up.",
+			`Nudge: ${nudgeCommand}`,
+			childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
 			`Status: subagent({ action: "status", id: "${runTarget}" })`,
 			`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,
 		].filter((line): line is string => Boolean(line)).join("\n");
@@ -197,10 +195,9 @@ export function formatControlNoticeMessage(event: ControlEvent, childIntercomTar
 		`Run: ${runTarget}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
 		`Signal: ${event.message}`,
 		event.recentFailureSummary ? `Recent failures: ${event.recentFailureSummary}` : undefined,
-		"Hint: Inspect status first unless the run is clearly blocked.",
-		childIntercomTarget
-			? `Nudge: ${nudgeCommand}`
-			: "Nudge: no child message route registered",
+		"Hint: Inspect status first unless the run is clearly blocked. Live async nudges interrupt the child before sending the follow-up.",
+		`Nudge: ${nudgeCommand}`,
+		childIntercomTarget ? `Direct intercom target: ${childIntercomTarget}` : undefined,
 		`Status: subagent({ action: "status", id: "${runTarget}" })`,
 		`Interrupt: subagent({ action: "interrupt", id: "${runTarget}" })`,
 	].filter((line): line is string => Boolean(line)).join("\n");

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -135,14 +135,15 @@ function stripAssistantSubagentToolCallBlocks(message: unknown): unknown | undef
 }
 
 export function stripParentOnlySubagentMessages(messages: unknown[]): unknown[] {
+	const preserveCurrentFanoutToolHistory = process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1";
 	let changed = false;
 	const filtered: unknown[] = [];
 	for (const message of messages) {
-		if (isParentOnlySubagentMessage(message) || isSubagentToolResultMessage(message)) {
+		if (isParentOnlySubagentMessage(message) || (!preserveCurrentFanoutToolHistory && isSubagentToolResultMessage(message))) {
 			changed = true;
 			continue;
 		}
-		const stripped = stripAssistantSubagentToolCallBlocks(message);
+		const stripped = preserveCurrentFanoutToolHistory ? message : stripAssistantSubagentToolCallBlocks(message);
 		if (stripped === undefined) {
 			changed = true;
 			continue;

package/src/runs/shared/workflow-graph.ts

@@ -5,7 +5,7 @@ export interface WorkflowGraphBuildInput {
 	runId: string;
 	mode?: SubagentRunMode;
 	steps: ChainStep[];
-	results?: Array<Pick<SingleResult, "exitCode" | "detached" | "interrupted" | "timedOut" | "error" | "acceptance">>;
+	results?: Array<Pick<SingleResult, "exitCode" | "detached" | "interrupted" | "error" | "acceptance">>;
 	currentFlatIndex?: number;
 	currentStepIndex?: number;
 	stepStatuses?: Array<{ status?: string; error?: string }>;
@@ -26,8 +26,6 @@ function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undef
 			return "paused";
 		case "detached":
 			return "detached";
-		case "timed-out":
-			return "timed-out";
 		case "pending":
 			return "pending";
 		default:
@@ -35,10 +33,9 @@ function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undef
 	}
 }
 
-function resultStatus(result: Pick<SingleResult, "exitCode" | "detached" | "interrupted" | "timedOut"> | undefined): WorkflowNodeStatus | undefined {
+function resultStatus(result: Pick<SingleResult, "exitCode" | "detached" | "interrupted"> | undefined): WorkflowNodeStatus | undefined {
 	if (!result) return undefined;
 	if (result.detached) return "detached";
-	if (result.timedOut) return "timed-out";
 	if (result.interrupted) return "paused";
 	return result.exitCode === 0 ? "completed" : "failed";
 }
@@ -66,7 +63,6 @@ function seqLabel(step: SequentialStep, stepIndex: number): string {
 function summarizeParallelStatuses(statuses: WorkflowNodeStatus[]): WorkflowNodeStatus {
 	if (statuses.some((status) => status === "running")) return "running";
 	if (statuses.some((status) => status === "failed")) return "failed";
-	if (statuses.some((status) => status === "timed-out")) return "timed-out";
 	if (statuses.some((status) => status === "paused")) return "paused";
 	if (statuses.some((status) => status === "detached")) return "detached";
 	if (statuses.length > 0 && statuses.every((status) => status === "completed")) return "completed";

package/src/shared/atomic-json.ts

@@ -1,16 +1,73 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-export function writeAtomicJson(filePath: string, payload: object): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	const tempPath = path.join(
-		path.dirname(filePath),
-		`.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
-	);
-	try {
-		fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
-		fs.renameSync(tempPath, filePath);
-	} finally {
-		fs.rmSync(tempPath, { force: true });
+type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
+
+type AtomicJsonWriterOptions = {
+	fs?: AtomicJsonFs;
+	now?: () => number;
+	pid?: number;
+	random?: () => number;
+	retryRenameErrors?: boolean;
+	retryDelaysMs?: readonly number[];
+	wait?: (delayMs: number) => void;
+};
+
+const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200] as const;
+const RETRYABLE_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+
+function waitSync(delayMs: number): void {
+	const end = Date.now() + delayMs;
+	while (Date.now() < end) {
+		// writeAtomicJson is synchronous because callers often update status from sync callbacks.
 	}
 }
+
+function isRetryableRenameError(error: unknown): boolean {
+	const code = (error as NodeJS.ErrnoException | undefined)?.code;
+	return typeof code === "string" && RETRYABLE_RENAME_ERROR_CODES.has(code);
+}
+
+function renameWithRetry(
+	fsImpl: AtomicJsonFs,
+	sourcePath: string,
+	targetPath: string,
+	retryDelaysMs: readonly number[],
+	wait: (delayMs: number) => void,
+): void {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			fsImpl.renameSync(sourcePath, targetPath);
+			return;
+		} catch (error) {
+			const delayMs = retryDelaysMs[attempt];
+			if (delayMs === undefined || !isRetryableRenameError(error)) throw error;
+			wait(delayMs);
+		}
+	}
+}
+
+export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
+	const fsImpl = options.fs ?? fs;
+	const now = options.now ?? Date.now;
+	const pid = options.pid ?? process.pid;
+	const random = options.random ?? Math.random;
+	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
+	const retryDelaysMs = retryRenameErrors ? options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS : [];
+	const wait = options.wait ?? waitSync;
+	return (filePath: string, payload: object): void => {
+		fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+		const tempPath = path.join(
+			path.dirname(filePath),
+			`.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,
+		);
+		try {
+			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
+			renameWithRetry(fsImpl, tempPath, filePath, retryDelaysMs, wait);
+		} finally {
+			fsImpl.rmSync(tempPath, { force: true });
+		}
+	};
+}
+
+export const writeAtomicJson = createAtomicJsonWriter();

package/src/shared/settings.ts

@@ -103,6 +103,7 @@ export interface DynamicParallelStep {
 	failFast?: boolean;
 	phase?: string;
 	label?: string;
+	acceptance?: AcceptanceInput;
 }
 
 /** Parallel step: multiple agents running concurrently */

package/src/shared/types.ts

@@ -30,7 +30,7 @@ export interface ChainOutputMapEntry {
 
 export type ChainOutputMap = Record<string, ChainOutputMapEntry>;
 
-export type WorkflowNodeStatus = "pending" | "running" | "completed" | "failed" | "paused" | "detached" | "timed-out";
+export type WorkflowNodeStatus = "pending" | "running" | "completed" | "failed" | "paused" | "detached";
 
 export interface WorkflowGraphNode {
 	id: string;
@@ -142,7 +142,7 @@ export interface ControlEvent {
 	recentFailureSummary?: string;
 }
 
-export type SubagentResultStatus = "completed" | "failed" | "paused" | "detached" | "timed-out";
+export type SubagentResultStatus = "completed" | "failed" | "paused" | "detached";
 export type SubagentRunMode = "single" | "parallel" | "chain";
 
 export type PublicNestedStepSummary = Pick<
@@ -239,7 +239,7 @@ export interface ModelAttempt {
 	usage?: Usage;
 }
 
-export type AcceptanceProvenanceLevel = "none" | "attested" | "checked" | "verified" | "reviewed";
+export type AcceptanceLevel = "auto" | "none" | "attested" | "checked" | "verified" | "reviewed";
 
 export type AcceptanceEvidenceKind =
 	| "changed-files"
@@ -275,15 +275,16 @@ export interface AcceptanceReviewGate {
 }
 
 export interface AcceptanceConfig {
+	level?: AcceptanceLevel;
 	criteria?: Array<string | AcceptanceGate>;
 	evidence?: AcceptanceEvidenceKind[];
 	verify?: AcceptanceVerifyCommand[];
-	review?: AcceptanceReviewGate;
+	review?: AcceptanceReviewGate | false;
 	stopRules?: string[];
-	maxFinalizationTurns?: number;
+	reason?: string;
 }
 
-export type AcceptanceInput = AcceptanceConfig;
+export type AcceptanceInput = AcceptanceLevel | false | AcceptanceConfig;
 
 export interface ResolvedAcceptanceGate extends AcceptanceGate {
 	id: string;
@@ -293,18 +294,15 @@ export interface ResolvedAcceptanceGate extends AcceptanceGate {
 }
 
 export interface ResolvedAcceptanceConfig {
-	level: AcceptanceProvenanceLevel;
+	level: Exclude<AcceptanceLevel, "auto">;
 	explicit: boolean;
 	inferredReason: string[];
 	criteria: ResolvedAcceptanceGate[];
 	evidence: AcceptanceEvidenceKind[];
 	verify: AcceptanceVerifyCommand[];
-	review?: AcceptanceReviewGate;
+	review?: AcceptanceReviewGate | false;
 	stopRules: string[];
-	finalization: {
-		mode: "none" | "self-review-loop";
-		maxTurns: number;
-	};
+	reason?: string;
 }
 
 export interface AcceptanceReport {
@@ -368,25 +366,6 @@ export type AcceptanceLedgerStatus =
 	| "accepted"
 	| "rejected";
 
-export interface AcceptanceFinalizationTurn {
-	turn: number;
-	prompt: string;
-	status: AcceptanceLedgerStatus;
-	rawOutput?: string;
-	report?: AcceptanceReport;
-	parseError?: string;
-	runtimeChecks: AcceptanceRuntimeCheck[];
-	verifyRuns: AcceptanceVerifyResult[];
-	failureMessage?: string;
-}
-
-export interface AcceptanceFinalizationLedger {
-	mode: "self-review-loop";
-	status: "not-run" | "completed" | "failed";
-	maxTurns: number;
-	turns: AcceptanceFinalizationTurn[];
-}
-
 export interface AcceptanceLedger {
 	status: AcceptanceLedgerStatus;
 	explicit: boolean;
@@ -395,12 +374,9 @@ export interface AcceptanceLedger {
 	criteria: ResolvedAcceptanceGate[];
 	childReport?: AcceptanceReport;
 	childReportParseError?: string;
-	initialChildReport?: AcceptanceReport;
-	initialChildReportParseError?: string;
 	runtimeChecks: AcceptanceRuntimeCheck[];
 	verifyRuns: AcceptanceVerifyResult[];
 	reviewResult?: AcceptanceReviewResult;
-	finalization?: AcceptanceFinalizationLedger;
 	parentDecision?: {
 		status: "accepted" | "rejected";
 		at: string;
@@ -408,13 +384,6 @@ export interface AcceptanceLedger {
 	};
 }
 
-export interface ResourceLimitExceeded {
-	kind: "maxExecutionTimeMs" | "maxTokens";
-	limit: number;
-	observed?: number;
-	message: string;
-}
-
 export interface SingleResult {
 	agent: string;
 	task: string;
@@ -422,8 +391,6 @@ export interface SingleResult {
 	detached?: boolean;
 	detachedReason?: string;
 	interrupted?: boolean;
-	timedOut?: boolean;
-	resourceLimitExceeded?: ResourceLimitExceeded;
 	messages?: Message[];
 	usage: Usage;
 	model?: string;
@@ -612,6 +579,7 @@ export interface AsyncStatus {
 	cwd?: string;
 	currentStep?: number;
 	chainStepCount?: number;
+	pendingAppends?: number;
 	parallelGroups?: AsyncParallelGroupStatus[];
 	workflowGraph?: WorkflowGraphSnapshot;
 	steps?: Array<{
@@ -648,7 +616,6 @@ export interface AsyncStatus {
 		structuredOutputPath?: string;
 		structuredOutputSchemaPath?: string;
 		acceptance?: AcceptanceLedger;
-		resourceLimitExceeded?: ResourceLimitExceeded;
 	}>;
 	sessionDir?: string;
 	outputFile?: string;
@@ -790,8 +757,6 @@ export interface RunSyncOptions {
 	cwd?: string;
 	signal?: AbortSignal;
 	interruptSignal?: AbortSignal;
-	timeoutMs?: number;
-	timeoutAt?: number;
 	allowIntercomDetach?: boolean;
 	intercomEvents?: IntercomEventBus;
 	onUpdate?: (r: import("@earendil-works/pi-agent-core").AgentToolResult<Details>) => void;
@@ -810,8 +775,6 @@ export interface RunSyncOptions {
 	outputPath?: string;
 	outputMode?: OutputMode;
 	maxSubagentDepth?: number;
-	maxExecutionTimeMs?: number;
-	maxTokens?: number;
 	nestedRoute?: NestedRouteInfo;
 	/** Override the agent's default model (format: "provider/id" or just "id") */
 	modelOverride?: string;
@@ -853,6 +816,13 @@ interface ExtensionChainConfig {
 	};
 }
 
+export interface ProactiveSkillSubagentsConfig {
+	enabled?: boolean;
+	minReferences?: number;
+	maxRecommendations?: number;
+	preferredAgent?: string;
+}
+
 export interface ExtensionConfig {
 	asyncByDefault?: boolean;
 	forceTopLevelAsync?: boolean;
@@ -864,6 +834,7 @@ export interface ExtensionConfig {
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 	intercomBridge?: IntercomBridgeConfig;
+	proactiveSkillSubagents?: ProactiveSkillSubagentsConfig | false;
 }
 
 // ============================================================================
@@ -954,7 +925,7 @@ export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
 export const POLL_INTERVAL_MS = 250;
 export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
-export const SUBAGENT_ACTIONS = ["list", "get", "create", "update", "delete", "status", "interrupt", "resume", "doctor"] as const;
+export const SUBAGENT_ACTIONS = ["list", "get", "create", "update", "delete", "status", "interrupt", "resume", "append-step", "doctor"] as const;
 
 export const DEFAULT_FORK_PREAMBLE =
 	"You are a delegated subagent running from a fork of the parent session. " +

package/src/shared/utils.ts

@@ -192,7 +192,8 @@ export function getFinalOutput(messages: Message[]): string {
 			const hasAssistantError = ("errorMessage" in msg && typeof msg.errorMessage === "string" && msg.errorMessage.length > 0)
 				|| ("stopReason" in msg && msg.stopReason === "error");
 			if (hasAssistantError) continue;
-			for (const part of msg.content) {
+			for (let j = msg.content.length - 1; j >= 0; j--) {
+				const part = msg.content[j];
 				if (part.type === "text" && part.text.trim().length > 0) return part.text;
 			}
 		}
@@ -204,13 +205,6 @@ export function getSingleResultOutput(result: Pick<SingleResult, "finalOutput" |
 	return result.finalOutput ?? getFinalOutput(result.messages ?? []);
 }
 
-export function formatResourceLimitExceeded(input: { agent: string; kind: "maxExecutionTimeMs" | "maxTokens"; limit: number; observed?: number }): string {
-	if (input.kind === "maxExecutionTimeMs") {
-		return `Resource limit exceeded for ${input.agent}: maxExecutionTimeMs ${input.limit}ms.`;
-	}
-	return `Resource limit exceeded for ${input.agent}: maxTokens ${input.limit}${input.observed !== undefined ? ` (observed ${input.observed})` : ""}.`;
-}
-
 /**
  * Extract display items (text and tool calls) from messages
  */