zidane-ui 9.1.13 → 9.1.14

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

@@ -1,20 +1,20 @@
-import { closableClient } from "./closable-client.js";
 import { machinesError } from "../machines/headless/host.js";
-import { createPresenceStore } from "../machines/headless/presence.js";
 import { createMachineLists, createOnlineMachines, lazyReadable } from "../machines/headless/stores.js";
+import { closableClient } from "./closable-client.js";
+import { createPresenceStore } from "../machines/headless/presence.js";
 import { createHostSyncReads } from "../machines/headless/sync.js";
 import { serverOAuthFlow } from "./server-oauth-flow.js";
-import { IpcErrorCode, formatJoinString } from "zidane/ipc/browser";
+import { formatJoinString } from "zidane/ipc/browser";
 //#region src/adapters/server-machines-host.ts
 /**
 * A `MachinesHost` on a running zidane-server, over a shared browser client
 * (`createServerClient`), for a web app the server serves: the one server it
-* talks to (from the client's state and the handshake: name, version, the
-* token's scope, uptime), its machines (`machines.list`, `machines.forget`,
+* talks to (from the client's state and the handshake: name, version,
+* uptime), its machines (`machines.list`, `machines.forget`,
 * kept current by the `machine:status` signal and re-read after every
 * handshake; `tokens.machineInvite` makes a join code when the server's
 * `url` is given), its self-update (`server.update.*`), its client tokens
-* (`tokens.list` / `create` / `revoke`, re-read on `tokens:changed`), what it can do (`host.capabilities`)
+* (`tokens.list` / `create` / `revoke` / `pair`, re-read on `tokens:changed`), what it can do (`host.capabilities`)
 * and per-session presence
 * (`presence.list`, kept current by `presence:changed`, re-listed after every
 * handshake). Of settings sync, the server's side: its record
@@ -23,10 +23,9 @@ import { IpcErrorCode, formatJoinString } from "zidane/ipc/browser";
 * override (`sync.reset`), its providers (`auth.status`) and a sign-in there
 * (`auth.oauth.*`, `serverOAuthFlow`).
 *
-* What a token may do comes from the handshake (`client.can`), in
-* `permitted`: a `chat` or `approve` token lists machines and reads the
-* update status, only an `admin` one forgets machines, runs updates and
-* manages tokens. The components hide what is not permitted.
+* What the server offers comes from the handshake (`client.can`), in
+* `permitted`. It is `null` until the handshake lands. The components hide
+* what is not permitted.
 *
 * A store it hands out may listen to the client for good (who is online):
 * `close()` stops every listener.
@@ -37,8 +36,6 @@ import { IpcErrorCode, formatJoinString } from "zidane/ipc/browser";
 * machine `links`, `pickFolder`, the local `daemon`, and this computer's sync
 * engine (`sync.state`, `configure`, `push`, `takeOver`: a browser is not a device
 * that pushes its settings; `sync.claim` / `sync.push` are a device's calls).
-* `sync.*` needs an admin token: below it the record reads `null` and a reset
-* rejects.
 */
 /** The id the server goes by until its handshake names it (`hello.hostId`). */
 const SERVER_MACHINES_HOST_ID = "server";
@@ -68,7 +65,7 @@ function createServerMachinesHost(options) {
 		if (state.status === "open" && !wasOpen) lastConnectedAt = Date.now();
 		wasOpen = state.status === "open";
 		everOpen ||= wasOpen;
-		const status = state.status === "open" ? "connected" : state.status === "connecting" ? everOpen ? "reconnecting" : "connecting" : state.status === "retrying" ? "reconnecting" : state.status === "refused" ? state.reason === "protocol" ? "version-mismatch" : state.reason === "token" || state.reason === "scope" ? "auth-refused" : "offline" : "offline";
+		const status = state.status === "open" ? "connected" : state.status === "connecting" ? everOpen ? "reconnecting" : "connecting" : state.status === "retrying" ? "reconnecting" : state.status === "refused" ? state.reason === "protocol" ? "version-mismatch" : state.reason === "token" ? "auth-refused" : "offline" : "offline";
 		const error = state.status === "retrying" ? state.error : state.status === "refused" ? state.message : void 0;
 		return {
 			id: hello?.hostId ?? "server",
@@ -77,8 +74,6 @@ function createServerMachinesHost(options) {
 			status,
 			...error ? { error } : {},
 			...hello?.appVersion ? { serverVersion: hello.appVersion } : {},
-			...hello?.scope ? { scope: hello.scope === "admin" ? "admin" : "chat" } : {},
-			...hello?.adminCommands ? { adminCommands: hello.adminCommands } : {},
 			...hello?.startedAt ? { startedAt: hello.startedAt } : {},
 			...hello?.machineServe ? { machineServe: true } : {},
 			...lastConnectedAt ? { lastConnectedAt } : {}
@@ -117,9 +112,13 @@ function createServerMachinesHost(options) {
 	}, (onChange) => {
 		const offStatus = onMachineStatus(() => onChange(SERVER_MACHINES_HOST_ID));
 		const offOpen = client.onOpen(() => onChange(SERVER_MACHINES_HOST_ID));
+		const offChanged = client.onSignal((signal) => {
+			if (signal.kind === "machine:changed") onChange(SERVER_MACHINES_HOST_ID);
+		});
 		return () => {
 			offStatus();
 			offOpen();
+			offChanged();
 		};
 	});
 	const syncStatus = createHostSyncReads(() => client.call("sync.status", {}), (onChange) => {
@@ -141,9 +140,15 @@ function createServerMachinesHost(options) {
 	};
 	return {
 		hosts,
+		...options.newChat ? { newChat: options.newChat } : {},
 		machines: {
 			list: () => lists(SERVER_MACHINES_HOST_ID),
 			online: createOnlineMachines(onMachineStatus),
+			onJoin: (_hostId, listener) => client.onSignal((signal) => {
+				if (signal.kind !== "machine:join") return;
+				const { kind: _kind, ...event } = signal;
+				listener(event);
+			}),
 			forget: (_hostId, machineId) => guard("forget", async () => {
 				await client.call("machines.forget", { machineId });
 			}),
@@ -153,14 +158,10 @@ function createServerMachinesHost(options) {
 					return {
 						code,
 						expiresAt,
-						join: formatJoinString(serverUrl, code)
+						join: formatJoinString(client.hello()?.clientUrl ?? serverUrl, code)
 					};
 				} catch (error) {
-					const forbidden = error?.code === IpcErrorCode.Forbidden;
-					throw {
-						...machinesError("invite", error),
-						...forbidden ? { forbidden } : {}
-					};
+					throw machinesError("invite", error);
 				}
 			} } : {}
 		},
@@ -172,10 +173,8 @@ function createServerMachinesHost(options) {
 		},
 		tokens: {
 			list: (_hostId) => guard("tokens", () => client.call("tokens.list", {})),
-			create: (_hostId, name, scope) => guard("tokens", () => client.call("tokens.create", {
-				name,
-				scope
-			})),
+			create: (_hostId, name) => guard("tokens", () => client.call("tokens.create", { name })),
+			pair: (_hostId, params = {}) => guard("tokens", () => client.call("tokens.pair", params)),
 			revoke: (_hostId, id) => guard("tokens", async () => {
 				await client.call("tokens.revoke", { id });
 			}),

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

@@ -19,7 +19,7 @@ interface ServerOnboardingHostOptions {
   /** The folder on the server whose extension providers and catalog count. Absent: the server user's scope. */
   cwd?: string;
   /**
-   * `false` leaves out keys, sign-ins, connectors and extensions, for a token without the `admin` scope.
+   * `false` leaves out keys, sign-ins, connectors and extensions.
    * Default: `client.can('auth.setApiKey')` once the handshake has landed, `true` before it.
    */
   canConfigure?: boolean;

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

@@ -20,10 +20,9 @@ import { CONNECTORS, connectorById, connectorInstalled, connectorServerConfig, n
 * without it). The look is the page's: pass `themes` and `appIcons` to offer
 * Look, and `onCommitted` to apply what a run picked for this page.
 *
-* Reading needs a `chat` token. Keys, sign-ins, installs and the write need
-* `admin`. Built after the handshake (`await client.ready`), the host follows
-* the token: with a lesser one, Connect lists the providers and installs and
-* keys are left out.
+* Built after the handshake (`await client.ready`). Keys, sign-ins and
+* installs show when the server's hello lists `auth.setApiKey`
+* (`canConfigure`).
 *
 * When the handshake lists them: what zidane finds on the server's machine
 * (`onboarding.detect`: other agents, local model servers, the GitHub

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

@@ -217,9 +217,28 @@ function createServerSessionHost(options) {
 				if (await client.call("chat.isRunning", { sessionId: sideId })) await client.call("chat.interrupt", { sessionId: sideId });
 				await client.call("sessions.delete", { sessionId: sideId });
 			},
-			subscribe: (onChange) => client.onSignal((signal) => {
-				if (signal.kind === "sessions:changed" && signal.op === "update") onChange(signal.sessionId);
-			})
+			subscribe: (onChange) => {
+				const picks = /* @__PURE__ */ new Map();
+				return client.onSignal((signal) => {
+					if (signal.kind !== "sessions:changed") return;
+					if (signal.op === "delete") {
+						picks.delete(signal.sessionId);
+						return;
+					}
+					const { row } = signal;
+					const pick = JSON.stringify([
+						row.providerKey,
+						row.modelId,
+						row.effort,
+						row.modelOptions,
+						row.account,
+						row.agentId
+					]);
+					const before = picks.get(signal.sessionId);
+					picks.set(signal.sessionId, pick);
+					if (signal.op === "update" && before !== pick) onChange(signal.sessionId);
+				});
+			}
 		} } : {},
 		...client.can("secrets.list") ? { secrets: {
 			entries: secrets.entries,

package/dist/adapters/server-settings-accounts.js

@@ -1,11 +1,11 @@
 import { serverOAuthFlow } from "./server-oauth-flow.js";
 import { createSettingsResource, keyedSettingsResources } from "../settings/headless/resource.js";
 import { settingsMcpServerOf } from "../settings/headless/mcp.js";
-import { IpcErrorCode, ServerCallError, ServerConnectionError } from "zidane/ipc/browser";
+import { ServerConnectionError } from "zidane/ipc/browser";
 //#region src/adapters/server-settings-accounts.ts
 const errorOf = (error) => {
 	const detail = error instanceof Error ? error.message : void 0;
-	const kind = error instanceof ServerConnectionError ? "unreachable" : error instanceof ServerCallError && error.code === IpcErrorCode.Forbidden ? "refused" : "failed";
+	const kind = error instanceof ServerConnectionError ? "unreachable" : "failed";
 	return detail ? {
 		kind,
 		detail

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

@@ -1,15 +1,15 @@
 import { writable } from "../chat/headless/store.js";
-import { closableClient } from "./closable-client.js";
 import { DEFAULT_SETTINGS } from "../settings/headless/catalog.js";
+import { closableClient } from "./closable-client.js";
 import { serverSettingsSections } from "./server-settings-sections.js";
 import { serverSettingsAccounts } from "./server-settings-accounts.js";
 import { serverSettingsModels } from "./server-settings-models.js";
 import { serverSettingsPerformance } from "./server-settings-performance.js";
-import { IpcErrorCode, ServerCallError, ServerConnectionError } from "zidane/ipc/browser";
+import { ServerConnectionError } from "zidane/ipc/browser";
 //#region src/adapters/server-settings-host.ts
 const errorOf = (error) => {
 	const detail = error instanceof Error ? error.message : void 0;
-	const kind = error instanceof ServerConnectionError ? "unreachable" : error instanceof ServerCallError && error.code === IpcErrorCode.Forbidden ? "refused" : "failed";
+	const kind = error instanceof ServerConnectionError ? "unreachable" : "failed";
 	return detail ? {
 		kind,
 		detail

package/dist/adapters/server-settings-performance.js

@@ -1,24 +1,22 @@
-import { IpcErrorCode, ServerCallError } from "zidane/ipc/browser";
+import { ServerCallError } from "zidane/ipc/browser";
 //#region src/adapters/server-settings-performance.ts
 /**
 * The performance group of the zidane-server `SettingsHost`
 * (`createServerSettingsHost`), over the shared browser client: the
-* server's own figures (`perf.*`, admin), its samples held
+* server's own figures (`perf.*`), its samples held
 * (`perf.history`), followed while shown (`perf.watch`, `perf:sample`;
 * watched again after a reconnect) and a listed process's threads
-* (`perf.threads`). Offered when the token reaches them; a server too old
-* for them or a chat token has none, and the page says it is not available.
+* (`perf.threads`). Offered when the server has them; a server too old
+* for them has none, and the page says it is not available.
 * No counters, report or profiles: a server keeps none.
 */
 /** JSON-RPC's "method not found": a server older than `perf.*`. */
 const METHOD_NOT_FOUND = -32601;
 const watchErrorOf = (error) => {
-	const code = error instanceof ServerCallError ? error.code : void 0;
-	if (code === METHOD_NOT_FOUND) return { kind: "unavailable" };
-	const detail = error instanceof Error ? error.message : String(error);
+	if ((error instanceof ServerCallError ? error.code : void 0) === METHOD_NOT_FOUND) return { kind: "unavailable" };
 	return {
-		kind: code === IpcErrorCode.Forbidden ? "refused" : "failed",
-		detail
+		kind: "failed",
+		detail: error instanceof Error ? error.message : String(error)
 	};
 };
 /**

package/dist/adapters/server-settings-sections.js

@@ -1,31 +1,30 @@
 import { createSettingsResource, keyedSettingsResources } from "../settings/headless/resource.js";
-import { IpcErrorCode, ServerCallError, ServerConnectionError, extensionInstallErrorData } from "zidane/ipc/browser";
+import { ServerCallError, ServerConnectionError, extensionInstallErrorData } from "zidane/ipc/browser";
 //#region src/adapters/server-settings-sections.ts
 /**
 * The catalog and diagnostics groups of the zidane-server `SettingsHost`
 * (`createServerSettingsHost`), over the shared browser client:
 *
-* - `environments`: `environments.list` / `.update` (admin) / `.verify`.
-* - `instructions`: `sessions.contextSegments`, `sessions.createSystemOverride` (admin).
+* - `environments`: `environments.list` / `.update` / `.verify`.
+* - `instructions`: `sessions.contextSegments`, `sessions.createSystemOverride`.
 * - `hostCatalog`: `catalog.skills|mcps|extensions|plugins`, kept current by
-*   `catalog:changed`; installs (`catalog.install|remove|update`, admin)
-*   when the server takes them (`remoteInstalls` on its hello) and the
-*   token reaches them; the extensions' source browser (`extensions.browse`)
-*   and a change of origin (`extensions.changeOrigin`, admin, when the
-*   server takes installs). Its MCP servers are the accounts' `mcp` group.
+*   `catalog:changed`; installs (`catalog.install|remove|update`)
+*   when the server takes them (`remoteInstalls` on its hello); the
+*   extensions' source browser (`extensions.browse`) and a change of origin
+*   (`extensions.changeOrigin`, when the server takes installs). Its MCP servers are the accounts' `mcp` group.
 *
 * - `extensions`: the server's extensions (`catalog.extensions`), a source's
 *   extensions (`extensions.browse`), a user-scope extension installed
-*   again from another source (`extensions.changeOrigin`, admin, when the
+*   again from another source (`extensions.changeOrigin`, when the
 *   server takes installs), the options and action rows their folder declares
 *   (`extensions.configSchema` / `actions`, refetched on `catalog:changed`),
 *   the actions' probes (`extensions.actionStatuses`), a run
-*   (`extensions.runAction`, admin) and a scaffold (`extensions.create`,
-*   admin, when the server takes installs; a project one inside the server's
+*   (`extensions.runAction`) and a scaffold (`extensions.create`, when the
+*   server takes installs; a project one inside the server's
 *   workspace roots).
 * - `claudeImport`: the server's `~/.claude` (`claudeImport.detect` / `run`,
-*   admin, when the server takes installs).
-* - `logs`: the server's log (`logs.list`, admin), followed while shown
+*   when the server takes installs).
+* - `logs`: the server's log (`logs.list`), followed while shown
 *   (`logs.watch`, `logs:record`; watched again after a reconnect).
 *
 * Left out, as the protocol has no method for them: the local-disk
@@ -36,7 +35,7 @@ import { IpcErrorCode, ServerCallError, ServerConnectionError, extensionInstallE
 */
 const errorOf = (error) => {
 	const detail = error instanceof Error ? error.message : void 0;
-	const kind = error instanceof ServerConnectionError ? "unreachable" : error instanceof ServerCallError && error.code === IpcErrorCode.Forbidden ? "refused" : "failed";
+	const kind = error instanceof ServerConnectionError ? "unreachable" : "failed";
 	const found = error instanceof ServerCallError ? extensionInstallErrorData(error.data)?.candidates : void 0;
 	return {
 		kind,

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

@@ -2,8 +2,8 @@ import { ARTIFACT_BADGES_MAX } from "zidane/chat/pure";
 //#region src/adapters/server-sidebar-host.ts
 /**
 * A `SidebarHost` on a running zidane-server: a session's environment
-* commands (`sessions.environmentActions`, `sessions.runEnvironmentAction`,
-* which needs an `admin` token), setting a failed environment up again
+* commands (`sessions.environmentActions`, `sessions.runEnvironmentAction`),
+* setting a failed environment up again
 * (`sessions.retryEnvironment`) and, when the handshake lists it, the rows'
 * badges (`artifacts.badges`, read again on a session's `artifact:recorded` /
 * `artifact:changed` and on `catalog:changed` for extensions).

package/dist/adapters/sse-host.js

@@ -3,6 +3,8 @@ import { createLiveState } from "./live.js";
 import { createSseParser } from "./sse-parser.js";
 import { SSE_PROTOCOL_HEADER } from "./sse-protocol.js";
 //#region src/adapters/sse-host.ts
+/** Reads of a transcript older than its window before a hydrate gives up (see `hydrate`). */
+const HYDRATE_ATTEMPTS = 4;
 /**
 * Creates a {@link ChatHost} over HTTP and server-sent events, talking to a handler from {@link createSseHandler}. Actions are POSTs and each watched transcript is one streaming GET that resumes after a drop.
 *
@@ -15,7 +17,7 @@ function createSseHost(options) {
 	const streams = /* @__PURE__ */ new Map();
 	const headers = async (extra) => {
 		const h = new Headers(typeof options.headers === "function" ? await options.headers() : options.headers);
-		h.set(SSE_PROTOCOL_HEADER, String(1));
+		h.set(SSE_PROTOCOL_HEADER, String(2));
 		for (const [k, v] of Object.entries(extra ?? {})) h.set(k, v);
 		return h;
 	};
@@ -43,16 +45,71 @@ function createSseHost(options) {
 				lingering.delete(sessionId);
 				streams.get(sessionId)?.abort();
 				streams.delete(sessionId);
+				stopRereadRetry(sessionId);
 			}, 1e3));
 		}
 	});
-	const hydrate = async (sessionId) => {
+	/**
+	* Reads the session's transcript into its window. If the read is older than a write the window applied since, it
+	* is read again. The first retry is at once, and each later one waits longer, up to four reads in all. So a server
+	* that keeps answering older is not asked in a loop. Then the caller's error path takes over (a stream retries on
+	* its own schedule).
+	*/
+	const hydrate = async (sessionId, attempt = 0) => {
 		const h = await request("GET", `/sessions/${sid(sessionId)}/events`);
-		state.hydrate(sessionId, h.events, { running: h.running });
+		if (!state.hydrate(sessionId, h.events, { running: h.running }, h.pos, h.historyId)) {
+			if (attempt + 1 >= HYDRATE_ATTEMPTS) throw new Error(`GET /sessions/${sessionId}/events: older than the transcript on show`);
+			const wait = attempt === 0 ? 0 : Math.min((options.reconnectMs ?? 500) * 2 ** (attempt - 1), 1e4);
+			if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+			return hydrate(sessionId, attempt + 1);
+		}
 		for (const i of state.pending(sessionId).get()) state.resolveInteraction(i.requestId);
 		for (const i of h.interactions) state.addInteraction(sessionId, i.request);
 		return h.cursor;
 	};
+	/**
+	* Reads a transcript again (a rewrite, a missed write, a run's end). One 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). If a read failed and nothing else asks, it is retried with the
+	* stream's backoff while the session is streamed and its rows are still behind. The stream resumes from its last
+	* id, so it does not read the transcript again before the session's next write.
+	*/
+	const rereads = /* @__PURE__ */ new Map();
+	const rereadRetries = /* @__PURE__ */ new Map();
+	const reread = (sessionId, failures = rereadRetries.get(sessionId)?.failures ?? 0) => {
+		const inFlight = rereads.get(sessionId);
+		if (inFlight) {
+			inFlight.again = true;
+			return;
+		}
+		clearTimeout(rereadRetries.get(sessionId)?.timer);
+		rereadRetries.delete(sessionId);
+		const entry = { again: false };
+		rereads.set(sessionId, entry);
+		let failed = false;
+		hydrate(sessionId).catch((error) => {
+			failed = true;
+			onError(error);
+		}).finally(() => {
+			rereads.delete(sessionId);
+			if (!state.tailDue(sessionId)) return;
+			if (entry.again) return reread(sessionId);
+			if (!failed || !streams.has(sessionId)) return;
+			const wait = Math.min((options.reconnectMs ?? 500) * 2 ** failures, 1e4);
+			const timer = setTimeout(() => {
+				rereadRetries.delete(sessionId);
+				if (streams.has(sessionId)) reread(sessionId, failures + 1);
+			}, wait);
+			rereadRetries.set(sessionId, {
+				timer,
+				failures: failures + 1
+			});
+		});
+	};
+	const stopRereadRetry = (sessionId) => {
+		clearTimeout(rereadRetries.get(sessionId)?.timer);
+		rereadRetries.delete(sessionId);
+	};
 	const onRecord = (sessionId, record) => {
 		switch (record.type) {
 			case "event":
@@ -60,6 +117,7 @@ function createSseHost(options) {
 				return true;
 			case "run":
 				state.setRunning(sessionId, record.data.running, record.data.running ? void 0 : record.data.ok === false ? "error" : "completed");
+				if (!record.data.running && state.takeRefetchDue(sessionId)) reread(sessionId);
 				return true;
 			case "interaction":
 				state.addInteraction(sessionId, record.data.request);
@@ -70,7 +128,11 @@ function createSseHost(options) {
 			case "session":
 				upsert(record.data.session);
 				return true;
+			case "history":
+				if (state.applyHistory(sessionId, record.data)) reread(sessionId);
+				return true;
 			case "reset": return false;
+			default: return true;
 		}
 	};
 	const open = async (sessionId) => {
@@ -160,6 +222,7 @@ function createSseHost(options) {
 				lingering.delete(sessionId);
 				streams.get(sessionId)?.abort();
 				streams.delete(sessionId);
+				stopRereadRetry(sessionId);
 				sessions.set((all) => all.filter((s) => s.id !== sessionId));
 			}
 		},
@@ -210,6 +273,8 @@ function createSseHost(options) {
 			lingering.clear();
 			for (const c of streams.values()) c.abort();
 			streams.clear();
+			for (const { timer } of rereadRetries.values()) clearTimeout(timer);
+			rereadRetries.clear();
 		}
 	};
 }

package/dist/adapters/sse-protocol.d.ts

@@ -1,8 +1,11 @@
 import { ChatEvent, ChatInteraction, ChatSession, SendInput } from "../chat/headless/host.js";
+import { HistoryChange } from "zidane/chat/pure";
 import { InteractionRequest, InteractionResponse } from "zidane/chat";
 //#region src/adapters/sse-protocol.d.ts
 /** Version of the HTTP and server-sent-events protocol between {@link createSseHost} and {@link createSseHandler}. */
-declare const SSE_PROTOCOL_VERSION = 1;
+declare const SSE_PROTOCOL_VERSION = 2;
+/** The first protocol version whose clients take `history` records. */
+declare const SSE_HISTORY_RECORDS_VERSION = 2;
 /** Name of the response header that carries the protocol version. */
 declare const SSE_PROTOCOL_HEADER = "X-Zidane-Chat-Protocol";
 /** Body of `GET /sessions/:id/events`: the transcript so far, plus what a client needs to start streaming. */
@@ -15,6 +18,10 @@ interface HydrateResponse {
   cursor: string;
   /** Requests from the agent that still wait for an answer. */
   interactions: ChatInteraction[];
+  /** The history position the events are at. A `history` record at or below it is in them already. Absent when unknown. */
+  pos?: number;
+  /** The numbering `pos` counts in (`HistoryPosition.historyId`). */
+  historyId?: string;
 }
 /** Body of `POST /sessions/:id/send`. */
 interface SendBody {
@@ -56,6 +63,9 @@ type StreamRecord = {
   data: {
     session: ChatSession;
   };
+} | {
+  type: 'history';
+  data: HistoryChange;
 } | {
   type: 'reset';
   data: Record<string, never>;
@@ -98,4 +108,4 @@ declare function attachmentsFromPreviews(attachments: SendBody['attachments']):
   name?: string;
 }[];
 //#endregion
-export { AnswerBody, HydrateResponse, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, StreamRecord, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor };
+export { AnswerBody, HydrateResponse, SSE_HISTORY_RECORDS_VERSION, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, SendBody, StreamRecord, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor };

package/dist/adapters/sse-protocol.js

@@ -1,6 +1,8 @@
 //#region src/adapters/sse-protocol.ts
 /** Version of the HTTP and server-sent-events protocol between {@link createSseHost} and {@link createSseHandler}. */
-const SSE_PROTOCOL_VERSION = 1;
+const SSE_PROTOCOL_VERSION = 2;
+/** The first protocol version whose clients take `history` records. */
+const SSE_HISTORY_RECORDS_VERSION = 2;
 /** Name of the response header that carries the protocol version. */
 const SSE_PROTOCOL_HEADER = "X-Zidane-Chat-Protocol";
 /**
@@ -53,4 +55,4 @@ function attachmentsFromPreviews(attachments) {
 	});
 }
 //#endregion
-export { SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor };
+export { SSE_HISTORY_RECORDS_VERSION, SSE_PROTOCOL_HEADER, SSE_PROTOCOL_VERSION, attachmentsFromPreviews, encodeSseRecord, formatCursor, parseCursor };

package/dist/app/AppHostProvider.js

@@ -3,6 +3,7 @@ import { ApprovalsProvider } from "../approvals/ApprovalsProvider.js";
 import { ChatProvider } from "../chat/ChatProvider.js";
 import { ComposerHostProvider } from "../chat/composer/ComposerHostProvider.js";
 import { ExtensionsProvider } from "../extensions/ExtensionsProvider.js";
+import { NoticeStackProvider } from "./NoticeStack.js";
 import { SidebarHostProvider } from "../chat/sidebar/SidebarHostProvider.js";
 import { FilesProvider } from "../files/FilesProvider.js";
 import { GitProvider } from "../git/GitProvider.js";
@@ -30,7 +31,7 @@ import { createContext, useContext } from "react";
 * `SessionProvider` when `host.session` is, `ApprovalsProvider` when
 * `host.approvals` is, `ExtensionsProvider` when `host.extensions` is, `FilesProvider` when `host.files` is, `GitProvider` when `host.git` is, `MachinesProvider` when `host.machines` is, `SettingsProvider` when `host.settings` is, `TerminalProvider` when `host.terminal` is, `KeybindingsProvider` when `host.keybindings` is and
 * `AppearanceProvider` when `host.appearance` is, and always a `KeyCommandsProvider` (the key command
-* registry: register shortcuts with `useKeyCommands`). `host.workspace` goes in
+* registry: register shortcuts with `useKeyCommands`) and a `NoticeStackProvider` (`useNotify`). `host.workspace` goes in
 * context for each `WorkspaceProvider` below (`WorkspaceHostProvider`), and
 * `host.onboarding` for each `OnboardingProvider` below (`OnboardingHostProvider`), `host.composer`
 * for each rich composer below (`ComposerHostProvider`), `host.sidebar` for the
@@ -109,11 +110,11 @@ function AppHostProvider({ host, chatLabels, loadExtensionModule, children: app
 	}) : children;
 	return /* @__PURE__ */ jsx(AppHostContext.Provider, {
 		value: host,
-		children: host.chat ? /* @__PURE__ */ jsx(ChatProvider, {
+		children: /* @__PURE__ */ jsx(NoticeStackProvider, { children: host.chat ? /* @__PURE__ */ jsx(ChatProvider, {
 			host: host.chat,
 			...chatLabels ? { labels: chatLabels } : {},
 			children: withPalette
-		}) : withPalette
+		}) : withPalette })
 	});
 }
 /** Returns the {@link AppHost} from the nearest {@link AppHostProvider}. Throws when called outside one. */

package/dist/app/ModalProvider.d.ts

@@ -151,20 +151,30 @@ interface ScreenShellProps {
   headerActions?: ReactNode;
   /** The main column's body. */
   children: ReactNode;
+  /**
+   * On a window too narrow for two columns (a phone), the one pane shown: the left column (`aside`) or the main one
+   * (`main`, with a back button to the left column). Absent: the columns sit side by side at any width.
+   */
+  narrowPane?: 'aside' | 'main';
+  /** Back from the main pane to the left column, on a narrow window. */
+  onNarrowBack?: () => void;
   /** Extra classes on the root. */
   className?: string;
   /** Inline styles on the root. */
   style?: CSSProperties;
 }
+/** Below this window width (px), a {@link ScreenShell} given `narrowPane` shows one pane at a time. */
+declare const SCREEN_NARROW_MAX = 640;
 /**
  * Two-column full-window shell mirroring the chat layout: a sidebar-width
  * left column on the tray tone (traffic-light spacer, back button,
  * then whatever navigation the surface provides) and a main column with a
  * heading row over the content. Escape and the back button both call
- * `onClose`.
+ * `onClose`. On a narrow window with `narrowPane`, one pane at a time at full
+ * width: the left column, or the main one under a back button.
  *
  * @param props - The heading, the left column, the body and `onClose`.
  */
-declare function ScreenShell({ title, description, lead, screenLabel, onClose, aside, asideFooter, headerActions, children, className, style }: ScreenShellProps): import("react").JSX.Element;
+declare function ScreenShell({ title, description, lead, screenLabel, onClose, aside, asideFooter, headerActions, children, narrowPane, onNarrowBack, className, style }: ScreenShellProps): import("react").JSX.Element;
 //#endregion
-export { LayerOptions, MODAL_TITLE_ID, ModalChromeInset, ModalContextValue, ModalOpenOptions, ModalProvider, ModalProviderProps, ModalScrimKind, ModalShell, ModalShellProps, ModalVariant, ScreenShell, ScreenShellProps, useModal, useOptionalModal };
+export { LayerOptions, MODAL_TITLE_ID, ModalChromeInset, ModalContextValue, ModalOpenOptions, ModalProvider, ModalProviderProps, ModalScrimKind, ModalShell, ModalShellProps, ModalVariant, SCREEN_NARROW_MAX, ScreenShell, ScreenShellProps, useModal, useOptionalModal };