zidane-ui 9.1.11 → 9.1.14

package/dist/adapters/index.d.ts

@@ -7,7 +7,7 @@ import { FromWorker, MessageEndpoint, ToWorker, WORKER_PROTOCOL_VERSION, WorkerR
 import { WorkerHostOptions, createWorkerHost, exposeRunHost } from "./worker-host.js";
 import { SseHost, SseHostOptions, createSseHost } from "./sse-host.js";
 import { SseParser, SseRecord, createSseParser } from "./sse-parser.js";
-import { AnswerBody, HydrateResponse, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, StreamRecord, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor } from "./sse-protocol.js";
+import { AnswerBody, HydrateResponse, SSE_HISTORY_RECORDS_VERSION, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, StreamRecord, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor } from "./sse-protocol.js";
 import { SERVER_AUTH_CHECK_PATH, ServerCallError, ServerClient, ServerClientOptions, ServerClientState, ServerConnectionError, ServerRefusal, createServerClient } from "./server-client.js";
 import { ServerHost, ServerHostOptions, createServerHost, toChatModelProviders, toChatSession, toSidebarListSession } from "./server-host.js";
 import { ServerApprovalsHostOptions, createServerApprovalsHost } from "./server-approvals-host.js";
@@ -26,4 +26,4 @@ import { applyLiveEvent, closeThinkingSegment, finishLive } from "../chat/headle
 import { LiveState, LiveStateOptions, LiveTranscript, createLiveState } from "./live.js";
 import "./live-events.js";
 import { StreamPacer, StreamPacerOptions, createStreamPacer } from "./stream-pacer.js";
-export { AnswerBody, BrowserAppearanceHostOptions, BrowserKeybindingsHostOptions, BrowserWorkspaceHostOptions, EXTENSION_HOST_MODULES_GLOBAL, ExtensionFlowStepHandler, ExtensionHostModule, ExtensionHostModuleSources, ExtensionHostModules, ExtensionModuleLinkError, ExtensionModuleLoad, ExtensionModuleLoadError, ExtensionsClientAnnounce, FromWorker, HydrateResponse, LinkedExtensionModule, LiveState, LiveStateOptions, LiveTranscript, MessageEndpoint, RunContext, RunFn, RunHost, RunHostOptions, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, ServerApprovalsHostOptions, ServerCallError, type ServerClient, type ServerClientOptions, type ServerClientState, ServerComposerHost, ServerComposerHostOptions, ServerConnectionError, ServerExtensionAssetsAccess, ServerExtensionBundle, ServerExtensionBundleLookup, ServerExtensionCommandWire, ServerExtensionCommands, ServerExtensionDialogs, ServerExtensionModuleLoader, ServerExtensionModuleLoaderOptions, ServerExtensionsHost, ServerExtensionsHostOptions, ServerFilesHostOptions, ServerGitHostOptions, ServerHost, ServerHostOptions, ServerMachinesHost, ServerMachinesHostOptions, ServerOnboardingHost, ServerOnboardingHostOptions, ServerPaletteHost, ServerPaletteHostOptions, type ServerRefusal, ServerSessionHost, ServerSessionHostOptions, ServerSettingsHost, ServerSettingsHostOptions, ServerSidebarHostOptions, ServerTerminalHostOptions, ServerWebviewSources, ServerWebviewSourcesOptions, SseHost, SseHostOptions, SseParser, SseRecord, StreamPacer, StreamPacerOptions, StreamRecord, ToWorker, WORKER_PROTOCOL_VERSION, WorkerHostOptions, WorkerRunInput, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerExtensionModuleLoader, createServerExtensionsHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createServerWebviewSources, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, installExtensionHostModules, linkExtensionModule, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };
+export { AnswerBody, BrowserAppearanceHostOptions, BrowserKeybindingsHostOptions, BrowserWorkspaceHostOptions, EXTENSION_HOST_MODULES_GLOBAL, ExtensionFlowStepHandler, ExtensionHostModule, ExtensionHostModuleSources, ExtensionHostModules, ExtensionModuleLinkError, ExtensionModuleLoad, ExtensionModuleLoadError, ExtensionsClientAnnounce, FromWorker, HydrateResponse, LinkedExtensionModule, LiveState, LiveStateOptions, LiveTranscript, MessageEndpoint, RunContext, RunFn, RunHost, RunHostOptions, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_HISTORY_RECORDS_VERSION, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, ServerApprovalsHostOptions, ServerCallError, type ServerClient, type ServerClientOptions, type ServerClientState, ServerComposerHost, ServerComposerHostOptions, ServerConnectionError, ServerExtensionAssetsAccess, ServerExtensionBundle, ServerExtensionBundleLookup, ServerExtensionCommandWire, ServerExtensionCommands, ServerExtensionDialogs, ServerExtensionModuleLoader, ServerExtensionModuleLoaderOptions, ServerExtensionsHost, ServerExtensionsHostOptions, ServerFilesHostOptions, ServerGitHostOptions, ServerHost, ServerHostOptions, ServerMachinesHost, ServerMachinesHostOptions, ServerOnboardingHost, ServerOnboardingHostOptions, ServerPaletteHost, ServerPaletteHostOptions, type ServerRefusal, ServerSessionHost, ServerSessionHostOptions, ServerSettingsHost, ServerSettingsHostOptions, ServerSidebarHostOptions, ServerTerminalHostOptions, ServerWebviewSources, ServerWebviewSourcesOptions, SseHost, SseHostOptions, SseParser, SseRecord, StreamPacer, StreamPacerOptions, StreamRecord, ToWorker, WORKER_PROTOCOL_VERSION, WorkerHostOptions, WorkerRunInput, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerExtensionModuleLoader, createServerExtensionsHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createServerWebviewSources, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, installExtensionHostModules, linkExtensionModule, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };

package/dist/adapters/index.js

@@ -8,7 +8,7 @@ import { createRunHost } from "./run-host.js";
 import { WORKER_PROTOCOL_VERSION, decodeFromWorker, decodeToWorker } from "./worker-protocol.js";
 import { createWorkerHost, exposeRunHost } from "./worker-host.js";
 import { createSseParser } from "./sse-parser.js";
-import { SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor } from "./sse-protocol.js";
+import { SSE_HISTORY_RECORDS_VERSION, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor } from "./sse-protocol.js";
 import { createSseHost } from "./sse-host.js";
 import { SERVER_AUTH_CHECK_PATH, ServerCallError, ServerConnectionError, createServerClient } from "./server-client.js";
 import { createServerHost, toChatModelProviders, toChatSession, toSidebarListSession } from "./server-host.js";
@@ -25,4 +25,4 @@ import { createServerSettingsHost } from "./server-settings-host.js";
 import { createServerSidebarHost } from "./server-sidebar-host.js";
 import { createServerExtensionsHost } from "./server-extensions-host.js";
 import { createStreamPacer } from "./stream-pacer.js";
-export { EXTENSION_HOST_MODULES_GLOBAL, ExtensionModuleLinkError, ExtensionModuleLoadError, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, ServerCallError, ServerConnectionError, WORKER_PROTOCOL_VERSION, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerExtensionModuleLoader, createServerExtensionsHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createServerWebviewSources, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, installExtensionHostModules, linkExtensionModule, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };
+export { EXTENSION_HOST_MODULES_GLOBAL, ExtensionModuleLinkError, ExtensionModuleLoadError, SERVER_AUTH_CHECK_PATH, SERVER_MACHINES_HOST_ID, SSE_HISTORY_RECORDS_VERSION, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, ServerCallError, ServerConnectionError, WORKER_PROTOCOL_VERSION, applyLiveEvent, attachmentsFromPreviews, closeThinkingSegment, createBrowserAppearanceHost, createBrowserKeybindingsHost, createBrowserWorkspaceHost, createLiveState, createRunHost, createServerApprovalsHost, createServerClient, createServerComposerHost, createServerExtensionModuleLoader, createServerExtensionsHost, createServerFilesHost, createServerGitHost, createServerHost, createServerMachinesHost, createServerOnboardingHost, createServerPaletteHost, createServerSessionHost, createServerSettingsHost, createServerSidebarHost, createServerTerminalHost, createServerWebviewSources, createSseHost, createSseParser, createStreamPacer, createWorkerHost, decodeFromWorker, decodeToWorker, encodeSseRecord, exposeRunHost, finishLive, formatCursor, installExtensionHostModules, linkExtensionModule, parseCursor, toChatModelProviders, toChatSession, toSidebarListSession };

package/dist/adapters/live.d.ts

@@ -1,6 +1,8 @@
 import { Readable, Writable } from "../chat/headless/store.js";
 import { ChatAttachment, ChatEvent, ChatInteraction, ChatSession, ChatSessionStatus, Transcript, TranscriptState } from "../chat/headless/host.js";
 import { applyLiveEvent, finishLive } from "../chat/headless/streams/live-events.js";
+import { PendingEcho } from "../chat/headless/streams/store.js";
+import { HistoryChange, HistorySince } from "zidane/chat/pure";
 import { InteractionRequest } from "zidane/chat";
 //#region src/adapters/live.d.ts
 /** One session's live transcript: its state store and the echo bookkeeping. */
@@ -8,7 +10,7 @@ interface LiveTranscript {
   /** The session's transcript state, updated as events arrive. */
   state: Writable<TranscriptState>;
   /** Prompts this client echoed itself, waiting for the host's echo to drop (the store's pending-echo list). */
-  echoes: string[];
+  echoes: PendingEcho[];
 }
 /** The client half of the live transcript: the stores a {@link ChatHost} exposes, fed by live events. Shared by every adapter. */
 interface LiveState {
@@ -18,8 +20,32 @@ interface LiveState {
   transcript(sessionId: string): LiveTranscript;
   /** The `Transcript` a host hands the components, with `onFirstSubscribe` / `onLastUnsubscribe` hooks. */
   readable(sessionId: string, extra?: Pick<Transcript, 'loadEarlier'>): Transcript;
-  /** Replaces a session's events with a loaded history and marks it hydrated. `patch` sets other transcript state fields, such as `running`. */
-  hydrate(sessionId: string, events: readonly ChatEvent[], patch?: Partial<TranscriptState>): void;
+  /**
+   * Replaces a session's events with a loaded history and marks it hydrated. `patch` sets other transcript state
+   * fields, such as `running`. `pos` is the history position the history was read at, and `historyId` is its
+   * numbering. Returns `false` and replaces nothing when the history is older than a write the window applied
+   * since. The adapter then reads it again.
+   */
+  hydrate(sessionId: string, events: readonly ChatEvent[], patch?: Partial<TranscriptState>, pos?: number, historyId?: string): boolean;
+  /**
+   * Applies one history write (`history:changed`) to a session's window with the shared rule
+   * (`applyHistoryOp`). Returns `true` when the adapter must hydrate the session again now (a rewrite, a
+   * missed write). While its run streams, that read waits for the run's end (`takeRefetchDue`).
+   */
+  applyHistory(sessionId: string, change: HistoryChange): boolean;
+  /** Whether the session must be hydrated again now that its run ended (see `applyHistory`). Clears the flag. */
+  takeRefetchDue(sessionId: string): boolean;
+  /** Applies the reconnect ladder's second step (`applyHistorySince`). Returns `true` when the adapter must hydrate the session again. */
+  applyHistorySince(sessionId: string, since: HistorySince<ChatEvent>): boolean;
+  /** The history position the session's window is at (its reconnect bookmark), when known. */
+  historyPos(sessionId: string): number | undefined;
+  /** The numbering of {@link LiveState.historyPos}, when known. */
+  historyId(sessionId: string): string | undefined;
+  /**
+   * Whether the session's rows are behind its history position. This is so when a tail read that a write asked for
+   * has not landed (it failed, or it waits for the run's end). A reconnect then reads the tail.
+   */
+  tailDue(sessionId: string): boolean;
   /** A live event from the agent; `echo` marks the host repeating a prompt (dropped when this client echoed it). */
   apply(sessionId: string, event: ChatEvent, echo?: boolean): void;
   /** Show the user's prompt at once (with its attachment previews); the host's echo of it is then dropped. */

package/dist/adapters/live.js

@@ -103,7 +103,8 @@ function createLiveState(options = {}) {
 			readables.set(sessionId, r);
 			return r;
 		},
-		hydrate(sessionId, events, patch) {
+		hydrate(sessionId, events, patch, pos, historyId) {
+			if (store.adoptHistoryPos(sessionId, pos, historyId) === "stale") return false;
 			const t = transcript(sessionId);
 			t.echoes = [];
 			t.state.set((s) => ({
@@ -112,7 +113,14 @@ function createLiveState(options = {}) {
 				events: [...events],
 				hydrated: true
 			}));
+			return true;
 		},
+		applyHistory: (sessionId, change) => store.applyHistory(sessionId, change),
+		takeRefetchDue: (sessionId) => store.takeRefetchDue(sessionId),
+		applyHistorySince: (sessionId, since) => store.applyHistorySince(sessionId, since),
+		historyPos: (sessionId) => store.getHistoryPosSnapshot(sessionId),
+		historyId: (sessionId) => store.getHistoryIdSnapshot(sessionId),
+		tailDue: (sessionId) => store.isTailDue(sessionId),
 		apply(sessionId, event, echo) {
 			transcript(sessionId);
 			store.applySignal({

package/dist/adapters/server-composer-host.js

@@ -146,6 +146,20 @@ function createServerComposerHost(options) {
 		return () => void listeners.delete(filtered);
 	};
 	let seq = 0;
+	/** Each session's fields a `#` reference shows: a row change that moves none of them (a write to its history, a run) reads nothing again. */
+	const chatKeys = /* @__PURE__ */ new Map();
+	const chatsMoved = (signal) => {
+		if (signal.op === "delete") return chatKeys.delete(signal.sessionId) || true;
+		const key = JSON.stringify([
+			signal.row.title,
+			signal.row.archived,
+			signal.row.projectRoot,
+			signal.row.cwd
+		]);
+		const moved = chatKeys.get(signal.sessionId) !== key;
+		chatKeys.set(signal.sessionId, key);
+		return moved;
+	};
 	const resources = createResourceStore({
 		invalidation: () => ({ onInvalidate: (listener) => on([
 			"settings:changed",
@@ -156,8 +170,9 @@ function createServerComposerHost(options) {
 			"sessions:changed"
 		], (signal) => {
 			if (signal.kind === "settings:changed" || signal.kind === "catalog:changed") listener({ topic: "models" });
-			else if (signal.kind === "sessions:changed") listener({ topic: "chats" });
-			else if (signal.kind === "event") {
+			else if (signal.kind === "sessions:changed") {
+				if (chatsMoved(signal)) listener({ topic: "chats" });
+			} else if (signal.kind === "event") {
 				if (signal.event.kind === "tool-result") listener({ topic: "files" });
 			} else listener({
 				topic: "session:context",

package/dist/adapters/server-extensions-host.d.ts

@@ -79,7 +79,6 @@ interface ServerExtensionsHost extends ExtensionsHost {
   commands: ServerExtensionCommands;
   panelChanged: NonNullable<ExtensionsHost['panelChanged']>;
   openLink: NonNullable<ExtensionsHost['openLink']>;
-  scope: NonNullable<ExtensionsHost['scope']>;
   /** With `assets`: the webview URLs the server mints. */
   webviews?: ExtensionWebviews & ServerWebviewSources;
   /** Settles once the first listing of the folder's items, settings, commands and integrations is in. */

package/dist/adapters/server-extensions-host.js

@@ -1,10 +1,10 @@
 import { writable } from "../chat/headless/store.js";
+import { ExtensionsHostError } from "../extensions/headless/host.js";
 import { createServerWebviewSources } from "./extension-modules.js";
 import { createDialogQueue } from "../extensions/headless/dialog-queue.js";
 import { createUiEffectChannel } from "../extensions/headless/effect-channel.js";
-import { ExtensionsHostError } from "../extensions/headless/host.js";
 import { EXTENSION_TOKENS } from "../extensions/headless/wire.js";
-import { IpcErrorCode, ServerCallError, ServerConnectionError, createExtensionsClient } from "zidane/ipc/browser";
+import { ServerCallError, ServerConnectionError, createExtensionsClient } from "zidane/ipc/browser";
 //#region src/adapters/server-extensions-host.ts
 /**
 * An `ExtensionsHost` on a running zidane-server, over the same client as the chat host
@@ -22,9 +22,7 @@ import { IpcErrorCode, ServerCallError, ServerConnectionError, createExtensionsC
 *   - `ctx.ui` panels, navigation, composer edits, notifications and `ctx.keymap.dispatch` chords into a
 *     `createUiEffectChannel`, answered with `ui.client.reply`
 *   - links: `openLink` offers a link to the folder's link handlers (`extensions.links.open`)
-*   - the token's scope (`scope`, from the handshake): action settings above it show disabled
-*   - RPC: `rpc.call` (aborts send `rpc.cancel`); the server checks each method's `scope` against
-*     this window's token (`rpc.forbidden` below it)
+*   - RPC: `rpc.call` (aborts send `rpc.cancel`)
 *   - stores: `extensions.storage.load` / `.set`, kept current by `extensions:storage`; a write shows at
 *     once and settles to what the server holds (a refused one is put back)
 *   - settings (`extensions.settings`, the catalog provenance), integrations, commands (with their
@@ -56,11 +54,6 @@ const CATALOG_KINDS = [
 function hostError(err) {
 	if (err instanceof ExtensionsHostError) return err;
 	if (err instanceof ServerConnectionError) return new ExtensionsHostError({ code: "unavailable" });
-	if (err instanceof ServerCallError && err.code === IpcErrorCode.Forbidden) return new ExtensionsHostError({
-		code: "refused",
-		reason: "not-allowed",
-		message: err.message
-	});
 	if (err instanceof Error && err.name === "RpcCallError" && typeof err.type === "string") {
 		const { type, data } = err;
 		return new ExtensionsHostError({
@@ -447,11 +440,8 @@ function createServerExtensionsHost(options) {
 		if (reconnected) reset();
 	}));
 	if (client.hello()) sendAnnounce().catch(onError);
-	const ready = refreshAll();
-	const scope = writable(client.hello()?.scope ?? null);
-	offs.push(client.onOpen((hello) => scope.set(hello.scope ?? null)));
 	return {
-		ready,
+		ready: refreshAll(),
 		items,
 		invoke,
 		dialogs,
@@ -467,7 +457,6 @@ function createServerExtensionsHost(options) {
 			const { handled } = await ext.links.open(cwd, link).catch(rethrow);
 			return handled;
 		},
-		scope,
 		storage: storage.storage,
 		settings: settings.settings,
 		integrations: integrations.integrations,
@@ -726,7 +715,7 @@ function serverIntegrations(client, folder, onError, onStep) {
 					key: key ?? "",
 					methodId
 				}).catch((err) => {
-					if (err instanceof ServerCallError && err.code !== IpcErrorCode.Forbidden) throw new ExtensionsHostError({
+					if (err instanceof ServerCallError) throw new ExtensionsHostError({
 						code: "refused",
 						reason: "invalid",
 						message: err.message

package/dist/adapters/server-git-host.js

@@ -5,8 +5,8 @@ import { parseRepoInput } from "zidane/chat/pure";
 * host (`createServerClient`, or `createServerHost(...).client`).
 *
 * What it offers: the server's folders for a session's folder (`fs.listDirs`,
-* inside the server's workspace roots, with what the hello's `clone` and
-* `createFolders` allow there), creating and searching them (`fs.mkdir`,
+* inside the server's workspace roots, with what the server offers there),
+* creating and searching them (`fs.mkdir`,
 * `fs.searchDirs`), a shared machine's folders (`machines.listDirs`), the
 * environment kinds a new session can run in
 * (`environments.list`, read again on `settings:changed`, where environment
@@ -21,9 +21,7 @@ import { parseRepoInput } from "zidane/chat/pure";
 * the first workspace root by default). A session's tool results refresh the
 * git bar (`event` signals), and so do its refs moving (`subscribeRefs`:
 * `git.watch`, `git:refs`, watched again after a reconnect). Each git member
-* is offered when the connection may call its method (`client.can`): reads,
-* cloning and new folders need a `chat` token, the other writes an `admin`
-* one.
+* is offered when the server's hello lists its method (`client.can`).
 *
 * Not offered: a native folder dialog, and clone on send (the browser has no
 * project on this computer to start from: `originUrl`, `cloneOnServer`).
@@ -60,22 +58,15 @@ function readSync(result) {
 	};
 }
 /**
-* What the server lets this connection do in its folders: the hello's flags, and the methods its token reaches. An
-* older server sends no flags: the methods its hello lists say it then. `undefined` when neither says.
+* What the server offers in its folders, from the methods its hello lists. `undefined` when it lists none (an older
+* server).
 */
 function folderAllows(client) {
-	const hello = client.hello();
-	const searchFolders = client.can("fs.searchDirs");
-	if (hello?.clone !== void 0 || hello?.createFolders !== void 0) return {
-		createFolders: hello.createFolders === true && client.can("fs.mkdir"),
-		clone: hello.clone === true && client.can("git.clone"),
-		searchFolders
-	};
-	if (!hello?.methods) return void 0;
+	if (!client.hello()?.methods) return void 0;
 	return {
 		createFolders: client.can("fs.mkdir"),
 		clone: client.can("git.clone"),
-		searchFolders
+		searchFolders: client.can("fs.searchDirs")
 	};
 }
 /** The repository import over `git.clone`: one clone per connection, landing in the first workspace root by default. */

package/dist/adapters/server-host.js

@@ -3,6 +3,7 @@ import { createLiveState } from "./live.js";
 import { createServerClient } from "./server-client.js";
 import { wireOriginal } from "../chat/headless/send-flow.js";
 import { createServerTranscriptMembers } from "./server-transcript-members.js";
+import { climbReconnectLadder, createRecentChanges, cursorValid } from "zidane/chat/pure";
 //#region src/adapters/server-host.ts
 /** Transcript turns per page. */
 const PAGE_TURNS = 200;
@@ -38,6 +39,7 @@ function toSidebarListSession(row) {
 	return {
 		...toChatSession(row),
 		cwd: row.cwd ?? row.projectRoot ?? "",
+		...row.lastUserMessageAt !== void 0 ? { lastUserMessageAt: row.lastUserMessageAt } : {},
 		...row.projectRoot ? { projectRoot: row.projectRoot } : {},
 		...row.spaceId ? { spaceId: row.spaceId } : {},
 		...row.isMain ? { isMain: true } : {},
@@ -80,12 +82,15 @@ function createServerHost(options) {
 	const client = options.client ?? createServerClient(options);
 	const connection = writable(client.state());
 	const watched = /* @__PURE__ */ new Set();
+	/** Per transcript, the scroll-back cursor and the history position it was taken at. */
 	const cursors = /* @__PURE__ */ new Map();
 	/** Last signal number seen per session, and the host process that numbered it. */
 	const seqs = /* @__PURE__ */ new Map();
 	let epoch;
 	/** Signals that arrive between a hydrate's snapshot and its replace, replayed after it. */
 	const hydrating = /* @__PURE__ */ new Map();
+	/** A session's signals that arrive while its reconnect ladder runs (`resume`), applied after what it brings. */
+	const resuming = /* @__PURE__ */ new Map();
 	const models = writable([]);
 	const state = createLiveState({
 		onOpen: (sessionId) => {
@@ -99,14 +104,21 @@ function createServerHost(options) {
 	const facetListeners = /* @__PURE__ */ new Set();
 	const onSignal = (signal, meta) => {
 		const sessionId = "sessionId" in signal && typeof signal.sessionId === "string" ? signal.sessionId : void 0;
-		if (sessionId && meta) seqs.set(sessionId, meta.seq);
-		if ((signal.kind === "event" || signal.kind === "run:start" || signal.kind === "run:end") && hydrating.has(signal.sessionId)) {
+		if (sessionId && resuming.has(sessionId)) {
+			resuming.get(sessionId).push({
+				signal,
+				...meta ? { meta } : {}
+			});
+			return;
+		}
+		if ((signal.kind === "event" || signal.kind === "run:start" || signal.kind === "run:end" || signal.kind === "history:changed") && hydrating.has(signal.sessionId)) {
 			hydrating.get(signal.sessionId).push({
 				signal,
 				...meta ? { meta } : {}
 			});
 			return;
 		}
+		if (sessionId && meta) seqs.set(sessionId, meta.seq);
 		switch (signal.kind) {
 			case "event":
 				state.apply(signal.sessionId, signal.event, signal.echo);
@@ -114,8 +126,10 @@ function createServerHost(options) {
 			case "run:start":
 			case "run:end":
 				if (signal.kind === "run:start") state.setRunning(signal.sessionId, true);
-				else state.setRunning(signal.sessionId, false, signal.ok ? "completed" : "error");
-				if (state.sessions.get().some((s) => s.id === signal.sessionId && s.title === UNTITLED)) refreshTitles().catch(onError);
+				else {
+					state.setRunning(signal.sessionId, false, signal.ok ? "completed" : "error");
+					if (state.takeRefetchDue(signal.sessionId) && watched.has(signal.sessionId)) reread(signal.sessionId);
+				}
 				return;
 			case "interaction:request":
 				state.addInteraction(signal.sessionId, signal.request);
@@ -126,58 +140,152 @@ function createServerHost(options) {
 			case "sessions:facets":
 				for (const listener of [...facetListeners]) listener(signal.sessionId, signal.facets);
 				return;
-			case "sessions:changed":
-				for (const listener of [...changed]) listener(signal.sessionId);
-				refresh().catch(onError);
-				if (signal.op === "update" && watched.has(signal.sessionId)) hydrate(signal.sessionId).catch(onError);
+			case "sessions:changed": {
+				const listed = signal.op === "delete" || signal.row.sideOf ? void 0 : signal.row;
+				const change = signal.op === "delete" ? {
+					op: "delete",
+					sessionId: signal.sessionId
+				} : {
+					op: signal.op,
+					sessionId: signal.sessionId,
+					...listed ? { row: toSidebarListSession(listed) } : {}
+				};
+				if (signal.op === "delete") {
+					state.sessions.set((all) => withoutSession(all, signal.sessionId));
+					listChanges.note(signal.sessionId, null);
+				} else if (listed) {
+					const session = toChatSession(listed);
+					upsertSession(session);
+					listChanges.note(session.id, session);
+				}
+				for (const listener of [...changed]) listener(change);
+				return;
+			}
+			case "history:changed":
+				if (watched.has(signal.sessionId) && state.applyHistory(signal.sessionId, signal)) reread(signal.sessionId);
+				return;
 		}
 	};
 	const loadPage = async (sessionId, before) => {
-		const params = {
+		return client.call("sessions.loadEvents", {
 			sessionId,
 			limit: PAGE_TURNS,
 			...before !== void 0 ? { before } : {}
-		};
-		const result = await client.call("sessions.loadEvents", params);
-		return Array.isArray(result) ? { events: result } : result;
+		});
 	};
-	const hydrate = async (sessionId) => {
+	const hydrate = async (sessionId, attempts = 3) => {
 		const buffered = [];
 		hydrating.set(sessionId, buffered);
+		let stale = false;
 		try {
 			const page = await loadPage(sessionId);
 			const running = await client.call("chat.isRunning", { sessionId });
-			cursors.set(sessionId, page.cursor);
-			state.hydrate(sessionId, page.events, {
+			stale = !state.hydrate(sessionId, page.events, {
 				running,
 				hasEarlier: page.cursor !== void 0
+			}, page.pos, page.historyId);
+			if (!stale) cursors.set(sessionId, {
+				before: page.cursor,
+				...page.pos !== void 0 ? { pos: page.pos } : {},
+				...page.pos !== void 0 && page.historyId !== void 0 ? { historyId: page.historyId } : {}
 			});
 		} finally {
 			if (hydrating.get(sessionId) === buffered) hydrating.delete(sessionId);
 			for (const { signal, meta } of buffered) onSignal(signal, meta);
 		}
+		if (stale && attempts > 1) return hydrate(sessionId, attempts - 1);
 		const interactions = await client.call("interactions.list", { sessionId });
 		for (const i of state.pending(sessionId).get()) state.resolveInteraction(i.requestId);
 		for (const i of interactions) state.addInteraction(sessionId, i.request);
 	};
-	/** After a reconnect: replay what the transcript missed, or reload it when the server can't. */
-	const resume = async (sessionId) => {
-		const afterSeq = seqs.get(sessionId);
-		if (epoch && afterSeq !== void 0 && client.can("sessions.resume")) {
-			const result = await client.call("sessions.resume", {
-				sessionId,
-				epoch,
-				afterSeq
-			});
-			if (result.ok) {
-				for (const { seq, signal } of result.signals) onSignal(signal, { seq });
-				return;
+	/**
+	* Reads a transcript again for a signal (a rewrite, a missed write, a run's end). One such read per session is in
+	* flight. A read asked for while another runs is made when the first ends, if the first did not bring the window up
+	* to date (it failed, or a write asked for rows it lacks).
+	*/
+	const rereads = /* @__PURE__ */ new Map();
+	const reread = (sessionId) => {
+		const inFlight = rereads.get(sessionId);
+		if (inFlight) {
+			inFlight.again = true;
+			return;
+		}
+		const entry = { again: false };
+		rereads.set(sessionId, entry);
+		hydrate(sessionId).catch(onError).finally(() => {
+			rereads.delete(sessionId);
+			if (entry.again && state.tailDue(sessionId) && watched.has(sessionId)) reread(sessionId);
+		});
+	};
+	/**
+	* Climbs the reconnect ladder from the transcript's bookmark after a
+	* reconnect. The session's live signals wait until the ladder's rows are in
+	* (the signals it missed, or the rows appended since), and apply after them.
+	*/
+	const resume = async (sessionId, bookmark) => {
+		const held = [];
+		resuming.set(sessionId, held);
+		/**
+		* Applies `missed` (the ladder's rows), then what arrived live meanwhile. It
+		* skips the signals that the replay also carried (numbered up to `replayedTo`).
+		*/
+		const release = (missed = () => void 0, replayedTo = -1) => {
+			if (resuming.get(sessionId) === held) resuming.delete(sessionId);
+			try {
+				missed();
+			} finally {
+				for (const { signal, meta } of held) if (meta === void 0 || meta.seq > replayedTo) onSignal(signal, meta);
+			}
+		};
+		const outcome = await climbReconnectLadder(bookmark, {
+			resume: async (from, afterSeq) => {
+				const result = await client.call("sessions.resume", {
+					sessionId,
+					epoch: from,
+					afterSeq
+				});
+				return result.ok ? result.signals : null;
+			},
+			since: async (afterPos, historyId) => {
+				const result = await client.call("sessions.historySince", {
+					sessionId,
+					afterPos,
+					historyId
+				}).catch(() => null);
+				return result?.ok ? {
+					events: result.events,
+					pos: result.pos,
+					floor: result.floor,
+					historyId: result.historyId,
+					...result.after !== void 0 ? { after: result.after } : {}
+				} : null;
 			}
+		}).catch((error) => {
+			release();
+			throw error;
+		});
+		if (outcome.via === "resume") {
+			const { signals } = outcome;
+			release(() => {
+				for (const { seq, signal } of signals) onSignal(signal, { seq });
+			}, signals.at(-1)?.seq ?? -1);
+			return;
+		}
+		const since = outcome.via === "since" ? outcome.since : void 0;
+		let read = since === void 0;
+		release(() => {
+			if (since) read = state.applyHistorySince(sessionId, since);
+		});
+		if (!read) {
+			const running = await client.call("chat.isRunning", { sessionId });
+			state.setRunning(sessionId, running);
+			if (running || !state.takeRefetchDue(sessionId)) return;
 		}
 		await hydrate(sessionId);
 	};
 	const loadEarlier = async (sessionId) => {
-		const before = cursors.get(sessionId);
+		const cursor = cursors.get(sessionId);
+		const before = cursor?.before;
 		const t = state.transcript(sessionId).state;
 		if (before === void 0 || t.get().loadingEarlier) return;
 		t.set((s) => ({
@@ -186,7 +294,19 @@ function createServerHost(options) {
 		}));
 		try {
 			const page = await loadPage(sessionId, before);
-			cursors.set(sessionId, page.cursor);
+			if (!cursorValid(cursor?.pos, page, cursor?.historyId)) {
+				t.set((s) => ({
+					...s,
+					loadingEarlier: false
+				}));
+				await hydrate(sessionId);
+				return;
+			}
+			cursors.set(sessionId, {
+				before: page.cursor,
+				...cursor?.pos !== void 0 ? { pos: cursor.pos } : {},
+				...cursor?.historyId !== void 0 ? { historyId: cursor.historyId } : {}
+			});
 			t.set((s) => ({
 				...s,
 				events: [...page.events, ...s.events],
@@ -201,19 +321,19 @@ function createServerHost(options) {
 			onError(error);
 		}
 	};
+	/** The changes applied while the list is read again. They are newer than its answer (`createRecentChanges`). */
+	const listChanges = createRecentChanges();
 	const refresh = async () => {
-		const rows = await client.call("sessions.list", { archive: "all" });
-		state.sessions.set(rows.map(toChatSession));
-	};
-	/** Takes the listed titles only: a run's status, set from its signals, stays. */
-	const refreshTitles = async () => {
-		const rows = await client.call("sessions.list", { archive: "all" });
-		const titles = new Map(rows.map((r) => [r.id, r.title || UNTITLED]));
-		state.sessions.set((all) => all.some((s) => titles.has(s.id) && titles.get(s.id) !== s.title) ? all.map((s) => titles.has(s.id) && titles.get(s.id) !== s.title ? {
-			...s,
-			title: titles.get(s.id)
-		} : s) : all);
+		const reading = listChanges.begin();
+		try {
+			const rows = await client.call("sessions.list", { archive: "all" });
+			state.sessions.set(listChanges.end(reading, rows.map(toChatSession), (list, session, id) => session ? withSession(list, session) : withoutSession(list, id)));
+		} finally {
+			listChanges.drop(reading);
+		}
 	};
+	/** A session's row from a change signal, in place (a new one first). */
+	const upsertSession = (session) => state.sessions.set((all) => withSession(all, session));
 	const loadModels = async () => {
 		if (!client.can("models.list")) return;
 		const { providers } = await client.call("models.list", options.cwd ? { cwd: options.cwd } : {});
@@ -223,13 +343,23 @@ function createServerHost(options) {
 		client.onState((s) => connection.set(s)),
 		client.onSignal(onSignal),
 		client.onOpen((hello, reconnected) => {
-			const sameProcess = epoch !== void 0 && hello.signalEpoch === epoch;
+			const bookmarks = [...watched].map((sessionId) => state.tailDue(sessionId) ? { sessionId } : {
+				sessionId,
+				...state.historyPos(sessionId) !== void 0 && state.historyId(sessionId) !== void 0 ? {
+					pos: state.historyPos(sessionId),
+					historyId: state.historyId(sessionId)
+				} : {},
+				...epoch !== void 0 && seqs.has(sessionId) ? {
+					epoch,
+					seq: seqs.get(sessionId)
+				} : {}
+			});
+			if (epoch === void 0 || hello.signalEpoch !== epoch) seqs.clear();
 			epoch = hello.signalEpoch;
-			if (!sameProcess) seqs.clear();
 			loadModels().catch(onError);
 			if (!reconnected) return;
 			refresh().catch(onError);
-			for (const id of watched) resume(id).catch(onError);
+			for (const bookmark of bookmarks) resume(bookmark.sessionId, bookmark).catch(onError);
 		})
 	];
 	const ready = client.ready.then(() => refresh());
@@ -439,5 +569,13 @@ function createServerHost(options) {
 		}
 	};
 }
+/** `list` with `session`'s row in place, or first when it is new. */
+function withSession(list, session) {
+	return list.some((s) => s.id === session.id) ? list.map((s) => s.id === session.id ? session : s) : [session, ...list];
+}
+/** `list` without the session's row. */
+function withoutSession(list, sessionId) {
+	return list.some((s) => s.id === sessionId) ? list.filter((s) => s.id !== sessionId) : list;
+}
 //#endregion
 export { createServerHost, toChatModelProviders, toChatSession, toSidebarListSession };

package/dist/adapters/server-machines-host.d.ts

@@ -12,6 +12,8 @@ interface ServerMachinesHostOptions {
    * Absent: no `machines.invite`.
    */
   url?: string;
+  /** Opens a new chat on the server, or on one of its machines (the app's own navigation). Absent: no `newChat`. */
+  newChat?: (hostId: string, machine?: string) => void;
 }
 /** The {@link MachinesHost} {@link createServerMachinesHost} returns. */
 interface ServerMachinesHost extends MachinesHost {