pi-subagents 0.64.0 → 0.65.0

package/src/workflows/scripted-workflow.ts

@@ -9,7 +9,14 @@ import type { AcceptanceRecoveryMetadata, HostStepNodeV1, SingleResult } from ".
 import { normalizeWorkflowHostCommandParams, type WorkflowHostCommandParams, type WorkflowHostCommandResult } from "./host-command.ts";
 
 const KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function validGitRef(ref: unknown): ref is string {
+	if (typeof ref !== "string" || !ref || ref === "@" || Buffer.byteLength(ref, "utf-8") > 1024 || ref.startsWith("/") || ref.endsWith("/") || ref.includes("//") || ref.includes("..") || ref.includes("@{")) return false;
+	if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu.test(ref)) return false;
+	if (/[[\]\\~^:?*\u0000-\u0020\u007f]/u.test(ref) || ref.endsWith(".") || ref.endsWith(".lock")) return false;
+	return ref.split("/").every((component) => component.length > 0 && component !== "." && component !== ".." && !component.startsWith(".") && !component.endsWith(".") && !component.endsWith(".lock"));
+}
 const requireFromPackage = createRequire(import.meta.url);
+const WORKFLOW_ASSEMBLY_FLUSH_TIMEOUT_MS = 5_000;
 
 export interface WorkflowScriptValidationError {
 	message: string;
@@ -49,6 +56,12 @@ let suppressNativePromiseConsumption = 0;
 const activeNativePromises = [];
 const pending = new Map();
 const runKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function validGitRef(ref) {
+  if (typeof ref !== "string" || !ref || ref === "@" || new TextEncoder().encode(ref).length > 1024 || ref.startsWith("/") || ref.endsWith("/") || ref.includes("//") || ref.includes("..") || ref.includes("@{")) return false;
+  if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu.test(ref)) return false;
+  if (/[[\]\\~^:?*\u0000-\u0020\u007f]/u.test(ref) || ref.endsWith(".") || ref.endsWith(".lock")) return false;
+  return ref.split("/").every((component) => component.length > 0 && component !== "." && component !== ".." && !component.startsWith(".") && !component.endsWith(".") && !component.endsWith(".lock"));
+}
 const trackedPromiseTrackers = new WeakMap();
 const trackedPromiseTargets = new WeakMap();
 let nativePromiseTrackers = new WeakMap();
@@ -611,6 +624,7 @@ function validateRunCall(key, params, label, fingerprints) {
   }
   if (Object.prototype.hasOwnProperty.call(params, "clarify")) throw new Error(label + " does not support clarify UI.");
   if (params.worktree !== undefined && typeof params.worktree !== "boolean") throw new Error(label + " worktree must be true or false.");
+  if (params.baseRef !== undefined && (typeof params.baseRef !== "string" || !validGitRef(params.baseRef))) throw new Error(label + " baseRef must be a valid Git ref.");
   validateLaneMetadata(params.lane, label + " lane", key);
   if (params.gate !== undefined && (typeof params.gate !== "string" || !params.gate.trim())) throw new Error(label + " gate must be a non-empty command string.");
   if (params.gate !== undefined && params.acceptance !== undefined) throw new Error(label + " gate cannot be combined with acceptance; use one gate command or acceptance.verify.");
@@ -1070,6 +1084,8 @@ export interface RunWorkflowScriptOptions {
 	oneUsePermit?: { claim: (key: string) => string | undefined };
 	timeoutMs?: number;
 	signal?: AbortSignal;
+	/** Let an async workflow flush pure result assembly after reload once every child is terminal. */
+	continueAfterAbortWhenChildrenSettled?: (abortError: Error) => boolean;
 	/** Maximum children executing concurrently within this workflow. Defaults to 20. */
 	globalConcurrencyLimit?: number;
 	admit?: (calls: Array<{ key: string; params: Record<string, unknown> }>) => void | Promise<void>;
@@ -1614,7 +1630,7 @@ function resolveWorkflowParserEntry(): string {
 	}
 }
 
-const AUTO_RESUME_PARAM_KEYS = ["acceptance", "agentContract", "index", "intercomBridge", "label", "lane", "maxRuntimeMs", "output", "outputMode", "outputSchema", "phase", "skill", "skills", "task", "timeoutMs", "toolBudget", "worktree"] as const;
+const AUTO_RESUME_PARAM_KEYS = ["acceptance", "agentContract", "baseRef", "index", "intercomBridge", "label", "lane", "maxRuntimeMs", "output", "outputMode", "outputSchema", "phase", "skill", "skills", "task", "timeoutMs", "toolBudget", "worktree"] as const;
 
 function isZeroUsage(usage: unknown): boolean {
 	if (!isRecord(usage)) return false;
@@ -1682,6 +1698,9 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 	let acceptanceRecoveryBarrier: { key: string } | undefined;
 	let settled = false;
 	let finishing = false;
+	let assemblyAbortRequested = false;
+	let assemblyFlushTimer: ReturnType<typeof setTimeout> | undefined;
+	let abortError: Error | undefined;
 
 	const partial = (): Omit<WorkflowScriptResult, "value"> => ({ emits, console: consoleEntries, trace, children: childOrder.flatMap((key) => {
 		const child = children.get(key);
@@ -1750,6 +1769,10 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 		const finish = (outcome: { value: unknown } | { error: Error & { workflowErrorKind?: unknown } }) => {
 			if (settled || finishing) return;
 			finishing = true;
+			if (assemblyFlushTimer !== undefined) {
+				clearTimeout(assemblyFlushTimer);
+				assemblyFlushTimer = undefined;
+			}
 			childController.abort("error" in outcome ? outcome.error : new Error("Workflow script completed."));
 			void Promise.allSettled([...steers.values(), ...hostCalls.values()].map(({ promise }) => promise)).then(() => {
 				if (settled) return;
@@ -1781,6 +1804,26 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 				: typeof signalReason === "string"
 					? new Error(signalReason)
 					: new Error("Workflow script aborted.");
+			if (finishing) return;
+			abortError = error;
+			const allChildrenSettled = launches.size > 0
+				&& [...launches.keys()].every((key) => children.has(key));
+			let mayFlushAssembly = false;
+			try {
+				mayFlushAssembly = options.continueAfterAbortWhenChildrenSettled?.(error) === true;
+			} catch (callbackError) {
+				const callbackMessage = callbackError instanceof Error ? callbackError.message : String(callbackError);
+				return finish({ error: new Error(`Workflow assembly flush eligibility failed: ${callbackMessage}`) });
+			}
+			if (mayFlushAssembly && allChildrenSettled) {
+				// A reloaded async workflow may already be past its last child launch.
+				// Keep the worker alive for pure result assembly, but abort the child
+				// signal so any later launch or side effect cannot use stale context.
+				assemblyAbortRequested = true;
+				childController.abort(error);
+				assemblyFlushTimer = setTimeout(() => finish({ error }), WORKFLOW_ASSEMBLY_FLUSH_TIMEOUT_MS);
+				return;
+			}
 			for (const key of launches.keys()) {
 				if (children.has(key)) continue;
 				stoppedLaunches.add(key);
@@ -1873,6 +1916,7 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 				return;
 			}
 			if (message.type !== "call" || typeof message.callId !== "number" || typeof message.method !== "string" || !isRecord(message.args)) return;
+			if (assemblyAbortRequested) return finish({ error: abortError ?? new Error("Workflow context was replaced or reloaded.") });
 
 			const respond = (promise: Promise<unknown>, responsePath?: string, onBoundaryError?: (error: unknown) => void) => {
 				void promise.then(
@@ -2059,6 +2103,9 @@ export async function runWorkflowScript(options: RunWorkflowScriptOptions): Prom
 			if (params.worktree !== undefined && typeof params.worktree !== "boolean") {
 				return respond(Promise.reject(new Error(`runs.run('${key}') worktree must be true or false.`)));
 			}
+			if (params.baseRef !== undefined && (typeof params.baseRef !== "string" || !validGitRef(params.baseRef))) {
+				return respond(Promise.reject(new Error(`runs.run('${key}') baseRef must be a valid Git ref.`)));
+			}
 			if (params.gate !== undefined && (typeof params.gate !== "string" || !params.gate.trim())) {
 				return respond(Promise.reject(new Error(`runs.run('${key}') gate must be a non-empty command string.`)));
 			}

package/src/runs/shared/child-protocol.ts

@@ -1,415 +0,0 @@
-import { Buffer } from "node:buffer";
-import type { ProtocolOutputLimit } from "../../shared/types.ts";
-
-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 });
-			if (eventType === "compaction_end" && typeof willRetry === "boolean") return JSON.stringify({ type: "compaction_end", willRetry });
-			return undefined;
-		},
-	};
-}
-
-/**
- * Pi JSON mode emits granular message/tool events followed by aggregate
- * `turn_end`, `agent_end`, and `compaction_end` events that can duplicate
- * large 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"') || prefix.startsWith('{"type":"compaction_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).`;
-}
-
-export function createBoundedLineReader(options: {
-	stream?: "stdout" | "stderr";
-	maxPendingLineBytes?: number;
-	oversizedLineProjector?: OversizedLineProjector;
-	onLine: (line: string) => void;
-	onLimit: (limit: ProtocolOutputLimit) => void;
-}): {
-	push(chunk: Buffer | string): void;
-	end(): void;
-	exceeded(): boolean;
-} {
-	const maxPendingLineBytes = options.maxPendingLineBytes ?? MAX_CHILD_PENDING_LINE_BYTES;
-	if (!Number.isInteger(maxPendingLineBytes) || maxPendingLineBytes < 1) {
-		throw new Error("maxPendingLineBytes must be a positive integer.");
-	}
-	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 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);
-			const prefixFromPrior = prior.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES);
-			const prefix = prefixFromPrior.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
-				? prefixFromPrior
-				: Buffer.concat([prefixFromPrior, segment.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES - prefixFromPrior.length)]);
-			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;
-		return true;
-	};
-
-	return {
-		push(chunk) {
-			if (limitExceeded) return;
-			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-			let start = 0;
-			for (let index = 0; index < bytes.length; index++) {
-				if (bytes[index] !== 0x0a) continue;
-				if (!append(bytes.subarray(start, index))) return;
-				finishLine();
-				if (limitExceeded) return;
-				start = index + 1;
-			}
-			append(bytes.subarray(start));
-		},
-		end() {
-			if (!limitExceeded) finishLine();
-		},
-		exceeded: () => limitExceeded,
-	};
-}
-
-function trimToUtf8Boundary(buffer: Buffer, maxBytes: number): Buffer {
-	if (buffer.length <= maxBytes) return buffer;
-	let start = buffer.length - maxBytes;
-	while (start < buffer.length && (buffer[start]! & 0xc0) === 0x80) start++;
-	return buffer.subarray(start);
-}
-
-export function createBoundedByteTail(maxBytes = MAX_CHILD_STDERR_BYTES): {
-	push(chunk: Buffer | string): void;
-	text(): string;
-	byteLength(): number;
-} {
-	if (!Number.isInteger(maxBytes) || maxBytes < 1) throw new Error("maxBytes must be a positive integer.");
-	let tail: Buffer<ArrayBufferLike> = Buffer.alloc(0);
-	return {
-		push(chunk) {
-			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-			tail = trimToUtf8Boundary(Buffer.concat([tail, bytes]), maxBytes);
-		},
-		text: () => tail.toString("utf8"),
-		byteLength: () => tail.length,
-	};
-}
-
-export type ChildLifecycleAction = "start-drain" | "cancel-drain" | "none";
-
-export interface ChildLifecycleState {
-	compactionRetryActive: boolean;
-}
-
-export function projectChildLifecycle(event: { type?: string; willRetry?: unknown }, terminalAssistantStop = false, state?: ChildLifecycleState): ChildLifecycleAction {
-	if (event.type === "compaction_end") {
-		if (state) state.compactionRetryActive = event.willRetry === true;
-		return event.willRetry === true ? "cancel-drain" : "none";
-	}
-	if (event.type === "agent_start" || event.type === "auto_retry_start") {
-		if (state) state.compactionRetryActive = false;
-	}
-	if (event.type === "agent_end" && event.willRetry === true) return "cancel-drain";
-	if (event.type === "agent_end" && state) state.compactionRetryActive = false;
-	if (event.type === "agent_settled") return state?.compactionRetryActive ? "none" : "start-drain";
-	if (terminalAssistantStop) return "start-drain";
-	return "none";
-}