@astrosheep/pi-context 0.25.2 → 0.26.0

package/src/context/context-window.ts

@@ -24,6 +24,16 @@ export function currentReset(ctx: SessionReader): WindowMarker | undefined {
 	return undefined;
 }
 
+/** A reset is checkpoint-backed only when its marker directly follows a native compaction. */
+export function isCheckpointBackedReset(ctx: SessionReader, marker = currentReset(ctx)): boolean {
+	if (!marker?.parentId) return false;
+	const branch = ctx.sessionManager.getBranch();
+	const markerIndex = branch.findIndex((entry) => entry.id === marker.id);
+	const checkpoint = branch[markerIndex - 1];
+	return markerIndex > 0 && checkpoint?.id === marker.parentId && checkpoint.type === "compaction" &&
+		checkpoint.summary === "" && checkpoint.firstKeptEntryId === checkpoint.id;
+}
+
 /** Mint the durable identity of a session's root history window. */
 export function rootWindowId(sessionId: string): string {
 	return `pcw:${sessionId.slice(0, 8)}:root`;
@@ -106,7 +116,12 @@ export function windowUsage(ctx: Pick<ExtensionContext, "sessionManager" | "getC
 	if (!contextWindow) return undefined;
 	const windowId = reset.data.windowId;
 	try {
-		const messages: AgentMessage[] = projectWindow(ctx.sessionManager.buildSessionProjection().messages, windowId);
+		const canonicalMessages = ctx.sessionManager.buildSessionProjection().messages;
+		// New resets already cut the durable Pi projection. Marker slicing is retained only
+		// for sessions written before native reset checkpoints existed.
+		const messages: AgentMessage[] = isCheckpointBackedReset(ctx, reset)
+			? canonicalMessages
+			: projectWindow(canonicalMessages, windowId);
 		const { tokens } = estimateContextTokens(convertToLlm(messages));
 		return { tokens, contextWindow, percent: tokens / contextWindow * 100 };
 	} catch {

package/src/context/prompts.ts

@@ -1,4 +1,4 @@
-import type { NotesHome, NotesSnapshot } from "../notes/notes-snapshot.js";
+import type { NotesHome, NotesSnapshot } from "../pi/notes/snapshot.js";
 import { CONTEXT_WINDOW_OPEN_TAG, CONTEXT_WINDOW_CLOSE_TAG, POCKET_AGENT_LIMIT, POCKET_HUMAN_LIMIT, POCKET_MODEL_LIMIT, POCKET_PROJECT_LIMIT, POCKET_SESSION_LIMIT, PROTOCOL_BLOCK, GUIDANCE_OPEN_TAG, GUIDANCE_CLOSE_TAG } from "../protocol.js";
 
 /** Codex-style <context_window> identity block: the resolved agent and model names plus first/current/previous window ids. */
@@ -62,7 +62,7 @@ function notesIndex(snapshot: NotesSnapshot): string {
 	if (recentNotes.length > 0) {
 		const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (by prefix, most recent first within each: up to ${POCKET_SESSION_LIMIT} from this session, ${POCKET_PROJECT_LIMIT} from @project, ${POCKET_HUMAN_LIMIT} from @human, ${POCKET_AGENT_LIMIT} from @self, ${POCKET_MODEL_LIMIT} from @model). A note's content never appears here, so its name has to say what the note is about:`];
 		for (const row of recentNotes) {
-			lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${relativeTime(row.meta.updated_at, snapshot.openedAt)})`);
+			lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${relativeTime(row.meta.updatedAt, snapshot.openedAt)})`);
 		}
 		sections.push(lines.join("\n"));
 	}

package/src/context/reset-artifacts.ts

@@ -20,11 +20,17 @@ export function sendContinuation(pi: ExtensionAPI): void {
 }
 
 /**
- * The closed, ordered reset shape: marker, matching boot, continuation. This is the one
- * source of the reset message and the one place that mints the new window identity.
+ * The closed, ordered reset shape: retain-none native checkpoint, marker, matching boot,
+ * continuation. The boot snapshot is acquired asynchronously after capturing this identity.
  */
-export function buildResetDrafts(ctx: ExtensionContext, notifyIncompleteNotes?: IncompleteNotesNotifier) {
-	const sessionPrefix = ctx.sessionManager.getSessionId().slice(0, 8);
+export async function buildResetDrafts(
+	ctx: ExtensionContext,
+	notifyIncompleteNotes?: IncompleteNotesNotifier,
+	isCurrent: () => boolean = () => true,
+): Promise<[SessionBoundaryDraft, SessionBoundaryDraft, SessionBoundaryDraft, SessionBoundaryDraft]> {
+	const sessionId = ctx.sessionManager.getSessionId();
+	const previousId = currentWindowId(ctx);
+	const sessionPrefix = sessionId.slice(0, 8);
 	const usedWindowIds = new Set(
 		ctx.sessionManager.getBranch().filter(isWindowMarker).map((entry) => entry.data.windowId),
 	);
@@ -32,27 +38,13 @@ export function buildResetDrafts(ctx: ExtensionContext, notifyIncompleteNotes?:
 	do {
 		windowId = `pcw:${sessionPrefix}:${randomUUID().slice(0, 8)}`;
 	} while (usedWindowIds.has(windowId));
-	const boot = buildBootMessage(ctx, windowId, currentWindowId(ctx), notifyIncompleteNotes);
+	const boot = await buildBootMessage(ctx, windowId, previousId, notifyIncompleteNotes, isCurrent);
 	return [
+		{ type: "compaction", summary: "", firstKeptEntryId: null },
 		{ type: "custom", customType: RESET_MARKER_TYPE, data: { windowId } },
 		{ type: "custom_message", customType: BOOT_TYPE, content: boot.content, display: false, details: { windowId } },
 		{ type: "custom_message", customType: CONTINUATION_TYPE, content: CONTINUATION, display: false },
-	] satisfies [SessionBoundaryDraft, SessionBoundaryDraft, SessionBoundaryDraft];
-}
-
-/** Persist the marker and send both hidden reset messages; returns the new window id. */
-export function persistManualReset(pi: ExtensionAPI, ctx: ExtensionContext, notifyIncompleteNotes?: IncompleteNotesNotifier): string {
-	const [marker, boot, continuation] = buildResetDrafts(ctx, notifyIncompleteNotes);
-	pi.appendEntry(marker.customType, marker.data);
-	pi.sendMessage(
-		{ customType: boot.customType, content: boot.content, display: boot.display, details: boot.details },
-		{ triggerTurn: false },
-	);
-	pi.sendMessage(
-		{ customType: continuation.customType, content: continuation.content, display: continuation.display },
-		{ triggerTurn: false },
-	);
-	return boot.details.windowId;
+	];
 }
 
 /**
@@ -93,9 +85,19 @@ export function resetTailCommitted(ctx: ExtensionContext, markerId: string, wind
 }
 
 /** Emit only the reset artifacts an incomplete tail is missing, in the closed order. */
-export function repairResetTail(pi: ExtensionAPI, ctx: ExtensionContext, marker: WindowMarker, notifyIncompleteNotes?: IncompleteNotesNotifier): void {
+export async function repairResetTail(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	marker: WindowMarker,
+	notifyIncompleteNotes?: IncompleteNotesNotifier,
+	isCurrent: () => boolean = () => true,
+): Promise<void> {
 	const tail = inspectResetTail(ctx, marker.id, marker.data.windowId);
 	if (!tail || (tail.boot && tail.continuation)) return;
-	if (!tail.boot) sendBoot(pi, buildBootMessage(ctx, marker.data.windowId, previousWindowId(ctx, marker.id), notifyIncompleteNotes));
-	if (!tail.continuation) sendContinuation(pi);
+	const boot = tail.boot ? undefined : await buildBootMessage(ctx, marker.data.windowId, previousWindowId(ctx, marker.id), notifyIncompleteNotes, isCurrent);
+	if (!isCurrent()) return;
+	const latest = inspectResetTail(ctx, marker.id, marker.data.windowId);
+	if (!latest) return;
+	if (!latest.boot && boot) sendBoot(pi, boot);
+	if (!latest.continuation && (latest.boot || boot)) sendContinuation(pi);
 }

package/src/context/reset-lifecycle.ts

@@ -1,11 +1,11 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { isContextOverflow, isRecoverableLength } from "@earendil-works/pi-ai";
 import type { AgentBeforeSettleEvent, ExtensionAPI, ExtensionContext, SessionBoundaryDraft } from "@earendil-works/pi-coding-agent";
-import { currentReset } from "./context-window.js";
+import { currentReset, currentWindowId } from "./context-window.js";
 
 type BudgetOwner = {
 	automaticResetEnabled: (ctx: ExtensionContext) => boolean;
-	resetDue: (ctx: ExtensionContext) => boolean;
+	hardReserveDue: (ctx: ExtensionContext) => boolean;
 	consumeTurnEnd: (ctx: ExtensionContext) => SessionBoundaryDraft[];
 	clear: () => void;
 };
@@ -13,7 +13,9 @@ type BudgetOwner = {
 type ResetOptions = {
 	isEnabled: () => boolean;
 	budget: BudgetOwner;
-	buildReset: (ctx: ExtensionContext) => SessionBoundaryDraft[];
+	buildReset: (ctx: ExtensionContext, isCurrent: () => boolean) => SessionBoundaryDraft[] | Promise<SessionBoundaryDraft[]>;
+	getLifecycleGeneration?: () => number;
+	onResetReady?: (ctx: ExtensionContext, drafts: readonly SessionBoundaryDraft[]) => void;
 };
 
 function isAbort(message: AgentMessage, outcome: string | undefined, ctx: ExtensionContext): boolean {
@@ -26,79 +28,59 @@ function isOverflowLike(message: AgentMessage, ctx: ExtensionContext): boolean {
 		(ctx.model !== undefined && isRecoverableLength(message, ctx.model.maxTokens));
 }
 
-/**
- * Reset-control state. The concern is split into two independent, explicitly typed axes so
- * that no combination of independently combinable lifecycle booleans is legal by accident:
- *
- * - `request` is the single pending explicit wipe request ("none" or "explicit"). Repeated
- *   requests deduplicate while one is pending.
- * - `overflow` is the bounded provider-overflow recovery chain:
- *   - "idle"          no overflow failure is pending; recovery is available for a later chain.
- *   - "pending"       an overflow failure is pending; recovery is still available.
- *   - "pending-spent" an overflow failure is pending, but recovery was already spent this chain.
- *   - "spent"         recovery was spent and the failure is no longer pending.
- *
- * All eight combinations of the two axes are reachable (a request may arrive while an overflow
- * chain is pending, spent, or settled), and each has a defined transition. There is no state
- * whose fields silently contradict one another.
- */
-export type ResetRequestPhase = "none" | "explicit";
+export type ResetRequestSource = "manual" | "automatic";
+export type ResetRequest =
+	| { readonly phase: "none" }
+	| { readonly phase: "close-out"; readonly windowId: string; readonly source: ResetRequestSource }
+	| { readonly phase: "tool-requested"; readonly windowId: string };
 export type ResetOverflowPhase = "idle" | "pending" | "pending-spent" | "spent";
 
 export interface ResetControlState {
-	readonly request: ResetRequestPhase;
+	readonly request: ResetRequest;
 	readonly overflow: ResetOverflowPhase;
 }
 
+const NO_REQUEST: ResetRequest = { phase: "none" };
+
 export function initialResetControl(): ResetControlState {
-	return { request: "none", overflow: "idle" };
+	return { request: NO_REQUEST, overflow: "idle" };
 }
 
-/**
- * Facts for a completed turn. The three `get`-supplied fields are guards the adapter resolves
- * lazily: the reducer reads each one only in the branch where the previous adapter consulted it,
- * so policy resolution and pending-message probes keep their original call ordering.
- */
+/** Facts for a completed turn. Guard values stay lazy to preserve policy resolution order. */
 export interface ResetTurnEndFacts {
+	readonly windowId: string;
 	readonly aborted: boolean;
 	readonly overflow: boolean;
 	readonly failed: boolean;
 	readonly enabled: boolean;
 	readonly queued: boolean;
 	readonly automaticResetEnabled: boolean;
-	readonly thresholdDue: boolean;
+	readonly hardReserveDue: boolean;
 }
 
 /** Facts for the pre-settlement boundary; policy guards stay lazy for the same reason. */
 export interface ResetBeforeSettleFacts {
+	readonly windowId: string;
 	readonly queued: boolean;
 	readonly enabled: boolean;
 	readonly automaticResetEnabled: boolean;
 	readonly aborted: boolean;
+	readonly failed: boolean;
 }
 
 export type ResetControlEvent =
-	| { readonly type: "request" }
+	| { readonly type: "close_out"; readonly windowId: string; readonly source: ResetRequestSource }
+	| { readonly type: "tool_request"; readonly windowId: string }
 	| { readonly type: "turn_end"; readonly facts: ResetTurnEndFacts }
 	| { readonly type: "before_settle"; readonly facts: ResetBeforeSettleFacts }
 	| { readonly type: "settled" }
 	| { readonly type: "abort" }
 	| { readonly type: "clear" };
 
-/**
- * The requested effect of a transition. Effects are named, not performed: marker/boot/
- * continuation writes, continuation requests, and UI notices stay in the adapter.
- *
- * - "none"              keep any return value to the drafts already collected for this event.
- * - "requested"         a new explicit reset request was recorded.
- * - "already-requested" a request was already pending and was deduplicated.
- * - "commit-boundary"   build and commit the reset boundary now (turn_end).
- * - "recover-overflow"  build and commit the one bounded overflow recovery now (settle).
- */
 export type ResetControlEffect =
 	| "none"
-	| "requested"
-	| "already-requested"
+	| "close-out-armed"
+	| "already-pending"
 	| "commit-boundary"
 	| "recover-overflow";
 
@@ -107,59 +89,77 @@ export interface ResetControlResult {
 	readonly effect: ResetControlEffect;
 }
 
-/**
- * Pure reset-control transition. It performs no writes, no policy resolution of its own, and
- * no UI work; every fact it reads is supplied by the caller. Callers can therefore drive the
- * full transition table without a live Pi session.
- */
+function requestForWindow(request: ResetRequest, windowId: string): ResetRequest {
+	return request.phase !== "none" && request.windowId === windowId ? request : NO_REQUEST;
+}
+
+/** Pure reset-control transitions: request phases own close-out, tool commit, and fallback. */
 export function reduceResetControl(state: ResetControlState, event: ResetControlEvent): ResetControlResult {
 	switch (event.type) {
-		case "request": {
-			if (state.request === "explicit") return { state, effect: "already-requested" };
-			return { state: { ...state, request: "explicit" }, effect: "requested" };
+		case "close_out": {
+			const request = state.request;
+			if (request.phase === "tool-requested" && request.windowId === event.windowId) {
+				return { state, effect: "already-pending" };
+			}
+			if (request.phase === "close-out" && request.windowId === event.windowId) {
+				if (request.source === "manual" || event.source === "automatic") return { state, effect: "already-pending" };
+				return { state: { ...state, request: { ...request, source: "manual" } }, effect: "close-out-armed" };
+			}
+			return { state: { ...state, request: { phase: "close-out", windowId: event.windowId, source: event.source } }, effect: "close-out-armed" };
+		}
+		case "tool_request": {
+			const request = state.request;
+			if (request.phase === "tool-requested" && request.windowId === event.windowId) return { state, effect: "already-pending" };
+			return { state: { ...state, request: { phase: "tool-requested", windowId: event.windowId } }, effect: "close-out-armed" };
 		}
 		case "turn_end": {
 			const facts = event.facts;
-			const requested = state.request === "explicit";
-			// The explicit request is consumed by the turn boundary whether or not it commits.
-			const request: ResetRequestPhase = "none";
-			if (facts.aborted) {
-				// An aborted turn drops the whole boundary: no explicit request, no overflow chain.
-				return { state: { request, overflow: "idle" }, effect: "none" };
-			}
+			const request = requestForWindow(state.request, facts.windowId);
+			if (facts.aborted) return { state: initialResetControl(), effect: "none" };
 			if (facts.overflow) {
-				// A failure that Pi may recover natively: arm (or re-arm) the bounded settle path.
-				// A queued message, disabled mode, or disabled automatic reset leaves it disarmed.
 				const pending = !facts.queued && facts.enabled && facts.automaticResetEnabled;
 				const spent = state.overflow === "pending-spent" || state.overflow === "spent";
 				const overflow: ResetOverflowPhase = pending
 					? (spent ? "pending-spent" : "pending")
 					: (spent ? "spent" : "idle");
-				return { state: { request, overflow }, effect: "none" };
+				return { state: { request: NO_REQUEST, overflow }, effect: "none" };
+			}
+			if (facts.failed) return { state: { request: NO_REQUEST, overflow: state.overflow }, effect: "none" };
+			if (!facts.enabled) {
+				return { state: { request: NO_REQUEST, overflow: "idle" }, effect: "none" };
+			}
+			// A direct tool request commits after the whole tool batch. The budget cutoff is
+			// a separate hard-reserve safety path; ordinary close-out waits for settlement.
+			if (request.phase === "tool-requested" || facts.hardReserveDue) {
+				return { state: { request: NO_REQUEST, overflow: "idle" }, effect: "commit-boundary" };
 			}
-			// Any non-overflow completed turn supersedes an older overflow failure. A non-overflow
-			// error leaves the armed overflow chain untouched for the settle boundary.
-			const overflow: ResetOverflowPhase = facts.failed ? state.overflow : "idle";
-			if (!facts.enabled || facts.failed) return { state: { request, overflow }, effect: "none" };
-			// Explicit and threshold resets both commit at turn_end, after incoming and budget drafts.
-			const commit = requested || facts.thresholdDue;
-			return { state: { request, overflow }, effect: commit ? "commit-boundary" : "none" };
+			return { state: { request, overflow: "idle" }, effect: "none" };
 		}
 		case "before_settle": {
 			const facts = event.facts;
-			if (state.overflow !== "pending" && state.overflow !== "pending-spent") return { state, effect: "none" };
-			// Let a queued turn run first; its own turn_end settles or clears this chain.
-			if (facts.queued) return { state, effect: "none" };
-			const spent = state.overflow === "pending-spent";
-			if (!facts.enabled || !facts.automaticResetEnabled || facts.aborted) {
-				return { state: { ...state, overflow: spent ? "spent" : "idle" }, effect: "none" };
+			if (facts.aborted) return { state: initialResetControl(), effect: "none" };
+			const request = requestForWindow(state.request, facts.windowId);
+			if (state.overflow === "pending" || state.overflow === "pending-spent") {
+				if (facts.queued) {
+					return { state: { ...state, request: facts.failed ? NO_REQUEST : request }, effect: "none" };
+				}
+				const spent = state.overflow === "pending-spent";
+				if (!facts.enabled || !facts.automaticResetEnabled) {
+					return { state: { request: facts.failed ? NO_REQUEST : request, overflow: spent ? "spent" : "idle" }, effect: "none" };
+				}
+				return { state: { request: NO_REQUEST, overflow: "spent" }, effect: spent ? "none" : "recover-overflow" };
 			}
-			// The recovery is one-use per failure chain. Committing it spends the attempt.
-			return { state: { ...state, overflow: "spent" }, effect: spent ? "none" : "recover-overflow" };
+			if (facts.failed || !facts.enabled || request.phase !== "close-out") {
+				return { state: { ...state, request: NO_REQUEST }, effect: "none" };
+			}
+			if (facts.queued) return { state: { ...state, request }, effect: "none" };
+			if (request.source === "automatic" && !facts.automaticResetEnabled) {
+				return { state: { ...state, request: NO_REQUEST }, effect: "none" };
+			}
+			return { state: { request: NO_REQUEST, overflow: "idle" }, effect: "commit-boundary" };
 		}
 		case "settled":
-			// Settlement ends the failure chain but leaves a pending explicit request armed.
-			return { state: { ...state, overflow: "idle" }, effect: "none" };
+			return { state: initialResetControl(), effect: "none" };
 		case "abort":
 		case "clear":
 			return { state: initialResetControl(), effect: "none" };
@@ -167,71 +167,76 @@ export function reduceResetControl(state: ResetControlState, event: ResetControl
 }
 
 /**
- * Own reset requests at Pi 0.87 boundaries. Persisted windows are custom entries, not
- * compaction summaries: turn_end commits explicit/threshold resets after a complete tool
- * batch, while agent_before_settle commits the one bounded overflow recovery after Pi's
- * native recovery attempt has been cancelled.
- *
- * This function is the effect adapter: it captures Pi events, translates them into pure
- * reset-control transitions, and performs the resulting marker/boot/continuation writes and
- * notifications. The decision of what to do lives entirely in `reduceResetControl`.
+ * Own close-out requests at Pi's public turn and pre-settlement boundaries. Tool-requested
+ * resets commit at turn_end; manual and budget close-outs remain armed across note/tool turns
+ * and fall back at a successful agent_before_settle. Overflow recovery remains bounded.
  */
 export function registerResetLifecycle(pi: ExtensionAPI, options: ResetOptions) {
 	let sessionActive = true;
+	let lifecycleGeneration = 0;
 	let control = initialResetControl();
 
 	const clear = () => { control = reduceResetControl(control, { type: "clear" }).state; };
-	const resetBoundaryResult = (entries: SessionBoundaryDraft[], ctx: ExtensionContext) => {
+	const resetBoundaryResult = async (entries: SessionBoundaryDraft[], ctx: ExtensionContext) => {
+		const generation = lifecycleGeneration;
+		const outerGeneration = options.getLifecycleGeneration?.();
+		const sessionId = ctx.sessionManager.getSessionId();
+		const windowId = currentWindowId(ctx);
+		const isCurrent = () => sessionActive && lifecycleGeneration === generation &&
+			(outerGeneration === undefined || options.getLifecycleGeneration?.() === outerGeneration) && options.isEnabled() &&
+			ctx.signal?.aborted !== true && ctx.sessionManager.getSessionId() === sessionId && currentWindowId(ctx) === windowId;
+		let resetDrafts: SessionBoundaryDraft[];
 		try {
-			return { entries: [...entries, ...options.buildReset(ctx)], continue: true as const };
+			resetDrafts = await options.buildReset(ctx, isCurrent);
 		} catch (error) {
-			ctx.ui.notify(`pi-context: could not build reset (${String(error)}).`, "warning");
-			// The incoming drafts and budget drafts are already valid work from this
-			// boundary. Preserve them, but do not claim a continuation when reset
-			// construction failed.
+			if (isCurrent()) ctx.ui.notify(`pi-context: could not build reset (${String(error)}).`, "warning");
 			return entries.length > 0 ? { entries } : undefined;
 		}
+		if (!isCurrent()) return entries.length > 0 ? { entries } : undefined;
+		options.onResetReady?.(ctx, resetDrafts);
+		return { entries: [...entries, ...resetDrafts], continue: true as const };
 	};
 
-	pi.on("turn_end", (event, ctx) => {
+	pi.on("turn_end", async (event, ctx) => {
 		if (!sessionActive) return undefined;
 		const aborted = isAbort(event.message, event.outcome, ctx);
 		const stagedBudgetEntries = options.budget.consumeTurnEnd(ctx);
-		// Lifecycle owns whether drafts are acceptable for this turn. Budget only
-		// drains its instance-local staging, so aborts and disabled mode cannot commit it.
-		const budgetEntries = options.isEnabled() && !aborted ? stagedBudgetEntries : [];
+		const budgetEntries = options.isEnabled() && !aborted && event.outcome !== "error" ? stagedBudgetEntries : [];
 		const entries = [...(event.entries ?? []), ...budgetEntries];
 		const decision = reduceResetControl(control, {
 			type: "turn_end",
 			facts: {
+				windowId: currentWindowId(ctx),
 				aborted,
 				overflow: aborted ? false : isOverflowLike(event.message, ctx),
 				failed: event.outcome === "error",
 				enabled: options.isEnabled(),
 				get queued() { return event.context.pendingMessages.length > 0 || ctx.hasPendingMessages(); },
 				get automaticResetEnabled() { return options.budget.automaticResetEnabled(ctx); },
-				get thresholdDue() { return options.budget.resetDue(ctx); },
+				get hardReserveDue() { return options.budget.hardReserveDue(ctx); },
 			},
 		});
 		control = decision.state;
-		if (decision.effect === "commit-boundary") return resetBoundaryResult(entries, ctx);
+		if (decision.effect === "commit-boundary") return await resetBoundaryResult(entries, ctx);
 		return entries.length > 0 ? { entries } : undefined;
 	});
 
-	pi.on("agent_before_settle", (event: AgentBeforeSettleEvent, ctx) => {
+	pi.on("agent_before_settle", async (event: AgentBeforeSettleEvent, ctx) => {
 		if (!sessionActive) return undefined;
 		const decision = reduceResetControl(control, {
 			type: "before_settle",
 			facts: {
+				windowId: currentWindowId(ctx),
 				get queued() { return event.context.pendingMessages.length > 0 || ctx.hasPendingMessages(); },
 				get enabled() { return options.isEnabled(); },
 				get automaticResetEnabled() { return options.budget.automaticResetEnabled(ctx); },
-				get aborted() { return event.outcome === "aborted" || ctx.signal?.aborted === true; },
+				aborted: event.outcome === "aborted" || ctx.signal?.aborted === true,
+				failed: event.outcome === "error",
 			},
 		});
 		control = decision.state;
-		if (decision.effect !== "recover-overflow") return undefined;
-		return resetBoundaryResult(event.entries, ctx);
+		if (decision.effect !== "commit-boundary" && decision.effect !== "recover-overflow") return undefined;
+		return await resetBoundaryResult(event.entries, ctx);
 	});
 
 	pi.on("session_before_compact", (event, ctx) => {
@@ -242,30 +247,31 @@ export function registerResetLifecycle(pi: ExtensionAPI, options: ResetOptions)
 			if (event.reason === "manual") {
 				ctx.ui.notify("pi-context: /compact is disabled while context windows are active; use /wipe-memory to start a fresh window.", "warning");
 			}
-			// Native compaction is cancelled here. Threshold resets are decided solely from
-			// completed-turn usage at turn_end, never from canonical pre-request history.
 			return { cancel: true };
 		}
 		return undefined;
 	});
 
 	pi.on("agent_end", (_event, ctx) => {
-		if (ctx.signal?.aborted) clear();
+		if (ctx.signal?.aborted) control = reduceResetControl(control, { type: "abort" }).state;
 	});
 	pi.on("agent_settled", () => {
-		// A failed recovery chain is bounded to one reset/retry. Once Pi settles, a later
-		// user prompt starts a new chain; successful continuations clear this earlier.
 		control = reduceResetControl(control, { type: "settled" }).state;
 	});
-	pi.on("session_start", () => { clear(); sessionActive = true; });
-	pi.on("session_tree", clear);
-	pi.on("session_shutdown", () => { clear(); options.budget.clear(); sessionActive = false; });
+	pi.on("session_start", () => { lifecycleGeneration++; clear(); sessionActive = true; });
+	pi.on("session_tree", () => { lifecycleGeneration++; clear(); });
+	pi.on("session_shutdown", () => { lifecycleGeneration++; clear(); options.budget.clear(); sessionActive = false; });
 
 	return {
-		request() {
-			const decision = reduceResetControl(control, { type: "request" });
+		closeOut(windowId: string, source: ResetRequestSource) {
+			const decision = reduceResetControl(control, { type: "close_out", windowId, source });
+			control = decision.state;
+			return decision.effect;
+		},
+		request(windowId: string) {
+			const decision = reduceResetControl(control, { type: "tool_request", windowId });
 			control = decision.state;
-			return decision.effect === "already-requested" ? "rollover_already_pending" : "rollover_requested";
+			return decision.effect === "already-pending" ? "rollover_already_pending" : "rollover_requested";
 		},
 		clear,
 	};