@junghanacs/entwurf 0.50.0 → 0.52.0

package/pi/pi-durable/carrier/runtime.js

@@ -1,4 +1,3 @@
-                                                                     
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import {
 	clampThinkingLevel,
@@ -11,15 +10,22 @@ import {
 	                  
 	                    
 	                      
+	                       
 	            
+	             
 	                 
 	               
 	Harness,
 	                          
+	LiveDoc,
 	              
+	            
 	ROOT_CONVERSATION_ID,
 	                
 	               
+	                    
+	                    
+	              
 } from "@earendil-works/pi-durable";
 import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
 import { ModelRuntime } from "entwurf-pi-dist:core/model-runtime.js";
@@ -58,8 +64,19 @@ const context = BACKGROUND_CONTEXT;
 /** Everything the TUI renders. Plain values; no Harness objects cross this boundary. */
                               
 	                                                                                            
-	                                            
+	   
+	                                                                                                                  
+	                                                                                                                     
+	                                                                 
+	   
 	                                        
+	   
+	                                                                                                          
+	                                                                                                               
+	                                                                                                                 
+	        
+	   
+	                                    
 	                                                       
 	                                         
 	                                    
@@ -72,6 +89,11 @@ const context = BACKGROUND_CONTEXT;
 	                                                                                             
 	   
 	                                               
+	   
+	                                                                                                                  
+	                                                                                                 
+	   
+	                                                                               
  
 
                                     
@@ -156,6 +178,32 @@ function causeOf(error         )         {
 	return error instanceof Error ? error.message : String(error);
 }
 
+/** The shown conversation's active transcript and the newest entry ID in it. */
+                 
+	                                         
+	                        
+ 
+
+/** A read's active transcript and the watch attached right after the read. */
+                  
+	                                  
+	                      
+ 
+
+/** The newest entry ID of `entries`; a head marker comes first, so the last entry need not be the newest. */
+function newestOf(entries                        )         {
+	return entries.reduce((newest, entry) => Math.max(newest, entry.id), Number.NEGATIVE_INFINITY);
+}
+
+/** What the TUI renders: the watched documents with the active transcript as items. */
+function transcriptOf(view                  , entries                        )                 {
+	return {
+		conversation: view.conversation,
+		docs: view.docs,
+		items: entries.map((entry) => ({ kind: "entry"         , entry })),
+	};
+}
+
 export async function openDurable(options                    )                             {
 	// The type requires it; a JS caller is refused here, before the session root is created.
 	if (options.fence === undefined) {
@@ -187,8 +235,9 @@ export async function openDurable(options                    )
 		registry.install(Subagent);
 		for (const extension of options.extensions ?? []) registry.install(extension);
 
-		const pendingReports            = [];
-		let report                           = (error) => pendingReports.push(error);
+		// SDK 1.5 hands one tagged `Report` (what happened by `kind`, plus its `error`), not pi 1.4's (error, info).
+		const pendingReports           = [];
+		let report                             = (reported) => pendingReports.push(reported);
 		// Recorded BEFORE the call: once the open is attempted, no later outcome proves that nothing was opened.
 		ticket.storageOpenAttempted = true;
 		const backend = await openNodeSqliteStorage(location.database);
@@ -200,7 +249,7 @@ export async function openDurable(options                    )
 				registry,
 				settings,
 				env: envs.env,
-				onReport: (error) => report(error),
+				onReport: (reported) => report(reported),
 			},
 			context,
 		);
@@ -245,7 +294,23 @@ export async function openDurable(options                    )
 			cursor = page.next;
 		} while (cursor !== undefined);
 		let current               = root;
-		let conversation                                            = await root.viewState(context);
+		// The shown conversation's transcript is pi 1.4's active one (#155 D1). One official read gives the active range
+		// (`Conversation.context().entries`); the watch attached right after it starts at the next entry ID, so what is
+		// committed between the two is its first value. Nothing here derives an active range: when one changes, it is
+		// read again.
+		const seed = async (conversation              )                  => {
+			const read = await conversation.context(context);
+			const newest = newestOf(read.entries);
+			const attached = await conversation.watch(
+				context,
+				Number.isFinite(newest) ? { from: (newest + 1)            } : undefined,
+			);
+			return { watch: attached, shown: { entries: read.entries, newest } };
+		};
+		const first = await seed(root);
+		// The shown watch: the first one until `install` makes it so, then each one a switch or a new read installs.
+		let watch                               ;
+		let shown        = first.shown;
 		const models = ()                 =>
 			modelRuntime.getAvailableSnapshot().map((model) => ({
 				provider: model.provider,
@@ -256,7 +321,8 @@ export async function openDurable(options                    )
 
 		let state              = {
 			session: { id: location.id, directory: location.directory, cwd: location.cwd },
-			conversation: conversation.value,
+			conversation: first.watch.value,
+			transcript: transcriptOf(first.watch.value, shown.entries),
 			conversations: summaries,
 			models: models(),
 			notices: [],
@@ -279,13 +345,16 @@ export async function openDurable(options                    )
 			update({ notices: [...state.notices, { id: nextNotice++, level, message }].slice(-20) });
 		};
 		const fail = (error         )       => notice("error", error instanceof Error ? error.message : String(error));
-		report = (error) => {
-			const message = error instanceof Error ? error.message : String(error);
-			// A failing Session runs its close listeners first and reports the cause right after: that report names it.
-			if (state.failure !== undefined && state.failure.error === undefined) update({ failure: { error: message } });
-			else notice("warning", message);
+		report = (reported) => {
+			// The error the SDK reported, never the Report itself: that would read `[object Object]`.
+			const message = causeOf(reported.error);
+			// A failing Session runs its close listeners first and reports the cause right after, as `storage_failed`:
+			// that report names the failure the close listener recorded.
+			if (reported.kind === "storage_failed" && state.failure !== undefined && state.failure.error === undefined) {
+				update({ failure: { error: message } });
+			} else notice(reported.kind === "storage_failed" ? "error" : "warning", `${reported.kind}: ${message}`);
 		};
-		for (const error of pendingReports) report(error);
+		for (const reported of pendingReports) report(reported);
 		const failedListeners = new Set            ();
 		// The Session closes itself when its Storage fails. Its `closed` settles only after every running task returned,
 		// which a task ignoring its abort can delay without end, so the failure is shown from the close listener itself.
@@ -300,29 +369,124 @@ export async function openDurable(options                    )
 				}
 			}
 		});
-		let unsubscribe = conversation.subscribe((value) => update({ conversation: value }));
-		// Subagents appear as their conversations are created. A commit listener only records; it calls no Session API.
-		const unsubscribeCommits = harness.subscribeCommits((publication) => {
-			let conversations = state.conversations;
-			for (const change of publication.changes) {
-				if (change.type === "conversation") {
-					conversations = [...conversations, { id: change.value.id, label: label(change.value.id) }];
-				} else if (change.type === "entry" && change.value.kind === "pi.user") {
-					const id = change.value.conversationId;
-					conversations = conversations.map((summary) =>
-						summary.id === id && summary.title === undefined ? { ...summary, ...titleOf(change.value) } : summary,
-					);
+		let closing                           ;
+		// A watch that ends by itself while the Session runs leaves its part of the screen frozen: say so rather than look
+		// healthy (#155). Ending at close, at a failure the Session already shows, or by being replaced, is no news.
+		const ended = (part                          , end          )       => {
+			if (closing !== undefined || state.failure !== undefined) return;
+			if (end.kind !== "failed" && end.kind !== "listener_error") return;
+			update({ stalled: { ...state.stalled, [part]: causeOf(end.error) } });
+		};
+		// The watch whose entries wait: its conversation is being read again, or that read failed. A failed read holds
+		// the transcript where it was, said on screen, until a switch installs a new watch; there is no retry.
+		let held                               ;
+		// The shown conversation read again, one read at a time. It is installed only while `trigger` is still the shown
+		// watch: a switch made meanwhile wins, and the late read is dropped (#155 D1).
+		const reseed = (trigger                               )       => {
+			held = trigger;
+			const conversation = current;
+			void seed(conversation).then(
+				(next) => {
+					if (watch !== trigger) {
+						void next.watch.stop();
+						return;
+					}
+					install(conversation, next);
+				},
+				(error) => {
+					// A read refused by the close or the Session's own failure is no news, as `ended` has it.
+					if (watch !== trigger || closing !== undefined || state.failure !== undefined) return;
+					update({ stalled: { ...state.stalled, conversation: causeOf(error) } });
+				},
+			);
+		};
+		// One value of the shown watch. Entries past the newest one shown join the transcript in ID order. A head marker
+		// among them (a compaction or a reset) or a window starting past the newest one shown (it dropped entries the
+		// transcript lacks) is a new active range: read again, nothing appended until it lands.
+		const advance = (view                  )       => {
+			if (held !== undefined && held === watch) {
+				update({ conversation: view });
+				return;
+			}
+			const fresh = view.entries.filter((entry) => entry.id > shown.newest);
+			const restarts = fresh.some((entry) => entry.head !== undefined);
+			const skipped = view.before !== undefined && view.before > shown.newest;
+			if (restarts || skipped) {
+				update({ conversation: view });
+				reseed(watch);
+				return;
+			}
+			// A value without new entries (a document change, such as a streaming answer's progress) leaves the
+			// transcript as it is.
+			if (fresh.length === 0) {
+				update({ conversation: view });
+				return;
+			}
+			shown = { entries: [...shown.entries, ...fresh], newest: newestOf(fresh) };
+			update({ conversation: view, transcript: transcriptOf(view, shown.entries) });
+		};
+		// Every later value of the shown watch; a replaced watch's late frames are dropped.
+		const follow = (handle                   )       => {
+			handle.start(async (call) => {
+				if (handle !== watch) return;
+				if (call.kind === "failed") {
+					notice("warning", `The conversation view could not update: ${causeOf(call.error)}`);
+					return;
 				}
+				advance(call.value);
+			});
+			void handle.closed.then((end) => {
+				if (handle === watch) ended("conversation", end);
+			});
+		};
+		// Show `conversation` from a read: its active entries, then the watch's first value, which holds what was
+		// committed between the read and the attach and is taken exactly once here, then the watch's later values.
+		const install = (conversation              , next        )       => {
+			// The close and the Session's own failure end what is shown, as a switch does: a read landing after either
+			// is let go, its watch stopped (the Session may already have ended it), and nothing is patched or started.
+			if (closing !== undefined || state.failure !== undefined) {
+				void next.watch.stop();
+				return;
 			}
-			if (conversations !== state.conversations) update({ conversations });
+			const previous = watch;
+			current = conversation;
+			watch = next.watch;
+			shown = next.shown;
+			void previous?.stop();
+			// A new watch replaces a stalled one; the task graph's state is its own.
+			const stalled = state.stalled?.tasks === undefined ? undefined : { tasks: state.stalled.tasks };
+			update({ conversation: next.watch.value, transcript: transcriptOf(next.watch.value, shown.entries), stalled });
+			advance(next.watch.value);
+			follow(next.watch);
+		};
+		install(root, first);
+		// Subagents appear as their conversations are created. A commit observer only records; it calls no Session API.
+		// Its end decides nothing: SDK 1.5 ends it `failed` ("session closed") at a normal close as well (#155).
+		const commits = harness.observeCommits({
+			advance: (publication) => {
+				let conversations = state.conversations;
+				for (const change of publication.changes) {
+					if (change.type === "conversation") {
+						conversations = [...conversations, { id: change.value.id, label: label(change.value.id) }];
+					} else if (change.type === "entry" && change.value.kind === "pi.user") {
+						const id = change.value.conversationId;
+						conversations = conversations.map((summary) =>
+							summary.id === id && summary.title === undefined
+								? { ...summary, ...titleOf(change.value) }
+								: summary,
+						);
+					}
+				}
+				if (conversations !== state.conversations) update({ conversations });
+			},
+			end: () => {},
 		});
 
-		let tasks                                                ;
-		let unsubscribeTasks = ()       => {};
+		let tasks                            ;
 		const closeTasks = ()       => {
-			unsubscribeTasks();
-			tasks?.dispose();
+			const graph = tasks;
 			tasks = undefined;
+			void graph?.stop();
 		};
 
 		let queue = Promise.resolve();
@@ -331,15 +495,21 @@ export async function openDurable(options                    )
 			queue = queue.then(operation).catch(fail);
 			return queue;
 		};
-		const watchAnswer = (submission            )       => {
-			void submission.wait(context).then((settled) => {
-				if (settled.status === "unanswered" && settled.reason !== "aborted") {
+		// A run that ended without an answer stays on screen as its conversation's `pi.live.runFailure` (SDK 1.5), so an
+		// input that run settled adds no notice of its own; one settled without such a run (stale, say) still does.
+		const watchAnswer = (submission            , conversation              )       => {
+			void submission
+				.wait(context)
+				.then(async (settled) => {
+					if (settled.status !== "unanswered" || settled.reason === "aborted") return;
+					const live = await opened.snapshot(LiveDoc, conversation.id, context);
+					if (live?.runFailure?.inputs.includes(submission.id)) return;
 					notice(
 						"error",
 						`No answer: ${settled.reason}${settled.detail === undefined ? "" : ` ${JSON.stringify(settled.detail)}`}`,
 					);
-				}
-			}, fail);
+				})
+				.catch(fail);
 		};
 		const agentModel = () => {
 			const ref = agentOf(state.conversation).model;
@@ -354,7 +524,8 @@ export async function openDurable(options                    )
 					if (state.failure !== undefined) {
 						throw new Error("The session failed and takes no input. Close it, then reopen it with --continue.");
 					}
-					watchAnswer(await current.submit({ type: "input", content: text, whenBusy }, context));
+					const target = current;
+					watchAnswer(await target.submit({ type: "input", content: text, whenBusy }, context), target);
 				}),
 			compact: (instructions) =>
 				command(async () => {
@@ -408,12 +579,8 @@ export async function openDurable(options                    )
 				command(async () => {
 					const next = await opened.conversation(id, context);
 					if (next === undefined) throw new Error(`Conversation ${id} does not exist`);
-					const nextState = await next.viewState(context);
-					unsubscribe();
-					conversation.dispose();
-					current = next;
-					conversation = nextState;
-					unsubscribe = nextState.subscribe((value) => update({ conversation: value }));
+					// The same read as the open: the whole active transcript, whatever this process showed of it before.
+					install(next, await seed(next));
 				}),
 		};
 
@@ -424,14 +591,17 @@ export async function openDurable(options                    )
 		}
 		if (initial?.fallbackMessage !== undefined) notice("info", initial.fallbackMessage);
 		// The task graph is observed until close; its panel starts open and /tasks hides it.
-		const graph = await opened.taskGraph(context);
+		const graph = await opened.watchTaskGraph(context);
 		tasks = graph;
 		update({ tasks: graph.value });
-		unsubscribeTasks = graph.subscribe((value) => update({ tasks: value }));
+		graph.start(async (call) => {
+			if (call.kind === "value") update({ tasks: call.value });
+			else notice("warning", `The task graph could not update: ${causeOf(call.error)}`);
+		});
+		void graph.closed.then((end) => ended("tasks", end));
 		// Recovered work from an interrupted turn continues now.
 		harness.resume();
 
-		let closing                           ;
 		return {
 			view: {
 				current: () => state,
@@ -460,9 +630,8 @@ export async function openDurable(options                    )
 				closing ??= (async () => {
 					// First: the Session runs its close listeners inside its own close call.
 					unsubscribeClose();
-					unsubscribe();
-					unsubscribeCommits();
-					conversation.dispose();
+					void watch?.stop();
+					commits.detach();
 					closeTasks();
 					// The resource end the fence records (#157 B3). Storage is `closed` only when the first actual close
 					// resolved, no failure was seen before it, and the Session's own terminal result is not `failed`.
@@ -473,8 +642,10 @@ export async function openDurable(options                    )
 					try {
 						// Close writes no outcome: a running turn resumes with --continue.
 						await opened.close(context);
-						const ended = await opened.closed;
-						if (state.failure === undefined && ended.reason !== "failed") storage = "closed";
+						// SDK 1.5 tells the end by `kind`; pi 1.4's `reason` is absent there, and a type-stripped carrier would
+						// read it as undefined and call every end closed (#155).
+						const end = await opened.closed;
+						if (state.failure === undefined && end.kind !== "failed") storage = "closed";
 						try {
 							await envs.cleanup(context);
 						} catch (error) {

package/pi/pi-durable/carrier/subagent.js

@@ -1,5 +1,5 @@
-                                                     
-import {                        Type } from "@earendil-works/pi-ai";
+                                                             
+                                                              
 import {
 	AssistantEntry,
 	configure,
@@ -10,6 +10,7 @@ import {
 	                      
 	                         
 } from "@earendil-works/pi-durable";
+import { obj, str } from "@earendil-works/pi-schema";
 
 async function answerText(api                  , answer         , context         )                  {
 	const entry = await api.commit((tx) => tx.entry(AssistantEntry, answer), context);
@@ -29,7 +30,9 @@ export const Subagent            = defineExtension({
 			name: "subagent",
 			description:
 				"Delegate a self-contained task to a subagent with the same tools and get its answer back. Give it everything it needs to know; it does not see this conversation.",
-			parameters: Type.Object({ task: Type.String({ description: "What the subagent should do" }) }),
+			// pi-ai 1.5 no longer exports TypeBox's `Type`; pi-schema builds the same JSON Schema. `open` keeps the input
+			// as open as the TypeBox object was, since `obj()` alone closes it (SDK 1.5's own tools do the same, #155).
+			parameters: obj({ task: str({ description: "What the subagent should do" }) }, { open: true }),
 			// A rerun after a crash finds the child it created and the submission it made.
 			replay: "safe",
 			execute: async (args, api, context) => {

package/pi/pi-durable/carrier/tui.js

@@ -6,6 +6,7 @@
 	          
 	          
 	              
+	               
 	           
                                     
 import {
@@ -176,8 +177,9 @@ class CompactionComponent extends Box {
  
 
 /**
- * The lines above the editor: first what stays true for as long as it is true, the session's failure and the
- * compaction failure a conversation keeps until a compaction produces a summary, then the latest notices.
+ * The lines above the editor: first what stays true for as long as it is true, the session's failure, the
+ * compaction failure a conversation keeps until a compaction produces a summary, the run that ended without an
+ * answer until another run starts, and a view that stopped updating; then the latest notices.
  */
 export function durableNotices(view             )                                               {
 	const lines                                      = [];
@@ -188,9 +190,22 @@ export function durableNotices(view             )
 			message: `Session failed${cause}. It takes no more input, and a tool still running may take a while to stop. Close this session, then reopen it with --continue.`,
 		});
 	}
-	const compaction = ((view.conversation.docs["pi.live"] ?? {})             ).compactionFailure;
+	const live = (view.conversation.docs["pi.live"] ?? {})             ;
+	const compaction = live.compactionFailure;
 	if (compaction !== undefined) {
-		lines.push({ level: "error", message: `Compaction failed (${compaction.reason}): ${compaction.error}` });
+		lines.push({ level: "error", message: `Compaction failed (${compaction.trigger}): ${compaction.error}` });
+	}
+	// SDK 1.5 keeps why the newest run ended without an answer. An aborted run is the user's own stop, as before:
+	// the answer it cut off already says so.
+	const run = live.runFailure;
+	if (run !== undefined && run.reason !== "aborted") {
+		const detail = run.detail === undefined ? "" : ` (${run.detail})`;
+		lines.push({ level: "error", message: `No answer: ${run.reason}${detail}` });
+	}
+	for (const [part, error] of Object.entries(view.stalled ?? {})) {
+		if (error === undefined) continue;
+		const what = part === "tasks" ? "The task panel" : "The conversation";
+		lines.push({ level: "error", message: `${what} stopped updating: ${error}` });
 	}
 	return [...lines, ...view.notices.slice(-4)];
 }
@@ -289,7 +304,8 @@ class DurableTui {
 	         #summaries                        = [];
 	/** Tool output and summaries shown in full; toggled like pi. */
 	#expanded = false;
-	#renderedEntryIds           = [];
+	/** One key per transcript item on screen, in order (`keyOf`). */
+	#renderedKeys           = [];
 	#streaming                                       ;
 	#indicator                             ;
 	#statusText = "";
@@ -391,10 +407,11 @@ class DurableTui {
 
 	apply(view             )       {
 		const live = (view.conversation.docs["pi.live"] ?? {})             ;
-		this.#syncTranscript(view.conversation.entries);
+		// The active transcript, not the window: every entry of the active range, head marker first (#155 D1).
+		this.#syncTranscript(view.transcript.items);
 		const message = live.generation?.message                                ;
 		// A partial without its entry was dropped, for example by a retry: render the transcript again.
-		if (message === undefined && this.#streaming !== undefined) this.#rebuild(view.conversation.entries);
+		if (message === undefined && this.#streaming !== undefined) this.#rebuild(view.transcript.items);
 		if (message !== undefined) this.#syncStreaming(message);
 		for (const slot of live.tools ?? []) {
 			if (slot.status === "pending") continue;
@@ -476,8 +493,8 @@ class DurableTui {
 		} else if (generation?.deferred !== undefined) text = "Waiting for deferred response...";
 		else if (compaction !== undefined) {
 			text = compaction.retry
-				? `Retrying ${compaction.reason} compaction (attempt ${compaction.attempt + 1})...`
-				: `Compacting (${compaction.reason})...`;
+				? `Retrying ${compaction.trigger} compaction (attempt ${compaction.attempt + 1})...`
+				: `Compacting (${compaction.trigger})...`;
 		} else if (runningTool !== undefined) text = `Running ${runningTool.name}... (esc to abort)`;
 		else if (live.run !== undefined) text = "Working... (esc to abort)";
 		if (text === this.#statusText) return;
@@ -502,7 +519,7 @@ class DurableTui {
 			view.models.find((model) => model.provider === agent.model?.provider && model.modelId === agent.model.modelId)
 				?.contextWindow ?? 0;
 		if (contextWindow > 0) {
-			const tokens = contextTokens(view.conversation.entries);
+			const tokens = contextTokens(entriesOf(view.transcript.items));
 			const percent = tokens === undefined ? undefined : (tokens / contextWindow) * 100;
 			const text = `${percent === undefined ? "?" : percent.toFixed(1)}%/${formatTokens(contextWindow)}`;
 			stats.push(percent !== undefined && percent > 90 ? theme.fg("error", text) : text);
@@ -519,28 +536,38 @@ class DurableTui {
 		);
 	}
 
-	#syncTranscript(entries                        )       {
-		// Compaction and resets replace the head of the active transcript.
-		if (this.#renderedEntryIds.some((id, index) => entries[index]?.id !== id)) this.#rebuild(entries);
-		for (const entry of entries.slice(this.#renderedEntryIds.length)) {
-			this.#addEntry(entry);
-			this.#renderedEntryIds.push(entry.id);
+	#syncTranscript(items                           )       {
+		// The transcript grows at its end. A compaction or reset starts a new active range, its head marker first,
+		// which replaces what came before (#155 D1).
+		const keys = items.map(keyOf);
+		if (this.#renderedKeys.some((key, index) => keys[index] !== key)) this.#rebuild(items);
+		for (const item of items.slice(this.#renderedKeys.length)) {
+			this.#addItem(item);
+			this.#renderedKeys.push(keyOf(item));
 		}
 	}
 
-	#rebuild(entries                        )       {
+	#rebuild(items                           )       {
 		this.#chat.clear();
 		this.#discardTools();
 		this.#summaries.length = 0;
 		this.#rebuilt = true;
-		this.#renderedEntryIds = [];
+		this.#renderedKeys = [];
 		this.#streaming = undefined;
-		for (const entry of entries) {
-			this.#addEntry(entry);
-			this.#renderedEntryIds.push(entry.id);
+		for (const item of items) {
+			this.#addItem(item);
+			this.#renderedKeys.push(keyOf(item));
 		}
 	}
 
+	#addItem(item                )       {
+		if (item.kind === "entry") this.#addEntry(item.entry);
+		// The runtime's active transcript holds entries only; these two placeholders are the SDK item type's other kinds
+		// (#156 owns any load-more input).
+		else if (item.kind === "earlier") this.#addText("[earlier entries not shown]");
+		else this.#addText("[missing entries, loading...]");
+	}
+
 	#addEntry(entry             )       {
 		const message = entry.model?.[0];
 		if (entry.kind === "pi.user" && message?.role === "user") {
@@ -676,9 +703,20 @@ function totalUsage(state            )        {
 	return total;
 }
 
+/** The entries of transcript items, in ID order. */
+function entriesOf(items                           )                {
+	return items.flatMap((item) => (item.kind === "entry" ? [item.entry] : []));
+}
+
+/** What was rendered for an item stays valid while the same key stays in the same place. */
+function keyOf(item                )         {
+	if (item.kind === "entry") return `entry:${item.entry.id}`;
+	return item.kind === "gap" ? `gap:${item.after}:${item.upTo}` : "earlier";
+}
+
 /** Context size from the newest successful answer after the newest compaction; unknown before one. */
 function contextTokens(entries                        )                     {
-	// Kept entries follow the summary in the view but are older than it; only later answers measure the new context.
+	// Entries a summary keeps and those it replaced are older than it; only later answers measure the new context.
 	const compacted = Math.max(0, ...entries.filter((entry) => entry.kind === "pi.compaction").map((entry) => entry.id));
 	for (const entry of [...entries].reverse()) {
 		const message = entry.model?.[0];