@iowarp/clio-coder 0.3.0 → 0.3.1

package/src/domains/session/compaction/cut-point.ts

@@ -0,0 +1,171 @@
+/**
+ * Cut-point detection for compaction (Phase 12 slice 12c).
+ *
+ * Walks an entry list newest-to-oldest, accumulating estimated tokens, and
+ * reports where to slice so the suffix carries at least `keepRecentTokens`
+ * tokens of recent context. Ports pi-coding-agent's `findCutPoint` +
+ * `findTurnStartIndex` (pi-mono/packages/coding-agent/src/core/compaction/
+ * compaction.ts) against Clio's SessionEntry union.
+ *
+ * Invariant: the returned cut never lands on a `tool_result` message. Tool
+ * results must stay attached to the tool call that produced them, otherwise
+ * the replayed context shows a result with no originating call.
+ */
+
+import type { SessionEntry } from "../entries.js";
+import { estimateTokens } from "./tokens.js";
+
+export interface CutPointResult {
+	/** Index of the first entry to keep (start of the retained suffix). */
+	firstKeptEntryIndex: number;
+	/**
+	 * When the cut falls mid-turn (cut point is not a user turn start), the
+	 * index of the user message that started the turn being split. -1 when
+	 * the cut already lands on a turn boundary.
+	 */
+	turnStartIndex: number;
+	/** True when the cut splits a turn; `turnStartIndex` is valid in that case. */
+	isSplitTurn: boolean;
+}
+
+export interface FindCutPointOptions {
+	/** Inclusive lower bound on the search window. Defaults to 0. */
+	startIndex?: number;
+	/** Exclusive upper bound on the search window. Defaults to entries.length. */
+	endIndex?: number;
+}
+
+/**
+ * Scan backwards from `entryIndex` until we hit the user (or bashExecution)
+ * message that opened the current turn. Returns -1 when no such start is
+ * found inside the supplied window. `branchSummary` entries count as turn
+ * starts because they replace the upstream history at a fork point.
+ */
+function findTurnStartIndex(entries: ReadonlyArray<SessionEntry>, entryIndex: number, startIndex = 0): number {
+	for (let i = entryIndex; i >= startIndex; i--) {
+		const entry = entries[i];
+		if (!entry) continue;
+		if (entry.kind === "branchSummary") return i;
+		if (entry.kind === "bashExecution") return i;
+		if (entry.kind === "message" && entry.role === "user") return i;
+	}
+	return -1;
+}
+
+/** Entries we can cut at. `tool_result` is the only role we must NOT cut at. */
+function isValidCutPoint(entry: SessionEntry): boolean {
+	switch (entry.kind) {
+		case "message":
+			return entry.role !== "tool_result";
+		case "bashExecution":
+		case "custom":
+		case "skillActivation":
+		case "branchSummary":
+		case "compactionSummary":
+			return true;
+		case "modelChange":
+		case "thinkingLevelChange":
+		case "fileEntry":
+		case "sessionInfo":
+		case "label":
+		case "protectedArtifact":
+		case "taskLedger":
+		case "workerRun":
+			return false;
+	}
+}
+
+function findValidCutPoints(entries: ReadonlyArray<SessionEntry>, startIndex: number, endIndex: number): number[] {
+	const cuts: number[] = [];
+	for (let i = startIndex; i < endIndex; i++) {
+		const entry = entries[i];
+		if (!entry) continue;
+		if (isValidCutPoint(entry)) cuts.push(i);
+	}
+	return cuts;
+}
+
+/**
+ * Find the cut point that keeps at least `keepRecentTokens` tokens in the
+ * retained suffix. Never cuts at a `tool_result`. When walking forward from
+ * the chosen cut would swallow non-message bookkeeping entries (modelChange,
+ * thinkingLevelChange, fileEntry, sessionInfo), the cut is widened so those
+ * entries ride along with the suffix instead of being summarized.
+ *
+ * Small-session fallback: when the walker exhausts `entries` without ever
+ * accumulating `keepRecentTokens`, the pi-coding-agent reference left
+ * `cutIndex` at the oldest valid cut, which made `compact()` produce an
+ * empty `pre` slice and the chat-loop report "nothing to compact" on
+ * populated sessions below the keep-recent window. Clio's manual `/compact`
+ * expects to summarize whatever older history exists, so when no suffix
+ * crosses the threshold the cut falls back to the newest turn start (user
+ * message, bashExecution, or branchSummary). Sessions with only a single
+ * turn still land the cut at index 0. `pre` stays empty and the caller
+ * surfaces the honest "nothing to compact" notice.
+ */
+export function findCutPoint(
+	entries: ReadonlyArray<SessionEntry>,
+	keepRecentTokens: number,
+	opts: FindCutPointOptions = {},
+): CutPointResult {
+	const startIndex = opts.startIndex ?? 0;
+	const endIndex = opts.endIndex ?? entries.length;
+	const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
+	if (cutPoints.length === 0) {
+		return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
+	}
+
+	let accumulated = 0;
+	let cutIndex = -1;
+	for (let i = endIndex - 1; i >= startIndex; i--) {
+		const entry = entries[i];
+		if (!entry) continue;
+		accumulated += estimateTokens(entry);
+		if (accumulated >= keepRecentTokens) {
+			for (const candidate of cutPoints) {
+				if (candidate >= i) {
+					cutIndex = candidate;
+					break;
+				}
+			}
+			break;
+		}
+	}
+
+	if (cutIndex === -1) {
+		// Walker never crossed keepRecentTokens, or crossed but found no valid
+		// cut at/after the stop index (all valid cuts precede the tool_result
+		// tail). Prefer the newest turn start so older turns still feed the
+		// summary prompt. Absent any turn start, fall back to the oldest valid
+		// cut. That matches the pre-fix behavior, so pre stays empty and the
+		// orchestrator reports nothing to compact.
+		const lastTurnStart = findTurnStartIndex(entries, endIndex - 1, startIndex);
+		cutIndex = lastTurnStart !== -1 ? lastTurnStart : (cutPoints[0] ?? startIndex);
+	}
+
+	// Scan backwards from cutIndex to fold bookkeeping entries into the suffix.
+	while (cutIndex > startIndex) {
+		const prev = entries[cutIndex - 1];
+		if (!prev) break;
+		if (prev.kind === "compactionSummary") break;
+		if (
+			prev.kind === "message" ||
+			prev.kind === "bashExecution" ||
+			prev.kind === "custom" ||
+			prev.kind === "skillActivation" ||
+			prev.kind === "branchSummary"
+		) {
+			break;
+		}
+		cutIndex--;
+	}
+
+	const cutEntry = entries[cutIndex];
+	const cutIsUserTurn = !!cutEntry && cutEntry.kind === "message" && cutEntry.role === "user";
+	const turnStartIndex = cutIsUserTurn ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+	return {
+		firstKeptEntryIndex: cutIndex,
+		turnStartIndex,
+		isSplitTurn: !cutIsUserTurn && turnStartIndex !== -1,
+	};
+}

package/src/domains/session/compaction/defaults.ts

@@ -0,0 +1,34 @@
+/**
+ * Compaction settings: user-visible defaults.
+ *
+ * The public settings block is a single pressure threshold plus the recent-turn
+ * protection horizon. The structural type lives in `src/core/defaults.ts`
+ * alongside the rest of the settings tree so core code stays free of a
+ * backward domain dependency; this module pairs that type with the value the
+ * DEFAULT_SETTINGS tree and the chat-loop read at runtime.
+ */
+
+import type { CompactionSettings } from "../../../core/defaults.js";
+
+export type { CompactionSettings } from "../../../core/defaults.js";
+
+export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
+	auto: true,
+	threshold: 0.8,
+	excludeLastTurns: 6,
+};
+
+/**
+ * Tokens held in reserve for the summary response. Ported from
+ * pi-coding-agent's `DEFAULT_COMPACTION_SETTINGS.reserveTokens`; kept as an
+ * engine-level constant so adjusting it later does not require a settings
+ * migration.
+ */
+export const DEFAULT_RESERVE_TOKENS = 16_384;
+
+/**
+ * Minimum tokens of recent context the cut-point must keep. The estimator
+ * walks backwards until it has accumulated at least this many tokens, then
+ * cuts at the nearest valid boundary.
+ */
+export const DEFAULT_KEEP_RECENT_TOKENS = 20_000;

package/src/domains/session/compaction/mask-observations.ts

@@ -0,0 +1,265 @@
+/**
+ * Cheap pre-stage for compaction: mask the bodies of tool results older than
+ * the protected recent-turn horizon. Tool call/result pairing and metadata
+ * survive so replay dependencies stay intact; only the observation body is
+ * replaced with a short marker telling the model how to re-fetch.
+ *
+ * The same pass drops thinking blocks from assistant messages older than the
+ * horizon. Prior-turn reasoning is replayed by the local engine adapters
+ * (lmstudio `<think>` text, ollama `thinking`, llama.cpp `reasoning_content`)
+ * and counted by the pressure estimator, yet has no forward value once the
+ * turn is past the protected window; the Anthropic API drops it after every
+ * turn. No marker replaces it: thinking is model-internal and a marker would
+ * spend tokens to say nothing. Recent turns keep their thinking untouched so
+ * same-model signature replay still works where it matters.
+ *
+ * Entries that already carry a `contextCompaction` marker (from any earlier
+ * compaction run) are never rewritten again; thinking masking is naturally
+ * idempotent (a stripped message has no thinking blocks left) and stamps
+ * `mask_thinking` so the ledger records why the reasoning vanished.
+ */
+
+import type { MessageEntry, SessionEntry } from "../entries.js";
+import { calculateContextTokens } from "./tokens.js";
+
+export interface MaskObservationsResult {
+	entries: SessionEntry[];
+	changed: boolean;
+	tokensBefore: number;
+	tokensAfter: number;
+	maskedObservations: number;
+	maskedThinkingBlocks: number;
+	maskedThinkingChars: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function cloneEntry(entry: SessionEntry): SessionEntry {
+	return structuredClone(entry) as SessionEntry;
+}
+
+function textFromContent(content: unknown): string {
+	if (!Array.isArray(content)) return "";
+	const parts: string[] = [];
+	for (const block of content) {
+		if (!isRecord(block)) continue;
+		if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+	}
+	return parts.join("");
+}
+
+function stringifyPreview(value: unknown, limit = 10_000): string {
+	if (value === undefined || value === null) return "";
+	if (typeof value === "string") return value.length <= limit ? value : `${value.slice(0, limit - 3)}...`;
+	try {
+		const text = JSON.stringify(value);
+		if (!text) return "";
+		return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
+	} catch {
+		const text = String(value);
+		return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
+	}
+}
+
+function resultText(result: unknown): string {
+	if (typeof result === "string") return result;
+	if (!isRecord(result)) return stringifyPreview(result);
+	const contentText = textFromContent(result.content);
+	if (contentText.length > 0) return contentText;
+	if (typeof result.text === "string") return result.text;
+	if (typeof result.output === "string") return result.output;
+	if (typeof result.message === "string") return result.message;
+	return stringifyPreview(result);
+}
+
+function extractToolResultPayload(payload: unknown): {
+	obj: Record<string, unknown>;
+	result: unknown;
+	toolName: string;
+} {
+	const obj = isRecord(payload) ? payload : { result: payload };
+	const result = obj.result ?? obj.output ?? obj.out ?? obj.content ?? payload;
+	const toolName =
+		(typeof obj.toolName === "string" && obj.toolName) ||
+		(typeof obj.name === "string" && obj.name) ||
+		(typeof obj.tool === "string" && obj.tool) ||
+		"tool";
+	return { obj, result, toolName };
+}
+
+function lineCount(text: string): number {
+	if (text.length === 0) return 0;
+	return text.split(/\r\n|\r|\n/).length;
+}
+
+function observationMarker(toolName: string, text: string): string {
+	const preview = text.trim().replace(/\s+/g, " ").slice(0, 160);
+	const suffix = preview.length > 0 ? ` Preview: ${preview}` : "";
+	return `[Observation masked: ${toolName} output was ${lineCount(text)} lines, ${text.length} chars - contents masked to save context. Re-run the tool for current content.]${suffix}`;
+}
+
+function maskedToolResult(original: unknown, marker: string): Record<string, unknown> {
+	const details = isRecord(original) && isRecord(original.details) ? { ...original.details } : {};
+	return {
+		content: [{ type: "text", text: marker }],
+		details: {
+			...details,
+			contextCompaction: { stage: "mask_observations", at: new Date().toISOString() },
+		},
+	};
+}
+
+function alreadyCompacted(payload: unknown): boolean {
+	if (!isRecord(payload)) return false;
+	if (isRecord(payload.contextCompaction)) return true;
+	const summary = payload.resultSummary;
+	if (isRecord(summary) && isRecord(summary.contextCompaction)) return true;
+	const result = payload.result ?? payload.output ?? payload.out;
+	if (isRecord(result) && isRecord(result.details) && isRecord(result.details.contextCompaction)) return true;
+	return false;
+}
+
+function maskObservation(entry: MessageEntry): MessageEntry {
+	const next = cloneEntry(entry) as MessageEntry;
+	const { obj, result, toolName } = extractToolResultPayload(next.payload);
+	const text = resultText(result);
+	const marker = observationMarker(toolName, text);
+	next.payload = {
+		...obj,
+		result: maskedToolResult(result, marker),
+		output: undefined,
+		out: undefined,
+		content: undefined,
+		resultSummary: {
+			...(isRecord(obj.resultSummary) ? obj.resultSummary : {}),
+			bytes: 0,
+			truncated: true,
+			contextCompaction: {
+				stage: "mask_observations",
+				originalChars: text.length,
+				originalLines: lineCount(text),
+				at: new Date().toISOString(),
+			},
+		},
+	};
+	return next;
+}
+
+interface MaskedThinking {
+	entry: MessageEntry;
+	blocks: number;
+	chars: number;
+}
+
+/**
+ * Strip thinking content from a stale assistant message. Returns null when
+ * the message carries no thinking (the no-op case, which keeps `changed`
+ * honest and makes reruns naturally idempotent). Handles both shapes the
+ * session ledger contains: `content` blocks of type `thinking` and the
+ * payload-level `thinking` string some engine paths persist.
+ */
+function maskThinking(entry: MessageEntry): MaskedThinking | null {
+	const obj = isRecord(entry.payload) ? entry.payload : null;
+	if (!obj) return null;
+	let blocks = 0;
+	let chars = 0;
+	let content: unknown[] | undefined;
+	if (Array.isArray(obj.content)) {
+		content = obj.content.filter((block) => {
+			if (!isRecord(block) || block.type !== "thinking") return true;
+			blocks += 1;
+			if (typeof block.thinking === "string") chars += block.thinking.length;
+			return false;
+		});
+	}
+	if (typeof obj.thinking === "string" && obj.thinking.length > 0) {
+		blocks += 1;
+		chars += obj.thinking.length;
+	}
+	if (blocks === 0) return null;
+	const next = cloneEntry(entry) as MessageEntry;
+	next.payload = {
+		...obj,
+		...(content !== undefined ? { content } : {}),
+		thinking: undefined,
+		contextCompaction: {
+			...(isRecord(obj.contextCompaction) ? obj.contextCompaction : {}),
+			stage: "mask_thinking",
+			maskedThinkingChars: chars,
+			at: new Date().toISOString(),
+		},
+	};
+	return { entry: next, blocks, chars };
+}
+
+function isTurnStart(entry: SessionEntry): boolean {
+	if (entry.kind === "bashExecution" || entry.kind === "branchSummary") return true;
+	return entry.kind === "message" && entry.role === "user";
+}
+
+function recentTurnCutoff(entries: ReadonlyArray<SessionEntry>, excludeLastTurns: number): number {
+	const horizon = Math.max(1, Math.floor(excludeLastTurns));
+	let seen = 0;
+	for (let i = entries.length - 1; i >= 0; i -= 1) {
+		const entry = entries[i];
+		if (!entry || !isTurnStart(entry)) continue;
+		seen += 1;
+		if (seen >= horizon) return i;
+	}
+	return 0;
+}
+
+function invalidateUsage(entry: SessionEntry): SessionEntry {
+	if (entry.kind !== "message" || entry.role !== "assistant") return entry;
+	const obj = isRecord(entry.payload) ? entry.payload : null;
+	if (!obj || obj.contextUsageInvalidated === true) return entry;
+	const next = cloneEntry(entry) as MessageEntry;
+	next.payload = {
+		...obj,
+		contextUsageInvalidated: true,
+	};
+	return next;
+}
+
+export function maskStaleObservations(
+	entries: ReadonlyArray<SessionEntry>,
+	excludeLastTurns: number,
+): MaskObservationsResult {
+	const tokensBefore = calculateContextTokens(entries);
+	const cutoff = recentTurnCutoff(entries, excludeLastTurns);
+	let changed = false;
+	let maskedObservations = 0;
+	let maskedThinkingBlocks = 0;
+	let maskedThinkingChars = 0;
+	const next = entries.map((entry, index) => {
+		if (index >= cutoff || entry.kind !== "message") return entry;
+		if (entry.role === "tool_result") {
+			if (alreadyCompacted(entry.payload)) return entry;
+			changed = true;
+			maskedObservations += 1;
+			return maskObservation(entry);
+		}
+		if (entry.role === "assistant") {
+			const masked = maskThinking(entry);
+			if (!masked) return entry;
+			changed = true;
+			maskedThinkingBlocks += masked.blocks;
+			maskedThinkingChars += masked.chars;
+			return masked.entry;
+		}
+		return entry;
+	});
+
+	const finalEntries = changed ? next.map(invalidateUsage) : next;
+	return {
+		entries: finalEntries,
+		changed,
+		tokensBefore,
+		tokensAfter: calculateContextTokens(finalEntries),
+		maskedObservations,
+		maskedThinkingBlocks,
+		maskedThinkingChars,
+	};
+}

package/src/domains/session/compaction/session-entries.ts

@@ -0,0 +1,18 @@
+import { isSessionEntry, type SessionEntry } from "../entries.js";
+
+/**
+ * Validate session ledger records and return the structured entry sequence.
+ * The session header is removed by engine readers before this collector runs.
+ */
+export function collectSessionEntries(turns: ReadonlyArray<unknown>, filePath: string): SessionEntry[] {
+	const out: SessionEntry[] = [];
+	for (const raw of turns) {
+		if (!isSessionEntry(raw)) {
+			throw new Error(
+				`session ledger contains an unreadable entry (missing kind discriminant): ${filePath}. Remove or compact the session to reset.`,
+			);
+		}
+		out.push(raw);
+	}
+	return out;
+}

package/src/domains/session/compaction/tokens.ts

@@ -0,0 +1,147 @@
+/**
+ * Token estimation for session entries (Phase 12 slice 12c).
+ *
+ * Ports pi-coding-agent's chars/4 heuristic verbatim (reference:
+ * pi-mono/packages/coding-agent/src/core/compaction/compaction.ts:232
+ * `estimateTokens`). Pure functions, no I/O.
+ *
+ * Rationale for the heuristic (plan §3):
+ *   - Conservative by design: over-estimating trips compaction earlier,
+ *     never later. Missing a trigger and hitting provider overflow is
+ *     expensive; running a compaction on 80k when actual was 95k is cheap.
+ *   - pi-coding-agent ships it at scale, so we adopt the
+ *     known ceiling rather than introduce a new numeric contract.
+ *   - Exact per-provider counts (Anthropic /count_tokens, tiktoken) are
+ *     parked. The `TokenEstimator` interface below keeps them a drop-in
+ *     swap for a later phase.
+ */
+
+import type { Usage } from "../../../engine/types.js";
+import { ceilChars, contentChars, estimateAgentMessageTokens } from "../context-accounting.js";
+import type {
+	BashExecutionEntry,
+	BranchSummaryEntry,
+	CompactionSummaryEntry,
+	CustomEntry,
+	MessageEntry,
+	SessionEntry,
+} from "../entries.js";
+
+/** Contract future alternate estimators must satisfy. */
+export interface TokenEstimator {
+	estimateEntry(entry: SessionEntry): number;
+	calculateContextTokens(entries: ReadonlyArray<SessionEntry>, lastUsage?: Usage): number;
+}
+
+function estimateMessage(entry: MessageEntry): number {
+	return estimateAgentMessageTokens(entry);
+}
+
+function estimateBashExecution(entry: BashExecutionEntry): number {
+	return ceilChars(entry.command.length + entry.output.length);
+}
+
+function estimateCustom(entry: CustomEntry): number {
+	if (entry.data === undefined) return 0;
+	return ceilChars(contentChars(entry.data));
+}
+
+function estimateSummary(entry: BranchSummaryEntry | CompactionSummaryEntry): number {
+	return ceilChars(entry.summary.length);
+}
+
+/**
+ * Estimate the token load of a single session entry. Non-context-bearing
+ * kinds (modelChange, thinkingLevelChange, fileEntry, sessionInfo,
+ * label, protectedArtifact, taskLedger, workerRun) return 0 so they never
+ * distort the context budget.
+ */
+export function estimateTokens(entry: SessionEntry): number {
+	switch (entry.kind) {
+		case "message":
+			return estimateMessage(entry);
+		case "bashExecution":
+			return estimateBashExecution(entry);
+		case "custom":
+			return estimateCustom(entry);
+		case "skillActivation":
+			return ceilChars(JSON.stringify(entry.activation).length);
+		case "branchSummary":
+		case "compactionSummary":
+			return estimateSummary(entry);
+		case "modelChange":
+		case "thinkingLevelChange":
+		case "fileEntry":
+		case "sessionInfo":
+		case "label":
+		case "protectedArtifact":
+		case "taskLedger":
+		case "workerRun":
+			return 0;
+	}
+}
+
+function usageTotalTokens(usage: Usage): number {
+	return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+
+function extractUsage(payload: unknown): Usage | undefined {
+	if (!payload || typeof payload !== "object") return undefined;
+	const p = payload as { usage?: unknown; stopReason?: unknown; contextUsageInvalidated?: unknown };
+	if (p.contextUsageInvalidated === true) return undefined;
+	if (p.stopReason === "aborted" || p.stopReason === "error") return undefined;
+	const u = p.usage;
+	if (!u || typeof u !== "object") return undefined;
+	const usage = u as Partial<Usage>;
+	if (typeof usage.input !== "number" || typeof usage.output !== "number") return undefined;
+	return usage as Usage;
+}
+
+/**
+ * Walk entries from newest to oldest, returning the first assistant message
+ * whose payload carries a valid usage block. Aborted/error assistant turns
+ * are skipped because their usage is not meaningful for context accounting.
+ */
+export function getLastAssistantUsage(entries: ReadonlyArray<SessionEntry>): Usage | undefined {
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry?.kind !== "message" || entry?.role !== "assistant") continue;
+		const usage = extractUsage(entry.payload);
+		if (usage) return usage;
+	}
+	return undefined;
+}
+
+function findLastAssistantUsageIndex(entries: ReadonlyArray<SessionEntry>): number {
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry?.kind !== "message" || entry?.role !== "assistant") continue;
+		if (extractUsage(entry.payload)) return i;
+	}
+	return -1;
+}
+
+/**
+ * Total context tokens for the supplied entry list. When `lastUsage` is
+ * provided (or derivable from the entries), uses its totalTokens as the
+ * anchor and only estimates the entries that followed it. This matches
+ * pi-coding-agent's `estimateContextTokens` behavior and keeps the number
+ * accurate for sessions whose most recent assistant turn carried real
+ * provider usage data.
+ */
+export function calculateContextTokens(entries: ReadonlyArray<SessionEntry>, lastUsage?: Usage): number {
+	const usage = lastUsage ?? getLastAssistantUsage(entries);
+	if (usage) {
+		const anchorTokens = usageTotalTokens(usage);
+		const anchorIndex = findLastAssistantUsageIndex(entries);
+		let trailing = 0;
+		for (let i = anchorIndex + 1; i < entries.length; i++) {
+			const entry = entries[i];
+			if (entry) trailing += estimateTokens(entry);
+		}
+		return anchorTokens + trailing;
+	}
+	let total = 0;
+	for (const entry of entries) total += estimateTokens(entry);
+	return total;
+}