pi-posthorse 0.10.24 → 0.10.25

package/index.ts

@@ -14,6 +14,7 @@ import { policySnapshot } from "./src/budget.ts";
 import type { CompactionPolicy, PolicyReader } from "./src/contracts.ts";
 import { createWindowGuidance } from "./src/guidance.ts";
 import { registerHistory } from "./src/history.ts";
+import { toolFacts } from "./src/host.ts";
 import { safeJsonStringify } from "./src/message-text.ts";
 import { registerNotes } from "./src/notes.ts";
 import { createNotesStore } from "./src/note-store.ts";
@@ -22,9 +23,8 @@ import { PageReservations } from "./src/paging.ts";
 import { registerRollover } from "./src/rollover.ts";
 
 function activeToolTokens(pi: ExtensionAPI): number {
-	const active = new Set(pi.getActiveTools());
-	return pi
-		.getAllTools()
+	const { active, tools } = toolFacts(pi);
+	return tools
 		.filter((tool) => active.has(tool.name))
 		.reduce(
 			(total, tool) =>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-posthorse",
-	"version": "0.10.24",
+	"version": "0.10.25",
 	"type": "module",
 	"description": "Posthorse: fresh context, same journey. No-summary context rollover for Pi, with sparse budget reminders, handoffs, notes, and history.",
 	"keywords": [

package/src/boundary.ts

@@ -0,0 +1,95 @@
+import { AUTO_HANDOFF_PREFIX, isRecord, type EntryLike, type ProjectedEntry } from "./contracts.ts";
+
+export type BoundaryKind = "fork" | "native" | "automatic" | "explicit" | "posthorse";
+/** Everything the app derives from one persisted context boundary, decided in one place. */
+export type Boundary = {
+	readonly kind: BoundaryKind;
+	/** Counts as a Posthorse window: labels, reminder windows, and note provenance. */
+	readonly window: boolean;
+	/** An automatic recovery record that walks through earlier windows continue past. */
+	readonly chainsAncestry: boolean;
+	/** Starts a new guidance epoch; a provider summary block keeps the previous one. */
+	readonly freshGuidance: boolean;
+};
+
+export function windowHandoff(entry: EntryLike | undefined): string | undefined {
+	return entry?.type === "compaction" ? entry.summary : entry?.handoff;
+}
+/** An automatic recovery record opens with this prefix; an earlier window's walk may continue past it. */
+function automaticHandoff(entry: EntryLike): boolean {
+	return windowHandoff(entry)?.trim().startsWith(AUTO_HANDOFF_PREFIX) === true;
+}
+/**
+ * A compaction with a provider summary block carries forward the previous window's leading system
+ * message unchanged, so its guidance section must stay locked to that earlier epoch too.
+ */
+function providerSummaryBlock(entry: EntryLike): boolean {
+	return (
+		entry.type === "compaction" &&
+		isRecord(entry.providerSummary) &&
+		isRecord(entry.providerSummary.block)
+	);
+}
+function compactionKind(details: Readonly<Record<string, unknown>>): BoundaryKind {
+	if (details.reason === "threshold" || details.reason === "overflow") {
+		return "automatic";
+	}
+	return details.reason === "explicit" ? "explicit" : "posthorse";
+}
+export function classifyBoundary(entry?: EntryLike): Boundary | undefined {
+	if (entry?.type === "context_window") {
+		return {
+			kind: "fork",
+			window: true,
+			chainsAncestry: automaticHandoff(entry),
+			freshGuidance: true,
+		};
+	}
+	if (entry?.type !== "compaction") {
+		return undefined;
+	}
+	const details = isRecord(entry.details) ? entry.details : undefined;
+	const freshGuidance = !providerSummaryBlock(entry);
+	if (details?.posthorse !== 1) {
+		return { kind: "native", window: false, chainsAncestry: false, freshGuidance };
+	}
+	const kind = compactionKind(details);
+	return {
+		kind,
+		window: true,
+		chainsAncestry: kind === "automatic" && automaticHandoff(entry),
+		freshGuidance,
+	};
+}
+export function isWindow(entry: EntryLike): boolean {
+	return classifyBoundary(entry)?.window === true;
+}
+export function startsFreshGuidanceEpoch(entry: EntryLike): boolean {
+	return classifyBoundary(entry)?.freshGuidance === true;
+}
+export function chainsAncestry(entry?: EntryLike): boolean {
+	return classifyBoundary(entry)?.chainsAncestry === true;
+}
+/** The boundary already applied to a projection: a compaction with a visible tail. -1 when none. */
+export function activeBoundaryIndex(projected: readonly ProjectedEntry[]): number {
+	return projected.findIndex(
+		(entry) => entry.sourceEntry.type === "compaction" && entry.messages.length > 0,
+	);
+}
+/** First active branch entry, including tails retained by Pi's own /compact. */
+export function contextStart(entries: readonly EntryLike[]): {
+	start: number;
+	boundary?: EntryLike;
+} {
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry?.type === "context_window") {
+			return { start: i + 1, boundary: entry };
+		}
+		if (entry?.type === "compaction") {
+			const kept = entries.findIndex((candidate) => candidate.id === entry.firstKeptEntryId);
+			return { start: kept >= 0 ? kept : i + 1, boundary: entry };
+		}
+	}
+	return { start: 0 };
+}

package/src/budget.ts

@@ -24,11 +24,18 @@ export const ALL_GUIDANCE_TOOLS: GuidanceTools = {
 export type Budget = {
 	readonly contextWindow: number;
 	readonly reserveTokens: number;
-	readonly enabled: boolean;
+	/** One classification of how Posthorse may use this capacity. */
+	readonly state: BudgetState;
 	readonly usable: number;
 	readonly rolloverAt: number;
-	readonly supported: boolean;
 };
+export type BudgetState = "disabled" | "unsupported" | "enabled";
+function budgetState(enabled: boolean, usable: number): BudgetState {
+	if (!enabled) {
+		return "disabled";
+	}
+	return usable >= MIN_USABLE_TOKENS ? "enabled" : "unsupported";
+}
 /** A synchronous evaluation owns one snapshot; never carry it across an await. */
 export function policySnapshot(
 	ctx: ExtensionContext,
@@ -73,10 +80,9 @@ export function budgetFor(
 	return {
 		contextWindow,
 		reserveTokens,
-		enabled,
+		state: budgetState(enabled, usable),
 		usable,
 		rolloverAt: usable + 1,
-		supported: !enabled || usable >= MIN_USABLE_TOKENS,
 	};
 }
 export function budgetGuidanceKey(ctx: PolicyContext): string {
@@ -84,9 +90,9 @@ export function budgetGuidanceKey(ctx: PolicyContext): string {
 	if (budget === undefined) {
 		return ctx.getCompactionSettings().enabled ? "1:unknown" : "0:unknown";
 	}
-	return budget.enabled
-		? `1:${budget.contextWindow}:${budget.reserveTokens}`
-		: `0:${budget.contextWindow}`;
+	return budget.state === "disabled"
+		? `0:${budget.contextWindow}`
+		: `1:${budget.contextWindow}:${budget.reserveTokens}`;
 }
 export function unsupportedMessage(budget: Budget, newContextAvailable = true): string {
 	const n = (value: number) => value.toLocaleString("en-US");
@@ -104,7 +110,7 @@ function automaticGuidance(
 		const reset = tools.newContext ? " new_context remains available." : "";
 		return `Pi compaction is disabled in the available settings, so Posthorse sends no checkpoint reminder.${reset}`;
 	}
-	if (budget !== undefined && !budget.supported) {
+	if (budget?.state === "unsupported") {
 		return unsupportedMessage(budget, tools.newContext);
 	}
 	const line =
@@ -120,7 +126,8 @@ export function buildGuidance(
 	tools: GuidanceTools = ALL_GUIDANCE_TOOLS,
 ): string {
 	const budget = budgetFor(ctx);
-	const enabled = budget?.enabled ?? ctx.getCompactionSettings().enabled;
+	const enabled =
+		budget === undefined ? ctx.getCompactionSettings().enabled : budget.state !== "disabled";
 	const capacity =
 		budget === undefined
 			? "Configured context capacity is unknown."
@@ -148,20 +155,29 @@ function guidanceTokenCount(guidance: string): number {
 export function guidanceTokens(ctx: PolicyContext): number {
 	return guidanceTokenCount(guidanceFor(ctx));
 }
+/**
+ * Which guidance the reservation subtracts: the text rebuilt for the next request, or the host's
+ * effective text that is already in the prompt.
+ */
+export type GuidanceReservation = "rebuild" | "effective";
 /** Half the fresh capacity after prompt/tool/input overhead remains for continued work. */
 export function freshPayloadChars(
 	ctx: PolicyContext,
 	toolTokens: number,
-	pendingMessages: readonly MessageLike[] = [],
-	cap = MAX_HANDOFF_CHARS,
+	options: {
+		readonly pendingMessages?: readonly MessageLike[] | undefined;
+		readonly cap?: number | undefined;
+		readonly guidance?: GuidanceReservation | undefined;
+	} = {},
 ): number {
+	const { pendingMessages = [], cap = MAX_HANDOFF_CHARS, guidance = "rebuild" } = options;
 	const budget = budgetFor(ctx);
 	if (budget === undefined) {
 		return cap;
 	}
-	const line = budget.enabled && budget.supported ? budget.rolloverAt : budget.contextWindow;
+	const line = budget.state === "enabled" ? budget.rolloverAt : budget.contextWindow;
 	const reservedGuidance =
-		cap === MAX_HANDOFF_CHARS ? guidanceTokenCount(buildGuidance(ctx)) : guidanceTokens(ctx);
+		guidance === "rebuild" ? guidanceTokenCount(buildGuidance(ctx)) : guidanceTokens(ctx);
 	const promptTokens = Math.ceil(ctx.getSystemPrompt().length / 4) + reservedGuidance;
 	const pendingTokens = pendingMessages.reduce(
 		(total, message) =>
@@ -181,10 +197,13 @@ export function freshPayloadChars(
 export function pageCapacity(ctx: PolicyContext, toolTokens: () => number): number {
 	const usage = ctx.getContextUsage();
 	if (usage === undefined || usage.tokens === null) {
-		return freshPayloadChars(ctx, toolTokens(), [], MAX_PAGE_CHARS) / 4 + PAGE_MARGIN_TOKENS;
+		return (
+			freshPayloadChars(ctx, toolTokens(), { cap: MAX_PAGE_CHARS, guidance: "effective" }) /
+				4 +
+			PAGE_MARGIN_TOKENS
+		);
 	}
 	const budget = budgetFor(ctx, usage.contextWindow);
-	const line =
-		budget?.enabled === true && budget.supported ? budget.rolloverAt : usage.contextWindow;
+	const line = budget?.state === "enabled" ? budget.rolloverAt : usage.contextWindow;
 	return line - usage.tokens - guidanceTokens(ctx);
 }

package/src/context-tools.ts

@@ -12,10 +12,7 @@ import {
 } from "./contracts.ts";
 
 function rolloverStatus(budget: Budget | undefined): "disabled" | "enabled" | "unsupported" {
-	if (budget?.enabled !== true) {
-		return "disabled";
-	}
-	return budget.supported ? "enabled" : "unsupported";
+	return budget?.state ?? "disabled";
 }
 function contextReport(host: PolicyContext, newContextAvailable: boolean): TextResult {
 	const usage = host.getContextUsage();
@@ -34,14 +31,14 @@ function contextReport(host: PolicyContext, newContextAvailable: boolean): TextR
 		rolloverAt: budget?.rolloverAt,
 	};
 	const configured = `≈${n(Math.max(0, usage.contextWindow - usage.tokens))} tokens until the configured context limit (${n(usage.tokens)}/${n(usage.contextWindow)} used, ${Math.round(usage.percent ?? 0)}%). Best available native estimate.`;
-	if (budget?.enabled !== true) {
+	if (budget === undefined || budget.state === "disabled") {
 		return textResult(
 			`Automatic rollover is disabled in the available settings (Pi compaction.enabled=false). ${configured}`,
 			[],
 			display,
 		);
 	}
-	if (!budget.supported) {
+	if (budget.state === "unsupported") {
 		return textResult(
 			`${unsupportedMessage(budget, newContextAvailable)} ${configured}`,
 			[],

package/src/contracts.ts

@@ -118,6 +118,10 @@ export function unknownArray(value: unknown): readonly unknown[] | undefined {
 export function optionalString(value: unknown): string | undefined {
 	return typeof value === "string" ? value : undefined;
 }
+/** Some models send every optional argument; an empty string means the argument was omitted. */
+export function presentText(value: unknown): string | undefined {
+	return typeof value === "string" && value !== "" ? value : undefined;
+}
 export function requireValue(value: string | undefined, name: string, op: string): string {
 	if (value === undefined || value === "") {
 		throw new Error(`"${name}" is required for op "${op}".`);

package/src/epoch-cache.ts

@@ -0,0 +1,50 @@
+import { sessionIdentity, type SessionHost, type SessionIdentity } from "./host.ts";
+
+/** A cached value with the session state it was computed from. */
+export type EpochValue<Value> = {
+	readonly identity: SessionIdentity;
+	readonly value: Value;
+};
+export type EpochCache<Value> = {
+	readonly read: (ctx: SessionContext) => Value;
+	readonly reset: () => void;
+};
+export type SessionContext = { readonly sessionManager: SessionHost };
+
+function sameSession(left: SessionIdentity, right: SessionIdentity): boolean {
+	return left.sessionId === right.sessionId && left.file === right.file;
+}
+/**
+ * Caches one session fact for the current leaf. A new leaf recomputes unless its walk reaches the
+ * cached leaf entry itself: entry identity, not a reusable id, certifies an append-only extension.
+ */
+export function createEpochCache<Value>(
+	compute: (
+		ctx: SessionContext,
+		identity: SessionIdentity,
+		previous: EpochValue<Value> | undefined,
+	) => Value,
+): EpochCache<Value> {
+	let cached: (EpochValue<Value> & { readonly manager: object }) | undefined;
+	return {
+		reset: () => {
+			cached = undefined;
+		},
+		read: (ctx) => {
+			const manager: object = ctx.sessionManager;
+			const identity = sessionIdentity(ctx.sessionManager);
+			const previous =
+				cached !== undefined &&
+				cached.manager === manager &&
+				sameSession(cached.identity, identity)
+					? cached
+					: undefined;
+			if (previous !== undefined && previous.identity.leaf === identity.leaf) {
+				return previous.value;
+			}
+			const value = compute(ctx, identity, previous);
+			cached = { manager, identity, value };
+			return value;
+		},
+	};
+}

package/src/guidance.ts

@@ -7,7 +7,10 @@ import {
 	buildGuidance,
 	type GuidanceTools,
 } from "./budget.ts";
-import { isRecord, type EntryLike, type PolicyContext, type SnapshotReader } from "./contracts.ts";
+import type { EntryLike, PolicyContext, SnapshotReader } from "./contracts.ts";
+import { startsFreshGuidanceEpoch } from "./boundary.ts";
+import { createEpochCache, type EpochValue } from "./epoch-cache.ts";
+import { sessionEntry, toolFacts, type SessionHost, type SessionIdentity } from "./host.ts";
 
 export const WINDOW_GUIDANCE_TYPE = "posthorse-window-guidance";
 const guidanceRecordSchema = Type.Object({
@@ -24,11 +27,7 @@ type MemoryEpoch = {
 	readonly byBudget: Map<string, string>;
 	tools: GuidanceTools | undefined;
 };
-type EpochState = {
-	readonly manager: ExtensionContext["sessionManager"];
-	readonly sessionId: string;
-	readonly file: string | undefined;
-	readonly leaf: EntryLike | undefined;
+type GuidanceEpoch = {
 	readonly anchorKey: string;
 	readonly byBudget: ReadonlyMap<string, string>;
 	readonly tools: GuidanceTools | undefined;
@@ -40,58 +39,12 @@ export type WindowGuidance = {
 };
 
 export function activeGuidanceTools(pi: ExtensionAPI): GuidanceTools {
-	const active = new Set(pi.getActiveTools());
-	const unnamespaced = new Set(
-		pi
-			.getAllTools()
-			.filter((tool) => tool.namespace === undefined)
-			.map((tool) => tool.name),
-	);
+	const { activeUnnamespaced } = toolFacts(pi);
 	return {
-		newContext: active.has("new_context") && unnamespaced.has("new_context"),
-		getContextRemaining:
-			active.has("get_context_remaining") && unnamespaced.has("get_context_remaining"),
+		newContext: activeUnnamespaced.has("new_context"),
+		getContextRemaining: activeUnnamespaced.has("get_context_remaining"),
 	};
 }
-/**
- * A compaction with a provider summary block carries forward the previous window's leading system
- * message unchanged, so its guidance section must stay locked to that earlier epoch too.
- */
-function startsFreshGuidanceEpoch(entry: EntryLike): boolean {
-	if (entry.type === "context_window") {
-		return true;
-	}
-	return (
-		entry.type === "compaction" &&
-		!(isRecord(entry.providerSummary) && isRecord(entry.providerSummary.block))
-	);
-}
-function parentEntry(
-	manager: ExtensionContext["sessionManager"],
-	id: string | null | undefined,
-): EntryLike | undefined {
-	const raw: unknown = manager;
-	if (id === undefined || id === null || id === "" || !isRecord(raw)) {
-		return undefined;
-	}
-	return typeof raw.getEntry === "function" ? manager.getEntry(id) : undefined;
-}
-function sessionIdentityOf(manager: ExtensionContext["sessionManager"]): {
-	readonly sessionId: string;
-	readonly file: string | undefined;
-	readonly leaf: EntryLike | undefined;
-} {
-	const raw: unknown = manager;
-	const sessionId =
-		isRecord(raw) && typeof raw.getSessionId === "function" ? manager.getSessionId() : "";
-	const file =
-		isRecord(raw) && typeof raw.getSessionFile === "function"
-			? manager.getSessionFile()
-			: undefined;
-	const leafId =
-		isRecord(raw) && typeof raw.getLeafId === "function" ? manager.getLeafId() : null;
-	return { sessionId, file, leaf: parentEntry(manager, leafId) };
-}
 function collectGuidanceEntries(
 	entries: readonly EntryLike[],
 	baseByBudget?: ReadonlyMap<string, string>,
@@ -130,27 +83,27 @@ function withMemoryEpoch(
 	return { byBudget: merged, tools: collected.tools ?? memory.tools };
 }
 function scanGuidanceEpoch(
-	manager: ExtensionContext["sessionManager"],
-	identity: { readonly sessionId: string; readonly leaf: EntryLike | undefined },
-	previous: EpochState | undefined,
+	manager: SessionHost,
+	identity: SessionIdentity,
+	previous: EpochValue<GuidanceEpoch> | undefined,
 	memoryByEpoch: ReadonlyMap<string, MemoryEpoch> | undefined,
-): Pick<EpochState, "anchorKey" | "byBudget" | "tools"> {
+): GuidanceEpoch {
 	const reversed: EntryLike[] = [];
 	let anchor: EntryLike | undefined;
 	for (
 		let entry = identity.leaf;
 		entry !== undefined;
-		entry = parentEntry(manager, entry.parentId)
+		entry = sessionEntry(manager, entry.parentId)
 	) {
-		if (previous !== undefined && previous.leaf === entry) {
+		if (previous !== undefined && previous.identity.leaf === entry) {
 			const collected = collectGuidanceEntries(
 				reversed.reverse(),
-				previous.byBudget,
-				previous.tools,
+				previous.value.byBudget,
+				previous.value.tools,
 			);
 			return {
-				anchorKey: previous.anchorKey,
-				...withMemoryEpoch(collected, memoryByEpoch?.get(previous.anchorKey)),
+				anchorKey: previous.value.anchorKey,
+				...withMemoryEpoch(collected, memoryByEpoch?.get(previous.value.anchorKey)),
 			};
 		}
 		if (startsFreshGuidanceEpoch(entry)) {
@@ -170,42 +123,25 @@ function scanGuidanceEpoch(
 	};
 }
 export function createWindowGuidance(pi: ExtensionAPI): WindowGuidance {
-	let state: EpochState | undefined;
 	let memoryByManager = new WeakMap<object, Map<string, MemoryEpoch>>();
-	const readEpoch = (ctx: ExtensionContext): EpochState => {
-		const manager = ctx.sessionManager;
-		const { sessionId, file, leaf } = sessionIdentityOf(manager);
-		const previous =
-			state?.manager === manager && state.sessionId === sessionId && state.file === file
-				? state
-				: undefined;
-		if (previous !== undefined && previous.leaf === leaf) {
-			return previous;
-		}
-		state = {
-			manager,
-			sessionId,
-			file,
-			leaf,
-			...scanGuidanceEpoch(
-				manager,
-				{ sessionId, leaf },
-				previous,
-				memoryByManager.get(manager),
-			),
-		};
-		return state;
-	};
+	const epochs = createEpochCache<GuidanceEpoch>((ctx, identity, previous) =>
+		scanGuidanceEpoch(
+			ctx.sessionManager,
+			identity,
+			previous,
+			memoryByManager.get(ctx.sessionManager),
+		),
+	);
 	return {
 		resolve(ctx, host) {
-			const epoch = readEpoch(ctx);
+			const epoch = epochs.read(ctx);
 			const key = budgetGuidanceKey(host);
 			return (
 				epoch.byBudget.get(key) ?? buildGuidance(host, epoch.tools ?? ALL_GUIDANCE_TOOLS)
 			);
 		},
 		deliver(ctx, host) {
-			const epoch = readEpoch(ctx);
+			const epoch = epochs.read(ctx);
 			const key = budgetGuidanceKey(host);
 			const existing = epoch.byBudget.get(key);
 			if (existing !== undefined) {
@@ -225,7 +161,7 @@ export function createWindowGuidance(pi: ExtensionAPI): WindowGuidance {
 			}
 			memory.byBudget.set(key, text);
 			memory.tools ??= tools;
-			state = undefined;
+			epochs.reset();
 			pi.appendEntry(WINDOW_GUIDANCE_TYPE, {
 				version: 1,
 				budgetKey: key,
@@ -235,7 +171,7 @@ export function createWindowGuidance(pi: ExtensionAPI): WindowGuidance {
 			return text;
 		},
 		reset() {
-			state = undefined;
+			epochs.reset();
 			memoryByManager = new WeakMap();
 		},
 	};

package/src/history-cursor.ts

@@ -0,0 +1,43 @@
+import { presentText, unknownArray } from "./contracts.ts";
+
+/** Where a search page stopped: the anchor entry, its rank, its offset, and the search it belongs to. */
+export type HistoryCursor = readonly [id: string, priority: 0 | 1, offset: number, key: string];
+
+export function encodeCursor(cursor: HistoryCursor): string {
+	return Buffer.from(JSON.stringify(cursor)).toString("base64url");
+}
+export function cursorFor(
+	key: string,
+	hit: { readonly id: string; readonly priority: 0 | 1 },
+	offset: number,
+): string {
+	return encodeCursor([hit.id, hit.priority, offset, key]);
+}
+function cursorOffset(value: unknown, storedKey: unknown, key: string): number {
+	if (
+		typeof value !== "number" ||
+		!Number.isSafeInteger(value) ||
+		value < 0 ||
+		storedKey !== key
+	) {
+		throw new Error("Invalid cursor offset or scope.");
+	}
+	return value;
+}
+/** A cursor is anonymous unless it decodes to the same query and scope that produced it. */
+export function decodeCursor(encoded: string | undefined, key: string): HistoryCursor | undefined {
+	const cursor = presentText(encoded);
+	if (cursor === undefined) {
+		return undefined;
+	}
+	const value: unknown = JSON.parse(Buffer.from(cursor, "base64url").toString());
+	const parts = unknownArray(value);
+	if (parts === undefined || parts.length !== 4) {
+		throw new Error("Invalid cursor tuple.");
+	}
+	const [id, priority, offset, storedKey] = parts;
+	if (typeof id !== "string" || id === "" || (priority !== 0 && priority !== 1)) {
+		throw new Error("Invalid cursor anchor.");
+	}
+	return [id, priority, cursorOffset(offset, storedKey, key), key];
+}

package/src/history-entries.ts

@@ -1,5 +1,4 @@
 import {
-	isRecord,
 	isReminderType,
 	unknownArray,
 	type EntryLike,
@@ -7,6 +6,7 @@ import {
 	type MessageLike,
 	type WindowedEntry,
 } from "./contracts.ts";
+import { isWindow } from "./boundary.ts";
 import {
 	assistantFailure,
 	excerptAround,
@@ -20,32 +20,6 @@ import {
 	toolIdentity,
 } from "./message-text.ts";
 
-export function isWindow(entry: EntryLike): boolean {
-	return (
-		entry.type === "context_window" ||
-		(entry.type === "compaction" && isRecord(entry.details) && entry.details.posthorse === 1)
-	);
-}
-export function windowHandoff(entry: EntryLike | undefined): string | undefined {
-	return entry?.type === "compaction" ? entry.summary : entry?.handoff;
-}
-/** First active branch entry, including tails retained by Pi's own /compact. */
-export function contextStart(entries: readonly EntryLike[]): {
-	start: number;
-	boundary?: EntryLike;
-} {
-	for (let i = entries.length - 1; i >= 0; i--) {
-		const entry = entries[i];
-		if (entry?.type === "context_window") {
-			return { start: i + 1, boundary: entry };
-		}
-		if (entry?.type === "compaction") {
-			const kept = entries.findIndex((candidate) => candidate.id === entry.firstKeptEntryId);
-			return { start: kept >= 0 ? kept : i + 1, boundary: entry };
-		}
-	}
-	return { start: 0 };
-}
 export function contextEdits(entries: readonly EntryLike[]): Map<string, EntryLike> {
 	return new Map(
 		entries.flatMap((entry) =>

package/src/history-pages.ts

@@ -7,6 +7,7 @@ import {
 	type WindowedEntry,
 } from "./contracts.ts";
 import { excerpt, shortKey, sourceTag } from "./message-text.ts";
+import { cursorFor as cursorAt } from "./history-cursor.ts";
 import type { HistoryMatches, HistoryParams } from "./history-search.ts";
 import type { PageAccess } from "./paging.ts";
 
@@ -18,11 +19,6 @@ type SearchPage = {
 	readonly spans: readonly { readonly headerLength: number; readonly length: number }[];
 	readonly continuation: Continuation<string>;
 };
-function cursorFor(matches: HistoryMatches, hit: HistoryHit, offset: number): string {
-	return Buffer.from(JSON.stringify([hit.id, hit.priority, offset, matches.key])).toString(
-		"base64url",
-	);
-}
 function searchFooter(next: string): string {
 	return `\n[More results; continue with cursor "${next}" and the same query/scope.]`;
 }
@@ -70,7 +66,7 @@ function searchParts(matches: HistoryMatches, chars: number): SearchPage {
 		available -= fragment.part.length + 1;
 		continuation =
 			fragment.end < hit.text.length || parts.length < matches.hits.length
-				? { kind: "more", next: cursorFor(matches, hit, fragment.end) }
+				? { kind: "more", next: cursorAt(matches.key, hit, fragment.end) }
 				: { kind: "complete" };
 		if (available <= 0 || parts.length >= matches.limit) {
 			break;
@@ -87,7 +83,9 @@ export function searchPage(
 	const chars = pages.size(host);
 	const reserve = Math.max(
 		0,
-		...matches.hits.map((hit) => searchFooter(cursorFor(matches, hit, hit.text.length)).length),
+		...matches.hits.map(
+			(hit) => searchFooter(cursorAt(matches.key, hit, hit.text.length)).length,
+		),
 	);
 	if (reserve >= chars) {
 		pages.error(host, "History entry id is too large for pagination.");