zidane-ui 9.0.4 → 9.1.3

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

@@ -1,6 +1,14 @@
+import { DEFAULT_CHAT_LABELS } from "../labels.js";
 import { buildSessionRows } from "../session-list.js";
+import { groupRows } from "zidane/chat/pure";
 //#region src/chat/headless/sidebar/rows.ts
 /**
+* The sidebar's rows: zidane-ui's session-list model (sort, date / state /
+* project grouping, collapse, "show more") over the app's sessions, plus the
+* app's own layer on top: the Per host view's one section per host, and the
+* sections the list renders (`nestSidebarRows`).
+*/
+/**
 * The project a session is listed under: its repository's root, else its folder (`''`: none).
 *
 * @param session - Its folder and project root.
@@ -65,6 +73,51 @@ function hostFolderKey(session) {
 	if (!session.hostId || !path) return path;
 	return `${path.replace(/\/+$/, "") || "/"}${HOST_SEP}${session.hostId}`;
 }
+/**
+* The group each repository's sessions share across machines, by `repoKey`. A
+* repository with one local folder groups under that folder: its sessions on
+* servers join it. A repository only on servers groups under its first
+* server folder, in key order. A repository with several local folders (two
+* clones) is left out: each folder keeps its own group, and so does each
+* server folder.
+*
+* @param sessions - The listed sessions.
+*/
+function repoGroups(sessions) {
+	const local = /* @__PURE__ */ new Map();
+	const remote = /* @__PURE__ */ new Map();
+	for (const session of sessions) {
+		if (!session.repoKey || !projectPathOf(session)) continue;
+		if (session.hostId) {
+			const key = hostFolderKey(session);
+			const first = remote.get(session.repoKey);
+			if (first === void 0 || key < first) remote.set(session.repoKey, key);
+		} else {
+			const folders = local.get(session.repoKey) ?? /* @__PURE__ */ new Set();
+			folders.add(projectPathOf(session).replace(/\/+$/, "") || "/");
+			local.set(session.repoKey, folders);
+		}
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const [repoKey, first] of remote) {
+		const folders = local.get(repoKey);
+		if (!folders) groups.set(repoKey, first);
+		else if (folders.size === 1) groups.set(repoKey, [...folders][0]);
+	}
+	return groups;
+}
+/**
+* Whether `session` is listed under a project header: a local session in its
+* folder, or, for a header that names a `repoKey`, a server session of that
+* repository.
+*
+* @param session - The session.
+* @param project - The header's folder (`path`), its server (`hostId`) and its repository (`repoKey`).
+*/
+function isProjectMember(session, project) {
+	if (project.repoKey && session.hostId && session.repoKey === project.repoKey) return true;
+	return (session.hostId ?? void 0) === project.hostId && projectPathOf(session) === project.path;
+}
 /** A server folder's header: the folder, its server as `hostId` (a chip), without the local folder affordances. */
 function serverFolderHeader(row) {
 	if (row.kind !== "header" || !row.fullPath?.includes(HOST_SEP)) return row;
@@ -77,6 +130,15 @@ function serverFolderHeader(row) {
 		hostId
 	};
 }
+/** A header whose group holds a repository's sessions from several machines names the repository. */
+function withRepoKey(row, repoByGroup) {
+	if (row.kind !== "header" || row.fullPath === void 0) return row;
+	const repoKey = repoByGroup.get(row.fullPath);
+	return repoKey ? {
+		...row,
+		repoKey
+	} : row;
+}
 function withoutLocalPath(row) {
 	if (row.kind !== "header" || row.fullPath === void 0) return row;
 	const { fullPath: _fullPath, isGitRepo: _isGitRepo, ...rest } = row;
@@ -86,8 +148,9 @@ function withoutLocalPath(row) {
 * The sidebar's rows over every host. Per host: This computer's section
 * first, then each saved server's, each host's sessions grouped per folder
 * under its header. Any other view lists every host in one list, a server's
-* folder headers naming the server. Sessions of a server no longer saved are
-* not listed.
+* folder headers naming the server, and a repository's sessions on every
+* machine under one header ({@link repoGroups}). Sessions of a server no
+* longer saved are not listed.
 *
 * @param sessions - The sessions to list.
 * @param hosts - This machine and each saved server, in order.
@@ -98,8 +161,11 @@ function withoutLocalPath(row) {
 function buildHostSidebarRows(sessions, hosts, groupBy, sortBy, options = {}) {
 	const servers = new Map(hosts.filter((host) => host.kind === "server").map((host) => [host.id, host.name]));
 	if (groupBy !== "host") {
-		const rows = buildSidebarRows(sessions.filter((s) => !s.hostId || servers.has(s.hostId)), groupBy, sortBy, options, hostFolderKey);
-		return servers.size > 0 ? rows.map(serverFolderHeader) : rows;
+		const listed = sessions.filter((s) => !s.hostId || servers.has(s.hostId));
+		const groups = servers.size > 0 ? repoGroups(listed) : /* @__PURE__ */ new Map();
+		const repoByGroup = new Map([...groups].map(([repoKey, group]) => [group, repoKey]));
+		const rows = buildSidebarRows(listed, groupBy, sortBy, options, (s) => s.repoKey && groups.has(s.repoKey) ? groups.get(s.repoKey) : hostFolderKey(s));
+		return servers.size > 0 ? rows.map((row) => serverFolderHeader(withRepoKey(row, repoByGroup))) : rows;
 	}
 	const local = sessions.filter((s) => !s.hostId);
 	const collapsedGroups = options.collapsedGroups ?? EMPTY_SET;
@@ -127,6 +193,107 @@ function buildHostSidebarRows(sessions, hosts, groupBy, sortBy, options = {}) {
 	return out;
 }
 /**
+* An item's row and its child sessions' rows (none while it is collapsed).
+*
+* @param item - The item and its child sessions.
+* @param collapsedGroups - Collapsed row ids (an item collapses under its row id).
+*/
+function itemRows(item, collapsedGroups = EMPTY_SET) {
+	const id = `i-${item.entry.item.id}`;
+	const collapsed = collapsedGroups.has(id);
+	const out = [{
+		kind: "item",
+		id,
+		entry: item.entry,
+		collapsed,
+		childCount: item.children.length
+	}];
+	if (!collapsed) for (const session of item.children) out.push({
+		kind: "session",
+		id: session.id,
+		session,
+		itemId: id
+	});
+	return out;
+}
+const MISSING = "\0none";
+/**
+* The sidebar's rows under a query grouping (a space's, an extension's, the agents'): favorites
+* first, then one group per value in the grouping's order, the items of each group leading it. A
+* session whose value is a list is in each of its groups. The sessions come sorted.
+*
+* @param sessions - The sessions to list, in order.
+* @param groupBy - The grouping.
+* @param options - Collapse, labels, favorites and items.
+*/
+function buildQuerySidebarRows(sessions, groupBy, options = {}) {
+	const collapsedGroups = options.collapsedGroups ?? EMPTY_SET;
+	const out = [];
+	const favorites = options.isFavorite ? sessions.filter(options.isFavorite) : [];
+	const rest = favorites.length > 0 ? sessions.filter((s) => !options.isFavorite(s)) : sessions;
+	if (favorites.length > 0) {
+		const id = "h-Favorites";
+		const collapsed = collapsedGroups.has(id);
+		out.push({
+			kind: "header",
+			id,
+			label: options.favoritesLabel ?? DEFAULT_CHAT_LABELS.favorites,
+			collapsed,
+			favorites: true
+		});
+		if (!collapsed) for (const session of favorites) out.push({
+			kind: "session",
+			id: session.id,
+			session,
+			favorites: true
+		});
+	}
+	const groups = groupRows(rest, groupBy, {
+		...options.labels ? { labels: options.labels } : {},
+		...options.missingLabel ? { missingLabel: options.missingLabel } : {}
+	}).map((g) => ({
+		key: g.key,
+		label: g.label,
+		rows: g.rows
+	}));
+	const itemsByKey = /* @__PURE__ */ new Map();
+	for (const item of options.items ?? []) {
+		const key = item.entry.item.group ?? MISSING;
+		itemsByKey.set(key, [...itemsByKey.get(key) ?? [], item]);
+	}
+	for (const key of itemsByKey.keys()) {
+		if (groups.some((g) => (g.key ?? MISSING) === key)) continue;
+		const label = key === MISSING ? options.missingLabel ?? "" : groupBy.labels?.[key] ?? options.labels?.[key] ?? key;
+		const at = groups.findIndex((g) => g.key === null);
+		const group = {
+			key: key === MISSING ? null : key,
+			label,
+			rows: []
+		};
+		if (key === MISSING || at === -1) groups.push(group);
+		else groups.splice(at, 0, group);
+	}
+	for (const group of groups) {
+		const key = group.key ?? MISSING;
+		const id = `h-q:${key}`;
+		const collapsed = collapsedGroups.has(id);
+		out.push({
+			kind: "header",
+			id,
+			label: group.label,
+			collapsed
+		});
+		if (collapsed) continue;
+		for (const item of itemsByKey.get(key) ?? []) out.push(...itemRows(item, collapsedGroups));
+		for (const session of group.rows) out.push({
+			kind: "session",
+			id: session.id,
+			session
+		});
+	}
+	return out;
+}
+/**
 * The flat rows as nested sections: a host's section holds its groups, a
 * group's holds its rows. Rows before any header (a flat view) stay at the
 * top level, and so do a flat view's rows after its Favorites.
@@ -137,7 +304,24 @@ function nestSidebarRows(rows) {
 	const top = [];
 	let host = null;
 	let group = null;
+	let item = null;
 	for (const row of rows) {
+		if (row.kind === "session" && row.itemId !== void 0 && item?.id === row.itemId) {
+			item.children.push(row);
+			continue;
+		}
+		if (row.kind === "item") {
+			item = {
+				kind: "item",
+				id: row.id,
+				row,
+				children: []
+			};
+			const parent = group ?? host;
+			if (parent) parent.children.push(item);
+			else top.push(item);
+			continue;
+		}
 		if (row.kind === "host") {
 			host = {
 				kind: "section",
@@ -167,4 +351,4 @@ function nestSidebarRows(rows) {
 	return top;
 }
 //#endregion
-export { CHATS_BUCKET, buildHostSidebarRows, buildSidebarRows, groupsByFolder, nestSidebarRows, partitionMainSession, projectPathOf };
+export { CHATS_BUCKET, buildHostSidebarRows, buildQuerySidebarRows, buildSidebarRows, groupsByFolder, isProjectMember, itemRows, nestSidebarRows, partitionMainSession, projectPathOf, repoGroups };

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

@@ -27,20 +27,49 @@ interface SidebarListSession {
   isMain?: boolean;
   /** Its folder is a git repository. */
   isGitRepo?: boolean;
+  /**
+   * The repository its folder is a checkout of (`github.com/owner/repo`). Sessions of one
+   * repository on several machines are listed under one project.
+   */
+  repoKey?: string;
   /** Starred: listed under Favorites. */
   favorite?: boolean;
   /** Archived: listed only under the archived filter. */
   archived?: boolean;
+  /** The agent profile it runs (`AgentProfile.id`): the agent grouping and filter read it. */
+  agentId?: string;
+  /**
+   * What extensions computed for it, keyed `<extensionId>.<key>` (a query reads one as
+   * `facet.<extensionId>.<key>`). Absent: none, or a host that sends none.
+   */
+  facets?: Readonly<Record<string, unknown>>;
 }
 /** Which sessions the list reads: the archive axis is the one the host filters. */
 type SessionArchiveFilter = 'active' | 'archived' | 'all';
 /** Only sessions touched within the last day, 3, 7 or 30 days. */
 type SessionActivityFilter = 'all' | '1d' | '3d' | '7d' | '30d';
-/** How the sidebar groups its rows: the session list's groupings plus one section per host. */
-type SidebarGroupBy = 'none' | 'date' | 'state' | 'project' | 'host';
+/** How the sidebar groups its rows: the session list's groupings, one section per host, or one group per agent. */
+type SidebarGroupBy = 'none' | 'date' | 'state' | 'project' | 'host' | 'agent';
+/**
+ * In {@link SidebarExtensionView}: the view's own axis (`groupBy`, `sortBy`) in a space that has a
+ * grouping or sort of its own (an extension space, a saved view), where that one applies by default.
+ */
+declare const VIEW_CHOICE = "@view";
+/**
+ * The user's layer over what extensions contribute to the filter menu, kept per space with the rest
+ * of the view. Ids are the published ones (`<extension>/<id>`); an id no extension offers now is ignored.
+ */
+interface SidebarExtensionView {
+  /** Each contributed filter's value: `true` for an active toggle, an option id (select), option ids (multi). */
+  filters: Readonly<Record<string, boolean | string | readonly string[]>>;
+  /** A contributed sort, or {@link VIEW_CHOICE}. Absent: the space's sort when it has one, else `sortBy`. */
+  sort?: string;
+  /** A contributed grouping, or {@link VIEW_CHOICE}. Absent: the space's grouping when it has one, else `groupBy`. */
+  group?: string;
+}
 /** How the sidebar orders sessions inside a group. */
 type SidebarSortBy = 'recency' | 'createdTime' | 'alphabetical';
-/** The five filter axes, kept per space. */
+/** The filter axes, kept per space. */
 interface SidebarView {
   /** Active, archived or every session. */
   archive: SessionArchiveFilter;
@@ -52,6 +81,10 @@ interface SidebarView {
   groupBy: SidebarGroupBy;
   /** How the rows sort inside a group. */
   sortBy: SidebarSortBy;
+  /** Only this agent's sessions (`AgentProfile.id`), or null for every agent. */
+  agent?: string | null;
+  /** What the user picked of the extensions' filters, sorts and groupings. Absent: nothing. */
+  extension?: SidebarExtensionView;
 }
 //#endregion
-export { SessionActivityFilter, SessionArchiveFilter, SidebarGroupBy, SidebarListSession, SidebarSortBy, SidebarView };
+export { SessionActivityFilter, SessionArchiveFilter, SidebarExtensionView, SidebarGroupBy, SidebarListSession, SidebarSortBy, SidebarView, VIEW_CHOICE };

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

@@ -0,0 +1,8 @@
+//#region src/chat/headless/sidebar/types.ts
+/**
+* In {@link SidebarExtensionView}: the view's own axis (`groupBy`, `sortBy`) in a space that has a
+* grouping or sort of its own (an extension space, a saved view), where that one applies by default.
+*/
+const VIEW_CHOICE = "@view";
+//#endregion
+export { VIEW_CHOICE };

package/dist/chat/headless/sidebar/view.d.ts

@@ -28,6 +28,26 @@ interface SidebarViewsHost {
  * @param raw - The stored value.
  */
 declare function parseSidebarView(raw: unknown): SidebarView;
+/** Where the switcher's own order and hidden spaces persist. */
+declare const SIDEBAR_SWITCHER_KEY = "zg:sidebar-switcher:v1";
+/**
+ * The user's arrangement of the space switcher, over the spaces' own order: extension spaces
+ * included, which Settings › Spaces doesn't list.
+ */
+interface SpaceSwitcherPrefs {
+  /** Space ids in the order the user put them; a space not named keeps its place after them. */
+  order: readonly string[];
+  /** Space ids the switcher leaves out (their sessions stay where they are). */
+  hidden: readonly string[];
+}
+/** No arrangement yet: the spaces' own order, nothing hidden. */
+declare const DEFAULT_SWITCHER_PREFS: SpaceSwitcherPrefs;
+/**
+ * Stored switcher prefs, checked; anything malformed reads as none.
+ *
+ * @param raw - The stored value.
+ */
+declare function parseSwitcherPrefs(raw: unknown): SpaceSwitcherPrefs;
 /** Views per space id. */
 type SidebarViewMap = Record<string, SidebarView>;
 /** The conversation last open per space id. */
@@ -60,6 +80,10 @@ interface SidebarViews {
   forgetSession(sessionId: string, exceptSpaceId?: string): void;
   /** Read the host's copies once (no-op without a host). Call after creation. */
   sync(): void;
+  /** The switcher's order and hidden spaces, on this device. */
+  switcher: Readable<SpaceSwitcherPrefs>;
+  /** Replaces the switcher's prefs; persisted at once. */
+  setSwitcher(prefs: SpaceSwitcherPrefs): void;
 }
 /** Options of {@link createSidebarViews}. */
 interface SidebarViewsOptions {
@@ -79,4 +103,4 @@ interface SidebarViewsOptions {
  */
 declare function createSidebarViews(options?: SidebarViewsOptions): SidebarViews;
 //#endregion
-export { DEFAULT_SIDEBAR_VIEW, SIDEBAR_SPACE_KEY, SIDEBAR_VIEW_KEY, SidebarLastSessions, SidebarViewMap, SidebarViewRecord, SidebarViews, SidebarViewsHost, SidebarViewsOptions, SidebarViewsStorage, createSidebarViews, parseSidebarView, readSidebarViews };
+export { DEFAULT_SIDEBAR_VIEW, DEFAULT_SWITCHER_PREFS, SIDEBAR_SPACE_KEY, SIDEBAR_SWITCHER_KEY, SIDEBAR_VIEW_KEY, SidebarLastSessions, SidebarViewMap, SidebarViewRecord, SidebarViews, SidebarViewsHost, SidebarViewsOptions, SidebarViewsStorage, SpaceSwitcherPrefs, createSidebarViews, parseSidebarView, parseSwitcherPrefs, readSidebarViews };

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

@@ -42,13 +42,34 @@ const parseGroupBy = oneOf([
 	"date",
 	"state",
 	"project",
-	"host"
+	"host",
+	"agent"
 ]);
 const parseSortBy = oneOf([
 	"recency",
 	"createdTime",
 	"alphabetical"
 ]);
+function parseExtensionView(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+	const o = raw;
+	const filters = {};
+	if (o.filters && typeof o.filters === "object" && !Array.isArray(o.filters)) {
+		for (const [id, value] of Object.entries(o.filters)) if (value === true || typeof value === "string" && value.length > 0) filters[id] = value;
+		else if (Array.isArray(value)) {
+			const ids = value.filter((v) => typeof v === "string" && v.length > 0);
+			if (ids.length > 0) filters[id] = ids;
+		}
+	}
+	const sort = typeof o.sort === "string" && o.sort.length > 0 ? o.sort : void 0;
+	const group = typeof o.group === "string" && o.group.length > 0 ? o.group : void 0;
+	if (Object.keys(filters).length === 0 && !sort && !group) return void 0;
+	return {
+		filters,
+		...sort ? { sort } : {},
+		...group ? { group } : {}
+	};
+}
 /**
 * A stored view, every axis checked; what is missing or unknown takes the default.
 *
@@ -58,12 +79,37 @@ function parseSidebarView(raw) {
 	const o = raw && typeof raw === "object" ? raw : {};
 	const str = (v) => typeof v === "string" ? v : "";
 	const d = DEFAULT_SIDEBAR_VIEW;
+	const agent = typeof o.agent === "string" && o.agent.length > 0 ? o.agent : null;
+	const extension = parseExtensionView(o.extension);
 	return {
 		archive: parseArchive(str(o.archive)) ?? d.archive,
 		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: parseSortBy(str(o.sortBy)) ?? d.sortBy,
+		...agent ? { agent } : {},
+		...extension ? { extension } : {}
+	};
+}
+/** Where the switcher's own order and hidden spaces persist. */
+const SIDEBAR_SWITCHER_KEY = "zg:sidebar-switcher:v1";
+/** No arrangement yet: the spaces' own order, nothing hidden. */
+const DEFAULT_SWITCHER_PREFS = {
+	order: [],
+	hidden: []
+};
+/**
+* Stored switcher prefs, checked; anything malformed reads as none.
+*
+* @param raw - The stored value.
+*/
+function parseSwitcherPrefs(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return DEFAULT_SWITCHER_PREFS;
+	const o = raw;
+	const ids = (v) => Array.isArray(v) ? [...new Set(v.filter((x) => typeof x === "string" && x.length > 0))] : [];
+	return {
+		order: ids(o.order),
+		hidden: ids(o.hidden)
 	};
 }
 function viewsFrom(stored) {
@@ -134,6 +180,7 @@ function createSidebarViews(options = {}) {
 	const reopened = /* @__PURE__ */ new Set();
 	let switched = false;
 	let synced = false;
+	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 ? {
@@ -184,6 +231,12 @@ function createSidebarViews(options = {}) {
 			write(storage, SIDEBAR_SPACE_KEY, spaceId);
 			saveSpace(spaceId);
 		},
+		switcher,
+		setSwitcher(prefs) {
+			const next = parseSwitcherPrefs(prefs);
+			switcher.set(next);
+			write(storage, SIDEBAR_SWITCHER_KEY, JSON.stringify(next));
+		},
 		lastSessionOf: (spaceId) => lastSessions[spaceId] ?? null,
 		rememberSession(spaceId, sessionId) {
 			if (lastSessions[spaceId] === sessionId) return;
@@ -240,4 +293,4 @@ function createSidebarViews(options = {}) {
 	};
 }
 //#endregion
-export { DEFAULT_SIDEBAR_VIEW, SIDEBAR_SPACE_KEY, SIDEBAR_VIEW_KEY, createSidebarViews, parseSidebarView, readSidebarViews };
+export { DEFAULT_SIDEBAR_VIEW, DEFAULT_SWITCHER_PREFS, SIDEBAR_SPACE_KEY, SIDEBAR_SWITCHER_KEY, SIDEBAR_VIEW_KEY, createSidebarViews, parseSidebarView, parseSwitcherPrefs, readSidebarViews };

package/dist/chat/headless/streams/live-events.js

@@ -1,4 +1,4 @@
-import { appendMarkdownDelta, appendThinkingLines, finalizeStreamingMarkdown, mergeTargetIndex, ownerOf } from "zidane/chat/pure";
+import { appendMarkdownDelta, appendThinkingLines, finalizeStreamingMarkdown, mergeTargetIndex, ownerOf, upsertToolProgress } from "zidane/chat/pure";
 //#region src/chat/headless/streams/live-events.ts
 const rows = (events) => events;
 const timed = (events) => events;
@@ -48,6 +48,7 @@ function closeThinkingSegment(events, owner, now = Date.now()) {
 * @param markdown - How streamed markdown merges (`segmentChars`: where a long message splits). The reducer's default when omitted.
 */
 function applyLiveEvent(events, event, now = Date.now(), markdown) {
+	if (event.kind === "tool-progress") return upsertToolProgress(events, event);
 	const owner = ownerOf(event);
 	if (event.kind === "thinking") return timed(appendThinkingLines(rows(events), event.text, owner, event.depth, event.turnId, { onLaneOpen: (row) => ({
 		...row,

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

@@ -124,14 +124,20 @@ function createSessionStreams(options = {}) {
 		},
 		drop(sessionId) {
 			buckets.delete(sessionId);
+			transcripts.delete(sessionId);
 			store.drop(sessionId);
 		},
 		dropAll() {
 			buckets.clear();
+			transcripts.clear();
 			store.dropAll();
 		},
 		evictExcept(keep) {
 			for (const sessionId of [...buckets.keys()]) if (!keep.has(sessionId) && !store.getRunningSnapshot(sessionId)) buckets.delete(sessionId);
+			for (const sessionId of [...transcripts.keys()]) {
+				if (keep.has(sessionId) || store.getRunningSnapshot(sessionId) || store.getPageSnapshot(sessionId).loadingEarlier) continue;
+				transcripts.delete(sessionId);
+			}
 			store.evictExcept(keep);
 		},
 		confirmIdle(sessionId) {

package/dist/chat/headless/transcript/batch.d.ts

@@ -29,6 +29,26 @@ declare function summarizeToolBatch(tools: ReadonlyArray<Extract<Row, {
 declare const TOOL_GROUP_BOUNDARIES: ReadonlySet<Row['kind']>;
 declare const FOLD_CACHE: WeakMap<object, Row>;
 declare function sameMembers(a: readonly Row[], b: readonly Row[]): boolean;
+/**
+ * The id an aggregate row (a batch, an exchange fold, a message group) was
+ * first given, remembered by each of its members. A page of older history
+ * landing in front of the window extends the first aggregate backwards (its
+ * prompt, its earlier calls arrive): an id read off its new first member
+ * changed its React key, and the row remounted under the reader, blank for a
+ * frame. One hold per kind of aggregate: a prompt bounds both a fold and a
+ * message group.
+ */
+declare class IdHold {
+  private readonly ids;
+  /**
+   * The id one of `members` was given before, else `fresh`; never one `used` already holds (ids must stay unique in a pass).
+   *
+   * @param members - The aggregate's member rows.
+   * @param fresh - The id read off the aggregate as it is now.
+   * @param used - The ids this pass has given so far; the result is added.
+   */
+  take(members: readonly object[], fresh: string, used: Set<string>): string;
+}
 /**
  * Group consecutive `tool` rows (≥2) into a single `tool-batch` row so
  * the renderer can paint one Claude-Code-style collapsible header
@@ -74,4 +94,4 @@ declare function batchToolRuns(rows: readonly Row[], groupToolCalls?: boolean):
  */
 declare function batchThinkingRuns(rows: readonly Row[]): Row[];
 //#endregion
-export { FOLD_CACHE, TOOL_GROUP_BOUNDARIES, batchThinkingRuns, batchToolRuns, clusterByOwner, sameMembers, summarizeToolBatch };
+export { FOLD_CACHE, IdHold, TOOL_GROUP_BOUNDARIES, batchThinkingRuns, batchToolRuns, clusterByOwner, sameMembers, summarizeToolBatch };

package/dist/chat/headless/transcript/batch.js

@@ -118,10 +118,52 @@ function sameMembers(a, b) {
 	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 	return true;
 }
-function stableBatch(cache, members, membersOf, build) {
+/**
+* The id an aggregate row (a batch, an exchange fold, a message group) was
+* first given, remembered by each of its members. A page of older history
+* landing in front of the window extends the first aggregate backwards (its
+* prompt, its earlier calls arrive): an id read off its new first member
+* changed its React key, and the row remounted under the reader, blank for a
+* frame. One hold per kind of aggregate: a prompt bounds both a fold and a
+* message group.
+*/
+var IdHold = class {
+	ids = /* @__PURE__ */ new WeakMap();
+	/**
+	* The id one of `members` was given before, else `fresh`; never one `used` already holds (ids must stay unique in a pass).
+	*
+	* @param members - The aggregate's member rows.
+	* @param fresh - The id read off the aggregate as it is now.
+	* @param used - The ids this pass has given so far; the result is added.
+	*/
+	take(members, fresh, used) {
+		let id;
+		for (const member of members) {
+			const held = this.ids.get(member);
+			if (held !== void 0 && !used.has(held)) {
+				id = held;
+				break;
+			}
+		}
+		if (id === void 0) {
+			id = fresh;
+			for (let n = 2; used.has(id); n++) id = `${fresh}~${n}`;
+		}
+		for (const member of members) this.ids.set(member, id);
+		used.add(id);
+		return id;
+	}
+};
+const TOOL_BATCH_IDS = new IdHold();
+const TOOL_GROUP_IDS = new IdHold();
+const THINKING_BATCH_IDS = new IdHold();
+function stableBatch(cache, hold, used, members, membersOf, fresh, build) {
 	const hit = cache.get(members[0]);
-	if (hit && sameMembers(membersOf(hit), members)) return hit;
-	const next = build();
+	if (hit && sameMembers(membersOf(hit), members) && !used.has(hit.id)) {
+		used.add(hit.id);
+		return hit;
+	}
+	const next = build(hold.take(members, fresh, used));
 	cache.set(members[0], next);
 	return next;
 }
@@ -153,15 +195,16 @@ function stableBatch(cache, members, membersOf, build) {
 */
 function liftExchangeToolGroups(rows) {
 	const out = [...rows];
+	const used = /* @__PURE__ */ new Set();
 	let exchange = [];
 	const flush = () => {
 		if (exchange.length >= 2) {
 			const tools = exchange.map((i) => rows[i]);
 			const first = tools[0];
-			out[exchange[0]] = stableBatch(TOOL_GROUP_CACHE, tools, (row) => row.tools, () => ({
+			out[exchange[0]] = stableBatch(TOOL_GROUP_CACHE, TOOL_GROUP_IDS, used, tools, (row) => row.tools, `tg-${first.id}`, (id) => ({
 				...first.turnId !== void 0 ? { turnId: first.turnId } : {},
 				kind: "tool-batch",
-				id: `tg-${first.id}`,
+				id,
 				summary: summarizeToolBatch(tools),
 				tools
 			}));
@@ -206,19 +249,20 @@ function liftExchangeToolGroups(rows) {
 function batchToolRuns(rows, groupToolCalls = false) {
 	const pre = groupToolCalls ? liftExchangeToolGroups(rows) : rows;
 	const out = [];
+	const used = /* @__PURE__ */ new Set();
 	let run = [];
 	const flush = () => {
 		if (run.length === 0) return;
 		if (run.length === 1) out.push(run[0]);
 		else {
 			const first = run[0];
-			const id = `tb-${first.id}`;
+			const fresh = `tb-${first.id}`;
 			const owned = {};
 			if (first.childId !== void 0) owned.childId = first.childId;
 			if (first.depth !== void 0) owned.depth = first.depth;
 			if (first.turnId !== void 0) owned.turnId = first.turnId;
 			const tools = run;
-			out.push(stableBatch(TOOL_BATCH_CACHE, tools, (row) => row.tools, () => ({
+			out.push(stableBatch(TOOL_BATCH_CACHE, TOOL_BATCH_IDS, used, tools, (row) => row.tools, fresh, (id) => ({
 				...owned,
 				kind: "tool-batch",
 				id,
@@ -272,6 +316,7 @@ const THINKING_CHAIN_TRANSPARENT = /* @__PURE__ */ new Set(["tool", "tool-batch"
 */
 function batchThinkingRuns(rows) {
 	const out = [];
+	const used = /* @__PURE__ */ new Set();
 	let chain = [];
 	/** Rows between chained thoughts, re-emitted after the group. */
 	let deferred = [];
@@ -284,10 +329,10 @@ function batchThinkingRuns(rows) {
 			if (first.turnId !== void 0) owned.turnId = first.turnId;
 			const totalMs = chain.reduce((sum, t) => sum + (t.thinkingMs ?? 0), 0);
 			const thoughts = chain;
-			out.push(stableBatch(THINKING_BATCH_CACHE, thoughts, (row) => row.thoughts, () => ({
+			out.push(stableBatch(THINKING_BATCH_CACHE, THINKING_BATCH_IDS, used, thoughts, (row) => row.thoughts, `kb-${first.id}`, (id) => ({
 				...owned,
 				kind: "thinking-batch",
-				id: `kb-${first.id}`,
+				id,
 				thoughts,
 				...totalMs > 0 ? { totalMs } : {}
 			})));
@@ -313,4 +358,4 @@ function batchThinkingRuns(rows) {
 	return out;
 }
 //#endregion
-export { FOLD_CACHE, TOOL_GROUP_BOUNDARIES, batchThinkingRuns, batchToolRuns, clusterByOwner, sameMembers, summarizeToolBatch };
+export { FOLD_CACHE, IdHold, TOOL_GROUP_BOUNDARIES, batchThinkingRuns, batchToolRuns, clusterByOwner, sameMembers, summarizeToolBatch };