zidane-ui 9.1.13 → 9.1.14

package/dist/chat/headless/streams/store.js

@@ -3,9 +3,11 @@ import { inheritRowIdentity } from "../transcript/collapse.js";
 import { mergeLiveTail } from "./merge.js";
 import { mergePromptPreviews, missingPreviewData } from "./prompt-previews.js";
 import { defaultFrameScheduler } from "./scheduler.js";
-import { discardThinking, finalizeStreamingMarkdownForOwner, reconcileEvents, retagUserPromptEventsFromRefs } from "zidane/chat/pure";
+import { applyHistoryOp, applyHistorySince, discardThinking, finalizeStreamingMarkdownForOwner, readFreshness, reconcileEvents } from "zidane/chat/pure";
 //#region src/chat/headless/streams/store.ts
 const PARENT_OWNER = "parent";
+/** Numberings a window remembers leaving (`_retiredHistoryIds`). */
+const RETIRED_HISTORY_IDS = 8;
 /**
 * Module-level stable empty array — returned by `getEventsSnapshot` when
 * the session has no entry yet. Keeping this reference identical across
@@ -13,12 +15,39 @@ const PARENT_OWNER = "parent";
 * consumer mounts before its session hydrates.
 */
 const EMPTY_EVENTS = Object.freeze([]);
+/**
+* Finds the pending entry an echo answers. It is the entry with the echo's
+* message id (its `clientMessageId`, else `origin.messageId`). Else it is
+* the first entry with the echo's text and no message id of its own. If the
+* echo carries no message id, the first entry with its text matches. Returns
+* -1 for a genuine remote send.
+*/
+function pendingEchoIndex(pending, echo) {
+	const messageId = echo.clientMessageId ?? echo.origin?.messageId;
+	if (messageId !== void 0) {
+		const byId = pending.findIndex((p) => p.clientMessageId === messageId);
+		if (byId !== -1) return byId;
+		return pending.findIndex((p) => p.clientMessageId === void 0 && p.text === echo.text);
+	}
+	return pending.findIndex((p) => p.text === echo.text);
+}
 /** Page-state snapshot for a session with no hydrated page — stable identity. */
 const NO_PAGE = Object.freeze({
 	firstSeq: 0,
 	hasMore: false,
 	loadingEarlier: false
 });
+/** Builds a window's page state from a page it took. It holds the cursor and the history position of the cursor (the page's, else `fallback`). */
+function pageState(page, loadingEarlier, fallback) {
+	const at = page.pos !== void 0 ? page : fallback;
+	return {
+		firstSeq: page.firstSeq,
+		hasMore: page.hasMore,
+		loadingEarlier,
+		...at?.pos !== void 0 ? { pos: at.pos } : {},
+		...at?.pos !== void 0 && at.historyId !== void 0 ? { historyId: at.historyId } : {}
+	};
+}
 /**
 * Markdown merge options by default. No 64 KB segmenting: a reloaded
 * transcript shows each message whole (the renderer chunks long text
@@ -95,15 +124,17 @@ var SessionStreamStore = class {
 	_runSeq = /* @__PURE__ */ new Map();
 	_pages = /* @__PURE__ */ new Map();
 	/**
-	* Texts of user prompts THIS window appended optimistically that still
-	* await their host echo. The host stamps `echo: true` on the broadcast
-	* of the sender's own prompt (send / steer paths) for EVERY peer — it
-	* cannot know which window originated the send — so the dedupe lives
-	* here: one pending entry consumes one echo (keeping the local copy,
-	* which carries refs + attachments the canonical event doesn't).
+	* User prompts THIS window appended optimistically that still await their
+	* host echo. The host stamps `echo: true` on the broadcast of the sender's
+	* own prompt (send / steer paths) for EVERY peer. It cannot know which
+	* window sent the prompt, so the dedupe lives here. One pending entry
+	* consumes one echo and keeps the local copy, which carries refs and
+	* attachments that the canonical event does not.
 	* Echo-tagged prompts with NO pending match are genuine remote sends
 	* (another window, a daemon-drained queued prompt) and must render.
-	* Leftovers (failed sends) are cleared at `run:end`.
+	* The echo matches by the sender's message id when both carry one, else
+	* by text, and gives the local row its turn id. Leftovers (failed sends)
+	* are cleared at `run:end`.
 	*/
 	_pendingEcho = /* @__PURE__ */ new Map();
 	/**
@@ -111,6 +142,39 @@ var SessionStreamStore = class {
 	* the prompt shows up in the transcript (see `prompt-previews.ts`).
 	*/
 	_promptPreviews = /* @__PURE__ */ new Map();
+	/** The history position each window applied last (`applyHistory`). It is the window's bookmark in the session's history. */
+	_historyPos = /* @__PURE__ */ new Map();
+	/** The numbering of each window's `_historyPos` (`HistoryPosition.historyId`), when known. */
+	_historyId = /* @__PURE__ */ new Map();
+	/** Windows to fetch again when their run ends (`takeRefetchDue`, `markRefetchDue`). */
+	_refetchDue = /* @__PURE__ */ new Set();
+	/**
+	* Windows whose rows are behind their history position. A write asked for a
+	* tail read that has not landed yet (in flight, failed, or waiting for the
+	* run's end). The position stays the newest write seen, so a read older than
+	* it is stale. But it is not a bookmark. The reconnect ladder reads the tail,
+	* and a later write also reads the tail instead of applying in place.
+	*/
+	_tailDue = /* @__PURE__ */ new Set();
+	/** Per window, the numberings it left for another numbering. A read in one of them is older than the window. */
+	_retiredHistoryIds = /* @__PURE__ */ new Map();
+	/**
+	* Windows that saw their current run start (`run:start`, live or replayed).
+	* If a run ends in a hydrated window that never saw it start, the window
+	* missed the run's first rows. This happens after a drop that main could not
+	* replay, or when the window opened mid-run. The rows it read meanwhile also
+	* sit below the rows it streamed since. So it reads its tail at the run's
+	* end (`takeRefetchDue`).
+	*/
+	_runStarted = /* @__PURE__ */ new Set();
+	/**
+	* Windows that streamed rows since their last run boundary (a run's start or
+	* end, a page read). With `_running`, it tells a run whose start went by
+	* apart from a send that the host refused before it started. A refused send
+	* streams nothing, and its error row lives only in this store. Reading the
+	* tail drops that row.
+	*/
+	_runActivity = /* @__PURE__ */ new Set();
 	_listenersBySession = /* @__PURE__ */ new Map();
 	_listenersForHas = /* @__PURE__ */ new Set();
 	/**
@@ -242,27 +306,178 @@ var SessionStreamStore = class {
 		return this._pages.get(sessionId) ?? NO_PAGE;
 	}
 	/**
-	* Hydrate one replay page as the session's full window — the
-	* `loadEvents` (tail page) path. One notify covers both the events
-	* swap and the page-state swap.
+	* Hydrate one replay page as the session's full window (the
+	* `loadEvents` tail page path). One notify covers both the events
+	* swap and the page-state swap. Returns `false` and changes nothing
+	* when the page is older than a write the window applied since.
 	*
 	* @param sessionId - The session.
 	* @param page - The persisted page.
 	*/
 	setEventsPage(sessionId, page) {
+		if (this._freshness(sessionId, page) === "stale") return false;
+		if (page.pos !== void 0) this._setHistoryPos(sessionId, page.pos, page.historyId);
+		this._tailDue.delete(sessionId);
 		const had = this._events.has(sessionId);
 		const wasHydrated = this._pages.has(sessionId);
 		const prior = this._events.get(sessionId) ?? [];
-		const next = wasHydrated ? reconcileEvents(prior, page.events) : mergeLiveTail(prior, page.events);
+		const next = wasHydrated ? reconcileEvents(prior, page.events) : mergeLiveTail(this._withoutSavedLocalPrompts(sessionId, prior, page.events), page.events);
 		inheritRowIdentity(prior, next);
 		this._events.set(sessionId, next);
-		this._pages.set(sessionId, {
-			firstSeq: page.firstSeq,
-			hasMore: page.hasMore,
-			loadingEarlier: false
-		});
+		this._pages.set(sessionId, pageState(page, false));
+		this._runActivity.delete(sessionId);
 		this._notifySession(sessionId);
 		if (!had || !wasHydrated) this._notifyHas();
+		return true;
+	}
+	/**
+	* Applies one history write (`history:changed`) to the session's window.
+	* It uses the shared rule (`applyHistoryOp`, `zidane/chat/pure`). A
+	* streamed append changes nothing. An append that never streamed adds the
+	* rows it carries. A rewrite or a missed write asks for a fetch.
+	*
+	* Returns `true` when the caller must fetch the session's tail now and
+	* replace the window with it (`setEventsPage`). A window whose run streams
+	* fetches at the run's end instead (`takeRefetchDue`), and a window never
+	* hydrated is left to its first read.
+	*
+	* @param sessionId - The session.
+	* @param change - The write, as the signal carries it.
+	*/
+	applyHistory(sessionId, change) {
+		const events = this._events.get(sessionId) ?? [];
+		const context = this._historyContext(sessionId);
+		const result = applyHistoryOp(events, change, context);
+		return this._applyHistoryResult(sessionId, events, result, context);
+	}
+	/**
+	* Applies a shared history rule's answer to the window. Its position moves
+	* first. Then its rows change, or it asks for a tail read. It returns `true`
+	* for a read now. While the run streams, the read waits for the run's end.
+	* A window whose rows are behind (`_tailDue`) reads its tail on any write
+	* that moves it. It does not apply the write to rows that miss the earlier one.
+	*/
+	_applyHistoryResult(sessionId, events, result, context) {
+		this._setHistoryPos(sessionId, result.pos, result.historyId);
+		if (!this._pages.has(sessionId)) return false;
+		const moved = result.pos !== context.pos || result.historyId !== context.historyId;
+		if ("refetch" in result || moved && this._tailDue.has(sessionId)) {
+			this._tailDue.add(sessionId);
+			if (!this._running.get(sessionId)) return true;
+			this._refetchDue.add(sessionId);
+			return false;
+		}
+		if (result.rows !== events) {
+			this._events.set(sessionId, result.rows);
+			this._notifySession(sessionId);
+		}
+		return false;
+	}
+	/**
+	* Applies the reconnect ladder's second step to the session's window. That
+	* step brings the rows of the turns appended after its position
+	* (`sessions.historySince`, the shared `applyHistorySince`). Returns `true`
+	* when the caller must fetch the tail now (as {@link applyHistory} does).
+	*
+	* @param sessionId - The session.
+	* @param since - The rows and the position they bring the window to.
+	*/
+	applyHistorySince(sessionId, since) {
+		const events = this._events.get(sessionId) ?? [];
+		const context = this._historyContext(sessionId);
+		const result = applyHistorySince(events, since, context);
+		return this._applyHistoryResult(sessionId, events, result, context);
+	}
+	/**
+	* Moves the window to `pos` after an adapter's own hydrate replaced it with
+	* a tail read at `pos`. Returns `stale` if the read is older than a write
+	* the window applied since. The adapter then reads it again.
+	*
+	* @param sessionId - The session.
+	* @param pos - The read's position, when the host named one.
+	* @param historyId - The numbering `pos` counts in, when the host named one.
+	*/
+	adoptHistoryPos(sessionId, pos, historyId) {
+		const read = {
+			...pos !== void 0 ? { pos } : {},
+			...historyId !== void 0 ? { historyId } : {}
+		};
+		if (this._freshness(sessionId, read) === "stale") return "stale";
+		if (pos !== void 0) this._setHistoryPos(sessionId, pos, historyId);
+		this._tailDue.delete(sessionId);
+		return "fresh";
+	}
+	/** `readFreshness` against what the window applied, and the numberings it left. */
+	_freshness(sessionId, read) {
+		return readFreshness(read, this._historyPos.get(sessionId), this._historyId.get(sessionId), this._retiredHistoryIds.get(sessionId));
+	}
+	/** What the window applied last, for the shared history rules. */
+	_historyContext(sessionId) {
+		const pos = this._historyPos.get(sessionId);
+		const historyId = this._historyId.get(sessionId);
+		return {
+			...pos !== void 0 ? { pos } : {},
+			...historyId !== void 0 ? { historyId } : {}
+		};
+	}
+	/** Sets the window at `pos` of numbering `historyId`. If the numbering is unknown, none is kept. */
+	_setHistoryPos(sessionId, pos, historyId) {
+		this._historyPos.set(sessionId, pos);
+		const left = this._historyId.get(sessionId);
+		if (left !== void 0 && historyId !== void 0 && historyId !== left) {
+			const retired = this._retiredHistoryIds.get(sessionId) ?? /* @__PURE__ */ new Set();
+			retired.delete(historyId);
+			retired.add(left);
+			if (retired.size > RETIRED_HISTORY_IDS) retired.delete(retired.values().next().value);
+			this._retiredHistoryIds.set(sessionId, retired);
+		}
+		if (historyId !== void 0) this._historyId.set(sessionId, historyId);
+		else this._historyId.delete(sessionId);
+	}
+	/**
+	* Whether the session's window must be fetched again now that its run ended
+	* (see `applyHistory`, `markRefetchDue`). Clears the flag.
+	*
+	* @param sessionId - The session.
+	*/
+	takeRefetchDue(sessionId) {
+		if (this._running.get(sessionId)) return false;
+		return this._refetchDue.delete(sessionId);
+	}
+	/**
+	* Asks for the session's window to be read again at its run's end (`takeRefetchDue`). It is for a read dropped
+	* because a run streamed when it came back, or for a read that kept coming back older than the window.
+	*
+	* @param sessionId - The session.
+	*/
+	markRefetchDue(sessionId) {
+		this._refetchDue.add(sessionId);
+	}
+	/**
+	* Whether the session's rows are behind its history position. This is so
+	* when a write asked for a tail read that has not landed (in flight, failed,
+	* or waiting for the run's end). The reconnect ladder then reads the tail.
+	*
+	* @param sessionId - The session.
+	*/
+	isTailDue(sessionId) {
+		return this._tailDue.has(sessionId);
+	}
+	/**
+	* The history position the session's window applied last. It is `undefined` before its first `history:changed` or positioned page.
+	*
+	* @param sessionId - The session.
+	*/
+	getHistoryPosSnapshot(sessionId) {
+		return this._historyPos.get(sessionId);
+	}
+	/**
+	* The numbering of {@link getHistoryPosSnapshot}'s position, when known.
+	*
+	* @param sessionId - The session.
+	*/
+	getHistoryIdSnapshot(sessionId) {
+		return this._historyId.get(sessionId);
 	}
 	/**
 	* Splice an OLDER page in front of the hydrated window (lazy scrollback).
@@ -274,11 +489,7 @@ var SessionStreamStore = class {
 		const existing = this._events.get(sessionId) ?? [];
 		const wasHydrated = this._pages.has(sessionId);
 		this._events.set(sessionId, [...page.events, ...existing]);
-		this._pages.set(sessionId, {
-			firstSeq: page.firstSeq,
-			hasMore: page.hasMore,
-			loadingEarlier: false
-		});
+		this._pages.set(sessionId, pageState(page, false, this._pages.get(sessionId)));
 		this._notifySession(sessionId);
 		if (!wasHydrated) this._notifyHas();
 	}
@@ -356,6 +567,13 @@ var SessionStreamStore = class {
 		this._retry.clear();
 		this._systemMd.clear();
 		this._pages.clear();
+		this._historyPos.clear();
+		this._historyId.clear();
+		this._refetchDue.clear();
+		this._tailDue.clear();
+		this._retiredHistoryIds.clear();
+		this._runStarted.clear();
+		this._runActivity.clear();
 		this._pendingEcho.clear();
 		for (const sessionId of sessionIds) this._notifySession(sessionId);
 		if (had) this._notifyHas();
@@ -374,6 +592,13 @@ var SessionStreamStore = class {
 		this._retry.delete(sessionId);
 		this._systemMd.delete(sessionId);
 		this._pages.delete(sessionId);
+		this._historyPos.delete(sessionId);
+		this._historyId.delete(sessionId);
+		this._refetchDue.delete(sessionId);
+		this._tailDue.delete(sessionId);
+		this._retiredHistoryIds.delete(sessionId);
+		this._runStarted.delete(sessionId);
+		this._runActivity.delete(sessionId);
 		this._notifySession(sessionId);
 		if (!had || wasHydrated) this._notifyHas();
 	}
@@ -403,6 +628,13 @@ var SessionStreamStore = class {
 			this._fallback.delete(sessionId);
 			this._retry.delete(sessionId);
 			this._pages.delete(sessionId);
+			this._historyPos.delete(sessionId);
+			this._historyId.delete(sessionId);
+			this._refetchDue.delete(sessionId);
+			this._tailDue.delete(sessionId);
+			this._retiredHistoryIds.delete(sessionId);
+			this._runStarted.delete(sessionId);
+			this._runActivity.delete(sessionId);
 			this._notifySession(sessionId);
 			dropped = true;
 		}
@@ -425,6 +657,13 @@ var SessionStreamStore = class {
 		this._pages.delete(sessionId);
 		this._pendingEcho.delete(sessionId);
 		this._promptPreviews.delete(sessionId);
+		this._historyPos.delete(sessionId);
+		this._historyId.delete(sessionId);
+		this._refetchDue.delete(sessionId);
+		this._tailDue.delete(sessionId);
+		this._retiredHistoryIds.delete(sessionId);
+		this._runStarted.delete(sessionId);
+		this._runActivity.delete(sessionId);
 		if (had) {
 			this._notifySession(sessionId);
 			this._notifyHas();
@@ -493,8 +732,9 @@ var SessionStreamStore = class {
 	* @param text - The prompt text.
 	* @param refs - The completions the prompt used (skills, files), for its chips.
 	* @param rawAttachments - The prompt's attachments. Omitted for a pushed queued prompt, which takes the previews this client remembered for it.
+	* @param clientMessageId - The id the send gave the message (`SendOptions.clientMessageId`). The store matches the echo by it.
 	*/
-	appendUserPrompt(sessionId, text, refs, rawAttachments) {
+	appendUserPrompt(sessionId, text, refs, rawAttachments, clientMessageId) {
 		const had = this._events.has(sessionId);
 		const events = this._events.get(sessionId)?.slice() ?? [];
 		const attachments = rawAttachments === void 0 || missingPreviewData(rawAttachments) ? mergePromptPreviews(rawAttachments, this.takePromptPreviews(sessionId, text)) : rawAttachments;
@@ -506,7 +746,11 @@ var SessionStreamStore = class {
 		};
 		events.push(event);
 		const pending = this._pendingEcho.get(sessionId) ?? [];
-		pending.push(text);
+		pending.push({
+			text,
+			...clientMessageId !== void 0 ? { clientMessageId } : {},
+			event
+		});
 		this._pendingEcho.set(sessionId, pending);
 		this._events.set(sessionId, events);
 		this._notifySession(sessionId);
@@ -522,7 +766,7 @@ var SessionStreamStore = class {
 	*/
 	dropPendingEcho(sessionId, text) {
 		const pending = this._pendingEcho.get(sessionId);
-		const index = pending?.indexOf(text) ?? -1;
+		const index = pending?.findIndex((p) => p.text === text) ?? -1;
 		if (pending && index !== -1) pending.splice(index, 1);
 	}
 	/**
@@ -592,6 +836,8 @@ var SessionStreamStore = class {
 					this._notifyHas();
 				}
 				this._running.set(signal.sessionId, true);
+				this._runStarted.add(signal.sessionId);
+				this._runActivity.delete(signal.sessionId);
 				this._runSeq.set(signal.sessionId, (this._runSeq.get(signal.sessionId) ?? 0) + 1);
 				this._fallback.delete(signal.sessionId);
 				this._notifySession(signal.sessionId);
@@ -606,8 +852,12 @@ var SessionStreamStore = class {
 					...signal.detail ? { detail: signal.detail } : {}
 				}];
 				const had = this._events.has(signal.sessionId);
+				const wasRunning = this._running.get(signal.sessionId) === true;
 				this._events.set(signal.sessionId, next);
 				this._running.set(signal.sessionId, false);
+				const sawStart = this._runStarted.delete(signal.sessionId);
+				const streamed = this._runActivity.delete(signal.sessionId);
+				if (!sawStart && (wasRunning || streamed) && this._pages.has(signal.sessionId)) this._refetchDue.add(signal.sessionId);
 				this._retry.delete(signal.sessionId);
 				this._pendingEcho.delete(signal.sessionId);
 				this._notifySession(signal.sessionId);
@@ -624,11 +874,13 @@ var SessionStreamStore = class {
 				return;
 			}
 			case "event": {
+				if (signal.event.kind === "separator" && signal.echo && this._separateLocalPrompt(signal.sessionId)) return;
 				if (signal.event.kind === "user-prompt" && signal.echo) {
 					const pending = this._pendingEcho.get(signal.sessionId);
-					const index = pending?.indexOf(signal.event.text) ?? -1;
+					const index = pending ? pendingEchoIndex(pending, signal.event) : -1;
 					if (pending && index !== -1) {
-						pending.splice(index, 1);
+						const [local] = pending.splice(index, 1);
+						if (signal.event.turnId !== void 0) this._bindLocalPrompt(signal.sessionId, local.event, signal.event.turnId);
 						return;
 					}
 				}
@@ -643,6 +895,7 @@ var SessionStreamStore = class {
 				const had = this._events.has(signal.sessionId);
 				const prior = this._events.get(signal.sessionId) ?? [];
 				this._events.set(signal.sessionId, this._append(prior, event));
+				this._runActivity.add(signal.sessionId);
 				if (this._batch) this._notifySoon(signal.sessionId);
 				else this._notifySession(signal.sessionId);
 				if (!had) this._notifyHas();
@@ -662,17 +915,6 @@ var SessionStreamStore = class {
 				if (signal.discardTurnId) this._discardThinking(signal.sessionId, signal.source, signal.discardTurnId);
 				this._notifySession(signal.sessionId);
 				return;
-			case "prompt-turns": {
-				const events = this._events.get(signal.sessionId);
-				if (!events || events.length === 0) return;
-				const next = retagUserPromptEventsFromRefs(events, signal.refs);
-				if (next !== events) {
-					inheritRowIdentity(events, next);
-					this._events.set(signal.sessionId, next);
-					this._notifySession(signal.sessionId);
-				}
-				return;
-			}
 			case "stream:retry:cleared":
 				if (this._retry.get(signal.sessionId)?.source === signal.source) {
 					this._retry.delete(signal.sessionId);
@@ -742,6 +984,60 @@ var SessionStreamStore = class {
 		this._pendingNotify.clear();
 		for (const id of ids) this._notifySession(id);
 	}
+	/**
+	* Returns `live` without the prompts that this client appended and that the
+	* page already holds. These prompts still await their echo. They match by the
+	* send's message id, which the saved prompt carries (`origin.messageId`).
+	* Their pending entries stay, so the echo is still consumed. It binds
+	* nothing, because the row is gone.
+	*/
+	_withoutSavedLocalPrompts(sessionId, live, page) {
+		const pending = this._pendingEcho.get(sessionId);
+		if (!pending?.length) return live;
+		const saved = /* @__PURE__ */ new Set();
+		for (const event of page) {
+			const messageId = event.kind === "user-prompt" ? event.clientMessageId ?? event.origin?.messageId : void 0;
+			if (messageId !== void 0) saved.add(messageId);
+		}
+		const superseded = new Set(pending.flatMap((p) => p.clientMessageId !== void 0 && saved.has(p.clientMessageId) ? [p.event] : []));
+		return superseded.size === 0 ? live : live.filter((event) => !superseded.has(event));
+	}
+	/**
+	* Puts the host's exchange separator before the oldest prompt that this
+	* client appended and whose echo has not come yet (`appendUserPrompt`).
+	* Returns false when no such prompt is on show. The separator then appends
+	* like any event.
+	*/
+	_separateLocalPrompt(sessionId) {
+		const local = this._pendingEcho.get(sessionId)?.[0]?.event;
+		const events = this._events.get(sessionId);
+		const at = local && events ? events.indexOf(local) : -1;
+		if (!events || at === -1) return false;
+		if (events[at - 1]?.kind !== "separator") {
+			const next = events.slice();
+			next.splice(at, 0, {
+				kind: "separator",
+				text: ""
+			});
+			this._events.set(sessionId, next);
+			this._notifySession(sessionId);
+		}
+		return true;
+	}
+	/** Gives this client's optimistic prompt row the turn id its echo carries. A row that a reload replaced is left alone. */
+	_bindLocalPrompt(sessionId, local, turnId) {
+		const events = this._events.get(sessionId);
+		const at = events?.indexOf(local) ?? -1;
+		if (!events || at === -1) return;
+		const next = events.slice();
+		next[at] = {
+			...local,
+			turnId
+		};
+		inheritRowIdentity(events, next);
+		this._events.set(sessionId, next);
+		this._notifySession(sessionId);
+	}
 	/** Drop a stalled attempt's reasoning lane: the retry (or next model) streams its own, and the saved turn never holds it. */
 	_discardThinking(sessionId, source, turnId) {
 		const events = this._events.get(sessionId);

package/dist/chat/headless/streams/types.d.ts

@@ -1,5 +1,4 @@
 import { ChatEvent } from "../host.js";
-import { PromptTurnRef } from "zidane/chat/pure";
 import { StreamEvent, SystemMdFile } from "zidane/chat";
 //#region src/chat/headless/streams/types.d.ts
 /** The model serving a run after it fell back from the one picked. */
@@ -31,6 +30,10 @@ interface SessionPageState {
   hasMore: boolean;
   /** Whether a fetch of the previous page is in flight. */
   loadingEarlier: boolean;
+  /** The history position at which the cursor (`firstSeq`) was taken. An older page whose `floor` is past it is of another history. */
+  pos?: number;
+  /** The numbering `pos` counts in. An older page of another numbering is of another history. */
+  historyId?: string;
 }
 /** One page of a session's persisted transcript (the tail, or the page before a sequence number). */
 interface SessionStreamPage {
@@ -40,6 +43,12 @@ interface SessionStreamPage {
   firstSeq: number;
   /** Whether older turns exist before the page. */
   hasMore: boolean;
+  /** The history position the page was read at (`SessionEventsPage.pos`), when the host named one. */
+  pos?: number;
+  /** The session's floor when the page was read (set with `pos`). */
+  floor?: number;
+  /** The numbering `pos` counts in (`HistoryPosition.historyId`). */
+  historyId?: string;
 }
 /**
  * The live signals the session stream store reduces: zidane's host signals
@@ -101,12 +110,6 @@ type SessionStreamSignal<K extends string = string> =
   sessionId: K;
   source: string;
 } |
-/** Prompt turns just persisted: binds them to their live `user-prompt` rows. */
-{
-  kind: 'prompt-turns';
-  sessionId: K;
-  refs: readonly PromptTurnRef[];
-} |
 /** The `SYSTEM.md` override the session's prompt was composed with, or `null`. */
 {
   kind: 'system-md';

package/dist/chat/headless/transcript-labels.d.ts

@@ -32,6 +32,7 @@ declare const TRANSCRIPT_LABELS: {
   interactionAnsweredBy: (who: string) => string;
   badgePathUnavailable: string;
   badgeNoComposer: string;
+  badgeActionFailed: string;
   badgeCopied: string;
   badgeOpenIn: (app: string) => string;
   badgeOpenInBrowserPane: string;

package/dist/chat/interactions/PlanCard.js

@@ -1,3 +1,4 @@
+import { errorMessage } from "../../components/report-error.js";
 import { useChatLabels } from "../useChatLabels.js";
 import { useTranscriptRenderers } from "../transcript/renderers.js";
 import { BTN, BTN_DANGER, BTN_PRIMARY, CardError, INPUT, useAutoFocus } from "./card-ui.js";
@@ -43,7 +44,7 @@ function PlanCard({ request, autoFocus = false, onAnswer, Markdown, className, s
 				...comment.trim() ? { comment: comment.trim() } : {}
 			});
 		} catch (err) {
-			setError(err.message ?? String(err));
+			setError(errorMessage(err));
 			setBusy(false);
 		}
 	};
@@ -82,7 +83,10 @@ function PlanCard({ request, autoFocus = false, onAnswer, Markdown, className, s
 						className: BTN,
 						children: labels.back
 					}),
-					/* @__PURE__ */ jsx(CardError, { error }),
+					/* @__PURE__ */ jsx(CardError, {
+						error: error && labels.answerSendFailed,
+						detail: error
+					}),
 					/* @__PURE__ */ jsx("span", { className: "flex-1" }),
 					/* @__PURE__ */ jsx("button", {
 						type: "button",
@@ -110,7 +114,10 @@ function PlanCard({ request, autoFocus = false, onAnswer, Markdown, className, s
 					className: BTN_DANGER,
 					children: labels.planReject
 				}),
-				/* @__PURE__ */ jsx(CardError, { error }),
+				/* @__PURE__ */ jsx(CardError, {
+					error: error && labels.answerSendFailed,
+					detail: error
+				}),
 				/* @__PURE__ */ jsx("span", { className: "flex-1" }),
 				/* @__PURE__ */ jsx("button", {
 					type: "button",

package/dist/chat/interactions/QuestionForm.js

@@ -1,3 +1,4 @@
+import { errorMessage } from "../../components/report-error.js";
 import { useChatLabels } from "../useChatLabels.js";
 import { useTranscriptRenderers } from "../transcript/renderers.js";
 import { BTN_GHOST_LEADING, BTN_PRIMARY, CardError, INPUT, useAutoFocus } from "./card-ui.js";
@@ -71,7 +72,7 @@ function QuestionForm({ request, autoFocus = false, onAnswer, onDismiss, Markdow
 				...instructions.trim() ? { instructions: instructions.trim() } : {}
 			});
 		} catch (err) {
-			setError(err.message ?? String(err));
+			setError(errorMessage(err));
 			setBusy(false);
 		}
 	};
@@ -99,7 +100,7 @@ function QuestionForm({ request, autoFocus = false, onAnswer, onDismiss, Markdow
 		try {
 			await onDismiss();
 		} catch (err) {
-			setError(err.message ?? String(err));
+			setError(errorMessage(err));
 			setBusy(false);
 		}
 	};
@@ -172,7 +173,10 @@ function QuestionForm({ request, autoFocus = false, onAnswer, onDismiss, Markdow
 						className: BTN_GHOST_LEADING,
 						children: labels.dismiss
 					}),
-					/* @__PURE__ */ jsx(CardError, { error }),
+					/* @__PURE__ */ jsx(CardError, {
+						error: error && labels.answerSendFailed,
+						detail: error
+					}),
 					/* @__PURE__ */ jsx("span", { className: "flex-1" }),
 					/* @__PURE__ */ jsx("button", {
 						type: "button",

package/dist/chat/interactions/card-ui.d.ts

@@ -16,8 +16,10 @@ declare const FIELD = "zg-well text-zg-ui px-2.5";
 declare const INPUT = "zg-well text-zg-ui px-2.5 w-full placeholder:text-[var(--zg-text-subtle)]";
 /** Props for {@link CardError}. */
 interface CardErrorProps {
-  /** The message to show, or `null` to render nothing. */
+  /** The message to show, worded for people, or `null` to render nothing. */
   error: string | null;
+  /** The raw words behind it (an exception's message): folded under Details. */
+  detail?: string | null;
   /** Extra classes on the root element. */
   className?: string;
   /** Inline styles on the root element, merged after the component's own. */
@@ -26,9 +28,9 @@ interface CardErrorProps {
 /**
  * Renders an inline error message, or nothing when there is none.
  *
- * @param props - Component props: the `error` text.
+ * @param props - Component props: the `error` message and its raw `detail`.
  */
-declare function CardError({ error, className, style }: CardErrorProps): import("react").JSX.Element | null;
+declare function CardError({ error, detail, className, style }: CardErrorProps): import("react").JSX.Element | null;
 /**
  * Move keyboard focus to the card's first focusable control when asked
  * (the card became the head, or the user came through "Open inbox").