@narumitw/pi-subagents 2.1.4 → 3.0.0

package/src/integration-controller.ts

@@ -1,98 +0,0 @@
-import * as path from "node:path";
-
-export interface ManagedIntegrationExpectation {
-	taskId: string;
-	taskGeneration: number;
-	baseRepositoryGeneration: string;
-	dependencyVersions: Record<string, string>;
-	readSetVersions: Record<string, string>;
-	executionPlanId: string;
-	allowedScopes: string[];
-	patchDigest: string;
-	requiredEvidence: string[];
-}
-
-export interface ManagedIntegrationCandidate extends ManagedIntegrationExpectation {
-	changedPaths: string[];
-	evidence: Record<string, string>;
-	verifier: {
-		freshContext: boolean;
-		exactIntegratedTree: boolean;
-		status: "accepted" | "rework" | "rejected";
-	};
-}
-
-export interface ManagedIntegrationAcceptance {
-	status: "accepted";
-	taskId: string;
-	taskGeneration: number;
-	patchDigest: string;
-	executionPlanId: string;
-}
-
-export function verifyManagedIntegration(
-	expected: ManagedIntegrationExpectation,
-	candidate: ManagedIntegrationCandidate,
-): ManagedIntegrationAcceptance {
-	if (
-		candidate.taskId !== expected.taskId ||
-		candidate.taskGeneration !== expected.taskGeneration
-	) {
-		throw new Error("Managed integration rejected stale task generation");
-	}
-	if (candidate.baseRepositoryGeneration !== expected.baseRepositoryGeneration) {
-		throw new Error("Managed integration rejected stale base repository generation");
-	}
-	if (candidate.executionPlanId !== expected.executionPlanId) {
-		throw new Error("Managed integration rejected stale execution plan identity");
-	}
-	if (!sameRecord(candidate.dependencyVersions, expected.dependencyVersions)) {
-		throw new Error("Managed integration rejected stale dependency versions");
-	}
-	if (!sameRecord(candidate.readSetVersions, expected.readSetVersions)) {
-		throw new Error("Managed integration rejected stale read-set versions");
-	}
-	if (candidate.patchDigest !== expected.patchDigest) {
-		throw new Error("Managed integration rejected patch digest mismatch");
-	}
-	const allowedScopes = expected.allowedScopes.map(normalizedPath);
-	if (
-		!candidate.changedPaths.every((changedPath) => {
-			const normalizedChangedPath = normalizedPath(changedPath);
-			return allowedScopes.some(
-				(scope) =>
-					normalizedChangedPath === scope ||
-					normalizedChangedPath.startsWith(`${scope}${path.sep}`),
-			);
-		})
-	) {
-		throw new Error("Managed integration rejected a path outside the accepted scope");
-	}
-	if (expected.requiredEvidence.some((id) => !candidate.evidence[id])) {
-		throw new Error("Managed integration rejected missing required evidence");
-	}
-	if (!candidate.verifier.freshContext || !candidate.verifier.exactIntegratedTree) {
-		throw new Error("Managed integration requires a fresh verifier on the exact integrated tree");
-	}
-	if (candidate.verifier.status !== "accepted") {
-		throw new Error(`Managed integration verifier returned ${candidate.verifier.status}`);
-	}
-	return {
-		status: "accepted",
-		taskId: expected.taskId,
-		taskGeneration: expected.taskGeneration,
-		patchDigest: expected.patchDigest,
-		executionPlanId: expected.executionPlanId,
-	};
-}
-
-function normalizedPath(value: string): string {
-	if (!value || value.includes("\0")) throw new Error("Managed integration scope is invalid");
-	return path.resolve(path.sep, value.replaceAll("\\", path.sep));
-}
-
-function sameRecord(left: Record<string, string>, right: Record<string, string>): boolean {
-	const leftEntries = Object.entries(left).sort(([a], [b]) => a.localeCompare(b));
-	const rightEntries = Object.entries(right).sort(([a], [b]) => a.localeCompare(b));
-	return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
-}

package/src/limits.ts

@@ -1,75 +0,0 @@
-import { DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
-
-export const DEFAULT_MAX_OUTPUT_BYTES = DEFAULT_MAX_BYTES;
-export const DEFAULT_MAX_STDERR_BYTES = 16 * 1024;
-export const DEFAULT_MAX_CONTEXT_BYTES = DEFAULT_MAX_BYTES;
-export const MAX_SUBAGENT_TIMEOUT_MS = 2_147_483_647;
-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";
-
-export interface BoundedText {
-	text: string;
-	truncated: boolean;
-	originalBytes: number;
-}
-
-function normalizeByteLimit(maxBytes: number): number {
-	if (maxBytes === Number.POSITIVE_INFINITY) return Number.MAX_SAFE_INTEGER;
-	if (!Number.isFinite(maxBytes)) return 0;
-	return Math.max(0, Math.floor(maxBytes));
-}
-
-export function truncateUtf8(text: string, maxBytes: number): BoundedText {
-	const limit = normalizeByteLimit(maxBytes);
-	const originalBytes = Buffer.byteLength(text, "utf8");
-	if (originalBytes <= limit) return { text, truncated: false, originalBytes };
-	if (limit === 0) return { text: "", truncated: true, originalBytes };
-
-	const marker = Buffer.from(TRUNCATION_MARKER, "utf8");
-	if (marker.length >= limit) {
-		return {
-			text: Buffer.from(text, "utf8").subarray(0, limit).toString("utf8").replace(/�+$/g, ""),
-			truncated: true,
-			originalBytes,
-		};
-	}
-	const prefix = Buffer.from(text, "utf8")
-		.subarray(0, limit - marker.length)
-		.toString("utf8")
-		.replace(/�+$/g, "");
-	return { text: `${prefix}${TRUNCATION_MARKER}`, truncated: true, originalBytes };
-}
-
-export function truncateUtf8Tail(text: string, maxBytes: number): BoundedText {
-	const limit = normalizeByteLimit(maxBytes);
-	const bytes = Buffer.from(text, "utf8");
-	const originalBytes = bytes.length;
-	if (originalBytes <= limit) return { text, truncated: false, originalBytes };
-	if (limit === 0) return { text: "", truncated: true, originalBytes };
-
-	const marker = Buffer.from(TAIL_TRUNCATION_MARKER, "utf8");
-	if (marker.length >= limit) {
-		return {
-			text: bytes
-				.subarray(originalBytes - limit)
-				.toString("utf8")
-				.replace(/^�+/g, ""),
-			truncated: true,
-			originalBytes,
-		};
-	}
-	const suffix = bytes
-		.subarray(originalBytes - (limit - marker.length))
-		.toString("utf8")
-		.replace(/^�+/g, "");
-	return { text: `${TAIL_TRUNCATION_MARKER}${suffix}`, truncated: true, originalBytes };
-}
-
-export function appendBounded(current: string, addition: string, maxBytes: number): BoundedText {
-	return truncateUtf8(current + addition, maxBytes);
-}

package/src/orchestration-metrics.ts

@@ -1,116 +0,0 @@
-import type { SingleResult } from "./runner-types.js";
-import type { WorkItemLedgerSnapshot } from "./work-item-ledger.js";
-
-export interface OrchestrationMetrics {
-	workItems: number;
-	completed: number;
-	failedOrBlocked: number;
-	invalidated: number;
-	requiredTransfers: number;
-	resolvedTransfers: number;
-	transferCoverage: number;
-	attempts: number;
-	hedgedTasks: number;
-	requestedTools: number;
-	effectiveRequestedTools: number;
-	permissionPrecision: number;
-	workerReportedVerification: number;
-	executorAcceptedVerification: number;
-	verificationRework: number;
-	verificationRejected: number;
-	verificationInvalid: number;
-	verificationTreeMismatch: number;
-	panelValidReviews?: number;
-	panelFailedReviews?: number;
-	panelBlockingObjections?: number;
-	panelDissent?: number;
-	panelSynthesisState?: string;
-}
-
-export function calculateOrchestrationMetrics(
-	workflow: WorkItemLedgerSnapshot | undefined,
-	results: SingleResult[],
-	panel?: {
-		validReviewCount: number;
-		failedReviewCount: number;
-		blockingObjectionCount: number;
-		dissentCount: number;
-		state: string;
-	},
-): OrchestrationMetrics {
-	const items = workflow?.items ?? [];
-	const requiredTransfers = items.reduce((sum, item) => sum + item.inputArtifacts.length, 0);
-	const resolvedTransfers = items.reduce(
-		(sum, item) => sum + Object.keys(item.inputArtifactVersions).length,
-		0,
-	);
-	const requestedTools = results.reduce(
-		(sum, result) => sum + (result.executionPlan?.requestedTools.length ?? 0),
-		0,
-	);
-	const effectiveRequestedTools = results.reduce((sum, result) => {
-		const plan = result.executionPlan;
-		if (!plan) return sum;
-		return (
-			sum +
-			plan.requestedTools.filter((tool) => plan.effectiveTools?.includes(tool) === true).length
-		);
-	}, 0);
-	return {
-		workItems: items.length,
-		completed: items.filter((item) => item.state === "completed").length,
-		failedOrBlocked: items.filter((item) =>
-			["failed", "blocked", "needs-input", "interrupted"].includes(item.state),
-		).length,
-		invalidated: items.filter((item) => ["stale", "invalidated"].includes(item.state)).length,
-		requiredTransfers,
-		resolvedTransfers,
-		transferCoverage: requiredTransfers === 0 ? 1 : resolvedTransfers / requiredTransfers,
-		attempts: results.reduce((sum, result) => sum + (result.attemptCount ?? 1), 0),
-		hedgedTasks: results.filter((result) => result.hedged).length,
-		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" ||
-					item.acceptanceReceiptHistory.some((receipt) => receipt.decision === "rework")),
-		).length,
-		verificationRejected: items.filter(
-			(item) =>
-				!item.verifierFor &&
-				(item.verificationReceipt?.decision === "reject" || item.acceptanceState === "rejected"),
-		).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",
-					"verification-tree-drift",
-				].includes(item.outcomeReason ?? ""),
-		).length,
-		...(panel
-			? {
-					panelValidReviews: panel.validReviewCount,
-					panelFailedReviews: panel.failedReviewCount,
-					panelBlockingObjections: panel.blockingObjectionCount,
-					panelDissent: panel.dissentCount,
-					panelSynthesisState: panel.state,
-				}
-			: {}),
-	};
-}

package/src/outcome.ts

@@ -1,61 +0,0 @@
-import type { SubagentOutcomeStatus } from "./result-contract.js";
-
-export interface ClassifiedSubagentOutcome {
-	status: SubagentOutcomeStatus;
-	reasonCode?: string;
-	recoveryActions: string[];
-	retryable: boolean;
-}
-
-const TRANSIENT_REASONS = new Set(["transient-transport", "transient-tool"]);
-
-export function classifyStructuredOutcome(
-	status: SubagentOutcomeStatus,
-	reasonCode?: string,
-): ClassifiedSubagentOutcome {
-	if (TRANSIENT_REASONS.has(reasonCode ?? "") && status === "failed") {
-		return {
-			status,
-			...(reasonCode ? { reasonCode } : {}),
-			recoveryActions: ["retry"],
-			retryable: true,
-		};
-	}
-	const recoveryActions = recoveryFor(status, reasonCode);
-	return {
-		status,
-		...(reasonCode ? { reasonCode } : {}),
-		recoveryActions,
-		retryable: false,
-	};
-}
-
-function recoveryFor(status: SubagentOutcomeStatus, reasonCode?: string): string[] {
-	if (reasonCode === "missing-dependency" || reasonCode === "missing-context") {
-		return ["supply-input"];
-	}
-	if (reasonCode === "ambiguous-task") return ["clarify"];
-	if (reasonCode === "capability-mismatch" || reasonCode === "authority-missing") {
-		return ["reroute"];
-	}
-	if (reasonCode === "dependency-superseded" || status === "stale") return ["revalidate"];
-	if (reasonCode === "verification-failed") return ["replan", "verify"];
-	if (reasonCode === "unsupported-guarantee") return ["stop"];
-	switch (status) {
-		case "completed":
-		case "partial":
-			return [];
-		case "needs-input":
-			return ["supply-input"];
-		case "blocked":
-			return ["clarify"];
-		case "abstained":
-			return ["reroute"];
-		case "contract-invalid":
-			return ["repair-contract"];
-		case "interrupted":
-			return ["stop"];
-		case "failed":
-			return ["stop"];
-	}
-}

package/src/panel-child-group.ts

@@ -1,35 +0,0 @@
-import type { IsolatedWorkspace } from "./workspace.js";
-import { WorkspaceManager } from "./workspace.js";
-
-export class PanelChildGroup {
-	private readonly controller = new AbortController();
-	private readonly workspaces = new WorkspaceManager();
-	private closingStarted = false;
-	private cleanupComplete = false;
-	private readonly onParentAbort = () => this.controller.abort(this.parentSignal?.reason);
-
-	constructor(private readonly parentSignal?: AbortSignal) {
-		if (parentSignal?.aborted) this.controller.abort(parentSignal.reason);
-		else parentSignal?.addEventListener("abort", this.onParentAbort, { once: true });
-	}
-
-	get signal(): AbortSignal {
-		return this.controller.signal;
-	}
-
-	async createWorkspace(ownerId: string, cwd: string): Promise<IsolatedWorkspace> {
-		if (this.closingStarted) throw new Error("Panel child group is closing or closed");
-		return this.workspaces.create(ownerId, cwd);
-	}
-
-	async close(): Promise<void> {
-		if (this.cleanupComplete) return;
-		if (!this.closingStarted) {
-			this.closingStarted = true;
-			this.parentSignal?.removeEventListener("abort", this.onParentAbort);
-			if (!this.controller.signal.aborted) this.controller.abort("panel-settled");
-		}
-		await this.workspaces.cleanupAll();
-		this.cleanupComplete = true;
-	}
-}