@selesai/code 0.6.2 → 0.7.0

package/dist/extensions/pi-subagents/src/runs/shared/acceptance.ts

@@ -22,7 +22,7 @@ import type {
 	SubagentRunMode,
 } from "../../shared/types.ts";
 import { isAgentContractV1 } from "./agent-contract.ts";
-import { classifyTaskMutationIntent, resolveAgentRoutingRole, taskMayMutate } from "./task-intent.ts";
+import { classifyTaskMutationIntent, taskMayMutate } from "./task-intent.ts";
 
 const LEVEL_RANK: Record<Exclude<AcceptanceLevel, "auto">, number> = {
 	none: 0,
@@ -50,7 +50,7 @@ const ACCEPTANCE_CONFIG_KEYS = new Set(["level", "criteria", "evidence", "verify
 const ACCEPTANCE_GATE_KEYS = new Set(["id", "must", "evidence", "severity"]);
 const ACCEPTANCE_VERIFY_KEYS = new Set(["id", "command", "timeoutMs", "cwd", "env", "allowFailure"]);
 const ACCEPTANCE_REVIEW_KEYS = new Set(["agent", "focus", "required"]);
-const EXPLICIT_REVIEWED_UNAVAILABLE = "is an achieved status, not a requestable acceptance level. For a read-only reviewer call, omit acceptance. To require independent review of a writer result, use acceptance.review.required and orchestrate the reviewer separately.";
+const EXPLICIT_REVIEWED_UNAVAILABLE = "is an achieved status, not a requestable acceptance level. For a read-only commentator call, omit acceptance. To require independent review of a writer result, use acceptance.review.required and orchestrate the commentator separately.";
 
 function normalizeLevel(level: AcceptanceLevel | undefined): Exclude<AcceptanceLevel, "auto"> | "auto" {
 	return level ?? "auto";
@@ -82,21 +82,25 @@ function inferLevel(input: {
 	dynamic?: boolean;
 	dynamicGroup?: boolean;
 }): { level: Exclude<AcceptanceLevel, "auto">; reasons: string[]; criteria: string[]; evidence: AcceptanceEvidenceKind[]; review?: { agent?: string; required?: boolean } } {
+	const agent = input.agentName.toLowerCase();
 	const task = input.task?.toLowerCase() ?? "";
 	const reasons: string[] = [];
 	// Declared roles replace name heuristics, so use the full writer grammar to detect explicit mutation independently of the actual agent name.
-	const intent = classifyTaskMutationIntent(input.acceptanceRole ? "builder" : input.agentName, input.task ?? "");
-	const readOnlyTask = intent.kind === "read-only"
-		|| (intent.kind === "unknown" && /\b(?:read[- ]only|review[- ]only|no edits|without edits|inspect|summari[sz]e)\b/.test(task));
+	const intent = classifyTaskMutationIntent(input.acceptanceRole ? "worker" : input.agentName, input.task ?? "");
+	const taskMutation = taskMayMutate(input.task ?? "");
+	const reviewerStyleAgent = /\b(?:commentator|reviewer|oracle|advisor)\b/.test(agent);
+	const readOnlyTask = (intent.kind === "read-only" && (!taskMutation || reviewerStyleAgent))
+		|| (intent.kind === "unknown" && !taskMutation && /\b(?:read[- ]only|review[- ]only|no edits|without edits|inspect|summari[sz]e)\b/.test(task));
 	const rolePatchTask = input.acceptanceRole !== undefined
 		&& intent.kind !== "read-only"
 		&& !/\b(?:do not|don't|must not)\s+patch\b/.test(task)
 		&& /\bpatch\s+(?:(?:\.{0,2}[\\/])?(?:[\w.-]+[\\/])+[\w.-]+|[\w.-]+\.[a-z0-9]+\b|(?:the\s+)?parser\b)/.test(task);
-	const taskMayWrite = readOnlyTask ? false : taskMayMutate(input.task ?? "") || intent.kind === "implementation" || rolePatchTask;
-	const routingRole = resolveAgentRoutingRole(input.agentName, input.acceptanceRole);
-	const readOnlyAgent = routingRole === "read-only";
+	const taskMayWrite = readOnlyTask ? false : taskMutation || intent.kind === "implementation" || rolePatchTask;
+	const readOnlyAgent = input.acceptanceRole === "read-only"
+		|| (input.acceptanceRole === undefined && /\b(?:commentator|architect|explorer|recapper|researcher|reviewer|oracle|scout|context-builder|analyst)\b/.test(agent));
 	const writeTask = taskMayWrite
-		|| (routingRole === "writer" && !readOnlyTask);
+		|| (input.acceptanceRole === "writer" && !readOnlyTask)
+		|| (input.acceptanceRole === undefined && /\b(?:builder|worker)\b/.test(agent) && !readOnlyTask);
 	const inferredReadOnly = readOnlyTask || (input.acceptanceRole === "read-only" && !taskMayWrite);
 	const roleResolvesReadOnly = input.acceptanceRole !== undefined && inferredReadOnly;
 	const keywordRiskReadOnly = input.acceptanceRole === undefined ? intent.kind === "read-only" : inferredReadOnly;
@@ -117,7 +121,7 @@ function inferLevel(input: {
 		};
 	}
 	if (writeTask && !readOnlyTask) {
-		reasons.push(input.acceptanceRole === "writer" && !taskMayWrite ? "declared writer acceptance role" : "write-capable worker/task");
+		reasons.push(input.acceptanceRole === "writer" && !taskMayWrite ? "declared writer acceptance role" : "write-capable builder/task");
 		return {
 			level: "checked",
 			reasons,
@@ -126,7 +130,7 @@ function inferLevel(input: {
 		};
 	}
 	if (readOnlyAgent || readOnlyTask) {
-		reasons.push(input.acceptanceRole === "read-only" && !readOnlyTask ? "declared read-only acceptance role" : readOnlyAgent ? "read-only/reviewer-style agent" : "read-only task wording");
+		reasons.push(input.acceptanceRole === "read-only" && !readOnlyTask ? "declared read-only acceptance role" : readOnlyAgent ? "read-only/commentator-style agent" : "read-only task wording");
 		return {
 			level: "attested",
 			reasons,
@@ -167,6 +171,7 @@ export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"
 		if (input === "reviewed") errors.push(`${pathLabel} ${EXPLICIT_REVIEWED_UNAVAILABLE}`);
 		else if (!VALID_LEVELS.has(input as AcceptanceLevel)) errors.push(`${pathLabel} has invalid level '${input}'.`);
 		else if (input === "none") errors.push(`${pathLabel} level "none" requires a reason; use { level: "none", reason: "..." }.`);
+		else if (input === "verified") errors.push(`${pathLabel} level "verified" requires object form with at least one verify command.`);
 		return errors;
 	}
 	if (!input || typeof input !== "object" || Array.isArray(input)) {
@@ -230,7 +235,11 @@ export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"
 	} else if (value.evidence !== undefined) {
 		errors.push(`${pathLabel}.evidence must be an array. ${ACCEPTANCE_EVIDENCE_HELP}`);
 	}
-	if (value.verify !== undefined && !Array.isArray(value.verify)) errors.push(`${pathLabel}.verify must be an array.`);
+	if (value.level === "verified" && (!Array.isArray(value.verify) || value.verify.length === 0)) {
+		errors.push(`${pathLabel}.verify must contain at least one command when level is verified.`);
+	} else if (value.verify !== undefined && !Array.isArray(value.verify)) {
+		errors.push(`${pathLabel}.verify must be an array.`);
+	}
 	if (Array.isArray(value.verify)) {
 		for (const [index, command] of value.verify.entries()) {
 			if (!command || typeof command !== "object" || Array.isArray(command)) {
@@ -309,7 +318,7 @@ export function validateExecutionAcceptance(input: {
 }
 
 function normalizeCriteria(criteria: Array<string | { id?: string; must?: string; evidence?: AcceptanceEvidenceKind[]; severity?: "required" | "recommended" }> | undefined, evidence: AcceptanceEvidenceKind[]): ResolvedAcceptanceGate[] {
-	return (criteria ?? []).map((criterion, index) => {
+	return (criteria ?? []).map((criterion, index): ResolvedAcceptanceGate => {
 		if (typeof criterion === "string") {
 			return { id: `criterion-${index + 1}`, must: criterion, evidence, severity: "required" };
 		}
@@ -403,7 +412,7 @@ export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig, opt
 		lines.push("", "Runtime verification commands configured by parent:");
 		for (const command of acceptance.verify) lines.push(`- ${command.id}: ${command.command}`);
 	}
-	if (acceptance.review && acceptance.review !== false) {
+	if (acceptance.review) {
 		lines.push("", `Review gate: ${acceptance.review.required === false ? "optional" : "required"}${acceptance.review.agent ? ` by ${acceptance.review.agent}` : ""}.`);
 		if (acceptance.review.focus) lines.push(`Review focus: ${acceptance.review.focus}`);
 	}
@@ -648,6 +657,21 @@ function parseAcceptanceReportBody(body: string): { report?: AcceptanceReport; e
 	return validateAcceptanceReport(parseReportJson(body));
 }
 
+function parseUnterminatedAcceptanceReportFence(output: string): { report?: AcceptanceReport; error?: string } {
+	const opener = /```acceptance[-_]report\b[^\n]*\n/gi.exec(output);
+	if (!opener) return {};
+	const bodyStart = opener.index + opener[0].length;
+	if (output.indexOf("```", bodyStart) !== -1) return {};
+	try {
+		const validation = validateAcceptanceReport(JSON.parse(output.slice(bodyStart).trim()) as unknown);
+		return validation.report
+			? { report: validation.report }
+			: { error: `Failed to parse acceptance-report: Invalid acceptance-report: ${validation.errors.join("; ")}` };
+	} catch (error) {
+		return { error: `Failed to parse acceptance-report: ${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+
 function parseGenericJsonAcceptanceReportBody(body: string): { report?: AcceptanceReport; error?: string } {
 	const parsed = parseReportJson(body);
 	const normalized = normalizeAcceptanceReportValue(parsed);
@@ -679,6 +703,8 @@ export function parseAcceptanceReport(output: string): { report?: AcceptanceRepo
 	}
 	if (parseErrors.length > 0) return { error: `Failed to parse acceptance-report: ${parseErrors.join("; ")}` };
 	if (explicitFencePresent) {
+		const recovered = parseUnterminatedAcceptanceReportFence(output);
+		if (recovered.report || recovered.error) return recovered;
 		return { error: "Failed to parse acceptance-report: Empty or unterminated acceptance-report fence." };
 	}
 	for (const body of fencedBlocks(output, "(?:json|jsonc|json5)")) {
@@ -901,7 +927,7 @@ function reportEvidenceStatus(report: AcceptanceReport, kind: AcceptanceEvidence
 }
 
 function checkNoStagedFiles(cwd: string): AcceptanceRuntimeCheck {
-	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8" });
+	const result = spawnSync("git", ["status", "--short"], { cwd, encoding: "utf-8", windowsHide: true });
 	if (result.status !== 0) {
 		return { id: "no-staged-files", status: "not-applicable", message: "git status unavailable; no staged-files check skipped" };
 	}
@@ -940,7 +966,7 @@ function uniqueStrings(items: Array<string | undefined>): string[] {
 }
 
 export function aggregateAcceptanceReport(input: {
-	results: Array<Pick<SingleResult, "agent" | "acceptance" | "error" | "exitCode">>;
+	results: Array<Pick<SingleResult, "agent" | "acceptance" | "error"> & { exitCode: number | null }>;
 	notes?: string;
 }): AcceptanceReport {
 	const childReports = input.results.map((result) => result.acceptance?.childReport).filter((report): report is AcceptanceReport => Boolean(report));
@@ -950,7 +976,7 @@ export function aggregateAcceptanceReport(input: {
 		criteriaSatisfied: [
 			{ id: "criterion-1", status: successfulChildren ? "satisfied" : "not-satisfied", evidence: successfulChildren ? `All ${input.results.length} dynamic child run(s) completed without child or acceptance blockers.` : "Dynamic fanout produced no accepted child evidence." },
 			{ id: "criterion-2", status: successfulChildren ? "satisfied" : "not-satisfied", evidence: successfulChildren ? "Collected child acceptance evidence for aggregate review." : "Dynamic fanout produced no aggregate review evidence." },
-			...input.results.map((result, index) => ({
+			...input.results.map((result, index): { id?: string; status: "satisfied" | "not-satisfied" | "not-applicable"; evidence: string } => ({
 				id: `child-${index + 1}`,
 				status: result.exitCode === 0 && result.acceptance?.status !== "rejected" ? "satisfied" : "not-satisfied",
 				evidence: `${result.agent}: acceptance ${result.acceptance?.status ?? "unreported"}${result.error ? ` (${result.error})` : ""}`,
@@ -1146,7 +1172,7 @@ export async function evaluateAcceptance(input: {
 		ledger.evidenceStatus = ledger.status;
 	}
 
-	if (acceptance.review && acceptance.review !== false) {
+	if (acceptance.review) {
 		if (input.reviewResult?.status === "reviewed") {
 			ledger.reviewResult = input.reviewResult;
 			ledger.status = "reviewed";

package/dist/extensions/pi-subagents/src/runs/shared/capability-ceiling.ts

@@ -1,5 +1,4 @@
 import { Buffer } from "node:buffer";
-import "../../shared/env.ts";
 
 export const SUBAGENT_CAPABILITY_CEILING_VERSION = 1 as const;
 export const SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY = "pi-subagents.capability-ceiling.v1";

package/dist/extensions/pi-subagents/src/runs/shared/child-protocol.ts

@@ -6,6 +6,236 @@ export type { ProtocolOutputLimit } from "../../shared/types.ts";
 export const MAX_CHILD_PENDING_LINE_BYTES = 16 * 1024 * 1024;
 export const MAX_CHILD_STDERR_BYTES = 128 * 1024;
 const MAX_PROTOCOL_DIAGNOSTIC_BYTES = 4096;
+const MAX_PROJECTED_JSON_DEPTH = 256;
+
+export interface OversizedLineProjection {
+	push(chunk: Buffer): boolean;
+	finish(): string | undefined;
+}
+
+export interface OversizedLineProjector {
+	accepts(prefix: string): boolean;
+	create(): OversizedLineProjection;
+}
+
+type JsonContainer =
+	| { type: "array"; state: "value-or-end" | "value" | "comma-or-end" }
+	| { type: "object"; state: "key-or-end" | "key" | "colon" | "value" | "comma-or-end"; key?: string };
+
+type JsonToken =
+	| { type: "string"; role: "key" | "value"; value: string; capture: boolean; escape: boolean; unicodeDigits: number; unicodeValue: string }
+	| { type: "literal"; expected: string; index: number; value: boolean | null }
+	| { type: "number"; phase: "minus" | "zero" | "int" | "dot" | "frac" | "exp" | "exp-sign" | "exp-digits" };
+
+function createPiAggregateProjection(): OversizedLineProjection {
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const stack: JsonContainer[] = [];
+	let rootState: "value" | "end" = "value";
+	let token: JsonToken | undefined;
+	let valid = true;
+	let eventType: string | undefined;
+	let willRetry: boolean | undefined;
+
+	const parent = (): JsonContainer | undefined => stack.at(-1);
+	const isTopLevelField = (key: string | undefined): boolean => stack.length === 1 && parent()?.type === "object" && (key === "type" || key === "willRetry");
+
+	const completeValue = (value?: string | boolean | null): void => {
+		const container = parent();
+		if (!container) {
+			rootState = "end";
+			return;
+		}
+		if (container.type === "object") {
+			if (stack.length === 1 && container.key === "type" && typeof value === "string") eventType = value;
+			if (stack.length === 1 && container.key === "willRetry" && typeof value === "boolean") willRetry = value;
+			container.key = undefined;
+			container.state = "comma-or-end";
+		} else container.state = "comma-or-end";
+	};
+
+	const startValue = (char: string): boolean => {
+		const container = parent();
+		const key = container?.type === "object" ? container.key : undefined;
+		if (isTopLevelField(key)) {
+			if (key === "type") eventType = undefined;
+			else willRetry = undefined;
+		}
+		if (char === "{" || char === "[") {
+			if (stack.length >= MAX_PROJECTED_JSON_DEPTH) return false;
+			stack.push(char === "{" ? { type: "object", state: "key-or-end" } : { type: "array", state: "value-or-end" });
+			return true;
+		}
+		if (char === '"') {
+			token = { type: "string", role: "value", value: "", capture: key === "type" && stack.length === 1, escape: false, unicodeDigits: 0, unicodeValue: "" };
+			return true;
+		}
+		if (char === "t") token = { type: "literal", expected: "true", index: 1, value: true };
+		else if (char === "f") token = { type: "literal", expected: "false", index: 1, value: false };
+		else if (char === "n") token = { type: "literal", expected: "null", index: 1, value: null };
+		else if (char === "-") token = { type: "number", phase: "minus" };
+		else if (char === "0") token = { type: "number", phase: "zero" };
+		else if (char >= "1" && char <= "9") token = { type: "number", phase: "int" };
+		else return false;
+		return true;
+	};
+
+	const closeContainer = (): true => {
+		stack.pop();
+		completeValue();
+		return true;
+	};
+
+	const processChar = (char: string): boolean => {
+		if (token?.type === "string") {
+			if (token.unicodeDigits > 0) {
+				if (!/[0-9a-fA-F]/.test(char)) return false;
+				token.unicodeValue += char;
+				token.unicodeDigits--;
+				if (token.unicodeDigits === 0 && token.capture) {
+					if (token.value.length >= 64) return false;
+					token.value += String.fromCharCode(Number.parseInt(token.unicodeValue, 16));
+				}
+				return true;
+			}
+			if (token.escape) {
+				token.escape = false;
+				if (char === "u") { token.unicodeDigits = 4; token.unicodeValue = ""; return true; }
+				if (!'"\\/bfnrt'.includes(char)) return false;
+				if (token.capture) {
+					if (token.value.length >= 64) return false;
+					token.value += ({ b: "\b", f: "\f", n: "\n", r: "\r", t: "\t" } as Record<string, string>)[char] ?? char;
+				}
+				return true;
+			}
+			if (char === "\\") { token.escape = true; return true; }
+			if (char === '"') {
+				const finished = token;
+				token = undefined;
+				if (finished.role === "key") {
+					const container = parent();
+					if (!container || container.type !== "object") return false;
+					container.key = finished.value;
+					container.state = "colon";
+				} else completeValue(finished.capture ? finished.value : undefined);
+				return true;
+			}
+			if (char.charCodeAt(0) < 0x20) return false;
+			if (token.capture) {
+				if (token.value.length >= 64) return false;
+				token.value += char;
+			}
+			return true;
+		}
+		if (token?.type === "literal") {
+			if (char !== token.expected[token.index]) return false;
+			token.index++;
+			if (token.index === token.expected.length) {
+				const value = token.value;
+				token = undefined;
+				completeValue(value);
+			}
+			return true;
+		}
+		if (token?.type === "number") {
+			const phase = token.phase;
+			if (phase === "minus") {
+				if (char === "0") token.phase = "zero";
+				else if (char >= "1" && char <= "9") token.phase = "int";
+				else return false;
+				return true;
+			}
+			if (phase === "zero" || phase === "int") {
+				if (char >= "0" && char <= "9") { if (phase === "zero") return false; return true; }
+				if (char === ".") { token.phase = "dot"; return true; }
+				if (char === "e" || char === "E") { token.phase = "exp"; return true; }
+			} else if (phase === "dot") {
+				if (char >= "0" && char <= "9") { token.phase = "frac"; return true; }
+				return false;
+			} else if (phase === "frac") {
+				if (char >= "0" && char <= "9") return true;
+				if (char === "e" || char === "E") { token.phase = "exp"; return true; }
+			} else if (phase === "exp") {
+				if (char === "+" || char === "-") { token.phase = "exp-sign"; return true; }
+				if (char >= "0" && char <= "9") { token.phase = "exp-digits"; return true; }
+				return false;
+			} else if (phase === "exp-sign") {
+				if (char >= "0" && char <= "9") { token.phase = "exp-digits"; return true; }
+				return false;
+			} else if (phase === "exp-digits" && char >= "0" && char <= "9") return true;
+			if (!["zero", "int", "frac", "exp-digits"].includes(phase)) return false;
+			token = undefined;
+			completeValue();
+			return processChar(char);
+		}
+		if (char === " " || char === "\t" || char === "\r" || char === "\n") return true;
+		const container = parent();
+		if (!container) return rootState === "value" ? startValue(char) : false;
+		if (container.type === "object") {
+			if (container.state === "key-or-end" || container.state === "key") {
+				if (char === "}" && container.state === "key-or-end") return closeContainer();
+				if (char !== '"') return false;
+				token = { type: "string", role: "key", value: "", capture: stack.length === 1, escape: false, unicodeDigits: 0, unicodeValue: "" };
+				return true;
+			}
+			if (container.state === "colon") {
+				if (char !== ":") return false;
+				container.state = "value";
+				return true;
+			}
+			if (container.state === "value") return startValue(char);
+			if (char === ",") { container.state = "key"; return true; }
+			if (char === "}") return closeContainer();
+			return false;
+		}
+		if (container.state === "value-or-end" || container.state === "value") {
+			if (char === "]" && container.state === "value-or-end") return closeContainer();
+			return startValue(char);
+		}
+		if (char === ",") { container.state = "value"; return true; }
+		if (char === "]") return closeContainer();
+		return false;
+	};
+
+	const processText = (text: string): boolean => {
+		for (const char of text) if (!processChar(char)) return false;
+		return true;
+	};
+
+	return {
+		push(chunk) {
+			if (!valid) return false;
+			try { valid = processText(decoder.decode(chunk, { stream: true })); }
+			catch { valid = false; }
+			return valid;
+		},
+		finish() {
+			try { valid = valid && processText(decoder.decode()); }
+			catch { valid = false; }
+			if (token?.type === "number" && ["zero", "int", "frac", "exp-digits"].includes(token.phase)) {
+				token = undefined;
+				completeValue();
+			}
+			if (!valid || token || stack.length !== 0 || rootState !== "end") return undefined;
+			if (eventType === "turn_end") return '{"type":"turn_end"}';
+			if (eventType === "agent_end" && typeof willRetry === "boolean") return JSON.stringify({ type: "agent_end", willRetry });
+			return undefined;
+		},
+	};
+}
+
+/**
+ * Pi JSON mode emits granular message/tool events followed by aggregate
+ * `turn_end` and `agent_end` events that duplicate those payloads. Parallel
+ * image reads can make one aggregate record exceed the child line limit even
+ * though every granular event was valid. Replace only syntactically valid,
+ * redundant records with the lifecycle fields the runners consume.
+ */
+export const PI_AGGREGATE_EVENT_PROJECTOR: OversizedLineProjector = {
+	accepts(prefix) {
+		return prefix.startsWith('{"type":"turn_end"') || prefix.startsWith('{"type":"agent_end"');
+	},
+	create: createPiAggregateProjection,
+};
 
 export function formatProtocolOutputLimit(limit: ProtocolOutputLimit): string {
 	return `${limit.code}: child ${limit.stream} line exceeded ${limit.limitBytes} bytes (observed at least ${limit.observedBytes} bytes without a newline).`;
@@ -14,6 +244,7 @@ export function formatProtocolOutputLimit(limit: ProtocolOutputLimit): string {
 export function createBoundedLineReader(options: {
 	stream?: "stdout" | "stderr";
 	maxPendingLineBytes?: number;
+	oversizedLineProjector?: OversizedLineProjector;
 	onLine: (line: string) => void;
 	onLimit: (limit: ProtocolOutputLimit) => void;
 }): {
@@ -27,17 +258,67 @@ export function createBoundedLineReader(options: {
 	}
 	let pending: Buffer[] = [];
 	let pendingBytes = 0;
+	let projectedPrefix: Buffer<ArrayBufferLike> = Buffer.alloc(0);
+	let projectedTail: Buffer<ArrayBufferLike> = Buffer.alloc(0);
+	let projectedBytes = 0;
+	let projection: OversizedLineProjection | undefined;
+	let projectingOversizedLine = false;
 	let limitExceeded = false;
 
-	const emitPending = (): void => {
-		if (pendingBytes === 0) return;
-		options.onLine(Buffer.concat(pending, pendingBytes).toString("utf8"));
+	const diagnosticTail = (prior: Buffer, segment: Buffer): Buffer => {
+		const tailFromSegment = segment.subarray(Math.max(0, segment.length - MAX_PROTOCOL_DIAGNOSTIC_BYTES));
+		return tailFromSegment.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
+			? tailFromSegment
+			: Buffer.concat([prior.subarray(Math.max(0, prior.length - (MAX_PROTOCOL_DIAGNOSTIC_BYTES - tailFromSegment.length))), tailFromSegment]);
+	};
+
+	const failLimit = (observedBytes: number, prefix: Buffer, tail: Buffer): false => {
+		limitExceeded = true;
+		pending = [];
+		pendingBytes = 0;
+		projectingOversizedLine = false;
+		projection = undefined;
+		projectedPrefix = Buffer.alloc(0);
+		projectedTail = Buffer.alloc(0);
+		projectedBytes = 0;
+		options.onLimit({
+			code: "protocol_output_limit",
+			stream: options.stream ?? "stdout",
+			limitBytes: maxPendingLineBytes,
+			observedBytes,
+			diagnosticPrefix: prefix.toString("utf8"),
+			diagnosticTail: tail.toString("utf8"),
+		});
+		return false;
+	};
+
+	const finishLine = (): void => {
+		if (projectingOversizedLine) {
+			const projected = projection?.finish();
+			if (projected === undefined) {
+				failLimit(projectedBytes, projectedPrefix, projectedTail);
+			} else {
+				options.onLine(projected);
+			}
+		} else if (pendingBytes > 0) {
+			options.onLine(Buffer.concat(pending, pendingBytes).toString("utf8"));
+		}
 		pending = [];
 		pendingBytes = 0;
+		projectingOversizedLine = false;
+		projection = undefined;
+		projectedPrefix = Buffer.alloc(0);
+		projectedTail = Buffer.alloc(0);
+		projectedBytes = 0;
 	};
 
 	const append = (segment: Buffer): boolean => {
 		if (segment.length === 0) return true;
+		if (projectingOversizedLine) {
+			projectedBytes += segment.length;
+			projectedTail = diagnosticTail(projectedTail, segment);
+			return projection?.push(segment) === true || failLimit(projectedBytes, projectedPrefix, projectedTail);
+		}
 		const observedBytes = pendingBytes + segment.length;
 		if (observedBytes > maxPendingLineBytes) {
 			const prior = pendingBytes > 0 ? Buffer.concat(pending, pendingBytes) : Buffer.alloc(0);
@@ -45,22 +326,20 @@ export function createBoundedLineReader(options: {
 			const prefix = prefixFromPrior.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
 				? prefixFromPrior
 				: Buffer.concat([prefixFromPrior, segment.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES - prefixFromPrior.length)]);
-			const tailFromSegment = segment.subarray(Math.max(0, segment.length - MAX_PROTOCOL_DIAGNOSTIC_BYTES));
-			const tail = tailFromSegment.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
-				? tailFromSegment
-				: Buffer.concat([prior.subarray(Math.max(0, prior.length - (MAX_PROTOCOL_DIAGNOSTIC_BYTES - tailFromSegment.length))), tailFromSegment]);
-			limitExceeded = true;
-			pending = [];
-			pendingBytes = 0;
-			options.onLimit({
-				code: "protocol_output_limit",
-				stream: options.stream ?? "stdout",
-				limitBytes: maxPendingLineBytes,
-				observedBytes,
-				diagnosticPrefix: prefix.toString("utf8"),
-				diagnosticTail: tail.toString("utf8"),
-			});
-			return false;
+			const tail = diagnosticTail(prior, segment);
+			if (options.oversizedLineProjector?.accepts(prefix.toString("utf8"))) {
+				const candidate = options.oversizedLineProjector.create();
+				if (!candidate.push(prior) || !candidate.push(segment)) return failLimit(observedBytes, prefix, tail);
+				pending = [];
+				pendingBytes = 0;
+				projectingOversizedLine = true;
+				projection = candidate;
+				projectedPrefix = prefix;
+				projectedTail = tail;
+				projectedBytes = observedBytes;
+				return true;
+			}
+			return failLimit(observedBytes, prefix, tail);
 		}
 		pending.push(segment);
 		pendingBytes = observedBytes;
@@ -75,13 +354,14 @@ export function createBoundedLineReader(options: {
 			for (let index = 0; index < bytes.length; index++) {
 				if (bytes[index] !== 0x0a) continue;
 				if (!append(bytes.subarray(start, index))) return;
-				emitPending();
+				finishLine();
+				if (limitExceeded) return;
 				start = index + 1;
 			}
 			append(bytes.subarray(start));
 		},
 		end() {
-			if (!limitExceeded) emitPending();
+			if (!limitExceeded) finishLine();
 		},
 		exceeded: () => limitExceeded,
 	};
@@ -100,7 +380,7 @@ export function createBoundedByteTail(maxBytes = MAX_CHILD_STDERR_BYTES): {
 	byteLength(): number;
 } {
 	if (!Number.isInteger(maxBytes) || maxBytes < 1) throw new Error("maxBytes must be a positive integer.");
-	let tail = Buffer.alloc(0);
+	let tail: Buffer<ArrayBufferLike> = Buffer.alloc(0);
 	return {
 		push(chunk) {
 			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;

package/dist/extensions/pi-subagents/src/runs/shared/dynamic-fanout.ts

@@ -264,7 +264,7 @@ export function materializeDynamicParallelStep(step: DynamicParallelStep, output
 export function collectDynamicResults(
 	step: DynamicParallelStep,
 	items: DynamicMaterializedItem[],
-	results: Array<Pick<SingleResult, "agent" | "exitCode" | "error" | "timedOut" | "stopped" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { output?: string; finalOutput?: string }>,
+	results: Array<Pick<SingleResult, "agent" | "error" | "timedOut" | "stopped" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { exitCode: number | null; output?: string; finalOutput?: string }>,
 ): DynamicCollectedResult[] {
 	return items.map((entry, index) => {
 		const result = results[index];