@narumitw/pi-subagents 0.51.0 → 0.52.0

package/README.md

@@ -413,11 +413,58 @@ Run an explicit dependency workflow:
 }
 ```
 
+A verification-gated implementation declares one distinct verifier:
+
+```json
+{
+  "workflow": {
+    "tasks": [
+      {
+        "id": "implementation",
+        "agent": "worker",
+        "task": "Implement the contracted change.",
+        "resultFormat": "structured-v2",
+        "contract": {
+          "version": "pi-subagents:delegation:v2",
+          "level": "full",
+          "taskId": "implementation",
+          "objective": "Implement the contracted change",
+          "admission": {
+            "contextPressure": "medium",
+            "independentWorkItems": 1,
+            "coupling": "dense",
+            "verificationRequired": true,
+            "verificationAvailable": true,
+            "budgetAllowsChildren": true,
+            "requirementsComplete": true
+          }
+        }
+      },
+      {
+        "id": "verification",
+        "agent": "reviewer",
+        "task": "Independently verify the staged result.",
+        "dependsOn": ["implementation"],
+        "verifierFor": "implementation",
+        "resultFormat": "structured-v2"
+      }
+    ]
+  }
+}
+```
+
 Cycles, missing dependencies, conflicting integration owners, recursive workflow grandchildren, and unsafe retry or hedge policies fail before child launch.
 Workflow scheduling starts at most two mutating tasks concurrently, while declared read-only work may use the existing four-child ceiling.
 Set `workflow.honorAdmission: true` only when explicit contract admission metadata should be allowed to decline parent-owned or insufficient-evidence work before launch; admission never silently widens the requested architecture.
 Workflow result details include the final ledger, scheduling decisions, artifact versions, task generations, attempts, hedge use, accepted plan identity, and bounded capability-grant metadata.
-Explicit workflow transitions are also atomically persisted as mode-0600, private-text-redacted snapshots for current-session `list_workflows` and `get_workflow` inspection; in-flight tasks inspect as `interrupted`, and no prior side effect is automatically resumed.
+A task that explicitly requires independent verification must have exactly one direct-dependent `verifierFor` task using a different agent, and both tasks must request `structured-v2`.
+The producer stops in `awaiting-verification`, its own passing verification claims remain untrusted, and ordinary downstream tasks stay blocked until the executor records an accepted verifier receipt.
+The verifier runs alone in a fresh subprocess context against one bounded Git-visible tree identity and must encode `verification-accepted`, `verification-rework`, or `verification-rejected` through the documented `structured-v2` status and reason fields.
+Dirty-tree identity covers at most 1 MiB across separately framed staged and unstaged binary diffs plus bounded non-ignored untracked paths and bytes; submodules, unsupported states, and changing trees fail closed.
+A rework or rejection preserves bounded evidence but does not replay the producer automatically.
+This acceptance gate does not isolate operating-system effects and does not make shared-workspace mutation into manager-controlled patch integration.
+Explicit workflow transitions are also atomically persisted as mode-0600, private-text-redacted snapshots for current-session `list_workflows` and `get_workflow` inspection; running and awaiting-verification tasks inspect as `interrupted`, and no prior side effect is automatically resumed.
+When a v1 ledger is restored, legacy self-reported verification flags and artifact trust are cleared because they have no executor receipt.
 
 ## 🔁 Stateful agents
 
@@ -890,6 +937,8 @@ packages/pi-subagents/
 │   ├── execution-plan.ts         # Executor-owned authority and resource resolution
 │   ├── work-item-ledger.ts       # Persistent dependency and artifact state machine
 │   ├── work-item-persistence.ts  # Atomic redacted workflow state and inspection
+│   ├── workflow-verification.ts  # Executor-owned independent-verifier receipts
+│   ├── workflow-tree-identity.ts # Bounded exact Git-visible tree identities
 │   ├── integration-controller.ts # Fail-closed canonical integration admission
 │   ├── adaptive-scheduler.ts     # Dependency, capacity, budget, and conflict scheduling
 │   ├── semantic-snapshot.ts      # Privacy-safe continuation compatibility checks

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-subagents",
-	"version": "0.51.0",
+	"version": "0.52.0",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",

package/src/adaptive-scheduler.ts

@@ -9,7 +9,8 @@ export type SchedulingReason =
 	| "state-not-ready"
 	| "budget-exhausted"
 	| "capacity-exhausted"
-	| "scope-conflict";
+	| "scope-conflict"
+	| "verification-barrier";
 
 export interface SchedulingDecisionItem {
 	id: string;
@@ -57,6 +58,33 @@ export class AdaptiveScheduler {
 			),
 		);
 		const effectiveConcurrency = options.remainingBudgetMs > 0 ? availableSlots : 0;
+		const readyVerifier = ready.find((item) => item.verifierFor !== undefined);
+		if (readyVerifier) {
+			const verifierMayStart = effectiveConcurrency > 0 && options.activeCount === 0;
+			return {
+				policy: ADAPTIVE_SCHEDULER_POLICY,
+				workflowId: snapshot.workflowId,
+				workflowGeneration: snapshot.generation,
+				effectiveConcurrency: verifierMayStart ? 1 : 0,
+				selected: verifierMayStart ? [readyVerifier.id] : [],
+				decisions: snapshot.items
+					.map((item) => ({
+						id: item.id,
+						reason:
+							item.id === readyVerifier.id
+								? verifierMayStart
+									? ("selected" as const)
+									: ("capacity-exhausted" as const)
+								: item.state === "ready"
+									? ("verification-barrier" as const)
+									: item.state === "pending"
+										? ("dependency-not-ready" as const)
+										: ("state-not-ready" as const),
+						criticalPathDepth: depth.get(item.id) ?? 0,
+					}))
+					.sort((left, right) => left.id.localeCompare(right.id)),
+			};
+		}
 		const selected: string[] = [];
 		let mutatingCount = options.activeMutatingCount ?? 0;
 		const maxMutatingConcurrency = options.maxMutatingConcurrency ?? 2;

package/src/execution.ts

@@ -21,6 +21,7 @@ import {
 	startSubagentStatus,
 } from "./blocking-status.js";
 import { issueCapabilityGrant } from "./capability-grant.js";
+import { redactPrivateText } from "./context.js";
 import {
 	assertDelegationTargetAllowed,
 	type ResolvedSubagentTarget,
@@ -69,13 +70,21 @@ import {
 import { isRetryableResult, runHedgedAttempt, supervisionDelay } from "./supervision.js";
 import { TimeoutProgressJournal, TURN_TERMINATION_VERSION } from "./timeout-checkpoint.js";
 import type { TurnLimits } from "./turn-budget.js";
-import { requiresIndependentVerification } from "./verification-policy.js";
+import {
+	requiresIndependentVerification,
+	validateWorkflowVerificationGraph,
+} from "./verification-policy.js";
 import type { WorkItemLedger } from "./work-item-ledger.js";
 import {
 	createSessionWorkItemPersistence,
 	type WorkItemPersistence,
 } from "./work-item-persistence.js";
 import { createBlockingWorkLedger, resolveWorkflowTasks } from "./workflow-planning.js";
+import { captureWorkflowTreeIdentity, sameWorkflowTreeIdentity } from "./workflow-tree-identity.js";
+import {
+	createWorkflowVerificationReceipt,
+	workflowVerificationInstruction,
+} from "./workflow-verification.js";
 
 export const FALLBACK_TIMEOUT_MS = 10 * 60 * 1000;
 
@@ -173,6 +182,7 @@ export async function executeSubagent(
 		Number(hasSingle);
 	let workLedger: WorkItemLedger | undefined;
 	const workflowScheduling: ReturnType<AdaptiveScheduler["decide"]>[] = [];
+	const verificationTargetIds = new Set<string>();
 
 	const makeDetails =
 		(mode: "single" | "parallel" | "chain" | "workflow" | "panel") =>
@@ -191,6 +201,38 @@ export async function executeSubagent(
 				metrics: calculateOrchestrationMetrics(workflow, metricResults),
 			};
 		};
+	const workflowFailureResult = (
+		agentName: string,
+		task: string,
+		reasonCode: string,
+		message: string,
+		thinkingLevel?: SubagentThinkingLevel,
+	): SingleResult => ({
+		agent: agentName,
+		agentSource: agents.find((agent) => agent.name === agentName)?.source ?? "unknown",
+		task,
+		exitCode: 1,
+		messages: [],
+		stderr: message,
+		errorMessage: message,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			cost: 0,
+			contextTokens: 0,
+			turns: 0,
+		},
+		thinkingLevel,
+		finalOutput: "",
+		outcome: {
+			status: "failed",
+			reasonCode,
+			recoveryActions: ["revalidate"],
+			retryable: false,
+		},
+	});
 	const exhaustedResult = (
 		agentName: string,
 		task: string,
@@ -292,6 +334,7 @@ export async function executeSubagent(
 	}
 	if (hasWorkflow && params.workflow) {
 		for (const task of resolvedWorkflowTasks) {
+			if (task.verifierFor) verificationTargetIds.add(task.verifierFor);
 			const contract = normalizeDelegationContract(task.contract);
 			if (params.workflow.honorAdmission) {
 				const admission = contract?.admission;
@@ -322,17 +365,7 @@ export async function executeSubagent(
 					requiredCapabilities: task.requiredCapabilities ?? [],
 				})
 			) {
-				const verifier = resolvedWorkflowTasks.find(
-					(candidate) =>
-						candidate.verifierFor === task.id &&
-						candidate.dependsOn?.includes(task.id) &&
-						candidate.agent !== task.agent,
-				);
-				if (!verifier) {
-					throw new Error(
-						`Workflow task ${task.id} requires a distinct dependent verifier before launch`,
-					);
-				}
+				verificationTargetIds.add(task.id);
 			}
 			if (!task.retryPolicy && !task.hedgeAfterMs) continue;
 			const policy = contract?.sideEffectPolicy;
@@ -345,6 +378,13 @@ export async function executeSubagent(
 				);
 			}
 		}
+		validateWorkflowVerificationGraph(
+			resolvedWorkflowTasks.map((task) => ({
+				...task,
+				resultFormat: task.resultFormat ?? params.resultFormat,
+			})),
+			verificationTargetIds,
+		);
 	}
 	workLedger = createBlockingWorkLedger(params, resolvedWorkflowTasks, aggregator);
 	let workflowPersistence: WorkItemPersistence | undefined;
@@ -512,6 +552,19 @@ export async function executeSubagent(
 		);
 	}
 
+	const artifactsFromResult = (result: SingleResult) => {
+		const structured =
+			result.structuredResult?.version === "pi-subagents:result:v2"
+				? result.structuredResult
+				: undefined;
+		return (structured?.artifacts ?? []).map((artifact) => ({
+			id: artifact.id,
+			kind: artifact.kind,
+			version: artifact.version ?? artifact.digest ?? "unversioned",
+			digest: artifact.digest,
+			verified: false,
+		}));
+	};
 	const startWorkItem = (id: string, agentName: string) => {
 		if (workLedger?.get(id)?.state === "ready") {
 			return workLedger.start(id, `agent:${agentName}`);
@@ -548,24 +601,10 @@ export async function executeSubagent(
 			);
 			return;
 		}
-		const structured =
-			result.structuredResult?.version === "pi-subagents:result:v2"
-				? result.structuredResult
-				: undefined;
 		workLedger.complete(id, {
 			taskGeneration,
 			executionPlanId: result.executionPlan?.id,
-			artifacts: (structured?.artifacts ?? []).map((artifact) => ({
-				id: artifact.id,
-				kind: artifact.kind,
-				version: artifact.version ?? artifact.digest ?? "unversioned",
-				digest: artifact.digest,
-				verified:
-					structured?.verification.some((verification) => verification.status === "passed") ??
-					false,
-			})),
-			verificationAccepted:
-				structured?.verification.some((verification) => verification.status === "passed") ?? false,
+			artifacts: artifactsFromResult(result),
 		});
 	};
 
@@ -659,7 +698,9 @@ export async function executeSubagent(
 		const deadline = orchestrationDeadline;
 		const cancelWorkflowGeneration = () => {
 			for (const item of workLedger.snapshot().items) {
-				if (item.state === "running") workLedger.invalidate(item.id, "parent-aborted");
+				if (item.state === "running" || item.state === "awaiting-verification") {
+					workLedger.invalidate(item.id, "parent-aborted");
+				}
 			}
 		};
 		signal?.addEventListener("abort", cancelWorkflowGeneration, { once: true });
@@ -691,17 +732,73 @@ export async function executeSubagent(
 						const dependencies = (task.dependsOn ?? [])
 							.map((dependency) => resultsById.get(dependency))
 							.filter((result): result is SingleResult => result !== undefined);
-						const dependencyContext = dependencies.length
-							? `\n\nDependency results:\n${buildFanInContext(dependencies)}`
-							: "";
+						const verifierDependency = task.verifierFor
+							? resultsById.get(task.verifierFor)
+							: undefined;
+						const verifierStructuredResult =
+							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 displayTask = task.task;
-						const taskWithContext = truncateUtf8(
-							`${task.task}${dependencyContext}`,
-							DEFAULT_MAX_CONTEXT_BYTES,
-						).text;
-						const prepared = prepareTask(taskWithContext, task);
 						const target = workflowTargets[index];
 						const thinkingLevel = resolveThinkingLevel(task.agent, task.thinkingLevel);
+						let verifierTreeIdentity:
+							| Awaited<ReturnType<typeof captureWorkflowTreeIdentity>>
+							| undefined;
+						let verifierPreflightError: string | undefined;
+						let verifierPreflightCode: string | undefined;
+						if (task.verifierFor) {
+							const staged = workLedger.get(task.verifierFor);
+							if (!staged?.stagedTreeIdentity) {
+								verifierPreflightCode = "verification-tree-unavailable";
+								verifierPreflightError = `Verification target ${task.verifierFor} has no staged tree identity`;
+							} else {
+								try {
+									verifierTreeIdentity = await captureWorkflowTreeIdentity(target.cwd, { signal });
+									if (!sameWorkflowTreeIdentity(staged.stagedTreeIdentity, verifierTreeIdentity)) {
+										verifierPreflightCode = "verification-tree-mismatch";
+										verifierPreflightError =
+											"Workflow verification tree changed before verifier launch";
+									}
+								} catch (error) {
+									if (signal?.aborted) throw error;
+									verifierPreflightCode = "verification-tree-unavailable";
+									verifierPreflightError = error instanceof Error ? error.message : String(error);
+								}
+							}
+						}
+						const verificationTargetTask = task.verifierFor
+							? taskById.get(task.verifierFor)?.task
+							: undefined;
+						const verificationTargetContract = normalizeDelegationContract(
+							verificationTargetTask?.contract,
+						);
+						const verificationSuffix =
+							task.verifierFor && verifierTreeIdentity
+								? `\n\n${workflowVerificationInstruction(task.verifierFor, verifierTreeIdentity, {
+										acceptanceCriteria: [
+											...(verificationTargetTask?.acceptanceCriteria ?? []),
+											...(verificationTargetContract?.acceptanceCriteria ?? []),
+										],
+										requiredEvidence: verificationTargetContract?.requiredEvidence ?? [],
+									})}`
+								: "";
+						const baseTask = `${task.task}${dependencyContext}`;
+						const baseBudget = Math.max(
+							0,
+							DEFAULT_MAX_CONTEXT_BYTES - Buffer.byteLength(verificationSuffix, "utf8"),
+						);
+						const taskWithContext = `${truncateUtf8(baseTask, baseBudget).text}${verificationSuffix}`;
+						const prepared = prepareTask(taskWithContext, task);
 						const startedItem = startWorkItem(workItemId, task.agent);
 						const acceptedTaskGeneration = startedItem?.taskGeneration ?? 0;
 						await persistWorkLedger();
@@ -737,9 +834,20 @@ export async function executeSubagent(
 							);
 						};
 						const maxAttempts = task.retryPolicy?.maxAttempts ?? 1;
-						let result: SingleResult | undefined;
+						let result: SingleResult | undefined = verifierPreflightError
+							? attachTarget(
+									workflowFailureResult(
+										task.agent,
+										displayTask,
+										verifierPreflightCode ?? "verification-tree-unavailable",
+										verifierPreflightError,
+										thinkingLevel,
+									),
+									target,
+								)
+							: undefined;
 						let hedged = false;
-						for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+						for (let attempt = 1; !verifierPreflightError && attempt <= maxAttempts; attempt++) {
 							if (attempt > 1 && deadline !== undefined && Date.now() >= deadline) break;
 							const attempted = await runHedgedAttempt(runAttempt, signal, task.hedgeAfterMs);
 							hedged ||= attempted.hedged;
@@ -765,7 +873,123 @@ export async function executeSubagent(
 							};
 						}
 						resultsById.set(workItemId, result);
-						settleWorkItem(workItemId, result, acceptedTaskGeneration);
+						if (result.outcome?.status === "stale") {
+							// Cancellation or replacement already rotated and invalidated this generation.
+						} else if (task.verifierFor) {
+							const staged = workLedger.get(task.verifierFor);
+							const structured =
+								result.structuredResult?.version === "pi-subagents:result:v2"
+									? result.structuredResult
+									: undefined;
+							let failureReason: string | undefined = verifierPreflightError;
+							let failureCode: string | undefined = verifierPreflightCode;
+							let postVerifierIdentity = verifierTreeIdentity;
+							if (!failureReason) {
+								try {
+									postVerifierIdentity = await captureWorkflowTreeIdentity(target.cwd, { signal });
+									if (
+										!verifierTreeIdentity ||
+										!staged?.stagedTreeIdentity ||
+										!sameWorkflowTreeIdentity(verifierTreeIdentity, postVerifierIdentity) ||
+										!sameWorkflowTreeIdentity(staged.stagedTreeIdentity, postVerifierIdentity)
+									) {
+										failureCode = "verification-tree-mismatch";
+										failureReason = "Workflow verification tree changed during verifier execution";
+									}
+								} catch (error) {
+									if (signal?.aborted) throw error;
+									failureCode = "verification-tree-unavailable";
+									failureReason = error instanceof Error ? error.message : String(error);
+								}
+							}
+							if (
+								!failureReason &&
+								structured &&
+								staged?.acceptedExecutionPlanId &&
+								result.executionPlan?.id &&
+								postVerifierIdentity
+							) {
+								try {
+									const receipt = createWorkflowVerificationReceipt(structured, {
+										targetTaskId: staged.id,
+										targetTaskGeneration: staged.taskGeneration,
+										targetExecutionPlanId: staged.acceptedExecutionPlanId,
+										verifierTaskId: workItemId,
+										verifierTaskGeneration: acceptedTaskGeneration,
+										verifierExecutionPlanId: result.executionPlan.id,
+										treeIdentity: postVerifierIdentity,
+										sourceTruncated: result.truncated === true,
+									});
+									workLedger.completeVerification(workItemId, {
+										taskGeneration: acceptedTaskGeneration,
+										executionPlanId: result.executionPlan.id,
+										receipt,
+									});
+									if (receipt.decision !== "accept") {
+										const targetResult = resultsById.get(staged.id);
+										if (targetResult) {
+											targetResult.outcome = {
+												status: receipt.decision === "rework" ? "blocked" : "failed",
+												reasonCode:
+													receipt.decision === "rework"
+														? "verification-rework"
+														: "verification-rejected",
+												recoveryActions:
+													receipt.decision === "rework" ? ["replan", "verify"] : ["stop"],
+												retryable: false,
+											};
+										}
+									}
+								} catch (error) {
+									failureCode = "verification-receipt-invalid";
+									failureReason = error instanceof Error ? error.message : String(error);
+								}
+							} else if (!failureReason) {
+								failureCode = "verification-receipt-invalid";
+								failureReason = "Workflow verifier did not return a current structured-v2 result";
+							}
+							if (failureReason) {
+								const reasonCode = failureCode ?? "verification-receipt-invalid";
+								result.outcome = {
+									status:
+										reasonCode === "verification-receipt-invalid" ? "contract-invalid" : "failed",
+									reasonCode,
+									recoveryActions:
+										reasonCode === "verification-receipt-invalid"
+											? ["repair-contract"]
+											: ["revalidate"],
+									retryable: false,
+								};
+								result.errorMessage = failureReason;
+								workLedger.failVerification(workItemId, reasonCode);
+							}
+						} else if (verificationTargetIds.has(workItemId) && !isResultError(result)) {
+							try {
+								const treeIdentity = await captureWorkflowTreeIdentity(target.cwd, { signal });
+								if (!result.executionPlan?.id) {
+									throw new Error("Verification-required producer has no accepted ExecutionPlan");
+								}
+								workLedger.stageForVerification(workItemId, {
+									taskGeneration: acceptedTaskGeneration,
+									executionPlanId: result.executionPlan.id,
+									artifacts: artifactsFromResult(result),
+									treeIdentity,
+								});
+							} catch (error) {
+								if (signal?.aborted) throw error;
+								const message = error instanceof Error ? error.message : String(error);
+								result.outcome = {
+									status: "failed",
+									reasonCode: "verification-tree-unavailable",
+									recoveryActions: ["revalidate"],
+									retryable: false,
+								};
+								result.errorMessage = message;
+								settleWorkItem(workItemId, result, acceptedTaskGeneration);
+							}
+						} else {
+							settleWorkItem(workItemId, result, acceptedTaskGeneration);
+						}
 						await persistWorkLedger();
 						return result;
 					},
@@ -774,11 +998,19 @@ export async function executeSubagent(
 				if (batch.length === 0 || signal?.aborted) break;
 			}
 			for (const item of workLedger.snapshot().items) {
-				if (item.state !== "pending" && item.state !== "ready") continue;
+				if (
+					item.state !== "pending" &&
+					item.state !== "ready" &&
+					item.state !== "awaiting-verification"
+				) {
+					continue;
+				}
 				if (signal?.aborted) {
 					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") {
+					workLedger.settle(item.id, "blocked", "verification-not-completed");
 				} else {
 					const dependencyBlocked = item.dependencies.some(
 						(dependency) => workLedger.get(dependency)?.state !== "completed",
@@ -793,8 +1025,26 @@ export async function executeSubagent(
 			await persistWorkLedger();
 			const results = resolvedWorkflowTasks.map((task) => {
 				const completed = resultsById.get(task.id);
-				if (completed) return completed;
 				const item = workLedger.get(task.id);
+				if (completed) {
+					if (item && item.state !== "completed" && !isResultError(completed)) {
+						completed.outcome = {
+							status:
+								item.state === "needs-input"
+									? "needs-input"
+									: item.state === "interrupted"
+										? "interrupted"
+										: item.state === "failed"
+											? "failed"
+											: "blocked",
+							reasonCode: item.outcomeReason ?? "verification-not-accepted",
+							recoveryActions:
+								item.outcomeReason === "verification-rework" ? ["replan", "verify"] : ["stop"],
+							retryable: false,
+						};
+					}
+					return completed;
+				}
 				const outcomeStatus =
 					item?.state === "interrupted"
 						? "interrupted"

package/src/inspect.ts

@@ -537,6 +537,31 @@ function projectWorkflow(workflow: WorkItemLedgerSnapshot): Record<string, unkno
 			verified: artifact.verified,
 		})),
 		verificationAccepted: item.verificationAccepted,
+		stagedTreeIdentity: item.stagedTreeIdentity
+			? {
+					version: item.stagedTreeIdentity.version,
+					kind: item.stagedTreeIdentity.kind,
+					digest: item.stagedTreeIdentity.digest,
+				}
+			: undefined,
+		verificationReceipt: item.verificationReceipt
+			? {
+					version: item.verificationReceipt.version,
+					decision: item.verificationReceipt.decision,
+					targetTaskId: boundedPrivateText(item.verificationReceipt.targetTaskId, 256),
+					targetTaskGeneration: item.verificationReceipt.targetTaskGeneration,
+					targetExecutionPlanId: item.verificationReceipt.targetExecutionPlanId,
+					verifierTaskId: boundedPrivateText(item.verificationReceipt.verifierTaskId, 256),
+					verifierTaskGeneration: item.verificationReceipt.verifierTaskGeneration,
+					verifierExecutionPlanId: item.verificationReceipt.verifierExecutionPlanId,
+					treeIdentity: item.verificationReceipt.treeIdentity,
+					summary: boundedPrivateText(item.verificationReceipt.summary, 8 * 1024),
+					evidenceCount: item.verificationReceipt.evidence.length,
+					limitationCount: item.verificationReceipt.limitations.length,
+					createdAt: item.verificationReceipt.createdAt,
+					truncated: item.verificationReceipt.truncated,
+				}
+			: undefined,
 		outcomeReason: item.outcomeReason
 			? boundedPrivateText(item.outcomeReason, 2 * 1024)
 			: undefined,

package/src/orchestration-metrics.ts

@@ -14,6 +14,12 @@ export interface OrchestrationMetrics {
 	requestedTools: number;
 	effectiveRequestedTools: number;
 	permissionPrecision: number;
+	workerReportedVerification: number;
+	executorAcceptedVerification: number;
+	verificationRework: number;
+	verificationRejected: number;
+	verificationInvalid: number;
+	verificationTreeMismatch: number;
 	panelValidReviews?: number;
 	panelFailedReviews?: number;
 	panelBlockingObjections?: number;
@@ -65,6 +71,31 @@ export function calculateOrchestrationMetrics(
 		requestedTools,
 		effectiveRequestedTools,
 		permissionPrecision: requestedTools === 0 ? 1 : effectiveRequestedTools / requestedTools,
+		workerReportedVerification: results.filter(
+			(result, index) =>
+				!items[index]?.verifierFor &&
+				result.structuredResult?.version === "pi-subagents:result:v2" &&
+				result.structuredResult.verification.some(
+					(verification) => verification.status === "passed",
+				),
+		).length,
+		executorAcceptedVerification: items.filter((item) => item.verificationAccepted).length,
+		verificationRework: items.filter(
+			(item) => !item.verifierFor && item.verificationReceipt?.decision === "rework",
+		).length,
+		verificationRejected: items.filter(
+			(item) => !item.verifierFor && item.verificationReceipt?.decision === "reject",
+		).length,
+		verificationInvalid: items.filter(
+			(item) => !item.verifierFor && item.outcomeReason === "verification-receipt-invalid",
+		).length,
+		verificationTreeMismatch: items.filter(
+			(item) =>
+				!item.verifierFor &&
+				["verification-tree-mismatch", "verification-tree-unavailable"].includes(
+					item.outcomeReason ?? "",
+				),
+		).length,
 		...(panel
 			? {
 					panelValidReviews: panel.validReviewCount,

package/src/panel-execution.ts

@@ -389,7 +389,6 @@ export async function executePanel(input: PanelExecutionInput): Promise<PanelToo
 									},
 								]
 							: [],
-						verificationAccepted: false,
 					});
 				}
 				completed += 1;
@@ -554,7 +553,6 @@ export async function executePanel(input: PanelExecutionInput): Promise<PanelToo
 				workLedger.complete("synthesis", {
 					taskGeneration: synthesisWork.taskGeneration,
 					executionPlanId: synthesisResult.executionPlan?.id,
-					verificationAccepted: false,
 				});
 			}
 			await persistWork();

package/src/params.ts

@@ -106,7 +106,14 @@ const WorkflowTaskItem = Type.Object({
 	ownershipKeys: Type.Optional(Type.Array(Type.String({ maxLength: 256 }), { maxItems: 50 })),
 	acceptanceCriteria: Type.Optional(Type.Array(Type.String({ maxLength: 4096 }), { maxItems: 50 })),
 	integrationOwner: Type.Optional(Type.Boolean()),
-	verifierFor: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+	verifierFor: Type.Optional(
+		Type.String({
+			minLength: 1,
+			maxLength: 256,
+			description:
+				"Target task ID for one distinct direct-dependent structured-v2 verifier. The executor gates target acceptance on a current exact-tree receipt.",
+		}),
+	),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process" })),
 	timeoutMs: Type.Optional(TimeoutMs),
 	...TurnLimitFields,