@narumitw/pi-subagents 0.53.0 → 1.0.0

package/src/execution.ts

@@ -2,17 +2,18 @@
  * Blocking execution stays in one module so preflight, confirmation, cancellation generation,
  * launch, and settlement retain one ordered lifecycle owner across every mode.
  */
+
 import type { AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { AdaptiveScheduler } from "./adaptive-scheduler.js";
 import { evaluateDelegationAdmission } from "./admission-policy.js";
-import {
-	type AgentConfig,
-	type AgentScope,
-	discoverAgents,
-	type SubagentSettings,
-	type SubagentThinkingLevel,
-} from "./agents.js";
+import { discoverAgents } from "./agents/discovery.js";
+import type {
+	AgentConfig,
+	AgentScope,
+	SubagentSettings,
+	SubagentThinkingLevel,
+} from "./agents/types.js";
 import {
 	chainStatus,
 	fanInStatus,
@@ -20,7 +21,7 @@ import {
 	singleStatus,
 	startSubagentStatus,
 } from "./blocking-status.js";
-import { issueCapabilityGrant } from "./capability-grant.js";
+import { issueCapabilityGrant, revokeCapabilityGrant } from "./capability-grant.js";
 import { redactPrivateText } from "./context.js";
 import {
 	assertDelegationTargetAllowed,
@@ -33,6 +34,15 @@ import {
 	type DelegationContract,
 	normalizeDelegationContract,
 } from "./delegation-contract.js";
+import {
+	calculateExecutionBudget,
+	mergeTurnLimits,
+	resolveConfiguredTimeout,
+} from "./execution/budget.js";
+import {
+	assertSubagentDepthAllowed,
+	resolveDefaultSubagentTimeoutMs,
+} from "./execution/runtime-policy.js";
 import {
 	acknowledgeExecutionPlan,
 	createExecutionPlan,
@@ -63,10 +73,9 @@ import {
 import { safeTerminalLine } from "./safe-text.js";
 import {
 	DEFAULT_DELEGATION_CWD_POLICY,
-	readSubagentSettings,
 	resolveBlockingMaxParallelTasks,
-	resolveSubagentThinkingLevel,
-} from "./settings.js";
+} from "./settings/inspection.js";
+import { readSubagentSettings, resolveSubagentThinkingLevel } from "./settings.js";
 import { isRetryableResult, runHedgedAttempt, supervisionDelay } from "./supervision.js";
 import { TimeoutProgressJournal, TURN_TERMINATION_VERSION } from "./timeout-checkpoint.js";
 import type { TurnLimits } from "./turn-budget.js";
@@ -74,11 +83,16 @@ import {
 	requiresIndependentVerification,
 	validateWorkflowVerificationGraph,
 } from "./verification-policy.js";
+import { prepareVerifiedWorkflow } from "./verified-execution-contract.js";
 import type { WorkItemLedger } from "./work-item-ledger.js";
 import {
 	createSessionWorkItemPersistence,
 	type WorkItemPersistence,
 } from "./work-item-persistence.js";
+import {
+	WorkflowCompletionController,
+	workflowCompletionFailureReason,
+} from "./workflow-completion-controller.js";
 import { createBlockingWorkLedger, resolveWorkflowTasks } from "./workflow-planning.js";
 import { captureWorkflowTreeIdentity, sameWorkflowTreeIdentity } from "./workflow-tree-identity.js";
 import {
@@ -86,25 +100,12 @@ import {
 	workflowVerificationInstruction,
 } from "./workflow-verification.js";
 
-export const FALLBACK_TIMEOUT_MS = 10 * 60 * 1000;
-
-export function parsePositiveInteger(value: string | undefined): number | undefined {
-	if (!value) return undefined;
-	const parsed = Number.parseInt(value, 10);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}
-
-export function resolveDefaultSubagentTimeoutMs(): number {
-	return parsePositiveInteger(process.env.PI_SUBAGENT_TIMEOUT_MS) ?? FALLBACK_TIMEOUT_MS;
-}
-
-export function assertSubagentDepthAllowed(): void {
-	const depth = Number.parseInt(process.env.PI_SUBAGENT_DEPTH ?? "0", 10) || 0;
-	const maxDepth = parsePositiveInteger(process.env.PI_SUBAGENT_MAX_DEPTH) ?? 1;
-	if (depth >= maxDepth) {
-		throw new Error(`Subagent recursion depth limit reached (${maxDepth})`);
-	}
-}
+export {
+	assertSubagentDepthAllowed,
+	FALLBACK_TIMEOUT_MS,
+	parsePositiveInteger,
+	resolveDefaultSubagentTimeoutMs,
+} from "./execution/runtime-policy.js";
 
 export async function executeSubagent(
 	toolCallId: string,
@@ -124,50 +125,54 @@ export async function executeSubagent(
 	const maxParallelTasks = resolveBlockingMaxParallelTasks(config);
 	const discovery = discoverAgents(ctx.cwd, agentScope, config);
 	const agents = discovery.agents;
-	const resolvedWorkflowTasks = resolveWorkflowTasks(params, agents);
+	let resolvedWorkflowTasks = resolveWorkflowTasks(params, agents);
+	const verifiedWorkflow = params.workflow?.verifiedExecution
+		? prepareVerifiedWorkflow(resolvedWorkflowTasks, params.workflow.verifiedExecution)
+		: undefined;
+	if (verifiedWorkflow) {
+		const verifierAgent = agents.find(
+			(agent) => agent.name === params.workflow?.verifiedExecution?.verifierAgent,
+		);
+		if (!verifierAgent) {
+			throw new Error(
+				`Unknown verified execution agent: ${params.workflow?.verifiedExecution?.verifierAgent}`,
+			);
+		}
+		if (
+			!verifierAgent.capabilityManifest?.verificationRoles.includes("independent-review") ||
+			!verifierAgent.capabilityManifest.resultFormats.includes("structured-v2")
+		) {
+			throw new Error(
+				`Verified execution agent ${verifierAgent.name} lacks independent structured-v2 review capability`,
+			);
+		}
+		resolvedWorkflowTasks = verifiedWorkflow.tasks;
+	}
 	const confirmProjectAgents = params.confirmProjectAgents ?? true;
 	const resolveTimeoutMs = (agentName: string, localTimeoutMs?: number) =>
-		localTimeoutMs ??
-		params.timeoutMs ??
-		agents.find((agent) => agent.name === agentName)?.timeoutMs ??
-		resolveDefaultSubagentTimeoutMs();
+		resolveConfiguredTimeout(
+			agents,
+			agentName,
+			localTimeoutMs,
+			params.timeoutMs,
+			resolveDefaultSubagentTimeoutMs(),
+		);
 	const resolveThinkingLevel = (agentName: string, localThinkingLevel?: SubagentThinkingLevel) =>
 		resolveSubagentThinkingLevel(agents, agentName, params.thinkingLevel, localThinkingLevel);
 	let orchestrationDeadline: number | undefined;
-	const resolveTurnLimits = (local?: TurnLimits): TurnLimits => ({
-		idleTimeoutMs: local?.idleTimeoutMs ?? params.idleTimeoutMs,
-		maxTurns: local?.maxTurns ?? params.maxTurns,
-		maxToolCalls: local?.maxToolCalls ?? params.maxToolCalls,
-	});
-	const resolveExecutionBudget = (
-		agentName: string,
-		localTimeoutMs?: number,
-	):
-		| {
-				timeoutMs: number;
-				workTimeoutReason: "work_timeout" | "orchestration_timeout";
-				workTimeoutReportLimit: number;
-		  }
-		| undefined => {
-		const requested = resolveTimeoutMs(agentName, localTimeoutMs);
-		if (orchestrationDeadline === undefined) {
-			return {
-				timeoutMs: requested,
-				workTimeoutReason: "work_timeout",
-				workTimeoutReportLimit: requested,
-			};
-		}
-		const remaining = Math.floor(orchestrationDeadline - Date.now());
-		if (remaining < 1) return undefined;
-		const orchestrationLimited = remaining < requested;
-		return {
-			timeoutMs: Math.min(requested, remaining),
-			workTimeoutReason: orchestrationLimited ? "orchestration_timeout" : "work_timeout",
-			workTimeoutReportLimit: orchestrationLimited
-				? Math.floor(params.totalTimeoutMs as number)
-				: requested,
-		};
-	};
+	const resolveTurnLimits = (local?: TurnLimits): TurnLimits =>
+		mergeTurnLimits(local, {
+			idleTimeoutMs: params.idleTimeoutMs,
+			maxTurns: params.maxTurns,
+			maxToolCalls: params.maxToolCalls,
+		});
+	const resolveExecutionBudget = (agentName: string, localTimeoutMs?: number) =>
+		calculateExecutionBudget({
+			requestedTimeoutMs: resolveTimeoutMs(agentName, localTimeoutMs),
+			orchestrationDeadline,
+			totalTimeoutMs: params.totalTimeoutMs,
+			now: Date.now(),
+		});
 
 	const hasChain = (params.chain?.length ?? 0) > 0;
 	const hasTasks = (params.tasks?.length ?? 0) > 0;
@@ -386,7 +391,17 @@ export async function executeSubagent(
 			verificationTargetIds,
 		);
 	}
-	workLedger = createBlockingWorkLedger(params, resolvedWorkflowTasks, aggregator);
+	workLedger = createBlockingWorkLedger(
+		params,
+		resolvedWorkflowTasks,
+		aggregator,
+		verifiedWorkflow
+			? {
+					id: verifiedWorkflow.targetTaskId,
+					maxReworkCycles: verifiedWorkflow.maxReworkCycles,
+				}
+			: undefined,
+	);
 	let workflowPersistence: WorkItemPersistence | undefined;
 	if (hasWorkflow && workLedger) {
 		const owner =
@@ -698,13 +713,34 @@ export async function executeSubagent(
 		const deadline = orchestrationDeadline;
 		const cancelWorkflowGeneration = () => {
 			for (const item of workLedger.snapshot().items) {
-				if (item.state === "running" || item.state === "awaiting-verification") {
+				if (
+					item.state === "running" ||
+					item.state === "awaiting-verification" ||
+					(item.state === "completed" && item.acceptanceState === "pending")
+				) {
 					workLedger.invalidate(item.id, "parent-aborted");
 				}
 			}
 		};
-		signal?.addEventListener("abort", cancelWorkflowGeneration, { once: true });
+		let completionController: WorkflowCompletionController | undefined;
+		let abortListenerAttached = false;
 		try {
+			completionController = verifiedWorkflow
+				? new WorkflowCompletionController({
+						ledger: workLedger,
+						cwd:
+							workflowTargets[
+								resolvedWorkflowTasks.findIndex((task) => task.id === verifiedWorkflow.targetTaskId)
+							]?.cwd ?? ctx.cwd,
+						targetTaskId: verifiedWorkflow.targetTaskId,
+						verifierTaskId: verifiedWorkflow.verifierTaskId,
+						checks: verifiedWorkflow.checks,
+						signal,
+						deadlineAt: deadline,
+					})
+				: undefined;
+			signal?.addEventListener("abort", cancelWorkflowGeneration, { once: true });
+			abortListenerAttached = signal !== undefined;
 			while (true) {
 				const snapshot = workLedger.snapshot();
 				const remainingBudgetMs =
@@ -732,6 +768,8 @@ export async function executeSubagent(
 						const dependencies = (task.dependsOn ?? [])
 							.map((dependency) => resultsById.get(dependency))
 							.filter((result): result is SingleResult => result !== undefined);
+						const managedVerifier =
+							completionController !== undefined && workItemId === verifiedWorkflow?.verifierTaskId;
 						const verifierDependency = task.verifierFor
 							? resultsById.get(task.verifierFor)
 							: undefined;
@@ -739,15 +777,17 @@ export async function executeSubagent(
 							verifierDependency?.structuredResult?.version === "pi-subagents:result:v2"
 								? verifierDependency.structuredResult
 								: undefined;
-						const dependencyContext = task.verifierFor
-							? verifierStructuredResult
-								? `\n\nStaged target result:\n${redactPrivateText(
-										JSON.stringify(verifierStructuredResult),
-									)}`
-								: ""
-							: dependencies.length
-								? `\n\nDependency results:\n${buildFanInContext(dependencies)}`
-								: "";
+						const dependencyContext = managedVerifier
+							? ""
+							: task.verifierFor
+								? verifierStructuredResult
+									? `\n\nStaged target result:\n${redactPrivateText(
+											JSON.stringify(verifierStructuredResult),
+										)}`
+									: ""
+								: dependencies.length
+									? `\n\nDependency results:\n${buildFanInContext(dependencies)}`
+									: "";
 						const displayTask = task.task;
 						const target = workflowTargets[index];
 						const thinkingLevel = resolveThinkingLevel(task.agent, task.thinkingLevel);
@@ -782,8 +822,15 @@ export async function executeSubagent(
 						const verificationTargetContract = normalizeDelegationContract(
 							verificationTargetTask?.contract,
 						);
-						const verificationSuffix =
-							task.verifierFor && verifierTreeIdentity
+						const managedVerificationInstruction = managedVerifier
+							? completionController?.verifierPrompt()
+							: undefined;
+						if (managedVerifier && !managedVerificationInstruction) {
+							throw new Error("Verified execution verifier instruction is unavailable");
+						}
+						const verificationSuffix = managedVerifier
+							? `\n\n${managedVerificationInstruction}`
+							: task.verifierFor && verifierTreeIdentity
 								? `\n\n${workflowVerificationInstruction(task.verifierFor, verifierTreeIdentity, {
 										acceptanceCriteria: [
 											...(verificationTargetTask?.acceptanceCriteria ?? []),
@@ -792,12 +839,19 @@ export async function executeSubagent(
 										requiredEvidence: verificationTargetContract?.requiredEvidence ?? [],
 									})}`
 								: "";
+						const reworkSuffix =
+							completionController &&
+							workItemId === verifiedWorkflow?.targetTaskId &&
+							(workLedger.get(workItemId)?.taskGeneration ?? 1) > 1
+								? `\n\n${completionController.reworkPrompt()}`
+								: "";
 						const baseTask = `${task.task}${dependencyContext}`;
+						const requiredSuffix = `${reworkSuffix}${verificationSuffix}`;
 						const baseBudget = Math.max(
 							0,
-							DEFAULT_MAX_CONTEXT_BYTES - Buffer.byteLength(verificationSuffix, "utf8"),
+							DEFAULT_MAX_CONTEXT_BYTES - Buffer.byteLength(requiredSuffix, "utf8"),
 						);
-						const taskWithContext = `${truncateUtf8(baseTask, baseBudget).text}${verificationSuffix}`;
+						const taskWithContext = `${truncateUtf8(baseTask, baseBudget).text}${requiredSuffix}`;
 						const prepared = prepareTask(taskWithContext, task);
 						const startedItem = startWorkItem(workItemId, task.agent);
 						const acceptedTaskGeneration = startedItem?.taskGeneration ?? 0;
@@ -807,6 +861,17 @@ export async function executeSubagent(
 							if (!budget) {
 								return Promise.resolve(exhaustedResult(task.agent, displayTask, thinkingLevel));
 							}
+							const childPolicy = launchPolicy(
+								target,
+								prepared,
+								displayTask,
+								task.agent,
+								thinkingLevel,
+								budget.timeoutMs,
+								acceptedTaskGeneration,
+								budget,
+								resolveTurnLimits(task),
+							);
 							return runSingleAgent(
 								ctx.cwd,
 								agents,
@@ -820,17 +885,15 @@ export async function executeSubagent(
 								undefined,
 								makeDetails("workflow"),
 								undefined,
-								launchPolicy(
-									target,
-									prepared,
-									displayTask,
-									task.agent,
-									thinkingLevel,
-									budget.timeoutMs,
-									acceptedTaskGeneration,
-									budget,
-									resolveTurnLimits(task),
-								),
+								managedVerifier
+									? {
+											...childPolicy,
+											disableExtensions: true,
+											disableSkills: true,
+											disablePromptTemplates: true,
+											disableContextFiles: true,
+										}
+									: childPolicy,
 							);
 						};
 						const maxAttempts = task.retryPolicy?.maxAttempts ?? 1;
@@ -875,6 +938,72 @@ export async function executeSubagent(
 						resultsById.set(workItemId, result);
 						if (result.outcome?.status === "stale") {
 							// Cancellation or replacement already rotated and invalidated this generation.
+						} else if (managedVerifier && completionController) {
+							const structured =
+								result.structuredResult?.version === "pi-subagents:result:v2"
+									? result.structuredResult
+									: undefined;
+							try {
+								if (!structured || !result.executionPlan?.id) {
+									throw new Error(
+										"Verified execution verifier did not return a current structured-v2 result",
+									);
+								}
+								const completion = await completionController.completeVerifier({
+									taskGeneration: acceptedTaskGeneration,
+									executionPlanId: result.executionPlan.id,
+									verifierAgent: task.agent,
+									result: structured,
+									sourceTruncated: result.truncated,
+								});
+								const targetItem = workLedger.get(verifiedWorkflow?.targetTaskId ?? "");
+								if (
+									completion.decision === "rework" &&
+									targetItem?.acceptanceState === "rework-requested"
+								) {
+									const targetResult = resultsById.get(targetItem.id);
+									if (targetResult?.capabilityGrant?.state === "active") {
+										targetResult.capabilityGrant = revokeCapabilityGrant(
+											targetResult.capabilityGrant,
+											"verification-rework",
+											Date.now(),
+										);
+									}
+									if (result.capabilityGrant?.state === "active") {
+										result.capabilityGrant = revokeCapabilityGrant(
+											result.capabilityGrant,
+											"verification-rework",
+											Date.now(),
+										);
+									}
+									completionController.beginRework();
+								} else if (completion.decision !== "accept" && targetItem) {
+									const targetResult = resultsById.get(targetItem.id);
+									if (targetResult) {
+										targetResult.outcome = {
+											status: "failed",
+											reasonCode: targetItem.outcomeReason ?? "verification-rejected",
+											recoveryActions: ["stop"],
+											retryable: false,
+										};
+									}
+								}
+							} catch (error) {
+								if (signal?.aborted) throw error;
+								const message = error instanceof Error ? error.message : String(error);
+								const reasonCode = workflowCompletionFailureReason(error);
+								result.outcome = {
+									status: "failed",
+									reasonCode,
+									recoveryActions: ["revalidate"],
+									retryable: false,
+								};
+								result.errorMessage = message;
+								const verifierItem = workLedger.get(workItemId);
+								if (verifierItem?.state === "running") {
+									workLedger.failVerification(workItemId, reasonCode);
+								}
+							}
 						} else if (task.verifierFor) {
 							const staged = workLedger.get(task.verifierFor);
 							const structured =
@@ -963,6 +1092,34 @@ export async function executeSubagent(
 								result.errorMessage = failureReason;
 								workLedger.failVerification(workItemId, reasonCode);
 							}
+						} else if (
+							completionController &&
+							workItemId === verifiedWorkflow?.targetTaskId &&
+							!isResultError(result)
+						) {
+							try {
+								if (!result.executionPlan?.id) {
+									throw new Error("Verified execution producer has no accepted ExecutionPlan");
+								}
+								await completionController.stageTarget({
+									taskGeneration: acceptedTaskGeneration,
+									executionPlanId: result.executionPlan.id,
+									artifacts: artifactsFromResult(result),
+								});
+							} catch (error) {
+								if (signal?.aborted) throw error;
+								const message = error instanceof Error ? error.message : String(error);
+								result.outcome = {
+									status: "failed",
+									reasonCode: "verification-checks-unavailable",
+									recoveryActions: ["revalidate"],
+									retryable: false,
+								};
+								result.errorMessage = message;
+								if (workLedger.get(workItemId)?.state === "running") {
+									settleWorkItem(workItemId, result, acceptedTaskGeneration);
+								}
+							}
 						} else if (verificationTargetIds.has(workItemId) && !isResultError(result)) {
 							try {
 								const treeIdentity = await captureWorkflowTreeIdentity(target.cwd, { signal });
@@ -1001,7 +1158,8 @@ export async function executeSubagent(
 				if (
 					item.state !== "pending" &&
 					item.state !== "ready" &&
-					item.state !== "awaiting-verification"
+					item.state !== "awaiting-verification" &&
+					!(item.state === "completed" && item.acceptanceState === "pending")
 				) {
 					continue;
 				}
@@ -1009,7 +1167,10 @@ export async function executeSubagent(
 					workLedger.settle(item.id, "interrupted", "parent-aborted");
 				} else if (deadline !== undefined && Date.now() >= deadline) {
 					workLedger.settle(item.id, "blocked", "budget-exhausted");
-				} else if (item.state === "awaiting-verification") {
+				} else if (
+					item.state === "awaiting-verification" ||
+					(item.state === "completed" && item.acceptanceState === "pending")
+				) {
 					workLedger.settle(item.id, "blocked", "verification-not-completed");
 				} else {
 					const dependencyBlocked = item.dependencies.some(
@@ -1027,7 +1188,12 @@ export async function executeSubagent(
 				const completed = resultsById.get(task.id);
 				const item = workLedger.get(task.id);
 				if (completed) {
-					if (item && item.state !== "completed" && !isResultError(completed)) {
+					if (
+						item &&
+						(item.state !== "completed" ||
+							(item.acceptanceRequired && item.acceptanceState !== "accepted")) &&
+						!isResultError(completed)
+					) {
 						completed.outcome = {
 							status:
 								item.state === "needs-input"
@@ -1099,7 +1265,10 @@ export async function executeSubagent(
 				isError: isError || undefined,
 			};
 		} finally {
-			signal?.removeEventListener("abort", cancelWorkflowGeneration);
+			if (abortListenerAttached) {
+				signal?.removeEventListener("abort", cancelWorkflowGeneration);
+			}
+			completionController?.dispose();
 			try {
 				await persistWorkLedger();
 			} finally {

package/src/in-process-transport.ts

@@ -7,10 +7,11 @@ import {
 	SessionManager,
 	SettingsManager,
 } from "@earendil-works/pi-coding-agent";
-import { type AgentConfig, discoverAgents, type SubagentThinkingLevel } from "./agents.js";
+import { discoverAgents } from "./agents/discovery.js";
+import type { AgentConfig, SubagentThinkingLevel } from "./agents/types.js";
 import { redactPrivateText } from "./context.js";
 import { appendDelegationContract } from "./delegation-contract.js";
-import { resolveDefaultSubagentTimeoutMs } from "./execution.js";
+import { resolveDefaultSubagentTimeoutMs } from "./execution/runtime-policy.js";
 import { DEFAULT_MAX_CONTEXT_BYTES, DEFAULT_MAX_OUTPUT_BYTES, truncateUtf8 } from "./limits.js";
 import { resolvePiPromptResources } from "./prompt-resources.js";
 import type { AgentTurn, ManagedAgent, TurnOutcome } from "./registry.js";

package/src/inspect.ts

@@ -6,13 +6,13 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import {
-	type AgentConfig,
-	type AgentScope,
-	type ConsultationCwdPolicy,
-	type DelegationCwdPolicy,
-	discoverAgents,
-} from "./agents.js";
+import { discoverAgents } from "./agents/discovery.js";
+import type {
+	AgentConfig,
+	AgentScope,
+	ConsultationCwdPolicy,
+	DelegationCwdPolicy,
+} from "./agents/types.js";
 import { projectCapabilityManifest } from "./capabilities.js";
 import { resolveConsultTools } from "./consult-policy.js";
 import { buildContextSnapshot, type ContextMode } from "./context.js";
@@ -21,6 +21,7 @@ import { DEFAULT_MAX_CONTEXT_BYTES } from "./limits.js";
 import { resolvePiInvocation } from "./pi-invocation.js";
 import type { AgentRunInspectionDetail, AgentRunInspectionSummary } from "./registry.js";
 import { boundedPrivateText, boundText, safeDisplayPath, safeTerminalLine } from "./safe-text.js";
+import { resolveDelegationWorkflow } from "./settings/inspection.js";
 import {
 	inspectBlockingParallelLimitSettings,
 	inspectCompletionDeliverySettings,
@@ -30,7 +31,6 @@ import {
 	inspectStatefulLimitSettings,
 	inspectStatefulTransportSettings,
 	inspectSubagentSettings,
-	resolveDelegationWorkflow,
 } from "./settings.js";
 import type { StatefulSubagentRuntimeStatus } from "./stateful.js";
 import type { WorkItemLedgerSnapshot } from "./work-item-ledger.js";
@@ -404,6 +404,8 @@ function projectRunSummary(run: AgentRunInspectionSummary): Record<string, unkno
 		updatedAt: run.updatedAt,
 		historyCount: run.historyCount,
 		unreadMessages: run.unreadMessages,
+		turnGeneration: run.turnGeneration,
+		pendingCompletionCount: run.pendingCompletionCount,
 	};
 }
 
@@ -474,6 +476,8 @@ function projectRun(run: AgentRunInspectionDetail, ctx: ExtensionContext): Recor
 			: undefined,
 		semanticCompatibility: run.semanticCompatibility,
 		telemetry: run.telemetry,
+		currentRunId: run.currentRunId,
+		currentTurnGeneration: run.currentTurnGeneration,
 		currentTask: run.currentTask ? boundedPrivateText(run.currentTask, 2 * 1024) : undefined,
 		error: run.error ? boundedPrivateText(run.error, 2 * 1024) : undefined,
 		target: run.target
@@ -537,6 +541,33 @@ function projectWorkflow(workflow: WorkItemLedgerSnapshot): Record<string, unkno
 			verified: artifact.verified,
 		})),
 		verificationAccepted: item.verificationAccepted,
+		acceptanceStateVersion: item.acceptanceStateVersion,
+		acceptanceRequired: item.acceptanceRequired,
+		acceptanceState: item.acceptanceState,
+		reworkCount: item.reworkCount,
+		maxReworkCycles: item.maxReworkCycles,
+		acceptanceReceipt: item.acceptanceReceipt
+			? {
+					version: item.acceptanceReceipt.version,
+					decision: item.acceptanceReceipt.decision,
+					targetTaskId: boundedPrivateText(item.acceptanceReceipt.targetTaskId, 256),
+					targetTaskGeneration: item.acceptanceReceipt.targetTaskGeneration,
+					targetExecutionPlanId: item.acceptanceReceipt.targetExecutionPlanId,
+					verifierTaskId: boundedPrivateText(item.acceptanceReceipt.verifierTaskId, 256),
+					verifierTaskGeneration: item.acceptanceReceipt.verifierTaskGeneration,
+					verifierExecutionPlanId: item.acceptanceReceipt.verifierExecutionPlanId,
+					verifierAgent: boundedPrivateText(item.acceptanceReceipt.verifierAgent, 256),
+					beforeTreeIdentity: item.acceptanceReceipt.beforeTreeIdentity,
+					afterTreeIdentity: item.acceptanceReceipt.afterTreeIdentity,
+					patchDigest: item.acceptanceReceipt.patchDigest,
+					changedPathCount: item.acceptanceReceipt.changedPaths.length,
+					checkCount: item.acceptanceReceipt.checks.length,
+					requiredEvidenceCount: item.acceptanceReceipt.requiredEvidenceIds.length,
+					createdAt: item.acceptanceReceipt.createdAt,
+					sourceTruncated: item.acceptanceReceipt.sourceTruncated,
+				}
+			: undefined,
+		acceptanceReceiptHistoryCount: item.acceptanceReceiptHistory.length,
 		stagedTreeIdentity: item.stagedTreeIdentity
 			? {
 					version: item.stagedTreeIdentity.version,

package/src/limits.ts

@@ -8,6 +8,7 @@ export const DEFAULT_MAX_PARALLEL_TASKS = 8;
 export const MAX_CONFIGURABLE_PARALLEL_TASKS = 64;
 export const MAX_BLOCKING_PARALLEL_CONCURRENCY = 4;
 export const DEFAULT_MAX_MESSAGES = 200;
+export const MAX_TOOL_MESSAGE_BYTES = 2 * 1024;
 export const TRUNCATION_MARKER = "\n… [truncated by pi-subagents]";
 export const TAIL_TRUNCATION_MARKER = "… [truncated by pi-subagents]\n";
 

package/src/orchestration-metrics.ts

@@ -81,10 +81,15 @@ export function calculateOrchestrationMetrics(
 		).length,
 		executorAcceptedVerification: items.filter((item) => item.verificationAccepted).length,
 		verificationRework: items.filter(
-			(item) => !item.verifierFor && item.verificationReceipt?.decision === "rework",
+			(item) =>
+				!item.verifierFor &&
+				(item.verificationReceipt?.decision === "rework" ||
+					item.acceptanceReceiptHistory.some((receipt) => receipt.decision === "rework")),
 		).length,
 		verificationRejected: items.filter(
-			(item) => !item.verifierFor && item.verificationReceipt?.decision === "reject",
+			(item) =>
+				!item.verifierFor &&
+				(item.verificationReceipt?.decision === "reject" || item.acceptanceState === "rejected"),
 		).length,
 		verificationInvalid: items.filter(
 			(item) => !item.verifierFor && item.outcomeReason === "verification-receipt-invalid",
@@ -92,9 +97,11 @@ export function calculateOrchestrationMetrics(
 		verificationTreeMismatch: items.filter(
 			(item) =>
 				!item.verifierFor &&
-				["verification-tree-mismatch", "verification-tree-unavailable"].includes(
-					item.outcomeReason ?? "",
-				),
+				[
+					"verification-tree-mismatch",
+					"verification-tree-unavailable",
+					"verification-tree-drift",
+				].includes(item.outcomeReason ?? ""),
 		).length,
 		...(panel
 			? {