zidane-ui 9.1.13 → 9.1.14

package/dist/chat/headless/sidebar/view.js

@@ -11,6 +11,12 @@ import { DEFAULT_SPACE_ID } from "zidane/chat/pure";
 * too (`ChatHost.sessions.views`, the desktop app's database), it is read
 * once and wins for every space this run has not changed yet; a space only
 * this device knows is written back to it.
+*
+* In format 2 (`SIDEBAR_VIEW_VERSION`), the default sort is creation time.
+* Format 1 saved the whole view, with `sortBy: 'recency'` even when nobody
+* picked it. So a record without the mark (Storage's v1 key, the host's copy,
+* an older app's write) reads that sort as unset, on each read. Every record
+* written in format 2 carries the mark.
 */
 /** A view nobody changed yet. */
 const DEFAULT_SIDEBAR_VIEW = {
@@ -18,10 +24,14 @@ const DEFAULT_SIDEBAR_VIEW = {
 	project: null,
 	activity: "all",
 	groupBy: "project",
-	sortBy: "recency"
+	sortBy: "createdTime"
 };
+/** The format a view record carries (`v`). Format 1 had none, and its `sortBy: 'recency'` reads as the default. */
+const SIDEBAR_VIEW_VERSION = 2;
 /** Where the views persist: one map of space id → view. */
-const SIDEBAR_VIEW_KEY = "zg-sidebar-view:v1";
+const SIDEBAR_VIEW_KEY = "zg-sidebar-view:v2";
+/** Where format 1 kept them: read when the current key holds nothing, then removed. */
+const SIDEBAR_VIEW_KEY_V1 = "zg-sidebar-view:v1";
 /** Where the shown space persists. */
 const SIDEBAR_SPACE_KEY = "zg-sidebar-space";
 const oneOf = (members) => (raw) => members.includes(raw) ? raw : void 0;
@@ -48,6 +58,7 @@ const parseGroupBy = oneOf([
 const parseSortBy = oneOf([
 	"recency",
 	"createdTime",
+	"lastUserMessage",
 	"alphabetical"
 ]);
 function parseExtensionView(raw) {
@@ -71,13 +82,15 @@ function parseExtensionView(raw) {
 	};
 }
 /**
-* A stored view, every axis checked; what is missing or unknown takes the default.
+* A stored view, every axis checked. What is missing or unknown takes the default. A record
+* without the format mark (format 1) reads `sortBy: 'recency'` as unset, because it was format 1's default.
 *
 * @param raw - The stored value.
 */
 function parseSidebarView(raw) {
 	const o = raw && typeof raw === "object" ? raw : {};
 	const str = (v) => typeof v === "string" ? v : "";
+	const formerDefault = o.v !== 2 && o.sortBy === "recency";
 	const d = DEFAULT_SIDEBAR_VIEW;
 	const agent = typeof o.agent === "string" && o.agent.length > 0 ? o.agent : null;
 	const origin = o.origin === "scheduled" || o.origin === "unscheduled" ? o.origin : null;
@@ -87,7 +100,7 @@ function parseSidebarView(raw) {
 		project: typeof o.project === "string" && o.project.length > 0 ? o.project : null,
 		activity: parseActivity(str(o.activity)) ?? d.activity,
 		groupBy: parseGroupBy(str(o.groupBy)) ?? d.groupBy,
-		sortBy: parseSortBy(str(o.sortBy)) ?? d.sortBy,
+		sortBy: (formerDefault ? void 0 : parseSortBy(str(o.sortBy))) ?? d.sortBy,
 		...agent ? { agent } : {},
 		...origin ? { origin } : {},
 		...extension ? { extension } : {}
@@ -154,13 +167,18 @@ function write(storage, key, value) {
 		else storage?.setItem(key, value);
 	} catch {}
 }
+/** The stored per-space records: the current key, else format 1's. */
+function readRecords(storage) {
+	return parseJson(read(storage, "zg-sidebar-view:v2") ?? read(storage, SIDEBAR_VIEW_KEY_V1));
+}
 /**
-* The views the Storage holds: the per-space map, else the legacy per-axis keys as the default space's view.
+* The views the Storage holds: the per-space map (format 1's when the current key holds none),
+* else the legacy per-axis keys as the default space's view.
 *
 * @param storage - Where the views persist; absent reads nothing.
 */
 function readSidebarViews(storage) {
-	const stored = viewsFrom(parseJson(read(storage, SIDEBAR_VIEW_KEY)));
+	const stored = viewsFrom(readRecords(storage));
 	if (stored) return stored;
 	const legacy = Object.fromEntries(Object.entries(LEGACY_KEYS).map(([field, key]) => [field, read(storage, key)]));
 	return Object.values(legacy).some((v) => v !== void 0) ? { [DEFAULT_SPACE_ID]: parseSidebarView(legacy) } : {};
@@ -173,7 +191,7 @@ function readSidebarViews(storage) {
 function createSidebarViews(options = {}) {
 	const { storage, host, onError } = options;
 	const views = writable(readSidebarViews(storage));
-	let lastSessions = sessionsFrom(parseJson(read(storage, SIDEBAR_VIEW_KEY)));
+	let lastSessions = sessionsFrom(readRecords(storage));
 	const savedSpace = read(storage, SIDEBAR_SPACE_KEY);
 	const space = writable(savedSpace || (options.fallbackSpace ?? DEFAULT_SPACE_ID));
 	/** Spaces whose view changed this run: the host's older copy never overwrites them. */
@@ -185,15 +203,17 @@ function createSidebarViews(options = {}) {
 	const switcher = writable(parseSwitcherPrefs(parseJson(read(storage, SIDEBAR_SWITCHER_KEY))));
 	const recordOf = (spaceId, view = views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW) => {
 		const session = lastSessions[spaceId];
-		return session ? {
+		return {
 			...view,
-			session
-		} : view;
+			...session ? { session } : {},
+			v: 2
+		};
 	};
 	const persistViews = (next) => {
 		const ids = /* @__PURE__ */ new Set([...Object.keys(next), ...Object.keys(lastSessions)]);
 		const records = Object.fromEntries([...ids].map((id) => [id, recordOf(id, next[id] ?? DEFAULT_SIDEBAR_VIEW)]));
 		write(storage, SIDEBAR_VIEW_KEY, JSON.stringify(records));
+		write(storage, SIDEBAR_VIEW_KEY_V1, null);
 		for (const key of Object.values(LEGACY_KEYS)) write(storage, key, null);
 	};
 	const saveView = (spaceId, view) => {
@@ -295,4 +315,4 @@ function createSidebarViews(options = {}) {
 	};
 }
 //#endregion
-export { DEFAULT_SIDEBAR_VIEW, DEFAULT_SWITCHER_PREFS, SIDEBAR_SPACE_KEY, SIDEBAR_SWITCHER_KEY, SIDEBAR_VIEW_KEY, createSidebarViews, parseSidebarView, parseSwitcherPrefs, readSidebarViews };
+export { DEFAULT_SIDEBAR_VIEW, DEFAULT_SWITCHER_PREFS, SIDEBAR_SPACE_KEY, SIDEBAR_SWITCHER_KEY, SIDEBAR_VIEW_KEY, SIDEBAR_VIEW_VERSION, createSidebarViews, parseSidebarView, parseSwitcherPrefs, readSidebarViews };

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

@@ -10,8 +10,8 @@ interface SessionStreamActions<K extends string = string> {
   reset(sessionId: K): void;
   /** Forgets the session (a deleted one). */
   drop(sessionId: K): void;
-  /** Shows a sent prompt at once; the host's echo of it is then dropped. */
-  appendUserPrompt(sessionId: K, text: string, refs?: readonly PromptSegmentRef[], attachments?: readonly ChatAttachment[]): void;
+  /** Shows a sent prompt at once; the host's echo of it (matched by `clientMessageId` when given, else by text) is then dropped. */
+  appendUserPrompt(sessionId: K, text: string, refs?: readonly PromptSegmentRef[], attachments?: readonly ChatAttachment[], clientMessageId?: string): void;
   /** Unwinds one pending echo after a failed send. */
   dropPendingEcho(sessionId: K, text: string): void;
   /** Keeps a queued prompt's previews until the host sends it. */
@@ -32,8 +32,10 @@ interface SessionStreamActions<K extends string = string> {
   evictExcept(keep: ReadonlySet<K>): void;
   /** Forgets every session. */
   dropAll(): void;
-  /** Hydrates a tail page (events and scrollback bookkeeping, one notify). */
+  /** Hydrates a tail page (events and scrollback bookkeeping, one notify); a page older than a write applied since is read again. */
   setEventsPage(sessionId: K, page: SessionStreamPage): void;
+  /** Brings the session's window back in step after its signals may have gone missing (the reconnect ladder's last steps). */
+  resync(sessionId: K): void;
   /** Seeds the session's `SYSTEM.md` override. */
   seedSystemMd(sessionId: K, file: SystemMdFile | null): void;
   /** Names the session the user reads: its run-end compaction waits until it is backgrounded. */

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

@@ -11,10 +11,11 @@ function createSessionStreamActions(streams) {
 		drop: (sessionId) => streams.drop(sessionId),
 		dropAll: () => streams.dropAll(),
 		evictExcept: (keep) => streams.evictExcept(keep),
-		setEventsPage: (sessionId, page) => store.setEventsPage(sessionId, page),
+		setEventsPage: (sessionId, page) => streams.setEventsPage(sessionId, page),
+		resync: (sessionId) => streams.resync(sessionId),
 		seedSystemMd: (sessionId, file) => store.seedSystemMd(sessionId, file),
 		loadEarlier: (sessionId, options) => streams.loadEarlier(sessionId, options),
-		appendUserPrompt: (sessionId, text, refs, attachments) => store.appendUserPrompt(sessionId, text, refs, attachments),
+		appendUserPrompt: (sessionId, text, refs, attachments, clientMessageId) => store.appendUserPrompt(sessionId, text, refs, attachments, clientMessageId),
 		dropPendingEcho: (sessionId, text) => store.dropPendingEcho(sessionId, text),
 		rememberPromptPreviews: (sessionId, text, attachments) => store.rememberPromptPreviews(sessionId, text, attachments),
 		dropPromptPreviews: (sessionId, text) => store.dropPromptPreviews(sessionId, text),

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

@@ -1,10 +1,10 @@
-import { FrameScheduler, defaultFrameScheduler } from "./scheduler.js";
 import { OtherStreamSignal, SessionFallbackModel, SessionPageState, SessionRetryState, SessionStreamPage, SessionStreamSignal } from "./types.js";
 import { DrainPlan } from "./pacer.js";
-import { SessionStreamStore, SessionStreamStoreOptions, SessionStreamWrite } from "./store.js";
+import { FrameScheduler, defaultFrameScheduler } from "./scheduler.js";
+import { PendingEcho, SessionStreamStore, SessionStreamStoreOptions, SessionStreamWrite } from "./store.js";
 import { LoadEarlierOptions, SessionStreams, SessionStreamsOptions, createSessionStreams } from "./session-streams.js";
 import { mergeLiveTail } from "./merge.js";
 import { mergePromptPreviews, missingPreviewData } from "./prompt-previews.js";
 import { SessionStreamActions, createSessionStreamActions } from "./actions.js";
 import { selectEditEvents, stableSelection } from "./selectors.js";
-export { type DrainPlan, type FrameScheduler, type LoadEarlierOptions, type OtherStreamSignal, type SessionFallbackModel, type SessionPageState, type SessionRetryState, type SessionStreamActions, type SessionStreamPage, type SessionStreamSignal, SessionStreamStore, type SessionStreamStoreOptions, type SessionStreamWrite, type SessionStreams, type SessionStreamsOptions, createSessionStreamActions, createSessionStreams, defaultFrameScheduler, mergeLiveTail, mergePromptPreviews, missingPreviewData, selectEditEvents, stableSelection };
+export { type DrainPlan, type FrameScheduler, type LoadEarlierOptions, type OtherStreamSignal, type PendingEcho, type SessionFallbackModel, type SessionPageState, type SessionRetryState, type SessionStreamActions, type SessionStreamPage, type SessionStreamSignal, SessionStreamStore, type SessionStreamStoreOptions, type SessionStreamWrite, type SessionStreams, type SessionStreamsOptions, createSessionStreamActions, createSessionStreams, defaultFrameScheduler, mergeLiveTail, mergePromptPreviews, missingPreviewData, selectEditEvents, stableSelection };

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

@@ -3,16 +3,12 @@ import { ChatEvent } from "../host.js";
 /**
  * Hydrate a live-only window: the disk page followed by the live events
  * that disk does not have yet. Persisted turns and their live events share
- * a `turnId` (hooks pre-mint it), so the boundary is the LAST live event
- * whose turn is on the page — everything after it (the in-flight turn's
- * streaming markdown, a display-only error row) is kept; everything before
- * it is superseded by its persisted form. No live turn on the page (the
- * run's first turn is still streaming) keeps the whole live lane.
- *
- * Untagged live events in the kept suffix (a `user-prompt` echo is
- * broadcast bare and only retagged by `prompt-turns`, `steer:inject` echoes
- * likewise) are dropped when the page's trailing part already holds the
- * same `kind` + `text` — otherwise the disk copy and the echo both render.
+ * a `turnId` (the host mints it before it streams). So the boundary is the
+ * LAST live event whose turn is on the page. Everything after it (the
+ * in-flight turn's streaming markdown, a display-only error row) is kept.
+ * Everything up to it is superseded by its persisted form. If no live turn
+ * is on the page (the run's first turn is still streaming), the whole live
+ * lane is kept.
  *
  * @param live - The window's live events (never hydrated from disk).
  * @param page - The persisted page to hydrate it with.

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

@@ -3,16 +3,12 @@ import { reconcileEvents } from "zidane/chat/pure";
 /**
 * Hydrate a live-only window: the disk page followed by the live events
 * that disk does not have yet. Persisted turns and their live events share
-* a `turnId` (hooks pre-mint it), so the boundary is the LAST live event
-* whose turn is on the page — everything after it (the in-flight turn's
-* streaming markdown, a display-only error row) is kept; everything before
-* it is superseded by its persisted form. No live turn on the page (the
-* run's first turn is still streaming) keeps the whole live lane.
-*
-* Untagged live events in the kept suffix (a `user-prompt` echo is
-* broadcast bare and only retagged by `prompt-turns`, `steer:inject` echoes
-* likewise) are dropped when the page's trailing part already holds the
-* same `kind` + `text` — otherwise the disk copy and the echo both render.
+* a `turnId` (the host mints it before it streams). So the boundary is the
+* LAST live event whose turn is on the page. Everything after it (the
+* in-flight turn's streaming markdown, a display-only error row) is kept.
+* Everything up to it is superseded by its persisted form. If no live turn
+* is on the page (the run's first turn is still streaming), the whole live
+* lane is kept.
 *
 * @param live - The window's live events (never hydrated from disk).
 * @param page - The persisted page to hydrate it with.
@@ -29,17 +25,7 @@ function mergeLiveTail(live, page) {
 			break;
 		}
 	}
-	const boundaryTurn = lastPersisted === -1 ? void 0 : live[lastPersisted].turnId;
-	let trailingFrom = 0;
-	if (boundaryTurn) {
-		for (let i = page.length - 1; i >= 0; i--) if (page[i].turnId === boundaryTurn) {
-			trailingFrom = i + 1;
-			break;
-		}
-	}
-	const trailing = page.slice(trailingFrom);
-	const suffix = live.slice(lastPersisted + 1).filter((event) => event.turnId || !trailing.some((p) => p.kind === event.kind && p.text === event.text));
-	return [...reconcileEvents(live, page), ...suffix];
+	return [...reconcileEvents(live, page), ...live.slice(lastPersisted + 1)];
 }
 //#endregion
 export { mergeLiveTail };

package/dist/chat/headless/streams/session-streams.d.ts

@@ -1,8 +1,8 @@
-import { Transcript } from "../host.js";
-import { FrameScheduler } from "./scheduler.js";
+import { ChatEvent, Transcript } from "../host.js";
 import { OtherStreamSignal, SessionStreamPage, SessionStreamSignal } from "./types.js";
+import { FrameScheduler } from "./scheduler.js";
 import { SessionStreamStore } from "./store.js";
-import { MarkdownDeltaOptions } from "zidane/chat/pure";
+import { HistoryChange, HistorySince, MarkdownDeltaOptions } from "zidane/chat/pure";
 //#region src/chat/headless/streams/session-streams.d.ts
 /** Options for {@link createSessionStreams}. */
 interface SessionStreamsOptions<K extends string = string> {
@@ -12,10 +12,17 @@ interface SessionStreamsOptions<K extends string = string> {
   scheduler?: FrameScheduler;
   /** How streamed markdown merges. Default: one event per message. */
   markdown?: MarkdownDeltaOptions;
-  /** Loads a session's persisted tail page. Run-end compaction needs it; without it windows are never compacted. */
+  /** Loads a session's persisted tail page. Run-end compaction and a history rewrite's fetch need it; without it neither happens. */
   loadTail?(sessionId: K): Promise<SessionStreamPage>;
   /** Loads the page before `beforeSeq`. {@link SessionStreams.loadEarlier} needs it. */
   loadBefore?(sessionId: K, beforeSeq: number): Promise<SessionStreamPage>;
+  /**
+   * The reconnect ladder's second step (`sessions.historySince`). Reads the rows
+   * of the turns appended after `afterPos` of numbering `historyId`. Returns
+   * `null` when the host cannot say (a rewrite since, another history).
+   * {@link SessionStreams.resync} needs it to skip the tail read.
+   */
+  loadSince?(sessionId: K, afterPos: number, historyId: string): Promise<HistorySince<ChatEvent> | null>;
   /** Event count past which a background window is compacted at run end. Default: 2000. */
   compactAbove?: number;
 }
@@ -34,6 +41,24 @@ interface SessionStreams<K extends string = string> {
    * follows, so the transcript stays in causal order.
    */
   apply(signal: SessionStreamSignal<K> | OtherStreamSignal): void;
+  /**
+   * Applies one history write (`history:changed`) to a session's window
+   * (`SessionStreamStore.applyHistory`). A rewrite, a missed write or an
+   * append too large to carry its rows fetches the tail and replaces the
+   * window with it. The fetch happens at once, or at the end of a streaming run.
+   */
+  applyHistory(sessionId: K, change: HistoryChange): void;
+  /**
+   * Brings a session's window back in step after its live signals may have
+   * gone missing (the connection came back, and the signals could not be
+   * replayed). It climbs the reconnect ladder's last two steps
+   * (`climbReconnectLadder`). It applies the rows appended since its history
+   * position (`loadSince`), or else reads its tail again. A window that is not
+   * hydrated (dropped by a runtime switch) reads its tail.
+   */
+  resync(sessionId: K): void;
+  /** Hydrates a tail page into the store (`SessionStreamStore.setEventsPage`); a page cut before a write the window applied since is read again. */
+  setEventsPage(sessionId: K, page: SessionStreamPage): void;
   /** A session's transcript as a {@link ChatHost} hands it to the components (cached per session). */
   transcript(sessionId: K): Transcript;
   /** Empties a session's window and run state (and its smoothing bucket). */

package/dist/chat/headless/streams/session-streams.js

@@ -3,8 +3,17 @@ import { SessionStreamStore } from "./store.js";
 import { storeTranscript } from "./transcript.js";
 import "../smooth-stream.js";
 import { allBucketsEmpty, getOrCreateBucket, planDrainBeforeSignal, planFullDrain, planTickDrain } from "./pacer.js";
+import { climbReconnectLadder, cursorValid } from "zidane/chat/pure";
 //#region src/chat/headless/streams/session-streams.ts
 /**
+* `createSessionStreams`: the session stream store with everything a live
+* client wraps around it. Smooth streaming paces streamed markdown per
+* (session, owner) on a once-per-frame ticker; lazy scrollback fetches the
+* page before a window; run-end compaction swaps an oversized background
+* window back to its disk tail page. React-free: frames and fetches are
+* injected.
+*/
+/**
 * Event count past which a session's live window is compacted back to the
 * on-disk tail page at the next run-end boundary. Sized well above a tail
 * page (at least 200 turns) so compaction only ever fires after genuinely
@@ -68,9 +77,51 @@ function createSessionStreams(options = {}) {
 			if (store.getEventsSnapshot(sessionId) === snapshot) store.setEventsPage(sessionId, page);
 		}).catch(() => {});
 	};
+	/** One read per session is in flight. A read asked for meanwhile runs after it, if the first did not bring the window up to date. */
+	const reading = /* @__PURE__ */ new Map();
+	const refetch = (sessionId, attempts = 3) => {
+		if (!options.loadTail) return;
+		const inFlight = reading.get(sessionId);
+		if (inFlight) {
+			inFlight.again = true;
+			return;
+		}
+		const entry = { again: false };
+		reading.set(sessionId, entry);
+		const settle = () => {
+			if (reading.get(sessionId) === entry) reading.delete(sessionId);
+		};
+		const followUp = () => {
+			if (entry.again && !reading.has(sessionId) && store.isTailDue(sessionId) && !store.getRunningSnapshot(sessionId)) refetch(sessionId);
+		};
+		const runSeq = store.getRunSeqSnapshot(sessionId);
+		const hydrated = store.isHydrated(sessionId);
+		const again = () => {
+			if (attempts > 1) refetch(sessionId, attempts - 1);
+			else store.markRefetchDue(sessionId);
+		};
+		options.loadTail(sessionId).then((page) => {
+			settle();
+			if (store.isHydrated(sessionId) !== hydrated) return;
+			if (!hydrated && store.getHistoryPosSnapshot(sessionId) === void 0) return;
+			if (hydrated && store.getRunningSnapshot(sessionId)) {
+				store.markRefetchDue(sessionId);
+				return;
+			}
+			if (hydrated && store.getRunSeqSnapshot(sessionId) !== runSeq) return again();
+			if (!store.setEventsPage(sessionId, page)) again();
+		}).catch(() => {
+			settle();
+		}).finally(followUp);
+	};
 	const compactAfterRunEnd = (signal) => {
 		if (signal.kind !== "run:end") return;
 		const { sessionId } = signal;
+		if (store.takeRefetchDue(sessionId)) {
+			deferredCompact.delete(sessionId);
+			refetch(sessionId);
+			return;
+		}
 		if (!signal.ok) {
 			deferredCompact.delete(sessionId);
 			return;
@@ -110,6 +161,34 @@ function createSessionStreams(options = {}) {
 			store.applySignal(signal);
 			compactAfterRunEnd(signal);
 		},
+		applyHistory(sessionId, change) {
+			if (store.applyHistory(sessionId, change)) refetch(sessionId);
+		},
+		setEventsPage(sessionId, page) {
+			if (!store.setEventsPage(sessionId, page)) refetch(sessionId);
+		},
+		resync(sessionId) {
+			if (!store.isHydrated(sessionId)) {
+				options.loadTail?.(sessionId).then((page) => {
+					if (!store.isHydrated(sessionId)) streams.setEventsPage(sessionId, page);
+				}).catch(() => void 0);
+				return;
+			}
+			if (store.isTailDue(sessionId)) return refetch(sessionId);
+			const pos = store.getHistoryPosSnapshot(sessionId);
+			const historyId = store.getHistoryIdSnapshot(sessionId);
+			const loadSince = options.loadSince;
+			climbReconnectLadder({
+				sessionId,
+				...pos !== void 0 && historyId !== void 0 ? {
+					pos,
+					historyId
+				} : {}
+			}, loadSince ? { since: (afterPos, id) => loadSince(sessionId, afterPos, id) } : {}).then((outcome) => {
+				if (outcome.via !== "since") return refetch(sessionId);
+				if (store.applyHistorySince(sessionId, outcome.since)) refetch(sessionId);
+			}).catch(() => refetch(sessionId));
+		},
 		transcript(sessionId) {
 			let transcript = transcripts.get(sessionId);
 			if (!transcript) {
@@ -148,6 +227,7 @@ function createSessionStreams(options = {}) {
 			};
 			store.applyDrainPlan(planDrainBeforeSignal(buckets, signal));
 			store.applySignal(signal);
+			if (store.takeRefetchDue(sessionId)) refetch(sessionId);
 		},
 		loadEarlier(sessionId, opts) {
 			const page = store.getPageSnapshot(sessionId);
@@ -161,6 +241,12 @@ function createSessionStreams(options = {}) {
 					opts?.onSettled?.(false);
 					return;
 				}
+				if (!cursorValid(page.pos, older, page.historyId)) {
+					store.setLoadingEarlier(sessionId, false);
+					refetch(sessionId);
+					opts?.onSettled?.(false);
+					return;
+				}
 				store.prependEventsPage(sessionId, older);
 				opts?.onSettled?.(true);
 			}).catch(() => {

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

@@ -1,10 +1,19 @@
 import { ChatAttachment, ChatEvent } from "../host.js";
-import { FrameScheduler } from "./scheduler.js";
 import { OtherStreamSignal, SessionFallbackModel, SessionPageState, SessionRetryState, SessionStreamPage, SessionStreamSignal } from "./types.js";
 import { DrainPlan } from "./pacer.js";
-import { MarkdownDeltaOptions, PromptSegmentRef } from "zidane/chat/pure";
+import { FrameScheduler } from "./scheduler.js";
+import { HistoryChange, HistorySince, MarkdownDeltaOptions, PromptSegmentRef } from "zidane/chat/pure";
 import { SystemMdFile } from "zidane/chat";
 //#region src/chat/headless/streams/store.d.ts
+/** A prompt this client appended optimistically, awaiting its host echo (`SessionStreamStore.pendingEchoes`). */
+interface PendingEcho {
+  /** The prompt text. */
+  text: string;
+  /** The id the send gave the message, when it gave one. */
+  clientMessageId?: string;
+  /** The row the client appended. The echo gives it its turn id. */
+  event: ChatEvent;
+}
 /** Options for {@link SessionStreamStore}. */
 interface SessionStreamStoreOptions {
   /** Frames and timers for batched notifications. Default: {@link defaultFrameScheduler}. */
@@ -86,15 +95,17 @@ declare class SessionStreamStore<K extends string = string> {
   private _runSeq;
   private _pages;
   /**
-   * 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`.
    */
   private _pendingEcho;
   /**
@@ -102,6 +113,39 @@ declare class SessionStreamStore<K extends string = string> {
    * the prompt shows up in the transcript (see `prompt-previews.ts`).
    */
   private _promptPreviews;
+  /** The history position each window applied last (`applyHistory`). It is the window's bookmark in the session's history. */
+  private _historyPos;
+  /** The numbering of each window's `_historyPos` (`HistoryPosition.historyId`), when known. */
+  private _historyId;
+  /** Windows to fetch again when their run ends (`takeRefetchDue`, `markRefetchDue`). */
+  private _refetchDue;
+  /**
+   * 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.
+   */
+  private _tailDue;
+  /** Per window, the numberings it left for another numbering. A read in one of them is older than the window. */
+  private _retiredHistoryIds;
+  /**
+   * 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`).
+   */
+  private _runStarted;
+  /**
+   * 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.
+   */
+  private _runActivity;
   private _listenersBySession;
   private _listenersForHas;
   /**
@@ -194,14 +238,98 @@ declare class SessionStreamStore<K extends string = string> {
    */
   getPageSnapshot(sessionId: K | null): SessionPageState;
   /**
-   * 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: K, page: SessionStreamPage): void;
+  setEventsPage(sessionId: K, page: SessionStreamPage): boolean;
+  /**
+   * 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: K, change: HistoryChange): boolean;
+  /**
+   * 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.
+   */
+  private _applyHistoryResult;
+  /**
+   * 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: K, since: HistorySince<ChatEvent>): boolean;
+  /**
+   * 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: K, pos: number | undefined, historyId?: string): 'fresh' | 'stale';
+  /** `readFreshness` against what the window applied, and the numberings it left. */
+  private _freshness;
+  /** What the window applied last, for the shared history rules. */
+  private _historyContext;
+  /** Sets the window at `pos` of numbering `historyId`. If the numbering is unknown, none is kept. */
+  private _setHistoryPos;
+  /**
+   * 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: K): boolean;
+  /**
+   * 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: K): void;
+  /**
+   * 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: K): boolean;
+  /**
+   * 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: K): number | undefined;
+  /**
+   * The numbering of {@link getHistoryPosSnapshot}'s position, when known.
+   *
+   * @param sessionId - The session.
+   */
+  getHistoryIdSnapshot(sessionId: K): string | undefined;
   /**
    * Splice an OLDER page in front of the hydrated window (lazy scrollback).
    *
@@ -306,8 +434,9 @@ declare class SessionStreamStore<K extends string = string> {
    * @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: K, text: string, refs?: readonly PromptSegmentRef[], rawAttachments?: readonly ChatAttachment[]): void;
+  appendUserPrompt(sessionId: K, text: string, refs?: readonly PromptSegmentRef[], rawAttachments?: readonly ChatAttachment[], clientMessageId?: string): void;
   /**
    * Unwind ONE pending echo after a FAILED send — a refused/errored send
    * produces no run, so the `run:end` sweep never fires and the stale
@@ -324,7 +453,7 @@ declare class SessionStreamStore<K extends string = string> {
    *
    * @param sessionId - The session.
    */
-  pendingEchoes(sessionId: K): string[];
+  pendingEchoes(sessionId: K): PendingEcho[];
   /**
    * Low-level write: sets any of a session's events, run flag and page state
    * in one notification, with none of the signal rules (no finalize, no
@@ -366,6 +495,23 @@ declare class SessionStreamStore<K extends string = string> {
   private _notifySoon;
   /** Deliver notifications `_notifySoon` held back (also called before anything that must be immediate). */
   flushNotifications(): void;
+  /**
+   * 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.
+   */
+  private _withoutSavedLocalPrompts;
+  /**
+   * 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.
+   */
+  private _separateLocalPrompt;
+  /** Gives this client's optimistic prompt row the turn id its echo carries. A row that a reload replaced is left alone. */
+  private _bindLocalPrompt;
   /** Drop a stalled attempt's reasoning lane: the retry (or next model) streams its own, and the saved turn never holds it. */
   private _discardThinking;
   /**
@@ -382,4 +528,4 @@ declare class SessionStreamStore<K extends string = string> {
   private _notifyHas;
 }
 //#endregion
-export { SessionStreamStore, SessionStreamStoreOptions, SessionStreamWrite };
+export { PendingEcho, SessionStreamStore, SessionStreamStoreOptions, SessionStreamWrite };