@astrosheep/pi-context 0.25.1 → 0.26.0

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,
 	};

package/src/context/runtime.ts

@@ -2,10 +2,11 @@ import { getCurrentSystemMessage, Type } from "@earendil-works/pi-ai";
 import { VERSION, defineTool, type ExtensionAPI, type ExtensionContext, type SettingsManager } from "@earendil-works/pi-coding-agent";
 import { registerBudget } from "./budget.js";
 import { output } from "../tool-output.js";
-import { migrateLegacyHomes } from "../notes/paths.js";
-import { currentReset, isWindowMarker, projectRootWindow, projectWindow, rootWindowId } from "./context-window.js";
+import { migrateLegacyHomes } from "../pi/notes/adapter.js";
+import { currentReset, currentWindowId, isCheckpointBackedReset, isWindowBoot, isWindowMarker, projectRootWindow, projectWindow, rootWindowId, type WindowMarker } from "./context-window.js";
 import { registerResetLifecycle } from "./reset-lifecycle.js";
-import { buildResetDrafts, persistManualReset, resetTailCommitted } from "./reset-artifacts.js";
+import { buildResetDrafts, resetTailCommitted } from "./reset-artifacts.js";
+import { BOOT_TYPE, WARNING_CONTENT, WARNING_TYPE } from "../protocol.js";
 import { ensureBoot, type IncompleteNotesNotifier } from "./boot.js";
 
 declare const __PI_CONTEXT_BUILD__: { version: string; sourceHash: string };
@@ -22,6 +23,7 @@ function branchHasWindowMarker(ctx: ExtensionContext, fromId?: string): boolean
 /** Register the context-window runtime and its context-owned commands/tools. */
 export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsManager): void {
 	let enabled = true;
+	let lifecycleGeneration = 0;
 	let missingBootNotice: string | undefined;
 	const incompleteNotesNotified = new Set<string>();
 	const pendingResetNotices = new Set<string>();
@@ -32,8 +34,8 @@ export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsMana
 		if (pendingResetNotices.size === 0) return;
 		const branch = ctx.sessionManager.getBranch();
 		for (const windowId of pendingResetNotices) {
-			const marker = branch.find((entry) => isWindowMarker(entry) && entry.data.windowId === windowId);
-			if (!marker || !resetTailCommitted(ctx, marker.id, windowId)) continue;
+			const marker = branch.find((entry): entry is WindowMarker => isWindowMarker(entry) && entry.data.windowId === windowId);
+			if (!marker || !isCheckpointBackedReset(ctx, marker) || !resetTailCommitted(ctx, marker.id, windowId)) continue;
 			pendingResetNotices.delete(windowId);
 			ctx.ui.notify(`pi-context: memory cleared · ${windowId}`, "info");
 		}
@@ -52,18 +54,24 @@ export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsMana
 	const migrationWarning = migrateLegacyHomes();
 	if (migrationWarning) console.warn(`pi-context: ${migrationWarning}`);
 
-	const budget = registerBudget(pi, () => enabled, settingsManager);
+	const budget = registerBudget(pi, () => enabled, settingsManager, (windowId) => resets.closeOut(windowId, "automatic"));
 
-	pi.on("session_start", (_event, ctx) => {
+	pi.on("session_start", async (_event, ctx) => {
+		const generation = ++lifecycleGeneration;
 		if (!enabled) return;
 		missingBootNotice = undefined;
 		pendingResetNotices.clear();
-		ensureBoot(pi, ctx, notifyIncompleteNotes);
+		await ensureBoot(pi, ctx, notifyIncompleteNotes, () => generation === lifecycleGeneration && enabled);
 	});
-	pi.on("session_tree", (_event, ctx) => {
+	pi.on("session_tree", async (_event, ctx) => {
+		const generation = ++lifecycleGeneration;
 		missingBootNotice = undefined;
 		pendingResetNotices.clear();
-		if (enabled) ensureBoot(pi, ctx, notifyIncompleteNotes);
+		if (enabled) await ensureBoot(pi, ctx, notifyIncompleteNotes, () => generation === lifecycleGeneration && enabled);
+	});
+	pi.on("session_shutdown", () => {
+		lifecycleGeneration++;
+		pendingResetNotices.clear();
 	});
 
 	// Pi's branch summarizer receives raw entries and bypasses context_with_system. Do not
@@ -81,7 +89,11 @@ export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsMana
 		const reset = currentReset(ctx);
 		const windowId = reset?.data.windowId ?? rootWindowId(ctx.sessionManager.getSessionId());
 		try {
-			return { messages: reset ? projectWindow(event.messages, windowId) : projectRootWindow(event.messages, windowId) };
+			if (reset) {
+				if (!event.messages.some((message) => isWindowBoot(message, windowId))) throw new Error(`Missing boot for context window ${windowId}`);
+				return { messages: isCheckpointBackedReset(ctx, reset) ? event.messages : projectWindow(event.messages, windowId) };
+			}
+			return { messages: projectRootWindow(event.messages, windowId) };
 		} catch (error) {
 			if (missingBootNotice !== windowId) {
 				missingBootNotice = windowId;
@@ -101,9 +113,12 @@ export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsMana
 			const arg = args.trim().toLowerCase();
 			if (arg === "on") {
 				enabled = true;
-				ensureBoot(pi, cmdCtx, notifyIncompleteNotes);
+				const generation = ++lifecycleGeneration;
+				await ensureBoot(pi, cmdCtx, notifyIncompleteNotes, () => generation === lifecycleGeneration && enabled);
 			} else if (arg === "off") {
 				enabled = false;
+				lifecycleGeneration++;
+				pendingResetNotices.clear();
 				budget.clear();
 				resets.clear();
 			} else if (arg !== "") {
@@ -115,16 +130,25 @@ export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsMana
 	});
 
 	pi.registerCommand("wipe-memory", {
-		description: "Persist a fresh context window without calling the model",
+		description: "Ask the agent to close out its notes, then start a fresh context window",
 		handler: async (_args, cmdCtx) => {
 			if (!enabled) {
 				cmdCtx.ui.notify("pi-context: /wipe-memory requires /pi-context on.", "error");
 				return;
 			}
+			const requestedWindowId = currentWindowId(cmdCtx);
+			await cmdCtx.waitForIdle();
+			if (!enabled || currentWindowId(cmdCtx) !== requestedWindowId) return;
+			const armed = resets.closeOut(requestedWindowId, "manual");
+			if (armed === "already-pending") return;
+			try {
+				pi.sendMessage({ customType: WARNING_TYPE, content: WARNING_CONTENT, display: false }, { triggerTurn: true });
+			} catch (error) {
+				resets.clear();
+				cmdCtx.ui.notify(`pi-context: could not start manual close-out (${String(error)}).`, "error");
+				return;
+			}
 			await cmdCtx.waitForIdle();
-			if (!enabled) return;
-			resets.clear();
-			notifyCommittedResets(cmdCtx, persistManualReset(pi, cmdCtx, notifyIncompleteNotes));
 		},
 	});
 
@@ -133,18 +157,22 @@ export function registerContext(pi: ExtensionAPI, settingsManager?: SettingsMana
 		label: "Wipe memory",
 		description: "Wipe your in-context memory and start a fresh context window. Your session, notes, and history survive.",
 		parameters: Type.Object({}, { additionalProperties: false }),
-		async execute() {
+		async execute(_id, _params, _signal, _update, ctx) {
 			if (!enabled) return output({ error: "pi-context is off (/pi-context on to enable)" });
-			return output({ status: resets.request() }, undefined, true);
+			return output({ status: resets.request(currentWindowId(ctx)) }, undefined, true);
 		},
 	}));
 
 	const resets = registerResetLifecycle(pi, {
 		isEnabled: () => enabled,
-		buildReset: (ctx) => {
-			const drafts = buildResetDrafts(ctx, notifyIncompleteNotes);
-			pendingResetNotices.add(drafts[1].details.windowId);
-			return drafts;
+		buildReset: (ctx, isCurrent) => buildResetDrafts(ctx, notifyIncompleteNotes, isCurrent),
+		getLifecycleGeneration: () => lifecycleGeneration,
+		onResetReady: (_ctx, drafts) => {
+			const boot = drafts.find((draft) => draft.type === "custom_message" && draft.customType === BOOT_TYPE);
+			if (boot?.type === "custom_message" && boot.details && typeof boot.details === "object") {
+				const windowId = (boot.details as { windowId?: unknown }).windowId;
+				if (typeof windowId === "string") pendingResetNotices.add(windowId);
+			}
 		},
 		budget,
 	});

package/src/context/thresholds.ts

@@ -24,7 +24,7 @@ export function deriveThresholds(reserveTokens: number, margins: PiContextSettin
 	else {
 		const parsed = validMargin(margins.reminderMarginTokens);
 		if (parsed === undefined) {
-			warnings.push(`pi-context: ${reminderKey} must be a positive integer; using default ${DEFAULT_REMINDER_MARGIN_TOKENS}.`);
+			warnings.push(`pi-context: ${reminderKey} must be a positive integer; using the default reminder margin.`);
 			reminderMargin = DEFAULT_REMINDER_MARGIN_TOKENS;
 		} else reminderMargin = parsed;
 	}

package/src/dream/cli.ts

@@ -8,7 +8,7 @@ import { loadPlaybook, runDreamer, type DreamerSessionFactory, type DreamResult,
 import { gitCommit } from "./git.js";
 import { readDreamerSettings, type DreamerSetting } from "./settings.js";
 import { doctor } from "./doctor.js";
-import { notesRoot } from "../notes/paths.js";
+import { notesRoot } from "../pi/notes/adapter.js";
 
 function args(argv: string[]) { const out: Record<string, string | boolean> = {}; for (let i=0;i<argv.length;i++) { const a=argv[i]!; if (a === "--force" || a === "--help") out[a.slice(2)] = true; else if (a.startsWith("--")) out[a.slice(2)] = argv[++i] ?? ""; } return out; }
 function packageRoot(): string {

package/src/dream/doctor.ts

@@ -27,10 +27,13 @@ export function doctor(home: string): string[] {
 			if (fields.has(field[1]!)) report(path, `duplicate metadata key ${field[1]}; keep one value`);
 			fields.set(field[1]!, field[2]!.replace(/^(["'])(.*)\1$/, "$2"));
 		}
-		for (const [key, valid] of Object.entries({ origin: /^(user|self|external)$/, status: /^(active|superseded|pending|archived)$/, stale: /^(true|false)$/, access_count: /^\d+$/ })) {
+		for (const [key, valid] of Object.entries({ origin: /^(user|self|external)$/, status: /^(active|superseded|pending|archived)$/, stale: /^(true|false)$/, accessCount: /^\d+$/ })) {
 			if (!valid.test(fields.get(key) ?? "")) report(path, `missing/invalid ${key}; repair frontmatter`);
 		}
-		for (const key of ["created_at", "updated_at", "last_accessed"]) {
+		for (const [legacy, current] of [["created_at", "createdAt"], ["updated_at", "updatedAt"], ["last_accessed", "lastAccessed"], ["access_count", "accessCount"], ["source_window", "sourceWindow"], ["recurrence_count", "recurrenceCount"], ["recurrence_windows", "recurrenceWindows"]]) {
+			if (fields.has(legacy)) report(path, `legacy metadata key ${legacy}; manually migrate to ${current}`);
+		}
+		for (const key of ["createdAt", "updatedAt", "lastAccessed"]) {
 			const value = fields.get(key);
 			if (!value || !Number.isFinite(Date.parse(value))) report(path, `missing/invalid ${key}; use an ISO timestamp`);
 		}