pi-posthorse 0.10.13 → 0.10.15

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-posthorse",
-	"version": "0.10.13",
+	"version": "0.10.15",
 	"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/budget.ts

@@ -13,13 +13,6 @@ import {
 import { imagesOf, textOf } from "./message-text.ts";
 
 const MIN_USABLE_TOKENS = Math.ceil(MAX_HANDOFF_CHARS / 4) * 2;
-export const CHECKPOINT_GUIDANCE = `Keep working on the assigned task; Pi handles context rollover automatically.
-
-The current context window is not a deadline for finishing your task. Do not reduce scope, skip prescribed steps or verification, or issue a final progress summary because rollover is approaching.
-
-Update the task's current-state note if needed: goal, progress, decisions, and next steps. Use available file-editing tools at its absolute path; use notes write only for creation, substantial restructuring, or when editing tools are unavailable. Leave an already-current note unchanged. Then immediately execute the next prescribed task step in this run. No new_context call, waiting for rollover, or user "continue" is needed.
-
-Finish when the requested work and required verification are complete, or report a genuine blocker. Approaching context rollover is not a blocker.`;
 export type Budget = {
 	readonly contextWindow: number;
 	readonly reserveTokens: number;
@@ -84,8 +77,9 @@ function automaticGuidance(budget: Budget | undefined, enabled: boolean): string
 	const line =
 		budget === undefined
 			? ""
-			: ` The rollover line is ${budget.rolloverAt.toLocaleString("en-US")} tokens used under the available Pi settings.`;
-	return `${CHECKPOINT_GUIDANCE}\nAutomatic rollover follows Pi's compaction setting and retains a safe recent-message tail using compaction.keepRecentTokens, without model summarization.${line} At most one routine task-note reminder may arrive at the end of a working turn, never on a turn that ends the run. new_context is an optional deliberate clean reset, not a checkpoint requirement.`;
+			: `The rollover line is ${budget.rolloverAt.toLocaleString("en-US")} tokens used. `;
+	return `Pi rolls context over automatically, so the context window is not a deadline. Do not reduce scope, skip steps or verification, or write a final summary because rollover is near, and do not wait for the user to say "continue". Finish when the requested work and its verification are complete, or report a genuine blocker.
+${line}Rollover keeps a recent-message tail without summarizing. One task-note reminder may arrive at the end of a working turn near the line: update the note only if it is stale, then continue with the next step in the same run. new_context is an optional clean reset.`;
 }
 export function buildGuidance(ctx: PolicyContext): string {
 	const budget = budgetFor(ctx);
@@ -93,14 +87,12 @@ export function buildGuidance(ctx: PolicyContext): string {
 	const capacity =
 		budget === undefined
 			? "Configured context capacity is unknown."
-			: `Configured context capacity: ${budget.contextWindow.toLocaleString("en-US")} tokens. This is Pi's best available native limit, not remaining space or a measured provider boundary. Fresh windows use the active configuration; system instructions, tools, the handoff, retained recent messages, and new messages consume part of it.`;
+			: `Configured context capacity: ${budget.contextWindow.toLocaleString("en-US")} tokens (not remaining space).`;
 	return `## Automatic context management (Posthorse)
 ${automaticGuidance(budget, enabled)}
-${capacity}
-Do not guess context capacity or remaining space from response-token limits or reasoning budgets. Before reporting a remaining-token count or changing your work plan because of context limits, call get_context_remaining. If usage is unknown, report it as unknown. No routine budget checks are needed.
+${capacity} Do not guess capacity or remaining space from response-token or reasoning limits. Before reporting a remaining-token count or changing your work plan because of context limits, call get_context_remaining. If usage is unknown, report it as unknown. No routine budget checks are needed.
 After a rollover, earlier conversation stays in history. Restore notes and todos, then verify live state before stateful or external work; automatic handoffs record inputs, not progress.
-Keep one concise current-state note per task. Preserve decisions and safety constraints; link fuller evidence and history instead of copying them. Edit changed sections rather than resending unchanged content.
-Write handoffs and notes as normal readable prose; notes and history search match literal text.`;
+Keep one concise current-state note per task: goal, progress, decisions, and next steps. Preserve decisions and safety constraints, link fuller evidence instead of copying it, and edit only changed sections.`;
 }
 /** ponytail: native estimates omit request-local guidance; reserve it until post-transform usage is exposed. */
 export function guidanceTokens(ctx: PolicyContext): number {

package/src/history-pages.ts

@@ -84,13 +84,13 @@ export function searchPage(
 	host: PolicyContext,
 	pages: PageAccess,
 ): TextResult {
-	const chars = pages.size(host, { offset: 0, cursor: params.cursor });
+	const chars = pages.size(host);
 	const reserve = Math.max(
 		0,
 		...matches.hits.map((hit) => searchFooter(cursorFor(matches, hit, hit.text.length)).length),
 	);
 	if (reserve >= chars) {
-		pages.error(host, "History entry id is too large for pagination.", params.cursor);
+		pages.error(host, "History entry id is too large for pagination.");
 	}
 	const skippedNote =
 		matches.skipped > 0 && (params.cursor === undefined || params.cursor === "")
@@ -146,11 +146,7 @@ export function historyReadPage(
 	const shownId = shownEntryId(item, params.id, source);
 	const { offset, imageOffset } = readOffsets(item, params);
 	const firstImage = imageOffset < item.images.length ? 1 : 0;
-	const chars = access.pages.size(access.host, {
-		offset,
-		imageCount: firstImage,
-		imageOffset: item.images.length > 0 ? imageOffset : undefined,
-	});
+	const chars = access.pages.size(access.host, { imageCount: firstImage });
 	const imageEnd = Math.min(
 		item.images.length,
 		imageOffset + firstImage + Math.floor((chars - MIN_PAGE_CHARS) / ESTIMATED_IMAGE_CHARS),

package/src/history.ts

@@ -130,8 +130,7 @@ export function registerHistory(
 		async execute(...[, params, signal, , ctx]) {
 			const source = historySource(ctx);
 			if (params.op === "search") {
-				const fail = (message: string): never =>
-					pages.error(policy(ctx), message, params.cursor);
+				const fail = (message: string): never => pages.error(policy(ctx), message);
 				const matches = await historyMatches(source, params, signal, fail);
 				return searchPage(matches, params, policy(ctx), pages);
 			}

package/src/notes.ts

@@ -115,15 +115,10 @@ async function readNote(
 	const header = target.writable
 		? `File: ${path}\n`
 		: `Read-only live reference: notes read ${JSON.stringify({ scope: scopeDirectory(target.address), path: target.address.path })}\n`;
-	const host = access.host();
-	const chars = pages.size(host, { offset }) - header.length;
-	if (chars <= 0) {
-		pages.error(
-			host,
-			`Too little context remains to include the note path. Call new_context first, then retry with offset ${offset}.`,
-		);
-	}
-	const end = Math.min(text.length, offset + chars);
+	const end = Math.min(
+		text.length,
+		offset + pages.size(access.host(), { headerChars: header.length }),
+	);
 	const more =
 		end < text.length
 			? `\n[chars ${offset}-${end} of ${text.length}; continue with offset ${end}]`

package/src/paging.ts

@@ -11,11 +11,10 @@ import {
 	type TextResult,
 } from "./contracts.ts";
 
+/** What else the page carries: images share the budget, and the header comes out of the body. */
 export type PageRequest = {
-	readonly offset: number;
 	readonly imageCount?: number;
-	readonly cursor?: string | undefined;
-	readonly imageOffset?: number | undefined;
+	readonly headerChars?: number;
 };
 export type NotesPage = {
 	readonly rows: readonly string[];
@@ -27,13 +26,13 @@ export type NotesPage = {
 	readonly more?: boolean;
 };
 export type PageAccess = {
-	readonly size: (ctx: PolicyContext, request: PageRequest) => number;
+	readonly size: (ctx: PolicyContext, request?: PageRequest) => number;
 	readonly result: (
 		text: string,
 		images: readonly ImageLike[],
 		display: PosthorseDisplay,
 	) => TextResult;
-	readonly error: (ctx: PolicyContext, message: string, cursor?: string) => never;
+	readonly error: (ctx: PolicyContext, message: string) => never;
 	readonly notes: (ctx: PolicyContext, page: NotesPage) => TextResult;
 };
 type PageAccounting = {
@@ -58,18 +57,22 @@ export class PageReservations {
 	reset(): void {
 		this.accounting = { pendingTokens: 0, usage: undefined };
 	}
-	size(ctx: PolicyContext, request: PageRequest): number {
-		this.accounting = reconcile(this.accounting, ctx.getContextUsage()?.tokens);
+	/**
+	 * Body characters for the next page. Near the rollover line pages shrink to MIN_PAGE_CHARS
+	 * instead of refusing, so reading keeps making progress; Pi's rollover handles the overshoot.
+	 */
+	size(ctx: PolicyContext, request: PageRequest = {}): number {
+		this.settle(ctx);
 		const remaining = pageCapacity(ctx, this.toolTokens) - this.accounting.pendingTokens;
-		const chars = Math.min(
+		const budget = Math.min(
 			MAX_PAGE_CHARS,
 			Math.max(0, remaining - PAGE_MARGIN_TOKENS) * 4 -
 				(request.imageCount ?? 0) * ESTIMATED_IMAGE_CHARS,
 		);
-		if (chars < MIN_PAGE_CHARS) {
-			this.refuse(remaining, request);
-		}
-		return chars;
+		return Math.max(MIN_PAGE_CHARS, budget - (request.headerChars ?? 0));
+	}
+	private settle(ctx: PolicyContext): void {
+		this.accounting = reconcile(this.accounting, ctx.getContextUsage()?.tokens);
 	}
 	private reserve(text: string, imageCount = 0): void {
 		this.accounting = {
@@ -80,38 +83,21 @@ export class PageReservations {
 				imageCount * (ESTIMATED_IMAGE_CHARS / 4),
 		};
 	}
-	private refuse(remaining: number, request: PageRequest): never {
-		const position =
-			request.cursor !== undefined && request.cursor !== ""
-				? "with the same cursor"
-				: `with offset ${request.offset}${request.imageOffset === undefined ? "" : ` and imageOffset ${request.imageOffset}`}`;
-		const message = `Too little context remains to read a page safely. Call new_context first, then retry ${position}.`;
-		// Even refusals consume context; omit repeated guidance when it no longer fits.
-		const text = Math.ceil(message.length / 4) <= remaining ? message : "";
-		this.reserve(text);
-		throw new Error(text);
-	}
 	result(text: string, images: readonly ImageLike[], display: PosthorseDisplay): TextResult {
 		this.reserve(text, images.length);
 		return textResult(text, images, display);
 	}
-	error(ctx: PolicyContext, message: string, cursor?: string): never {
-		this.size(ctx, { offset: 0, cursor });
+	error(ctx: PolicyContext, message: string): never {
+		this.settle(ctx);
 		this.reserve(message);
 		throw new Error(message);
 	}
 	notes(ctx: PolicyContext, page: NotesPage): TextResult {
 		const { rows, offset, kind, empty, header = "", more } = page;
 		const text = rows.length > 0 ? rows.join("\n") : empty;
-		const chars = this.size(ctx, { offset }) - header.length;
+		const chars = this.size(ctx, { headerChars: header.length });
 		const footer = (end: number) =>
 			`\n[chars ${offset}-${end}${more === true ? "; more matches follow" : ` of ${text.length}`}; continue with offset ${end}]`;
-		if (chars <= footer(text.length).length) {
-			this.error(
-				ctx,
-				`Too little context remains to include the notes path. Call new_context first, then retry with offset ${offset}.`,
-			);
-		}
 		if (offset > 0 && offset >= text.length) {
 			this.error(ctx, "Offset is past the end; restart with offset 0.");
 		}

package/src/reminders.ts

@@ -231,10 +231,8 @@ function countRetainedFromProjected(
 			continue;
 		}
 		for (const msg of item.messages) {
-			const role = msg.role ?? "";
 			if (
-				role !== "system" &&
-				!stale({ role, customType: msg.customType, details: msg.details })
+				!stale({ role: msg.role ?? "", customType: msg.customType, details: msg.details })
 			) {
 				count += 1;
 			}

package/src/rollover.ts

@@ -6,7 +6,7 @@ import type {
 	SessionBeforeCompactEvent,
 	TurnEndEvent,
 } from "@earendil-works/pi-coding-agent";
-import { budgetFor, CHECKPOINT_GUIDANCE, freshPayloadChars } from "./budget.ts";
+import { budgetFor, freshPayloadChars } from "./budget.ts";
 import {
 	isRecord,
 	isReminderType,
@@ -113,22 +113,6 @@ function staleReminderPredicate(
 		isReminderType(message.customType) &&
 		(!enabled || !reminderMatches(message.details, fingerprint));
 }
-function retainedTailEnd(
-	messages: ContextWithSystemEvent["messages"],
-	start: number,
-	count: number,
-): number | undefined {
-	let remaining = count;
-	for (let index = start; index < messages.length; index += 1) {
-		if (messages[index]?.role !== "system") {
-			remaining -= 1;
-		}
-		if (remaining === 0) {
-			return index + 1;
-		}
-	}
-	return undefined;
-}
 function chronologicalRetainedTail(
 	messages: ContextWithSystemEvent["messages"],
 	ctx: ExtensionContext,
@@ -137,9 +121,12 @@ function chronologicalRetainedTail(
 	const summaryIndex = messages.findIndex((message) => message.role !== "system");
 	const first = messages[summaryIndex];
 	if (first?.role === "compactionSummary" && hasRetainedRolloverMarker(first.summary)) {
+		// Pi projects no system messages into the retained tail, but an earlier handler can
+		// present a retained message as one (pi-change-working-dir's directory snapshots).
+		// Count positions, not roles, so the record never lands inside the next tool batch.
 		const count = countRetainedMessages(ctx, stale);
-		const end = count > 0 ? retainedTailEnd(messages, summaryIndex + 1, count) : undefined;
-		if (end !== undefined) {
+		const end = summaryIndex + 1 + count;
+		if (count > 0 && end <= messages.length) {
 			const prefix = messages.slice(0, summaryIndex);
 			const retainedSlice = messages.slice(summaryIndex + 1, end);
 			const afterSlice = messages.slice(end);
@@ -457,7 +444,8 @@ export function registerRollover(
 			pi.sendMessage(
 				{
 					customType: REMINDER_TYPE,
-					content: `[posthorse] Routine task-note update.\n${CHECKPOINT_GUIDANCE}`,
+					content:
+						"[posthorse] Routine task-note update. Update the task's current-state note if it is stale, then continue with the next step in this run.",
 					display: true,
 					details: reminder.fingerprint,
 				},