@astrosheep/pi-context 0.22.1 → 0.23.0

package/src/reset-lifecycle.ts

@@ -12,7 +12,16 @@ export function registerResetLifecycle(pi: ExtensionAPI, options: {
 	isCurrentReset: (entryId: string, ctx: ExtensionContext) => boolean;
 	onReset: (entryId: string) => void;
 }) {
-	type Attempt = { completed: boolean; sessionId: string; explicit: boolean };
+	type Attempt = {
+		completed: boolean;
+		explicit: boolean;
+		nextRequested: boolean;
+		continuationStarted: boolean;
+		sessionId: string;
+		settled: boolean;
+		wait: Promise<void>;
+		release: () => void;
+	};
 	type Request =
 		| { phase: "idle" }
 		| { phase: "requested" }
@@ -21,38 +30,39 @@ export function registerResetLifecycle(pi: ExtensionAPI, options: {
 	let handledEntry: string | undefined;
 	let active = true;
 
+	const release = (attempt: Attempt) => {
+		if (attempt.settled) return;
+		attempt.settled = true;
+		if (state.phase === "compacting" && state.attempt === attempt) {
+			state = { phase: "idle" };
+			handledEntry = undefined;
+		}
+		attempt.release();
+	};
 	const clear = () => {
+		if (state.phase === "compacting") release(state.attempt);
 		state = { phase: "idle" };
 		handledEntry = undefined;
 	};
 	const valid = (request: Attempt, ctx: ExtensionContext) =>
 		active && options.isEnabled() && state.phase === "compacting" && state.attempt === request && ctx.sessionManager.getSessionId() === request.sessionId;
 
-	// State is intentionally not resumed from a pending request: a loaded session must
-	// not execute work from a tool that belonged to a previous runtime or tree branch.
-	pi.on("session_start", () => { clear(); active = true; });
-	pi.on("session_shutdown", () => { clear(); active = false; });
-	pi.on("session_tree", clear);
-
-	pi.on("agent_end", (_event, ctx) => {
-		if (!active || !options.isEnabled()) return;
-		if (ctx.signal?.aborted) {
-			// Esc cancels the user's run. Do not reset or resurrect it at settled.
-			state = { phase: "idle" };
-			return;
-		}
-	});
-
-	pi.on("agent_settled", (_event, ctx) => {
-		if (!active || !options.isEnabled() || state.phase === "compacting" || !ctx.isIdle()) return;
-		if (state.phase !== "requested") return;
-		// One owner for requested resets. Consume the request before any external call;
-		// repeated settled events and reentrant callbacks are harmless.
-		const request: Attempt = { completed: false, sessionId: ctx.sessionManager.getSessionId(), explicit: true };
+	const begin = (ctx: ExtensionContext) => {
+		let releaseWait!: () => void;
+		const request: Attempt = {
+			completed: false,
+			explicit: true,
+			nextRequested: false,
+			continuationStarted: false,
+			sessionId: ctx.sessionManager.getSessionId(),
+			settled: false,
+			wait: new Promise<void>((resolve) => { releaseWait = resolve; }),
+			release: () => releaseWait(),
+		};
 		state = { phase: "compacting", attempt: request };
 		const onError = (error: Error) => {
 			if (!valid(request, ctx)) return;
-			state = { phase: "idle" };
+			release(request);
 			// Do not retry from settled in a tight loop. A later prompt may trigger a
 			// native reset or explicitly request one.
 			ctx.ui.notify(`pi-context: reset did not complete (${error.message}). The conversation is retained; resume with another prompt.`, "warning");
@@ -61,19 +71,64 @@ export function registerResetLifecycle(pi: ExtensionAPI, options: {
 			ctx.compact({
 				onComplete: () => {
 					if (!valid(request, ctx)) return;
-					state = { phase: "idle" };
 					// session_compact only confirms the boundary. onComplete runs after
 					// Pi clears compaction state; sending inside the hook starts too early.
 					// A queued user prompt may already have started at compaction_end.
 					if (request.completed && ctx.isIdle() && !ctx.hasPendingMessages()) {
-						pi.sendMessage(options.continuation, { triggerTurn: true });
+						// The SDK detaches sendMessage, so own the next settled event before
+						// starting it. The originating agent_settled handler awaits wait.
+						if (request.continuationStarted) return;
+						request.continuationStarted = true;
+						try {
+							pi.sendMessage(options.continuation, { triggerTurn: true });
+						} catch (error) {
+							onError(error instanceof Error ? error : new Error(String(error)));
+						}
+						return;
 					}
+					release(request);
 				},
 				onError,
 			});
 		} catch (error) {
 			onError(error instanceof Error ? error : new Error(String(error)));
 		}
+		return request;
+	};
+
+	// State is intentionally not resumed from a pending request: a loaded session must
+	// not execute work from a tool that belonged to a previous runtime or tree branch.
+	pi.on("session_start", () => { clear(); active = true; });
+	pi.on("session_shutdown", () => { clear(); active = false; });
+	pi.on("session_tree", clear);
+
+	pi.on("agent_end", (_event, ctx) => {
+		if (!active || !options.isEnabled()) return;
+		if (ctx.signal?.aborted) {
+			// Esc cancels the user's run. Do not reset or resurrect it at settled.
+			clear();
+		}
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		if (!active || !options.isEnabled() || !ctx.isIdle()) return;
+		if (state.phase === "compacting" && state.attempt.continuationStarted) {
+			const preceding = state.attempt;
+			if (!preceding.nextRequested) {
+				release(preceding);
+				return;
+			}
+			// This settled event belongs to the continuation started by preceding.
+			// If it requested another reset, retain preceding until that reset's own
+			// continuation settles. Its eventual nested handler only releases its own
+			// waiter, so it never awaits itself.
+			const next = begin(ctx);
+			return next.wait.then(() => release(preceding));
+		}
+		if (state.phase !== "requested") return;
+		// One owner for requested resets. Consume the request before any external call;
+		// repeated settled events and reentrant callbacks are harmless.
+		return begin(ctx).wait;
 	});
 
 	pi.on("session_before_compact", (event, ctx) => {
@@ -103,9 +158,15 @@ export function registerResetLifecycle(pi: ExtensionAPI, options: {
 
 	return {
 		request() {
-			const pending = state.phase !== "idle";
-			if (!pending) state = { phase: "requested" };
-			return pending ? "rollover_already_pending" : "rollover_requested";
+			if (state.phase === "idle") {
+				state = { phase: "requested" };
+				return "rollover_requested";
+			}
+			if (state.phase === "compacting" && state.attempt.continuationStarted && !state.attempt.nextRequested) {
+				state.attempt.nextRequested = true;
+				return "rollover_requested";
+			}
+			return "rollover_already_pending";
 		},
 		clear,
 	};

package/src/tool-output.ts

@@ -115,16 +115,14 @@ export function readCharacterWindow<T>(text: string, offsetChars: number | undef
 }
 
 /**
- * One-line bracketed header preceding a raw character-window payload: the identity, the
- * delivered char range, and either the resume cursor or `end`. `tail` appends extra
- * metadata (notes add their timestamps) inside the same brackets.
+ * Fixed metadata block preceding any raw character-window payload. Callers supply their
+ * source identity fields in wire order; range and continuation semantics are shared.
  */
-export function characterWindowHeader(identity: string, window: CharacterWindow, tail = ""): string {
-	// The range end is offset + delivered count, never `total_chars`: a read resolved past the
-	// end delivers zero characters there, and the header must not render an inverted range.
+export function readWindowBlock(identity: ReadonlyArray<readonly [string, string]>, window: CharacterWindow): string {
 	const end = window.offset_chars + Array.from(window.content).length;
-	const resume = window.next_offset_chars === null ? "end" : `continue at offset_chars=${window.next_offset_chars}`;
-	return `[${identity} · chars ${window.offset_chars}-${end} of ${window.total_chars} · ${resume}${tail}]`;
+	const next = window.next_offset_chars === null ? "null" : String(window.next_offset_chars);
+	const fields = identity.map(([name, value]) => `${name}: ${value}`).join("\n");
+	return `--- READ WINDOW ---\n${fields}\nchars: [${window.offset_chars},${end}) of ${window.total_chars}\nnext_offset_chars: ${next}\n`;
 }
 
 /**
@@ -183,9 +181,8 @@ export function output(value: unknown, details?: unknown, terminate = false) {
 }
 
 /**
- * Encode a prose payload as raw text: a one-line bracketed metadata header, then the payload
- * verbatim. The model reads the note or history item itself instead of a JSON envelope;
- * `details` carries the slim metadata object and never duplicates the payload.
+ * Encode a prose payload as raw text: metadata prefix, a blank line, then the payload
+ * verbatim. `details` carries the slim metadata object and never duplicates the payload.
  */
 export function outputRaw(header: string, content: string, details: unknown, terminate = false) {
 	return { content: [{ type: "text" as const, text: `${header}\n${content}` }], details, terminate };