@narumitw/pi-subagents 0.52.0 → 0.54.0

package/src/workflow-planning-benchmark.ts

@@ -0,0 +1,95 @@
+export const AUTOMATION_BENCHMARK_VERSION = "pi-subagents:workflow-planning-benchmark:v1" as const;
+
+export const AUTOMATION_BENCHMARK_ARMS = [
+	"strong-single-agent",
+	"one-child",
+	"caller-authored-workflow",
+	"fixed-two-child",
+	"equal-budget-best-of-n",
+	"automation-compiled",
+] as const;
+
+export type AutomationBenchmarkArm = (typeof AUTOMATION_BENCHMARK_ARMS)[number];
+
+export interface AutomationBenchmarkProtocol {
+	version: typeof AUTOMATION_BENCHMARK_VERSION;
+	model: string;
+	evaluator: string;
+	taskIds: string[];
+	pairedSeeds: number[];
+	maxTokens: number;
+	maxCost: number;
+	maxWallClockMs: number;
+	maxMutatingChildren: number;
+	maxRecursiveDepth: number;
+	arms: AutomationBenchmarkArm[];
+}
+
+export interface AutomationBenchmarkAdapter {
+	arm: AutomationBenchmarkArm;
+	model: string;
+	evaluator: string;
+	maxTokens: number;
+	maxCost: number;
+	maxWallClockMs: number;
+	mutatingChildren: number;
+	recursiveDepth: number;
+	informationPolicy: "identical-repository-context";
+	toolPolicy: "matched-authority-ceiling";
+}
+
+export interface AutomationBenchmarkDryRun {
+	version: typeof AUTOMATION_BENCHMARK_VERSION;
+	pairedInstances: number;
+	arms: AutomationBenchmarkArm[];
+	valid: true;
+}
+
+export function validateAutomationBenchmark(
+	protocol: AutomationBenchmarkProtocol,
+	adapters: AutomationBenchmarkAdapter[],
+): AutomationBenchmarkDryRun {
+	if (protocol.version !== AUTOMATION_BENCHMARK_VERSION) {
+		throw new Error("Unsupported automation benchmark protocol");
+	}
+	if (protocol.taskIds.length < 1 || protocol.pairedSeeds.length < 2) {
+		throw new Error("Automation benchmark requires tasks and repeated paired seeds");
+	}
+	if (protocol.maxMutatingChildren !== 2 || protocol.maxRecursiveDepth !== 0) {
+		throw new Error("Automation benchmark width and depth must remain two and zero");
+	}
+	const arms = [...new Set(protocol.arms)].sort();
+	if (
+		arms.length !== AUTOMATION_BENCHMARK_ARMS.length ||
+		AUTOMATION_BENCHMARK_ARMS.some((arm) => !arms.includes(arm))
+	) {
+		throw new Error("Automation benchmark must include every frozen comparison arm");
+	}
+	for (const arm of AUTOMATION_BENCHMARK_ARMS) {
+		const adapter = adapters.find((candidate) => candidate.arm === arm);
+		if (!adapter) throw new Error(`Missing automation benchmark adapter ${arm}`);
+		if (
+			adapter.model !== protocol.model ||
+			adapter.evaluator !== protocol.evaluator ||
+			adapter.maxTokens !== protocol.maxTokens ||
+			adapter.maxCost !== protocol.maxCost ||
+			adapter.maxWallClockMs !== protocol.maxWallClockMs ||
+			adapter.informationPolicy !== "identical-repository-context" ||
+			adapter.toolPolicy !== "matched-authority-ceiling"
+		) {
+			throw new Error(`Automation benchmark adapter ${arm} violates matched resources`);
+		}
+		if (
+			adapter.mutatingChildren > protocol.maxMutatingChildren ||
+			adapter.recursiveDepth > protocol.maxRecursiveDepth
+		) {
+			throw new Error(`Automation benchmark adapter ${arm} exceeds width or depth`);
+		}
+	}
+	return {
+		version: AUTOMATION_BENCHMARK_VERSION,
+		pairedInstances: protocol.taskIds.length * protocol.pairedSeeds.length,
+		arms: [...AUTOMATION_BENCHMARK_ARMS],
+		valid: true,
+	};
+}

package/src/workflow-planning.ts

@@ -1,4 +1,4 @@
-import type { AgentConfig } from "./agents.js";
+import type { AgentConfig } from "./agents/types.js";
 import { routeByCapability } from "./capability-router.js";
 import { normalizeDelegationContract } from "./delegation-contract.js";
 import type { SubagentParams } from "./params.js";
@@ -20,9 +20,12 @@ type WorkRequest = {
 	writePaths?: string[];
 	ownershipKeys?: string[];
 	acceptanceCriteria?: string[];
+	requiredEvidence?: string[];
 	integrationOwner?: boolean;
 	verifierFor?: string;
 	dependencyPolicy?: "completed" | "settled";
+	acceptanceRequired?: boolean;
+	maxReworkCycles?: 0 | 1;
 };
 
 export function resolveWorkflowTasks(
@@ -54,6 +57,7 @@ export function createBlockingWorkLedger(
 	params: SubagentParams,
 	resolvedWorkflowTasks: ResolvedWorkflowTask[],
 	aggregator: Aggregator | undefined,
+	verifiedTarget?: { id: string; maxReworkCycles: 0 | 1 },
 ): WorkItemLedger | undefined {
 	if (params.agent && params.task) {
 		return WorkItemLedger.create({
@@ -109,6 +113,9 @@ export function createBlockingWorkLedger(
 					integrationOwner:
 						task.integrationOwner ??
 						(!hasExplicitIntegrationOwner && index === defaultIntegrationOwnerIndex),
+					...(verifiedTarget?.id === task.id
+						? { acceptanceRequired: true, maxReworkCycles: verifiedTarget.maxReworkCycles }
+						: {}),
 				}),
 			),
 		});
@@ -155,8 +162,11 @@ function definition(
 		writePaths: request.writePaths ?? contract?.requestedAuthority?.writePaths ?? [],
 		ownershipKeys: request.ownershipKeys ?? [],
 		acceptanceCriteria: request.acceptanceCriteria ?? contract?.acceptanceCriteria ?? [],
+		requiredEvidence: request.requiredEvidence ?? contract?.requiredEvidence ?? [],
 		integrationOwner: request.integrationOwner,
 		verifierFor: request.verifierFor,
 		dependencyPolicy: request.dependencyPolicy,
+		acceptanceRequired: request.acceptanceRequired,
+		maxReworkCycles: request.maxReworkCycles,
 	};
 }

package/src/workflow-ui.ts

@@ -1,5 +1,5 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { DelegationWorkflow } from "./settings.js";
+import type { DelegationWorkflow } from "./settings/inspection.js";
 
 export async function showWorkflowPreview(
 	ctx: ExtensionCommandContext,
@@ -46,8 +46,8 @@ function workflowEffects(current: DelegationWorkflow, next: DelegationWorkflow):
 	if (blockingEnabled(current) !== blockingEnabled(next)) {
 		effects.push(
 			blockingEnabled(next)
-				? "Add blocking `subagent` and read-only `subagent_consult`"
-				: "Remove blocking `subagent` and read-only `subagent_consult`",
+				? "Add blocking `subagent`, explicit `subagent_auto`, and read-only `subagent_consult`"
+				: "Remove blocking `subagent`, explicit `subagent_auto`, and read-only `subagent_consult`",
 		);
 	}
 	if (asyncEnabled(current) !== asyncEnabled(next)) {