pi-openai-toolkit 0.20.7 → 0.21.0

package/src/auto-mode/reviewer.ts

@@ -1,325 +0,0 @@
-import type {
-	AssistantMessage,
-	Context,
-	Message,
-	Tool,
-	ToolCall,
-} from "@earendil-works/pi-ai";
-import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { parseModelSpec } from "../runtime";
-import { backfillVerdictFields, buildReviewPrompt, reviewerSystemPrompt } from "./prompt";
-import {
-	boundReviewText,
-	type GuardianVerdict,
-	MAX_REVIEW_MODEL_KEY_CHARS,
-	type ReviewFailureCause,
-	type ReviewOutcome,
-	type RiskLevel,
-	type UserAuthorization,
-} from "./types";
-
-/** The reviewer needs model lookup plus whatever read-only tools we choose to give it. */
-export type ReviewerRegistry = Pick<ModelRegistry, "find" | "complete">;
-
-/**
- * One read-only investigation tool the reviewer may call. `parameters` is passed to
- * the provider verbatim; `execute` is ours, so the reviewer can never reach a tool
- * that is not in this list.
- */
-export type EvidenceTool = {
-	name: string;
-	description: string;
-	parameters: Tool["parameters"];
-	execute: (
-		args: Record<string, unknown>,
-		signal: AbortSignal | undefined,
-	) => Promise<string>;
-};
-
-const RISK_LEVELS: readonly string[] = ["low", "medium", "high", "critical"];
-const AUTHORIZATIONS: readonly string[] = ["unknown", "low", "medium", "high"];
-
-/**
- * Parse a reviewer answer. Only the outcome is required; risk, authorization, and
- * rationale are back-filled. Both the Codex-style field names and our earlier
- * `decision`/`reason` spelling are accepted, so an older reviewer prompt cached by
- * a provider still yields a usable verdict.
- *
- * A verdict we cannot read is reported as a failure, never guessed into approval.
- */
-export function parseReviewVerdict(text: string): GuardianVerdict | undefined {
-	for (const candidate of candidateJsonObjects(text)) {
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(candidate);
-		} catch {
-			continue;
-		}
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-		const record = parsed as Record<string, unknown>;
-		const rawOutcome = record.outcome ?? record.decision;
-		if (rawOutcome !== "allow" && rawOutcome !== "deny") continue;
-		const risk = String(record.risk_level ?? record.riskLevel ?? "").toLowerCase();
-		const authorization = String(
-			record.user_authorization ?? record.userAuthorization ?? "",
-		).toLowerCase();
-		const rationale =
-			typeof record.rationale === "string"
-				? record.rationale
-				: typeof record.reason === "string"
-					? record.reason
-					: undefined;
-		return backfillVerdictFields({
-			outcome: rawOutcome,
-			riskLevel: (RISK_LEVELS.includes(risk) ? risk : undefined) as RiskLevel | undefined,
-			userAuthorization: (AUTHORIZATIONS.includes(authorization) ? authorization : undefined) as
-				| UserAuthorization
-				| undefined,
-			rationale,
-		});
-	}
-	return undefined;
-}
-
-function candidateJsonObjects(text: string): string[] {
-	const candidates: string[] = [];
-	const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
-	if (fenced?.[1]) candidates.push(fenced[1].trim());
-	candidates.push(text.trim());
-	const brace = text.match(/\{[\s\S]*\}/);
-	if (brace?.[0]) candidates.push(brace[0]);
-	return candidates;
-}
-
-function firstTextBlock(message: AssistantMessage): string {
-	return message.content
-		.filter((block): block is { type: "text"; text: string } => block.type === "text")
-		.map((block) => block.text)
-		.join("")
-		.trim();
-}
-
-/**
- * Pi 0.85 typed tool-call arguments as `Record<string, any>` and Pi 0.86 tightened
- * them to the public `JsonObject`. Narrow with Pi's exported `ToolCall` instead of a
- * handwritten shape so the guard tracks whichever contract the installed Pi declares.
- */
-function toolCallBlocks(message: AssistantMessage): ToolCall[] {
-	return message.content.filter((block): block is ToolCall => block.type === "toolCall");
-}
-
-type ReviewAttempt<T> = {
-	value?: T;
-	errorMessage?: string;
-	timedOut: boolean;
-	cancelled: boolean;
-};
-
-/** One deadline owns every model and evidence operation in this review. */
-function createReviewDeadline(timeoutMs: number, callerSignal?: AbortSignal) {
-	const deadlineAt = Date.now() + timeoutMs;
-	const controller = new AbortController();
-	let timedOut = false;
-	let cancelled = false;
-	const abortFromCaller = () => {
-		if (controller.signal.aborted) return;
-		cancelled = true;
-		controller.abort();
-	};
-	const expire = () => {
-		if (controller.signal.aborted) return;
-		timedOut = true;
-		controller.abort();
-	};
-	if (callerSignal?.aborted) abortFromCaller();
-	else callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
-	const timer = setTimeout(expire, Math.max(0, timeoutMs));
-
-	return {
-		async run<T>(operation: (signal: AbortSignal) => Promise<T>): Promise<ReviewAttempt<T>> {
-			if (Date.now() >= deadlineAt) expire();
-			if (controller.signal.aborted) return { timedOut, cancelled };
-			let onAbort!: () => void;
-			const aborted = new Promise<ReviewAttempt<T>>((resolve) => {
-				onAbort = () => resolve({ timedOut, cancelled });
-				controller.signal.addEventListener("abort", onAbort, { once: true });
-			});
-			try {
-				// Both settlement handlers stay attached after cancellation, so an
-				// uncooperative dependency cannot leak an unhandled rejection.
-				const pending = Promise.resolve().then(() => {
-					controller.signal.throwIfAborted();
-					return operation(controller.signal);
-				}).then(
-					(value): ReviewAttempt<T> => ({ value, timedOut, cancelled }),
-					(error): ReviewAttempt<T> => ({ errorMessage: error instanceof Error ? error.message : String(error), timedOut, cancelled }),
-				);
-				const result = await Promise.race([pending, aborted]);
-				if (Date.now() >= deadlineAt) expire();
-				return { ...result, timedOut, cancelled };
-			} finally {
-				controller.signal.removeEventListener("abort", onAbort);
-			}
-		},
-		dispose() {
-			clearTimeout(timer);
-			callerSignal?.removeEventListener("abort", abortFromCaller);
-		},
-	};
-}
-
-function failure(cause: ReviewFailureCause, reason: string): ReviewOutcome {
-	return { kind: "unavailable", reason: boundReviewText(reason, 240), cause };
-}
-
-function outcomeFromVerdict(
-	verdict: GuardianVerdict,
-	reviewerModel: string,
-	evidenceRounds: number,
-): ReviewOutcome {
-	return verdict.outcome === "allow"
-		? { kind: "allow", verdict, reviewerModel, evidenceRounds }
-		: { kind: "deny", verdict, reviewerModel, evidenceRounds };
-}
-
-/**
- * Ask the reviewer model about one pending tool call.
- *
- * When `evidenceTools` are supplied the reviewer runs as a short bounded agent
- * loop: it may call read-only tools to establish facts, we execute those calls
- * ourselves, and we feed the results back. The whole exchange shares one deadline,
- * and the final round is forced to answer without tools, so a reviewer that keeps
- * investigating still terminates as a verdict or as an explicit failure.
- */
-export async function requestToolReview(params: {
-	registry: ReviewerRegistry;
-	reviewerModelSpec: string;
-	toolName: string;
-	toolInput: unknown;
-	transcript?: string;
-	cwd?: string;
-	timeoutMs: number;
-	signal?: AbortSignal;
-	evidenceTools?: EvidenceTool[];
-	maxEvidenceRounds?: number;
-}): Promise<ReviewOutcome> {
-	const parsed = parseModelSpec(params.reviewerModelSpec);
-	if (!parsed) {
-		return failure(
-			"not-configured",
-			`autoMode.reviewerModel "${params.reviewerModelSpec}" is not provider/model-id.`,
-		);
-	}
-
-	const model = params.registry.find(parsed.provider, parsed.modelId);
-	if (!model) {
-		return failure("not-configured", `Reviewer model ${params.reviewerModelSpec} is not available.`);
-	}
-	const reviewerModel = boundReviewText(`${model.provider}/${model.id}`, MAX_REVIEW_MODEL_KEY_CHARS);
-
-	const tools = params.evidenceTools ?? [];
-	const maxRounds = Math.max(0, params.maxEvidenceRounds ?? 0);
-	const useTools = tools.length > 0 && maxRounds > 0;
-	const toolByName = new Map(tools.map((tool) => [tool.name, tool]));
-	const messages: Message[] = [
-		{
-			role: "user",
-			content: [
-				{
-					type: "text",
-					text: buildReviewPrompt({
-						toolName: params.toolName,
-						toolInput: params.toolInput,
-						transcript: params.transcript,
-						cwd: params.cwd,
-					}),
-				},
-			],
-			timestamp: Date.now(),
-		},
-	];
-
-	const deadline = createReviewDeadline(params.timeoutMs, params.signal);
-	try {
-		let evidenceRounds = 0;
-		for (let round = 0; ; round += 1) {
-			const forceAnswer = !useTools || round >= maxRounds;
-			const context: Context = {
-				systemPrompt: reviewerSystemPrompt(useTools),
-				messages,
-				...(forceAnswer ? {} : { tools: tools.map(toProviderTool) }),
-			};
-
-			const attempt = await deadline.run((signal) => params.registry.complete(model, context, { signal, cacheRetention: "none" }));
-			if (attempt.cancelled) {
-				return failure("cancelled", "Auto-mode review was cancelled before it finished.");
-			}
-			if (attempt.timedOut) {
-				return failure("timeout", `Auto-mode review timed out after ${params.timeoutMs}ms.`);
-			}
-			if (attempt.errorMessage) {
-				return failure("provider-error", attempt.errorMessage);
-			}
-			const response = attempt.value;
-			if (!response) {
-				return failure("provider-error", "Reviewer returned no message.");
-			}
-			if (response.stopReason === "error" || response.stopReason === "aborted") {
-				return failure(
-					"provider-error",
-					response.errorMessage ?? `Reviewer stopped with "${response.stopReason}".`,
-				);
-			}
-
-			const calls = toolCallBlocks(response);
-			if (forceAnswer || calls.length === 0) {
-				const verdict = parseReviewVerdict(firstTextBlock(response));
-				if (!verdict) {
-					return failure("invalid-output", "Reviewer did not return a readable allow/deny verdict.");
-				}
-				return outcomeFromVerdict(verdict, reviewerModel, evidenceRounds);
-			}
-
-			messages.push(response);
-			evidenceRounds += 1;
-			for (const call of calls) {
-				const tool = toolByName.get(call.name);
-				if (!tool) {
-					messages.push(refusedToolResult(call, `Tool "${call.name}" is not available to the reviewer.`));
-					continue;
-				}
-				const evidence = await deadline.run((signal) => tool.execute(call.arguments, signal));
-				if (evidence.cancelled) return failure("cancelled", "Auto-mode review was cancelled during investigation.");
-				if (evidence.timedOut) return failure("timeout", `Auto-mode review timed out after ${params.timeoutMs}ms.`);
-				messages.push({
-					role: "toolResult",
-					toolCallId: call.id,
-					toolName: call.name,
-					content: [{ type: "text", text: boundReviewText(evidence.errorMessage ?? evidence.value ?? "", evidence.errorMessage ? 1_000 : 4_000) }],
-					isError: evidence.errorMessage !== undefined,
-					timestamp: Date.now(),
-				});
-			}
-		}
-	} finally {
-		deadline.dispose();
-	}
-}
-
-function toProviderTool(tool: EvidenceTool): Tool {
-	return { name: tool.name, description: tool.description, parameters: tool.parameters };
-}
-
-function refusedToolResult(
-	call: { id: string; name: string },
-	text: string,
-): Message {
-	return {
-		role: "toolResult",
-		toolCallId: call.id,
-		toolName: call.name,
-		content: [{ type: "text", text }],
-		isError: true,
-		timestamp: Date.now(),
-	};
-}

package/src/auto-mode/tool-review-tui.ts

@@ -1,211 +0,0 @@
-import { ToolExecutionComponent, type Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { boundReviewText } from "./types";
-
-const TOOL_REVIEW_PATCH = Symbol.for("pi-openai-toolkit.auto-mode.tool-execution-renderer.v1");
-const MAX_REVIEW_STATES = 256;
-const MAX_DISPLAY_DETAIL_CHARS = 180;
-
-export type ToolReviewDisplayState =
-	| { phase: "skipped"; toolName: string; detail: string }
-	| { phase: "reviewing"; toolName: string }
-	| { phase: "awaiting-user"; toolName: string }
-	| { phase: "allowed"; toolName: string; source: "reviewer" | "classifier" | "human"; detail?: string }
-	| { phase: "denied"; toolName: string; detail: string }
-	| { phase: "blocked"; toolName: string; detail: string };
-
-export interface ToolReviewRendererBridge {
-	readonly supported: boolean;
-	readonly reason?: string;
-	setTheme(theme: Theme | undefined): void;
-	setState(toolCallId: string, state: ToolReviewDisplayState): void;
-	clear(): void;
-}
-
-type ToolExecutionInstance = {
-	toolCallId?: unknown;
-};
-
-type RenderMethod = (this: ToolExecutionInstance, width: number) => string[];
-type PropertyRecord = Record<PropertyKey, unknown>;
-
-type ReviewStateStore = {
-	states: Map<string, ToolReviewDisplayState>;
-	theme?: Theme;
-};
-
-type PatchRecord = {
-	originalRender: RenderMethod;
-	store: ReviewStateStore;
-};
-
-function asPropertyRecord(value: unknown): PropertyRecord | undefined {
-	if ((typeof value !== "object" || value === null) && typeof value !== "function") return undefined;
-	return value as PropertyRecord;
-}
-
-function isRenderMethod(value: unknown): value is RenderMethod {
-	return typeof value === "function";
-}
-
-function isPatchRecord(value: unknown): value is PatchRecord {
-	const record = asPropertyRecord(value);
-	const store = record?.store;
-	return (
-		isRenderMethod(record?.originalRender) &&
-		!!store &&
-		typeof store === "object" &&
-		(store as { states?: unknown }).states instanceof Map
-	);
-}
-
-function createStore(): ReviewStateStore {
-	return { states: new Map<string, ToolReviewDisplayState>() };
-}
-
-function normalizeDisplayText(value: unknown): string {
-	return boundReviewText(value, MAX_DISPLAY_DETAIL_CHARS).replace(/\s+/g, " ").trim();
-}
-
-function getStatusPresentation(state: ToolReviewDisplayState): {
-	color: "accent" | "success" | "error" | "warning" | "muted";
-	text: string;
-} {
-	switch (state.phase) {
-		case "skipped":
-			return { color: "muted", text: `not reviewed · ${normalizeDisplayText(state.detail)}` };
-		case "reviewing":
-			return { color: "accent", text: `reviewing ${normalizeDisplayText(state.toolName)}` };
-		case "awaiting-user":
-			return { color: "warning", text: `waiting for approval of ${normalizeDisplayText(state.toolName)}` };
-		case "allowed":
-			return {
-				color: "success",
-				text: `allowed by ${state.source}${state.detail ? ` · ${normalizeDisplayText(state.detail)}` : ""}`,
-			};
-		case "denied":
-			return { color: "error", text: `denied · ${normalizeDisplayText(state.detail)}` };
-		case "blocked":
-			return { color: "warning", text: `blocked · ${normalizeDisplayText(state.detail)}` };
-	}
-}
-
-/**
- * Format the single line appended below a Pi tool block. Kept pure so width,
- * truncation, and untrusted reviewer text are testable without booting the TUI.
- */
-export function formatToolReviewLine(
-	state: ToolReviewDisplayState,
-	width: number,
-	theme?: Theme,
-): string {
-	const presentation = getStatusPresentation(state);
-	const plain = `  ${presentation.text}`;
-	const maxWidth = Number.isFinite(width) ? Math.max(1, Math.floor(width)) : 1;
-	const styled = theme ? theme.fg(presentation.color, plain) : plain;
-	const truncated = truncateToWidth(styled, maxWidth, "");
-	return truncated + " ".repeat(Math.max(0, maxWidth - visibleWidth(truncated)));
-}
-
-function normalizeState(state: ToolReviewDisplayState): ToolReviewDisplayState {
-	const toolName = normalizeDisplayText(state.toolName);
-	switch (state.phase) {
-		case "skipped":
-			return { phase: "skipped", toolName, detail: normalizeDisplayText(state.detail) };
-		case "reviewing":
-			return { phase: "reviewing", toolName };
-		case "awaiting-user":
-			return { phase: "awaiting-user", toolName };
-		case "allowed":
-			return state.detail
-				? { phase: "allowed", toolName, source: state.source, detail: normalizeDisplayText(state.detail) }
-				: { phase: "allowed", toolName, source: state.source };
-		case "denied":
-			return { phase: "denied", toolName, detail: normalizeDisplayText(state.detail) };
-		case "blocked":
-			return { phase: "blocked", toolName, detail: normalizeDisplayText(state.detail) };
-	}
-}
-
-function createUnsupportedBridge(reason: string): ToolReviewRendererBridge {
-	return {
-		supported: false,
-		reason,
-		setTheme: () => undefined,
-		setState: () => undefined,
-		clear: () => undefined,
-	};
-}
-
-function createBridge(store: ReviewStateStore, supported = true, reason?: string): ToolReviewRendererBridge {
-	return {
-		supported,
-		reason,
-		setTheme: (theme) => {
-			store.theme = theme;
-		},
-		setState: (toolCallId, state) => {
-			const id = toolCallId.trim();
-			if (!id) return;
-			store.states.set(id, normalizeState(state));
-			while (store.states.size > MAX_REVIEW_STATES) {
-				const oldest = store.states.keys().next().value;
-				if (oldest === undefined) break;
-				store.states.delete(oldest);
-			}
-		},
-		clear: () => {
-			store.states.clear();
-		},
-	};
-}
-
-/**
- * Install the optional per-tool review footer against Pi's exported
- * ToolExecutionComponent. Pi has no public decorator hook yet, so this is a
- * deliberately narrow, feature-detected compatibility patch. If the class or
- * its render method changes, callers retain the existing global footer path.
- */
-export function installToolReviewRenderer(
-	target: unknown = ToolExecutionComponent,
-): ToolReviewRendererBridge {
-	const targetRecord = asPropertyRecord(target);
-	const prototype = asPropertyRecord(targetRecord?.prototype);
-	if (!prototype) return createUnsupportedBridge("ToolExecutionComponent prototype is unavailable");
-
-	const existing = prototype[TOOL_REVIEW_PATCH];
-	if (isPatchRecord(existing)) return createBridge(existing.store);
-
-	const originalRender = prototype.render;
-	if (!isRenderMethod(originalRender)) return createUnsupportedBridge("ToolExecutionComponent.render is unavailable");
-
-	const store = createStore();
-	const wrappedRender: RenderMethod = function (this: ToolExecutionInstance, width: number): string[] {
-		const lines = originalRender.call(this, width);
-		if (!Array.isArray(lines) || typeof this.toolCallId !== "string") return lines;
-		const state = store.states.get(this.toolCallId);
-		if (!state) return lines;
-		return [...lines, formatToolReviewLine(state, width, store.theme)];
-	};
-	const patch: PatchRecord = { originalRender, store };
-
-	try {
-		Object.defineProperty(prototype, TOOL_REVIEW_PATCH, {
-			configurable: true,
-			enumerable: false,
-			writable: false,
-			value: patch,
-		});
-		prototype.render = wrappedRender;
-		if (prototype.render !== wrappedRender) throw new Error("ToolExecutionComponent.render is not writable");
-	} catch {
-		try {
-			delete prototype[TOOL_REVIEW_PATCH];
-		} catch {
-			// Best effort only: the compatibility fallback remains safe either way.
-		}
-		return createUnsupportedBridge("ToolExecutionComponent.render cannot be patched");
-	}
-
-	return createBridge(store);
-}

package/src/auto-mode/transcript.ts

@@ -1,135 +0,0 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import {
-	boundReviewText,
-	MAX_TRANSCRIPT_CHARS,
-	MAX_TRANSCRIPT_ENTRY_CHARS,
-	MAX_TRANSCRIPT_RECENT_ENTRIES,
-	MAX_TRANSCRIPT_TOOL_CHARS,
-	TRUNCATION_MARKER,
-} from "./types";
-
-/**
- * A transcript line already reduced to text, with the role kept so the reviewer can
- * tell whose words these are. `[user]` is the only role that carries authorization.
- */
-export type TranscriptLine = {
-	role: "user" | "assistant" | "tool";
-	text: string;
-};
-
-function textOfContent(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content
-		.map((block) => {
-			if (!block || typeof block !== "object") return "";
-			const record = block as Record<string, unknown>;
-			if (record.type === "text" && typeof record.text === "string") return record.text;
-			if (record.type === "image") return "[image omitted]";
-			if (record.type === "toolCall" && typeof record.name === "string") {
-				const args = record.arguments;
-				return `${record.name} ${typeof args === "object" && args ? JSON.stringify(args) : ""}`.trim();
-			}
-			return "";
-		})
-		.filter(Boolean)
-		.join("\n")
-		.trim();
-}
-
-/**
- * Flatten session entries into reviewer lines. Non-message entries are skipped,
- * except a compaction summary, which is kept as a `[user]`-adjacent context marker
- * because it is the only surviving view of the older conversation.
- */
-export function sessionEntriesToLines(entries: readonly SessionEntry[]): TranscriptLine[] {
-	const lines: TranscriptLine[] = [];
-	for (const entry of entries) {
-		if (entry.type === "compaction" && typeof entry.summary === "string") {
-			// Defer bounding until selection so the transcript reports truncation.
-			if (entry.summary) lines.push({ role: "assistant", text: `[earlier conversation summary] ${entry.summary}` });
-			continue;
-		}
-		if (entry.type !== "message") continue;
-		const message = entry.message as { role?: unknown; content?: unknown };
-		const text = textOfContent(message.content);
-		if (!text) continue;
-		if (message.role === "user") lines.push({ role: "user", text });
-		else if (message.role === "assistant") lines.push({ role: "assistant", text });
-		else if (message.role === "toolResult") lines.push({ role: "tool", text });
-	}
-	return lines;
-}
-
-function renderLine(index: number, line: TranscriptLine, maxChars = MAX_TRANSCRIPT_ENTRY_CHARS): string {
-	const body = boundReviewText(line.text, maxChars);
-	return `[${index}] [${line.role}]: ${body}`;
-}
-
-/**
- * Build a bounded transcript the way Codex's guardian does: user turns are the
- * anchors and are protected, tool and assistant evidence gets its own smaller
- * budget so verbose command output cannot crowd out the human conversation that
- * actually establishes authorization.
- *
- * Selection order is newest-first, then rendered in chronological order.
- */
-export function buildReviewTranscript(
-	lines: readonly TranscriptLine[],
-	budgets: {
-		maxTotalChars?: number;
-		maxToolChars?: number;
-		maxRecentEntries?: number;
-	} = {},
-): { text: string; omitted: boolean } {
-	const maxTotalChars = Math.max(0, budgets.maxTotalChars ?? MAX_TRANSCRIPT_CHARS);
-	const maxToolChars = Math.max(0, budgets.maxToolChars ?? MAX_TRANSCRIPT_TOOL_CHARS);
-	const maxRecentEntries = budgets.maxRecentEntries ?? MAX_TRANSCRIPT_RECENT_ENTRIES;
-	const recent = lines.slice(-Math.max(1, maxRecentEntries));
-	const notice = `${TRUNCATION_MARKER} conversation content was omitted or truncated.`;
-
-	function select(budget: number): { text: string; omitted: boolean } {
-		const selected = new Map<number, string>();
-		let totalChars = 0;
-		let toolChars = 0;
-		let omitted = recent.length < lines.length;
-		// Authorization gets the first claim on space, newest instructions first.
-		const indices = recent.map((_, index) => index).reverse();
-		for (const index of [...indices.filter((i) => recent[i]!.role === "user"), ...indices.filter((i) => recent[i]!.role !== "user")]) {
-			const line = recent[index]!;
-			const separator = selected.size > 0 ? 1 : 0;
-			const available = Math.min(budget - totalChars, line.role === "user" ? Infinity : maxToolChars - toolChars) - separator;
-			const prefix = `[${index + 1}] [${line.role}]: `;
-			if (available <= prefix.length + 3) {
-				omitted = true;
-				continue;
-			}
-			const rendered = renderLine(index + 1, line, Math.min(MAX_TRANSCRIPT_ENTRY_CHARS, available - prefix.length));
-			if (rendered.slice(prefix.length) !== line.text) omitted = true;
-			selected.set(index, rendered);
-			const cost = rendered.length + separator;
-			totalChars += cost;
-			if (line.role !== "user") toolChars += cost;
-		}
-		return {
-			text: [...selected].sort(([a], [b]) => a - b).map(([, text]) => text).join("\n"),
-			omitted,
-		};
-	}
-
-	const initial = select(maxTotalChars);
-	if (!initial.omitted) return initial;
-	if (maxTotalChars <= notice.length) return { text: notice.slice(0, maxTotalChars), omitted: true };
-	const bounded = select(maxTotalChars - notice.length - 1);
-	return { text: bounded.text ? `${notice}\n${bounded.text}` : notice, omitted: true };
-}
-
-/**
- * Build the reviewer transcript straight from session entries.
- */
-export function transcriptFromEntries(
-	entries: readonly SessionEntry[],
-	budgets?: Parameters<typeof buildReviewTranscript>[1],
-): { text: string; omitted: boolean } {
-	return buildReviewTranscript(sessionEntriesToLines(entries), budgets);
-}