@thaut/claude-ide 0.0.0-stage → 1.0.0

package/web/src/drafts.ts

@@ -0,0 +1,64 @@
+import { create } from "zustand";
+import type { ImageInput } from "@shared/protocol.ts";
+
+export type Attached = ImageInput & { id: string; url: string };
+export type Draft = { text: string; images: Attached[]; revision: number; generation: number; processing: number; rewindId?: string };
+export const useDrafts = create<{ drafts: Record<string, Draft> }>(() => ({ drafts: {} }));
+const key = (sid: string) => `cide.draft.${sid}`;
+const rewindKey = (sid: string) => `cide.draft-rewind.${sid}`;
+function read(key: string): string | undefined {
+  try { return localStorage.getItem(key) ?? undefined; } catch { return undefined; }
+}
+
+export function getDraft(sid: string): Draft {
+  const current = useDrafts.getState().drafts[sid];
+  if (current) return current;
+  const draft: Draft = { text: read(key(sid)) ?? "", images: [], revision: 0, generation: 0, processing: 0, rewindId: read(rewindKey(sid)) };
+  useDrafts.setState((s) => ({ drafts: { ...s.drafts, [sid]: draft } }));
+  return draft;
+}
+function write(sid: string, draft: Draft) {
+  useDrafts.setState((s) => ({ drafts: { ...s.drafts, [sid]: draft } }));
+  try {
+    if (draft.text) localStorage.setItem(key(sid), draft.text);
+    else localStorage.removeItem(key(sid));
+    if (draft.rewindId) localStorage.setItem(rewindKey(sid), draft.rewindId);
+    else localStorage.removeItem(rewindKey(sid));
+  } catch { /* In-memory drafts still work when storage is unavailable. */ }
+}
+export function editDraft(sid: string, patch: Partial<Pick<Draft, "text" | "images">>) {
+  const draft = getDraft(sid);
+  write(sid, { ...draft, ...patch, revision: draft.revision + 1 });
+}
+export function clearDraft(sid: string, revision?: number) {
+  const draft = getDraft(sid);
+  if (revision !== undefined && draft.revision !== revision) return;
+  write(sid, { ...draft, text: "", images: [], processing: 0, revision: draft.revision + 1, generation: draft.generation + 1 });
+}
+/** An explicit rewind replaces the draft; a server replay only initializes an untouched draft once. */
+export function setDraft(sid: string, text: string, rewindId?: string) {
+  const draft = getDraft(sid);
+  write(sid, { ...draft, text, images: [], processing: 0, rewindId, revision: draft.revision + 1, generation: draft.generation + 1 });
+}
+export function restoreRewindDraft(sid: string, text: string, rewindId: string, generation?: number) {
+  const draft = getDraft(sid);
+  if (generation !== undefined && draft.generation !== generation) return;
+  if (draft.rewindId === rewindId) return;
+  // Remember this rewind even when the user already has a draft (including an intentionally emptied one).
+  if (draft.text || draft.images.length || draft.processing || draft.revision) write(sid, { ...draft, rewindId });
+  else setDraft(sid, text, rewindId);
+}
+/** Reading belongs to the source session even after its Composer has unmounted. */
+export async function addDraftImages(sid: string, count: number, prepare: () => Promise<Attached[]>) {
+  const draft = getDraft(sid);
+  const generation = draft.generation;
+  write(sid, { ...draft, processing: draft.processing + count });
+  try {
+    const images = await prepare();
+    const current = getDraft(sid);
+    if (current.generation === generation) editDraft(sid, { images: [...current.images, ...images] });
+  } finally {
+    const current = getDraft(sid);
+    if (current.generation === generation) write(sid, { ...current, processing: Math.max(0, current.processing - count) });
+  }
+}

package/web/src/format.ts

@@ -0,0 +1,5 @@
+export function formatSize(n: number) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}

package/web/src/highlight.worker.ts

@@ -0,0 +1,49 @@
+/// <reference lib="webworker" />
+/**
+ * Syntax highlighting off the main thread: highlighting a few thousand lines takes
+ * seconds on a phone, and the page must keep scrolling and typing meanwhile.
+ * Shiki is loaded lazily (core + JS regex engine, no wasm); each grammar is its own chunk.
+ */
+
+type Highlighter = {
+  codeToHtml: (code: string, opts: { lang: string; themes: Record<string, string>; defaultColor: false }) => string;
+  loadLanguage: (...langs: unknown[]) => Promise<void>;
+  getLoadedLanguages: () => string[];
+};
+
+let highlighter: Promise<{ hl: Highlighter; langs: Record<string, () => Promise<unknown>> }> | undefined;
+
+function getHighlighter() {
+  highlighter ??= (async () => {
+    const [{ createHighlighterCore }, { createJavaScriptRegexEngine }, { bundledLanguages }, { bundledThemes }] = await Promise.all([
+      import("shiki/core"),
+      import("shiki/engine/javascript"),
+      import("shiki/langs"),
+      import("shiki/themes"),
+    ]);
+    const hl = await createHighlighterCore({
+      themes: [bundledThemes["github-light"](), bundledThemes["github-dark"]()],
+      langs: [],
+      engine: createJavaScriptRegexEngine({ forgiving: true }),
+    });
+    return { hl: hl as unknown as Highlighter, langs: bundledLanguages as unknown as Record<string, () => Promise<unknown>> };
+  })();
+  return highlighter;
+}
+
+async function highlight(code: string, lang: string): Promise<string | null> {
+  const { hl, langs } = await getHighlighter();
+  const loader = langs[lang];
+  if (!loader) return null;
+  if (!hl.getLoadedLanguages().includes(lang)) await hl.loadLanguage(loader());
+  const html = hl.codeToHtml(code, { lang, themes: { light: "github-light", dark: "github-dark" }, defaultColor: false });
+  // Keep only the <code> body; lines become blocks, so drop the newlines between them.
+  const m = /<code>([\s\S]*)<\/code>/.exec(html);
+  return m ? m[1]!.replace(/<\/span>\n<span class="line">/g, '</span><span class="line">') : null;
+}
+
+self.onmessage = async (e: MessageEvent<{ id: number; code: string; lang: string }>) => {
+  const { id, code, lang } = e.data;
+  const html = await highlight(code, lang).catch(() => null);
+  self.postMessage({ id, html });
+};

package/web/src/hooks.ts

@@ -0,0 +1,59 @@
+import { useQuery } from "@tanstack/react-query";
+import type { CommandInfo, ModelOption, ProjectInfo, SessionListItem } from "@shared/protocol.ts";
+import { api } from "./api.ts";
+
+export function useProjects() {
+  return useQuery({ queryKey: ["projects"], queryFn: () => api<ProjectInfo[]>("/api/projects") });
+}
+
+export function useSessions(projectId: string | undefined) {
+  return useQuery({
+    queryKey: ["sessions", projectId],
+    queryFn: () => api<SessionListItem[]>(`/api/projects/${projectId}/sessions`),
+    enabled: !!projectId,
+  });
+}
+
+export function useModels(projectId: string | undefined) {
+  return useQuery({
+    queryKey: ["models", projectId],
+    queryFn: () => api<ModelOption[]>(`/api/projects/${projectId}/models`),
+    enabled: !!projectId,
+    staleTime: 10 * 60_000,
+  });
+}
+
+export function useCommands(projectId: string | undefined) {
+  return useQuery({
+    queryKey: ["commands", projectId],
+    queryFn: () => api<CommandInfo[]>(`/api/projects/${projectId}/commands`),
+    enabled: !!projectId,
+    staleTime: 10 * 60_000,
+  });
+}
+
+export type OverviewItem = {
+  projectId: string;
+  projectName: string;
+  sessionId: string;
+  title: string;
+  state: "idle" | "running" | "requires_action";
+  waitingFor: ("ask" | "plan")[];
+  crons: number;
+  /** Optional for older servers; used to dedupe project-wide durable tasks. */
+  cronIds?: string[];
+  tasks: number;
+};
+
+export function useOverview() {
+  return useQuery({ queryKey: ["overview"], queryFn: () => api<OverviewItem[]>("/api/overview"), refetchInterval: 30_000 });
+}
+
+export function relativeTime(ms: number): string {
+  const s = Math.round((Date.now() - ms) / 1000);
+  if (s < 60) return "刚刚";
+  if (s < 3600) return `${Math.floor(s / 60)} 分钟前`;
+  if (s < 86400) return `${Math.floor(s / 3600)} 小时前`;
+  if (s < 86400 * 7) return `${Math.floor(s / 86400)} 天前`;
+  return new Date(ms).toLocaleDateString();
+}

package/web/src/item-view-state.test.ts

@@ -0,0 +1,51 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { ItemViewState } from "./item-view-state.ts";
+import { Transcript } from "./transcript.ts";
+
+test("manual stream collapse survives completion, remount and later preference changes", () => {
+  const state = new ItemViewState();
+  const transcript = new Transcript();
+  const events = [{ k: "delta" as const, msgId: "api", index: 0, kind: "thinking" as const, text: "thought", parent: null }];
+  const streaming = transcript.update(undefined, events)[0]!;
+  assert.equal(state.read(streaming.key, true, true).value, true);
+  const collapsed = state.write(streaming.key, false);
+  const completed = transcript.update(undefined, [...events, { k: "sdk", m: { type: "assistant", uuid: "frame", message: { id: "api", content: [{ type: "thinking", thinking: "thought" }] } } }])[0]!;
+  assert.ok(completed.kind === "thinking" && completed.streamStateKey);
+  assert.equal(state.read(completed.key, true, true, [completed.streamStateKey]), collapsed);
+  assert.equal(state.read(completed.key, true, true).value, false, "remount can use the final key alone");
+  const reopened = state.write(completed.key, true);
+  assert.equal(state.read(streaming.key, false, true), reopened, "replaying the stream alias sees the latest explicit action");
+  assert.equal(state.read("another-block", false, true).value, false);
+});
+
+test("late alias discovery overrides a mounted default but never a newer explicit choice", () => {
+  const state = new ItemViewState();
+  const mounted = state.read("final", true, true);
+  const streamChoice = state.write("stream", false);
+  assert.equal(state.read("final", true, true, ["stream"], mounted), streamChoice);
+  const finalChoice = state.write("final", true);
+  assert.equal(state.read("final", false, true, ["stream"], streamChoice), finalChoice);
+  assert.equal(state.read("stream", false, true), finalChoice);
+});
+
+test("default-only aliases preserve the original default and independent cards stay isolated", () => {
+  const state = new ItemViewState();
+  const original = state.read("stream", false, true);
+  state.read("final", true, true);
+  assert.equal(state.read("final", true, true, ["stream"]), original);
+  state.write("other:open", true);
+  assert.equal(state.read("other:all", false).value, false, "show-all and fold state are separate");
+  assert.equal(state.read(undefined, false).value, false);
+  const local = state.write(undefined, true);
+  assert.equal(state.read(undefined, false, false, [], local), local);
+});
+
+test("cache eviction is bounded while a mounted explicit choice can still be restored", () => {
+  const state = new ItemViewState(3);
+  const mounted = state.write("old", false);
+  for (const id of ["a", "b", "c"]) state.read(id, true, true);
+  assert.equal(state.read("old", true).value, true, "old unmounted state was evicted");
+  assert.equal(state.read("old", true, true, [], mounted), mounted);
+  assert.equal(state.read("a", false).value, false, "restoring mounted state still honors the capacity");
+});

package/web/src/item-view-state.ts

@@ -0,0 +1,43 @@
+export type ViewChoice = { value: boolean; revision: number };
+
+/** Scalar-only, bounded UI state for virtualized items. A completed reasoning
+ * block aliases its former stream key; explicit actions outrank either default. */
+export class ItemViewState {
+  private choices = new Map<string, ViewChoice>();
+  private revision = 0;
+
+  constructor(private readonly limit = 7500) {}
+
+  read(key: string | undefined, initial: boolean, rememberInitial = false, aliases: readonly string[] = [], mounted?: ViewChoice): ViewChoice {
+    if (key === undefined) return mounted ?? { value: initial, revision: 0 };
+    const keys = [...aliases, key];
+    const known = keys.flatMap((id) => this.choices.has(id) ? [this.choices.get(id)!] : []);
+    let choice = known[0] ?? mounted ?? { value: initial, revision: 0 };
+    for (const candidate of [...known, ...(mounted ? [mounted] : [])]) {
+      if (candidate.revision > choice.revision) choice = candidate;
+    }
+    if (known.length || rememberInitial || choice.revision > 0) this.link(keys, choice);
+    return choice;
+  }
+
+  write(key: string | undefined, value: boolean, aliases: readonly string[] = []): ViewChoice {
+    const choice = { value, revision: ++this.revision };
+    if (key !== undefined) this.link([...aliases, key], choice);
+    return choice;
+  }
+
+  private link(keys: readonly string[], choice: ViewChoice) {
+    const previous = new Set(keys.flatMap((key) => {
+      const value = this.choices.get(key);
+      return value && value !== choice ? [value] : [];
+    }));
+    if (previous.size) for (const [key, value] of this.choices) {
+      if (previous.has(value)) this.choices.set(key, choice);
+    }
+    for (const key of keys) {
+      if (this.choices.get(key) === choice) continue;
+      this.choices.delete(key); this.choices.set(key, choice);
+    }
+    while (this.choices.size > this.limit) this.choices.delete(this.choices.keys().next().value!);
+  }
+}

package/web/src/live-history-flow.test.ts

@@ -0,0 +1,77 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mergeSnapshot } from "./live-merge.ts";
+
+// Store/history flows need only the document's build metadata, not a browser.
+(globalThis as any).document = { querySelector: () => null };
+const { useLive, subscribeSession, loadSessionHistory } = await import("./live.ts");
+const snapshot = { state: "idle" as const, pending: [], planMode: false, crons: [], tasks: [] };
+const page = (revision = "branch") => ({ items: [{ type: "user", uuid: "persisted", message: { content: "history" } }], generation: "g", historyRevision: revision, older: "older" });
+const attach = (revision: string, reset = true) => {
+  const current = useLive.getState().sessions.s;
+  useLive.setState({ sessions: { s: mergeSnapshot(current, { epoch: "e", seq: 2, reset, historyRevision: revision, live: snapshot, events: [] }) } });
+};
+
+test("HTTP-first history works without WS, and first/checkpoint WS preserve historical browsing", async () => {
+  const original = globalThis.fetch;
+  let requests = 0;
+  globalThis.fetch = async () => { requests++; return Response.json(page()); };
+  useLive.setState({ sessions: {}, connected: false });
+  const unsubscribe = subscribeSession("s", "p");
+  try {
+    await loadSessionHistory("s", "p");
+    await loadSessionHistory("s", "p", "older");
+    const before = useLive.getState().sessions.s!;
+    assert.equal(before.history?.mode, "history");
+    assert.equal(requests, 2);
+    assert.equal(useLive.getState().connected, false);
+    attach("branch");
+    assert.deepEqual(useLive.getState().sessions.s?.history, before.history);
+    attach("branch");
+    assert.deepEqual(useLive.getState().sessions.s?.history, before.history);
+    assert.equal(useLive.getState().sessions.s?.resetCount, before.resetCount);
+    attach("rewound");
+    assert.equal(useLive.getState().sessions.s?.history, undefined);
+    assert.equal(useLive.getState().sessions.s?.resetCount, before.resetCount + 1);
+  } finally { unsubscribe(); globalThis.fetch = original; }
+});
+
+test("in-flight HTTP accepts matching first WS and rejects a stale branch without stranded loading", async () => {
+  const original = globalThis.fetch;
+  let resolve!: (response: Response) => void;
+  globalThis.fetch = () => new Promise((r) => { resolve = r; });
+  const unsubscribe = subscribeSession("s", "p");
+  try {
+    useLive.setState({ sessions: { s: { seq: 0, snapshot, events: [], resetCount: 0 } } });
+    const matching = loadSessionHistory("s", "p");
+    attach("branch");
+    resolve(Response.json(page()));
+    await matching;
+    assert.equal(useLive.getState().sessions.s?.history?.items[0]?.uuid, "persisted");
+    useLive.setState({ sessions: { s: { seq: 0, snapshot, events: [], resetCount: 0 } } });
+    const stale = loadSessionHistory("s", "p");
+    attach("rewound");
+    resolve(Response.json(page()));
+    await stale;
+    assert.equal(useLive.getState().sessions.s?.history, undefined);
+    assert.equal(useLive.getState().sessions.s?.resetCount, 1);
+    assert.equal(useLive.getState().sessions.s?.historyRevision, "rewound");
+  } finally { unsubscribe(); globalThis.fetch = original; }
+});
+
+
+test("HTTP adopts a recreated server view while WS is unavailable instead of retrying forever", async () => {
+  const original = globalThis.fetch;
+  globalThis.fetch = async () => Response.json(page("recreated"));
+  const unsubscribe = subscribeSession("s", "p");
+  try {
+    useLive.setState({ sessions: { s: { seq: 8, snapshot, events: [{ k: "user", uuid: "abandoned", text: "old", ts: 1 }], resetCount: 0, historyRevision: "previous" } } });
+    await loadSessionHistory("s", "p");
+    assert.equal(useLive.getState().sessions.s?.historyRevision, "recreated");
+    assert.equal(useLive.getState().sessions.s?.events.length, 0);
+    assert.equal(useLive.getState().sessions.s?.resetCount, 1);
+    await loadSessionHistory("s", "p");
+    assert.equal(useLive.getState().sessions.s?.resetCount, 1);
+    assert.equal(useLive.getState().sessions.s?.history?.loading, undefined);
+  } finally { unsubscribe(); globalThis.fetch = original; }
+});

package/web/src/live-merge.test.ts

@@ -0,0 +1,64 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { LiveEvent, LiveSnapshot } from "@shared/protocol.ts";
+import { mergeSnapshot, updateTodosFromEvents } from "./live-merge.ts";
+
+const live: LiveSnapshot = { state: "idle", pending: [], planMode: false, crons: [], tasks: [] };
+const ev = (n: number): LiveEvent => ({ k: "user", uuid: `u${n}`, text: `m${n}`, ts: n });
+
+test("the same incremental snapshot delivered twice appends its events once", () => {
+  const base = mergeSnapshot(undefined, { epoch: "e", seq: 2, reset: true, live, events: [{ seq: 1, ev: ev(1) }, { seq: 2, ev: ev(2) }] });
+  const inc = { epoch: "e", seq: 4, reset: false, live, events: [{ seq: 3, ev: ev(3) }, { seq: 4, ev: ev(4) }] };
+  const once = mergeSnapshot(base, inc);
+  const twice = mergeSnapshot(once, inc);
+  assert.deepEqual(twice.events.map((e) => (e as { uuid: string }).uuid), ["u1", "u2", "u3", "u4"]);
+  assert.equal(twice.seq, 4);
+});
+
+test("a reset snapshot replaces events and bumps resetCount", () => {
+  const base = mergeSnapshot(undefined, { epoch: "e", seq: 2, reset: true, live, events: [{ seq: 2, ev: ev(2) }] });
+  const next = mergeSnapshot(base, { epoch: "f", seq: 1, reset: true, live, events: [{ seq: 1, ev: ev(9) }] });
+  assert.equal(next.events.length, 1);
+  assert.equal(next.resetCount, base.resetCount + 1);
+});
+
+test("reconnect replay updates cached todos exactly like newly received messages", () => {
+  const base = mergeSnapshot(undefined, { epoch: "e", seq: 1, reset: true, live, events: [{ seq: 1, ev: ev(1) }] });
+  base.todos = [{ id: "1", subject: "first", status: "pending" }, { id: "2", subject: "second", status: "pending" }];
+  const fresh: LiveEvent[] = [{ k: "sdk", m: { type: "assistant", uuid: "updates", message: { content: [
+    { type: "tool_use", id: "update", name: "TaskUpdate", input: { taskId: "1", status: "completed" } },
+    { type: "tool_use", id: "delete", name: "TaskUpdate", input: { taskId: "2", status: "deleted" } },
+  ] } } }];
+  const msg = { epoch: "e", seq: 2, reset: false, live, events: [{ seq: 2, ev: fresh[0]! }] };
+  const next = mergeSnapshot(base, msg);
+  assert.deepEqual(next.todos, [{ id: "1", subject: "first", status: "completed" }]);
+  assert.deepEqual(next.todos, updateTodosFromEvents([...base.events, ...fresh], fresh, base.todos));
+  assert.deepEqual(mergeSnapshot(next, msg).todos, next.todos);
+  assert.equal(next.resetCount, base.resetCount);
+});
+
+test("reset replay does not inherit todos from the previous conversation branch", () => {
+  const base = mergeSnapshot(undefined, { epoch: "e", seq: 1, reset: true, live, events: [] });
+  base.todos = [{ id: "old", subject: "old branch", status: "pending" }];
+  const next = mergeSnapshot(base, { epoch: "e", seq: 2, reset: true, live, events: [{ seq: 2, ev: ev(2) }] });
+  assert.equal(next.todos, undefined);
+});
+
+
+test("checkpoint replay replaces cumulative draft but retains history and todos on the same view", () => {
+  const base = mergeSnapshot(undefined, { epoch: "e", seq: 1, reset: true, historyRevision: "view", live,
+    events: [{ seq: 1, ev: { k: "delta", msgId: "m", index: 0, kind: "text", text: "old", parent: null } }] });
+  base.history = { items: [], generation: "g", mode: "history", source: "main", request: 1 };
+  base.todos = [{ id: "t", subject: "keep", status: "pending" }];
+  const next = mergeSnapshot(base, { epoch: "e", seq: 2, reset: true, historyRevision: "view", live,
+    events: [{ seq: 2, ev: { k: "delta", msgId: "m", index: 0, kind: "text", text: "complete", parent: null, checkpoint: true } }] });
+  assert.equal(next.history, base.history);
+  assert.deepEqual(next.todos, base.todos);
+  assert.equal(next.resetCount, base.resetCount);
+  assert.equal(next.events.length, 1);
+  assert.equal((next.events[0] as any).text, "complete");
+  const rewound = mergeSnapshot(next, { epoch: "e", seq: 3, reset: false, historyRevision: "new-view", live, events: [] });
+  assert.equal(rewound.history, undefined);
+  assert.equal(rewound.todos, undefined);
+  assert.equal(rewound.resetCount, next.resetCount + 1);
+});

package/web/src/live-merge.ts

@@ -0,0 +1,50 @@
+import { boundSession, compactEvents, type HistoryWindow } from "./message-cache.ts";
+import type { LiveEvent, LiveSnapshot, SeqEvent } from "@shared/protocol.ts";
+import { buildItems, deriveTodos, type Todo } from "./transcript.ts";
+import { mergeAgentOwners } from "./agent-owners.ts";
+
+export type SessionLive = {
+  epoch?: string;
+  historyRevision?: string;
+  seq: number;
+  snapshot: LiveSnapshot;
+  events: LiveEvent[];
+  agentOwners?: Record<string, string>;
+  /** Bumped only when the transcript branch/view is invalidated. */
+  resetCount: number;
+  history?: HistoryWindow;
+  evicted?: boolean;
+  accessed?: number;
+  todos?: import("@shared/todos.ts").Todo[];
+};
+
+/** Replayed and newly received SDK messages must update the same cached todo state. */
+export function updateTodosFromEvents(events: LiveEvent[], added: LiveEvent[], initial?: Todo[]): Todo[] | undefined {
+  return added.some((e) => e.k === "sdk" && (e.m.type === "user" || e.m.type === "assistant"))
+    ? deriveTodos(buildItems(undefined, events), initial)
+    : initial;
+}
+
+/**
+ * Apply a subscription snapshot. `reset` replaces live replay, while the view revision
+ * determines whether persisted history is still valid. Incremental replay is idempotent.
+ */
+export function mergeSnapshot(
+  cur: SessionLive | undefined,
+  msg: { epoch: string; seq: number; reset: boolean; historyRevision?: string; live: LiveSnapshot; events: SeqEvent[] },
+): SessionLive {
+  // Legacy snapshots cannot prove branch continuity. New servers always attach a view
+  // revision, including the first WS response after an HTTP-only bootstrap.
+  const invalidated = !!cur && (msg.historyRevision !== undefined
+    ? cur.historyRevision !== undefined && cur.historyRevision !== msg.historyRevision
+    : msg.reset);
+  const replace = msg.reset || !cur || invalidated;
+  const fresh = replace ? msg.events.map((e) => e.ev) : msg.events.filter((e) => e.seq > cur!.seq).map((e) => e.ev);
+  const events = replace ? compactEvents(fresh) : fresh.length ? compactEvents([...cur!.events, ...fresh]) : cur!.events;
+  return boundSession({ ...cur, epoch: msg.epoch, historyRevision: msg.historyRevision ?? cur?.historyRevision,
+    agentOwners: mergeAgentOwners(invalidated ? undefined : cur?.agentOwners, fresh, msg.live.agentTasks),
+    seq: replace ? msg.seq : Math.max(msg.seq, cur!.seq), snapshot: msg.live, events,
+    history: invalidated ? undefined : cur?.history,
+    todos: updateTodosFromEvents(events, fresh, invalidated ? undefined : cur?.todos),
+    resetCount: (cur?.resetCount ?? 0) + (invalidated ? 1 : 0), accessed: Date.now() });
+}