pi-posthorse 0.8.1 → 0.9.0

package/README.md

@@ -17,12 +17,12 @@ Required qualification targets: latest stable official Pi and latest maintained
 
 ## Install
 
-Posthorse `0.8.1` requires Pi `>=1.0.0`. Update the host before installing this release; do not activate it on an older live fork.
+Posthorse `0.9.0` requires Pi `>=1.0.0`. Update the host before installing this release; do not activate it on an older live fork.
 
 ```bash
-pi install npm:pi-posthorse@0.8.1                        # from npm
-pi install git:github.com/fitchmultz/pi-posthorse@v0.8.1 # from Git
-pi -e npm:pi-posthorse@0.8.1                             # try it for one run without installing
+pi install npm:pi-posthorse@0.9.0                        # from npm
+pi install git:github.com/fitchmultz/pi-posthorse@v0.9.0 # from Git
+pi -e npm:pi-posthorse@0.9.0                             # try it for one run without installing
 ```
 
 Omit the version or tag to follow the latest release.
@@ -37,19 +37,19 @@ Keep exactly one copy loaded. `pi list` shows every package source; if a second
 
 Both hosts get the same tools, guidance, reminders, notes, history, and recovery records. Rollover is a public compaction entry retaining no earlier conversation, with the handoff as its summary; no summary model is called. `new_context` commits at turn end only after Posthorse's own callback succeeds and every sibling tool succeeds. A foreign tool with the same name cannot authorize a rollover. Automatic rollover handles `session_before_compact`; manual `/compact` stays Pi's own summarization.
 
-- **Native eligibility on both 1.0 targets:** Pi's compaction preparation must succeed before the automatic hook runs. Posthorse's custom compaction result bypasses the default summarizer and its credential lookup. With default `keepRecentTokens`, tiny overflow/truncated responses and a second large result without a new user turn can miss the hook. Lowering `keepRecentTokens` narrows, but does not eliminate, that gap. Oversized initial input can reach the provider before recovery.
-- **Policy:** reminders and budget reports use persisted settings by default; automatic rollover uses the live settings in the event. SDK hosts can inject live policy with `createPosthorse(getPolicy)`. Handoffs appear as compaction-summary messages. Background work owned outside the foreground batch is not serialized or stopped by Posthorse.
+- **Automatic eligibility on both hosts:** Pi's compaction preparation must succeed before the automatic hook runs. Posthorse's custom compaction result bypasses the default summarizer and its credential lookup. In fresh compaction windows without a subsequent projected turn-start input, Posthorse owns threshold rollover at completed turn end when known usage reaches the enabled, supported threshold; it preserves normal continuation and never requests another response after a final answer. Other threshold spans and overflow/truncated-response recovery stay Pi-owned. Tiny overflow/truncated responses can still miss native recovery, and oversized initial input can reach the provider before recovery.
+- **Policy:** guidance, reminders and budget reports use Pi's live effective settings, including runtime and per-model compaction overrides, defaults and validation; the turn-end threshold fallback uses this same policy reader, while the native automatic hook uses the live settings in its event. Manual settings-file edits take effect when Pi refreshes its live settings, just like Pi's own compaction, not on Posthorse's next evaluation. SDK hosts can inject policy with `createPosthorse(getPolicy)`. Handoffs appear as compaction-summary messages. Background work owned outside the foreground batch is not serialized or stopped by Posthorse.
 
 Legacy fork `context_window` entries remain readable for history recovery. New boundaries do not use the retired native-window/async ABI. Opening legacy fork journals in official Pi can reintroduce earlier context because official Pi does not interpret those old markers; do not assume cross-host session migration.
 
 ## How it works
 
 1. **Stable guidance.** Each request gets a native system-prompt section stating the best available native context capacity and, when automatic rollover is supported and enabled, its token threshold from the available Pi settings. Fresh windows get the same guidance, refreshed if the model or available settings change during a continuing turn. For virtual models, native limits can come from the routed physical model. These are capacity and policy limits, not remaining space. The guidance distinguishes context capacity from response-token limits and reasoning budgets, and requires a `get_context_remaining` check before reporting remaining tokens or changing plans because of context limits. Unknown usage stays unknown. There is no per-request meter or routine budget check. When an extension forces an opaque full prompt, Posthorse preserves it and supplies guidance as a request-local conversation message, because official Pi applies forced text after system-context hooks. Guidance is regenerated from current state rather than persisted in the transcript.
-2. **One best-effort checkpoint.** While Pi compaction is enabled, one reminder may appear shortly before Pi's rollover line, asking the model to update its current-state note with available file-editing tools and call `new_context`. Already-current notes need no rewrite; `notes write` remains the fallback for creation, substantial restructuring, or unavailable editing tools. A large turn, overflow, restart, or smaller model can reach rollover without it. Reminders are fingerprinted by window, context size, and reserve, so switching to a different context size gets a fresh reminder. Stale reminders and reminders left after disabling compaction are filtered from model input while remaining in history.
+2. **One best-effort checkpoint.** While Pi compaction is enabled, one reminder may arrive at the end of a working turn inside the checkpoint band before Pi's rollover line, never on a turn that ends the run. It cannot wake a finished agent or replace its final answer. The reminder asks the model to update its current-state note with available file-editing tools and call `new_context`. Already-current notes need no rewrite; `notes write` remains the fallback for creation, substantial restructuring, or unavailable editing tools. A large turn, overflow, restart, or smaller model can reach rollover without it. Reminders are fingerprinted by window, context size, and reserve, so switching to a different context size gets a fresh reminder. Stale reminders and reminders left after disabling compaction are filtered from model input while remaining in history.
 3. **`get_context_remaining`.** Reports the best available native estimate of tokens until Pi's automatic rollover line and until the configured context limit. That configured limit is not a measured provider rejection boundary. Pi's value is an estimate until the active model reports usage. Check before claiming a remaining-token count or changing plans because of context limits. The checkpoint reminder marks the deadline, so routine budget checks are unnecessary.
 4. **`new_context`.** Requests an atomic retain-none rollover once the current foreground tool batch succeeds. An optional handoff becomes the first state of the fresh window. Failed sibling writes, aborted turns, or a handoff that no longer fits after queued input prevent commitment. The request card is not proof that the boundary committed. Own successful callback IDs and admitted handoffs are consumed once at settlement; transcript names alone cannot request a reset.
 5. **Automatic rollover without summaries.** When Pi reaches the public automatic hook with a supported budget, Posthorse builds a bounded recovery record and retains only an invisible boundary sentinel. Cancellation or recovery construction failure leaves active context intact rather than silently invoking a summarizer. Unsupported small-model budgets retain Pi's native fallback. Manual `/compact` is unchanged. Native eligibility limits are listed above.
-6. **Bounded recovery record.** The automatic handoff quotes the window's first owner request, its latest owner input (a direct user input or `ask_question` outcome), and its latest input of any kind, including visible coordination messages. It adds tool result evidence: tool names and namespaces, call ids, requested and admitted execution arguments when available, result excerpts of up to 1,500 characters, and entry ids to recover the rest. Every other current-window input gets one index line with its label, time, and entry id; owner inputs keep a one-line preview there. Only a successful result positively linked to a projected unnamespaced `ask_question` call **and** an effective registered unnamespaced `ask_question` definition is an owner answer. Providers can omit call namespaces, so call metadata alone is insufficient. Namespaced, unregistered or unresolved-provenance results remain tool evidence, never owner approval. Legacy async results still visible in a projected journal remain eligible even across later complete assistant responses; this is history compatibility, not a new native-async execution path. A result Pi still projects is also eligible when its call was edited out or predates the window, without attributing it to another call. These results may already have been received or handled; they are not proof of current progress. Synchronous results with projected call provenance are kept only from the trailing batch without a later complete response. Pi context edits also apply to these inputs and results: omitted entries stay out, and replacements supersede their original content. A clearly labeled, possibly stale older checkpoint comes last. Older assistant prose is not treated as current state. Newly submitted input stays separate and is saved after the boundary, not copied into the handoff.
+6. **Bounded recovery record.** The automatic handoff quotes the window's first owner request, its latest owner input (a direct user input or `ask_question` outcome), and its latest input of any kind, including visible coordination messages. Across consecutive automatic boundaries, a window with no owner inputs carries the same first/latest owner anchors from the nearest earlier owner window, labeled as earlier, possibly already handled, and not current progress. The walk stops at that window or an explicit/native compaction checkpoint; context edits still omit or replace carried inputs, and `ask_question` answers keep the same provenance checks. The newest non-automatic checkpoint reached replaces nested automatic text, with bounded history pointers to skipped automatic record ids. Carried anchors share the existing payload budget; earlier automatic tool evidence is never nested. It adds tool result evidence: tool names and namespaces, call ids, requested and admitted execution arguments when available, result excerpts of up to 1,500 characters, and entry ids to recover the rest. Every other current-window input gets one index line with its label, time, and entry id; owner inputs keep a one-line preview there. Only a successful result positively linked to a projected unnamespaced `ask_question` call **and** an effective registered unnamespaced `ask_question` definition is an owner answer. Providers can omit call namespaces, so call metadata alone is insufficient. Namespaced, unregistered or unresolved-provenance results remain tool evidence, never owner approval. Legacy async results still visible in a projected journal remain eligible even across later complete assistant responses; this is history compatibility, not a new native-async execution path. A result Pi still projects is also eligible when its call was edited out or predates the window, without attributing it to another call. These results may already have been received or handled; they are not proof of current progress. Synchronous results with projected call provenance are kept only from the trailing batch without a later complete response. Pi context edits also apply to these inputs and results: omitted entries stay out, and replacements supersede their original content. A clearly labeled, possibly stale older checkpoint comes last. Older assistant prose is not treated as current state. Newly submitted input stays separate and is saved after the boundary, not copied into the handoff.
 7. **`notes` and `history`.** Notes are shared across linked worktrees, at the main checkout for conventional Git layouts or inside the common Git directory when metadata is stored separately. History searches normalized transcript text, skips entries whose full text the model already sees in its active context (and says how many), and returns stored images for a requested entry. Edited-away originals and checkpoint reminders stay searchable. Tool calls and results retain names, namespaces, and call ids; admitted execution arguments are labeled separately from requested arguments when present. When a handoff carries edited content, its entry ID points to the replacement; `history read` of that ID returns the replacement text or images. Reading the original entry ID still returns the raw journal content.
 
 Retain-none compaction removes prior tool receipts from active input; recovery records carry bounded excerpts and history IDs, while complete raw or edited receipts remain recoverable from the append-only journal. Posthorse no longer registers a native receipt-bounding hook. The host owns physical request sizing and output clamping; custom transports and raw payload replacements remain responsible for their request sizes.
@@ -70,6 +70,8 @@ Explicit and automatic handoffs are capped at 20,000 characters and half the nat
 
 Only one automatic compaction or rollover policy extension should be enabled at a time. Pi keeps the last non-cancel result from multiple handlers of the same hook, so load order would otherwise decide which policy wins.
 
+The fresh-window threshold fallback builds its recovery record from the boundary preview when its `turn_end` handler runs. Earlier turn-start drafts keep compaction Pi-owned; earlier context-edit drafts defer the fallback until usage can be re-evaluated after commit. Unlike the native automatic hook (which runs after all turn-end handlers), the eager fallback cannot observe later handlers' edits. Later projection-editing handlers must explicitly replace/remove its drafted compaction if they change its source evidence; ordering an editor before Posthorse lets its drafts defer rollover safely. A host post-boundary hook would be needed to include arbitrary later same-phase edits automatically.
+
 ## Tools
 
 - `new_context({ handoff? })`

package/index.ts

@@ -4,9 +4,13 @@
  * Pi owns persisted retain-none context boundaries. Posthorse owns reminder and
  * rollover policy, bounded recovery, durable notes, and history retrieval.
  */
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	SettingsManager,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import { registerPosthorseMessages } from "./ui.ts";
-import { persistedPolicy, policySnapshot } from "./src/budget.ts";
+import { policySnapshot } from "./src/budget.ts";
 import type { CompactionPolicy, PolicyReader } from "./src/contracts.ts";
 import { registerHistory } from "./src/history.ts";
 import { safeJsonStringify } from "./src/message-text.ts";
@@ -32,13 +36,14 @@ function activeToolTokens(pi: ExtensionAPI): number {
 			0,
 		);
 }
-/** SDK hosts can inject live policy; CLI hosts use the persisted settings snapshot. */
-export function createPosthorse(
-	getPolicy: PolicyReader = persistedPolicy,
-): (pi: ExtensionAPI) => void {
+/** Use Pi's live effective settings by default; SDK hosts can inject a policy reader. */
+export function createPosthorse(getPolicy?: PolicyReader): (pi: ExtensionAPI) => void {
 	return (pi) => {
+		const readPolicy: PolicyReader =
+			getPolicy ??
+			((ctx) => SettingsManager.inMemory(pi.getSettings()).getCompactionSettings(ctx.model));
 		const policy = (ctx: ExtensionContext, livePolicy?: CompactionPolicy) =>
-			policySnapshot(ctx, getPolicy, livePolicy);
+			policySnapshot(ctx, readPolicy, livePolicy);
 		const toolTokens = () => activeToolTokens(pi);
 		const pages = new PageReservations(toolTokens);
 		registerPosthorseMessages(pi);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-posthorse",
-	"version": "0.8.1",
+	"version": "0.9.0",
 	"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

@@ -1,9 +1,4 @@
-import {
-	estimateTokens,
-	getAgentDir,
-	SettingsManager,
-	type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
+import { estimateTokens, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	ESTIMATED_IMAGE_CHARS,
 	MAX_HANDOFF_CHARS,
@@ -18,8 +13,6 @@ import {
 import { imagesOf, textOf } from "./message-text.ts";
 
 const MIN_USABLE_TOKENS = Math.ceil(MAX_HANDOFF_CHARS / 4) * 2;
-export const SNAPSHOT_NOTE =
-	"Reminder and budget policy uses available settings (a persisted CLI snapshot by default); Pi's live settings control automatic compaction.";
 export const CHECKPOINT_STEPS =
 	"update the task's current-state note (goal, progress, decisions, next steps) with available file-editing tools at its absolute path; use notes write only for creation, substantial restructuring, or when editing tools are unavailable. If the note is already current, leave it unchanged. Then call new_context";
 export type Budget = {
@@ -30,18 +23,6 @@ export type Budget = {
 	readonly rolloverAt: number;
 	readonly supported: boolean;
 };
-export function persistedPolicy(ctx: ExtensionContext): CompactionPolicy {
-	const settings = SettingsManager.create(ctx.cwd, getAgentDir(), {
-		projectTrusted: ctx.isProjectTrusted(),
-	});
-	const errors = settings.drainErrors();
-	if (errors.length > 0) {
-		throw new Error(
-			`Posthorse could not read persisted Pi settings: ${errors.map((error) => error.error.message).join("; ")}`,
-		);
-	}
-	return settings.getCompactionSettings(ctx.model);
-}
 /** A synchronous evaluation owns one snapshot; never carry it across an await. */
 export function policySnapshot(
 	ctx: ExtensionContext,
@@ -103,7 +84,7 @@ function automaticGuidance(budget: Budget | undefined, enabled: boolean): string
 		budget === undefined
 			? ""
 			: ` The rollover line is ${budget.rolloverAt.toLocaleString("en-US")} tokens used under the available Pi settings.`;
-	return `Automatic rollover follows Pi's compaction setting.${line} At most one checkpoint reminder may arrive before the rollover line (${deadline}); when it does, stop normal work, ${CHECKPOINT_STEPS}.`;
+	return `Automatic rollover follows Pi's compaction setting.${line} At most one checkpoint reminder may arrive at the end of a working turn before the rollover line (${deadline}), never on a turn that ends the run; when it does, stop normal work, ${CHECKPOINT_STEPS}.`;
 }
 export function buildGuidance(ctx: PolicyContext): string {
 	const budget = budgetFor(ctx);

package/src/context-tools.ts

@@ -1,13 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { toolCards, type PosthorseDisplay } from "../ui.ts";
-import {
-	budgetFor,
-	freshPayloadChars,
-	SNAPSHOT_NOTE,
-	unsupportedMessage,
-	type Budget,
-} from "./budget.ts";
+import { budgetFor, freshPayloadChars, unsupportedMessage, type Budget } from "./budget.ts";
 import {
 	EMPTY_HANDOFF,
 	MAX_HANDOFF_CHARS,
@@ -38,7 +32,7 @@ function contextReport(host: PolicyContext): TextResult {
 		rollover,
 		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. ${SNAPSHOT_NOTE}`;
+	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) {
 		return textResult(
 			`Automatic rollover is disabled in the available settings (Pi compaction.enabled=false). ${configured}`,
@@ -100,7 +94,7 @@ export function registerContextTools(
 		label: "Context Remaining",
 		...toolCards("get_context_remaining"),
 		description:
-			"Estimate tokens left before Pi's automatic rollover and the configured context limit. Check before reporting remaining space or changing your work plan because of context limits. A checkpoint reminder already arrives before rollover; no routine checks are needed.",
+			"Estimate tokens left before Pi's automatic rollover and the configured context limit. Check before reporting remaining space or changing your work plan because of context limits. A checkpoint reminder may arrive before rollover on a working turn; no routine checks are needed.",
 		promptSnippet:
 			"verify remaining context before reporting a token count or changing plans because of context limits",
 		parameters: Type.Object({}),

package/src/history-entries.ts

@@ -213,7 +213,8 @@ export function toWindowedEntry(
 		images: imagesOf(entryContent(entry)),
 	};
 }
-export function windowProjection(): (entry: EntryLike) => WindowedEntry | undefined {
+/** Window ancestry is metadata-only; extracting text/images is a separate operation. */
+export function windowProjection(): (entry: EntryLike) => string {
 	const windows = new Map<string, string>();
 	return (entry) => {
 		const inherited = windows.get(entry.parentId ?? "") ?? "initial";
@@ -221,13 +222,15 @@ export function windowProjection(): (entry: EntryLike) => WindowedEntry | undefi
 		if (entry.id !== undefined && entry.id !== "") {
 			windows.set(entry.id, windowId);
 		}
-		return toWindowedEntry(entry, windowId);
+		return windowId;
 	};
 }
-export function* windowEntries(entries: readonly EntryLike[]): Generator<WindowedEntry> {
-	const project = windowProjection();
-	for (const entry of entries) {
-		const item = project(entry);
+export function* reverseWindowEntries(entries: readonly EntryLike[]): Generator<WindowedEntry> {
+	// Preserve parent-relative window labels without normalizing the whole branch.
+	// ponytail: ancestry still scans metadata; a native window-aware iterator could remove that cost.
+	const windows = entries.map(windowProjection());
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const item = toWindowedEntry(entries[i], windows[i]);
 		if (item !== undefined) {
 			yield item;
 		}

package/src/history-search.ts

@@ -7,7 +7,7 @@ import {
 	type HistoryHit,
 	type ProjectedEntry,
 } from "./contracts.ts";
-import { historyHit, seenText, windowEntries } from "./history-entries.ts";
+import { historyHit, seenText, reverseWindowEntries } from "./history-entries.ts";
 import { shortKey } from "./message-text.ts";
 import {
 	filesContaining,
@@ -267,7 +267,7 @@ function branchMatches(
 	accumulator: SearchProgress,
 ): number {
 	let skipped = 0;
-	for (const item of [...windowEntries(source.branch())].reverse()) {
+	for (const item of reverseWindowEntries(source.branch())) {
 		const hit = historyHit(item, query);
 		if (hit === undefined) {
 			continue;

package/src/history.ts

@@ -3,7 +3,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Type } from "typebox";
 import { toolCards } from "../ui.ts";
 import { requireValue, type PolicyContext, type WindowedEntry } from "./contracts.ts";
-import { windowEntries } from "./history-entries.ts";
+import { toWindowedEntry, windowProjection } from "./history-entries.ts";
 import { historyReadPage, searchPage } from "./history-pages.ts";
 import { historyMatches, type HistorySource } from "./history-search.ts";
 import type { PageAccess } from "./paging.ts";
@@ -17,18 +17,26 @@ function entryReference(id: string): { readonly entryId: string; readonly fileKe
 		fileKey: separator < 0 ? undefined : id.slice(separator + 1),
 	};
 }
+function branchEntry(source: HistorySource, id: string): WindowedEntry | undefined {
+	const project = windowProjection();
+	for (const entry of source.branch()) {
+		const windowId = project(entry);
+		const item = entry.id === id ? toWindowedEntry(entry, windowId) : undefined;
+		if (item !== undefined) {
+			return item;
+		}
+	}
+	return undefined;
+}
 async function findEntry(
 	source: HistorySource,
 	id: string,
 	signal?: AbortSignal,
 ): Promise<LocatedEntry> {
 	const { entryId, fileKey } = entryReference(id);
-	if (fileKey === undefined) {
-		for (const item of windowEntries(source.branch())) {
-			if (item.entry.id === entryId) {
-				return { item, source: "" };
-			}
-		}
+	const current = fileKey === undefined ? branchEntry(source, entryId) : undefined;
+	if (current !== undefined) {
+		return { item: current, source: "" };
 	}
 	const candidates =
 		fileKey === undefined && /^[\w-]+$/.test(entryId)
@@ -42,10 +50,8 @@ async function findEntry(
 		fileKey,
 		candidates: candidates === undefined ? undefined : (candidate) => candidates.has(candidate),
 	})) {
-		for await (const item of sessionWindowEntries(file, signal)) {
-			if (item.entry.id === entryId) {
-				return { item, source: relative(source.dir, file) };
-			}
+		for await (const item of sessionWindowEntries(file, signal, entryId)) {
+			return { item, source: relative(source.dir, file) };
 		}
 	}
 	throw new Error(

package/src/recovery.ts

@@ -1,5 +1,6 @@
 import {
 	AUTO_HANDOFF_PREFIX,
+	isRecord,
 	isReminderType,
 	type EntryLike,
 	type ProjectedEntry,
@@ -114,19 +115,13 @@ function priorCheckpoint(entry: EntryLike | undefined, limit: number): string |
 	}
 	const id = entry.id?.slice(0, 120) ?? "unknown";
 	const header = `[older checkpoint; possibly stale | context-window entry ${id}]`;
-	return boundedBlock(
-		header,
-		handoff.startsWith(AUTO_HANDOFF_PREFIX)
-			? `Prior automatic recovery text is not nested here. Use history read with entry ${id} if needed.`
-			: handoff,
-		limit,
-	);
+	return boundedBlock(header, handoff, limit);
 }
 function projectedCurrent(
 	entries: readonly EntryLike[],
 	projected: readonly ProjectedEntry[],
+	current: readonly EntryLike[] = entries.slice(contextStart(entries).start),
 ): EntryLike[] {
-	const current = entries.slice(contextStart(entries).start);
 	const edits = contextEdits(entries);
 	const omittedIds = new Set(
 		projected
@@ -198,6 +193,72 @@ function anchors(records: readonly RecoveryRecord[]): {
 		others: records.filter((record) => !selected.has(record)),
 	};
 }
+function automaticBoundary(entry: EntryLike | undefined): boolean {
+	if (
+		entry === undefined ||
+		windowHandoff(entry)?.trim().startsWith(AUTO_HANDOFF_PREFIX) !== true
+	) {
+		return false;
+	}
+	return (
+		entry.type === "context_window" ||
+		(isRecord(entry.details) &&
+			entry.details.posthorse === 1 &&
+			(entry.details.reason === "threshold" || entry.details.reason === "overflow"))
+	);
+}
+function recoveryAncestry(
+	entries: readonly EntryLike[],
+	projected: readonly ProjectedEntry[],
+	ownerQuestionRegistered: boolean,
+): {
+	readonly checkpoint?: EntryLike;
+	readonly carried: readonly RecoveryRecord[];
+	readonly skipped: readonly string[];
+} {
+	let prefix = entries;
+	let boundary = contextStart(prefix).boundary;
+	const skipped: string[] = [];
+	while (automaticBoundary(boundary) && boundary !== undefined) {
+		skipped.push(boundary.id?.slice(0, 120) ?? "unknown");
+		prefix = prefix.slice(0, prefix.indexOf(boundary));
+		const window = contextStart(prefix);
+		const restored = projectedCurrent(entries, projected, prefix.slice(window.start));
+		const historical = restored.map((sourceEntry) => ({
+			sourceEntry,
+			messages: sourceEntry.message === undefined ? [] : [sourceEntry.message],
+		}));
+		const owners = ownerRecords(restored, historical, ownerQuestionRegistered).filter(
+			(record) => record.kind === "owner",
+		);
+		if (owners.length > 0) {
+			return {
+				checkpoint: automaticBoundary(window.boundary) ? undefined : window.boundary,
+				carried: anchors(owners).fixed,
+				skipped,
+			};
+		}
+		boundary = window.boundary;
+	}
+	return { checkpoint: boundary, carried: [], skipped };
+}
+function skippedRecords(ids: readonly string[], limit: number): string | undefined {
+	if (ids.length === 0) {
+		return undefined;
+	}
+	let names = ids[0];
+	let count = 1;
+	while (count < ids.length) {
+		const next = `, ${ids[count]}`;
+		if (names.length + next.length > limit) {
+			break;
+		}
+		names += next;
+		count++;
+	}
+	const omitted = ids.length - count;
+	return `Earlier automatic records skipped (not nested; use history read): ${names}${omitted > 0 ? `; ${omitted} earlier record(s) not listed.` : ""}`;
+}
 function projectedToolEntries(
 	entries: readonly EntryLike[],
 	projected: readonly ProjectedEntry[],
@@ -324,25 +385,35 @@ export function buildAutoHandoff(
 	maxChars: number,
 	ownerQuestionRegistered: boolean,
 ): string {
-	const priorWindow = contextStart(entries).boundary;
+	const history = recoveryAncestry(entries, projected, ownerQuestionRegistered);
+	const priorWindow = history.checkpoint;
 	const records = ownerRecords(
 		projectedCurrent(entries, projected),
 		projected,
 		ownerQuestionRegistered,
 	);
 	const { fixed, others } = anchors(records);
-	const currentHeader =
-		records.length > 0
-			? "Current-window inputs (chronological):"
+	if (!records.some((record) => record.kind === "owner")) {
+		fixed.unshift(
+			...history.carried.map((record) => ({
+				...record,
+				label: `${record.label}; carried from an earlier window, possibly already handled; not current progress`,
+			})),
+		);
+	}
+	const inputHeader =
+		fixed.length > 0
+			? "Selected owner and coordination inputs (chronological):"
 			: "No selected current-window owner or visible coordination inputs were found.";
 	const batch = recoverableToolResults(projectedToolEntries(entries, projected));
 	const header = batchHeader(batch);
 	const minimum = [
 		PREAMBLE,
-		currentHeader,
+		inputHeader,
 		...fixed.map((record) => formatRecord(record, 0)),
 		header,
 		priorCheckpoint(priorWindow, 0),
+		skippedRecords(history.skipped, 0),
 	];
 	const plan = planBatch(
 		batch,
@@ -350,19 +421,25 @@ export function buildAutoHandoff(
 		Math.max(0, maxChars - joined(minimum).length - HANDOFF_OVERHEAD_RESERVE),
 	);
 	const handoff = windowHandoff(priorWindow)?.trim();
-	const count = fixed.length + (handoff === undefined || handoff === "" ? 0 : 1);
+	const count =
+		fixed.length +
+		(handoff === undefined || handoff === "" ? 0 : 1) +
+		(history.skipped.length > 0 ? 1 : 0);
 	const fixedBudget = Math.max(
 		0,
-		maxChars - joined([PREAMBLE, currentHeader, plan.bare]).length - HANDOFF_OVERHEAD_RESERVE,
+		maxChars - joined([PREAMBLE, inputHeader, plan.bare]).length - HANDOFF_OVERHEAD_RESERVE,
 	);
 	const fixedLimit =
 		count > 0
 			? Math.min(MAX_RECOVERY_RECORD_CHARS, Math.floor(fixedBudget / count))
 			: MAX_RECOVERY_RECORD_CHARS;
-	const prior = priorCheckpoint(priorWindow, fixedLimit);
+	const prior = joined([
+		priorCheckpoint(priorWindow, fixedLimit),
+		skippedRecords(history.skipped, fixedLimit),
+	]);
 	const fixedParts = [
 		PREAMBLE,
-		currentHeader,
+		inputHeader,
 		...fixed.map((record) => formatRecord(record, fixedLimit)),
 	];
 	const renderedBatch = renderBatch(plan, fixedParts, prior, maxChars);

package/src/rollover.ts

@@ -18,6 +18,7 @@ import {
 	REMINDER_TYPE,
 	type CompactionPolicy,
 	type PolicyContext,
+	type ProjectedEntry,
 	type ReminderFingerprint,
 } from "./contracts.ts";
 import { registerContextTools } from "./context-tools.ts";
@@ -104,6 +105,18 @@ function explicitReset(
 		continue: true,
 	};
 }
+function endsRun(
+	event: TurnEndEvent,
+	ctx: { readonly hasPendingMessages?: () => boolean },
+): boolean {
+	return (
+		event.message.role === "assistant" &&
+		!event.message.content.some((part) => part.type === "toolCall") &&
+		!event.continue &&
+		event.context.pendingMessages.length === 0 &&
+		ctx.hasPendingMessages?.() !== true
+	);
+}
 function reminderBudget(
 	host: PolicyContext,
 ): { readonly budget: Budget; readonly tokens: number } | undefined {
@@ -126,7 +139,15 @@ function reminderBudget(
 function sendReminder(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
-	available: { readonly budget: Budget; readonly tokens: number },
+	available: {
+		readonly budget: Budget;
+		readonly tokens: number;
+		readonly pendingMessages: readonly {
+			readonly role: string;
+			readonly customType?: string;
+			readonly details?: unknown;
+		}[];
+	},
 	reminders: ReminderLookup,
 ): void {
 	const { budget, tokens } = available;
@@ -136,7 +157,15 @@ function sendReminder(
 		contextWindow: budget.contextWindow,
 		reserveTokens: budget.reserveTokens,
 	};
-	if (hasReminder(state.reminders, fingerprint)) {
+	if (
+		hasReminder(state.reminders, fingerprint) ||
+		available.pendingMessages.some(
+			(message) =>
+				message.role === "custom" &&
+				isReminderType(message.customType) &&
+				reminderMatches(message.details, fingerprint),
+		)
+	) {
 		return;
 	}
 	pi.sendMessage(
@@ -225,6 +254,92 @@ function reportAutomaticFailure(ctx: ExtensionContext, error: unknown): void {
 		console.error(message);
 	}
 }
+function freshWindowWithoutInput(projected: readonly ProjectedEntry[]): boolean {
+	const boundary = projected.findIndex(
+		(entry) => entry.sourceEntry.type === "compaction" && entry.messages.length > 0,
+	);
+	if (boundary < 0) {
+		return false;
+	}
+	const turnStarts = new Set([
+		"user",
+		"custom",
+		"bashExecution",
+		"branchSummary",
+		"compactionSummary",
+	]);
+	return !projected
+		.slice(boundary + 1)
+		.some(
+			(entry) =>
+				entry.sourceEntry.type !== "compaction" &&
+				entry.messages.some((message) => turnStarts.has(message.role ?? "")),
+		);
+}
+function reachedThreshold(host: PolicyContext): boolean {
+	const usage = host.getContextUsage();
+	const budget = budgetFor(host);
+	return (
+		budget?.supported === true &&
+		budget.enabled &&
+		usage !== undefined &&
+		usage.tokens !== null &&
+		usage.tokens >= budget.rolloverAt
+	);
+}
+function fallbackTurnEligible(event: TurnEndEvent, ctx: ExtensionContext): boolean {
+	return (
+		event.outcome === "completed" &&
+		!(event.message.role === "assistant" && event.message.stopReason === "length") &&
+		ctx.signal?.aborted !== true &&
+		!event.entries.some((entry) => entry.type === "compaction" || entry.type === "context_edit")
+	);
+}
+function thresholdFallback(
+	pi: ExtensionAPI,
+	event: TurnEndEvent,
+	ctx: ExtensionContext,
+	capacity: { readonly host: PolicyContext; readonly toolTokens: () => number },
+): BoundaryResult | undefined {
+	if (!fallbackTurnEligible(event, ctx)) {
+		return undefined;
+	}
+	const { host, toolTokens } = capacity;
+	if (!reachedThreshold(host)) {
+		return undefined;
+	}
+	if (!freshWindowWithoutInput(event.context.contextEntries)) {
+		return undefined;
+	}
+	const projected = event.context.contextEntries;
+	const limit = freshPayloadChars(host, toolTokens(), event.context.pendingMessages);
+	const ownerQuestionRegistered = pi
+		.getAllTools()
+		.some((tool) => tool.name === "ask_question" && tool.namespace === undefined);
+	const summary = buildAutoHandoff(
+		ctx.sessionManager.getBranch(),
+		projected,
+		limit,
+		ownerQuestionRegistered,
+	);
+	if (limit < MIN_PAGE_CHARS || summary.length > limit) {
+		return undefined;
+	}
+	// ponytail: turn_end drafts are eager. Later projection editors must replace/remove this draft;
+	// upgrade to a host post-boundary hook if recovery must include later handler edits.
+	return {
+		entries: [
+			...event.entries,
+			{
+				type: "compaction",
+				summary,
+				firstKeptEntryId: null,
+				details: { posthorse: 1, reason: "threshold" },
+			},
+		],
+		continue: event.continue,
+	};
+}
 function registerAutomaticRollover(
 	pi: ExtensionAPI,
 	policy: SnapshotReader,
@@ -318,9 +433,24 @@ export function registerRollover(
 				freshPayloadChars(host, activeToolTokens(), event.context.pendingMessages),
 			);
 		}
+		const fallback = thresholdFallback(pi, event, ctx, {
+			host,
+			toolTokens: activeToolTokens,
+		});
+		if (fallback !== undefined) {
+			return fallback;
+		}
+		if (endsRun(event, ctx)) {
+			return;
+		}
 		const available = reminderBudget(host);
 		if (available !== undefined) {
-			sendReminder(pi, ctx, available, reminders);
+			sendReminder(
+				pi,
+				ctx,
+				{ ...available, pendingMessages: event.context.pendingMessages },
+				reminders,
+			);
 		}
 		return;
 	});

package/src/session-files.ts

@@ -11,7 +11,7 @@ import {
 	type WindowedEntry,
 } from "./contracts.ts";
 import { lfLines } from "./files.ts";
-import { windowProjection } from "./history-entries.ts";
+import { toWindowedEntry, windowProjection } from "./history-entries.ts";
 import { shortKey } from "./message-text.ts";
 
 function execFileText(
@@ -141,6 +141,7 @@ function parsedEntry(line: string): EntryLike | undefined {
 export async function* sessionWindowEntries(
 	file: string,
 	signal?: AbortSignal,
+	entryId?: string,
 ): AsyncGenerator<WindowedEntry> {
 	if (!existsSync(file)) {
 		return;
@@ -151,7 +152,11 @@ export async function* sessionWindowEntries(
 		if (entry === undefined) {
 			continue;
 		}
-		const item = project(entry);
+		const windowId = project(entry);
+		if (entryId !== undefined && entry.id !== entryId) {
+			continue;
+		}
+		const item = toWindowedEntry(entry, windowId);
 		if (item !== undefined) {
 			yield item;
 		}