@mirrowel/opencode-openshare 0.1.0 → 0.2.0-dev.1

package/src/core.ts

@@ -45,6 +45,7 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { METADATA_KEY, loadConfig, resolveShareMode, spoolDirFor, URL_FILE_NONE, resolveServer, saveServerToken, type ShareConfig, type ShareMode, type ServerEntry } from "./config.js"
+import { CONTRACT_VERSION, cursorFor, isV2NativeMessage, messageTombstone, normalizeV1Diff, normalizeV1Message } from "./contract.js"
 
 // --- minimal structural types (hand-written: the standalone bundle must
 // not depend on the plugin SDK at runtime; shapes verified against
@@ -148,6 +149,10 @@ type SessionState = {
   /** any remote completed a handshake — used to detect LATER creates
    * (fan-out adds, post-mismatch recreates) which need a history backfill */
   everConnected: boolean
+  /** contract v2 merge state: v1 hosts stream parts separately; the v2
+   * item embeds content, so the engine holds the assembled view per
+   * message and re-emits the normalized whole on every update */
+  merged: Map<string, { info?: Record<string, unknown>; parts: Map<string, Record<string, unknown>> }>
 }
 
 type Message = { info?: Record<string, unknown>; parts?: Record<string, unknown>[] }
@@ -239,10 +244,11 @@ type ItemEntry = { key: string; item: Record<string, unknown> }
 function itemFor(type: string, data: unknown, sessionID: string): ItemEntry | undefined {
   if (type === "model") return { key: `model/${sessionID}`, item: { type, sessionID, data } }
   if (type === "prefs") return { key: "prefs", item: { type, data } }
-  if (type === "session") return { key: `session/${(data as SessionInfo)?.id ?? ""}`, item: { type, data } }
-  if (type === "message") return { key: `message/${(data as MessageInfo)?.id ?? ""}`, item: { type, data } }
-  if (type === "part")
-    return { key: `part/${(data as PartInfo)?.messageID ?? ""}/${(data as PartInfo)?.id ?? ""}`, item: { type, data } }
+  if (type === "session") return { key: `session/${(data as SessionInfo)?.id ?? ""}`, item: { type, sessionID, data } }
+  // v2 messages carry no sessionID inside data (v1 infos did); the item
+  // envelope stamps it so multi-session folds (parent + subagents) can
+  // group without guessing
+  if (type === "message") return { key: `message/${(data as MessageInfo)?.id ?? ""}`, item: { type, sessionID, data } }
   if (type === "session_diff") return { key: `session_diff/${sessionID}`, item: { type, sessionID, data } }
   return undefined
 }
@@ -527,6 +533,7 @@ export function createEngine(deps: EngineDeps): Engine {
     activated: false,
     wroteBinding: false,
     everConnected: false,
+    merged: new Map(),
   })
 
   const refreshConfig = () => {
@@ -775,6 +782,15 @@ export function createEngine(deps: EngineDeps): Engine {
       logError("spool save failed", (e as Error)?.message || e)
     }
   }
+  // hot path: appending one pending frame must not re-serialize the whole
+  // queue (O(n^2) during backfill bursts) — append the line instead
+  const spoolAppend = (st: SessionState, r: RemoteState, f: { items: unknown[]; status: string }) => {
+    try {
+      appendFileSync(queuePath(st, r.url), JSON.stringify(f) + "\n")
+    } catch (e) {
+      logError("spool append failed", (e as Error)?.message || e)
+    }
+  }
   const spoolLoad = (st: SessionState, r: RemoteState) => {
     try {
       const meta = JSON.parse(readFileSync(metaPath(st, r.url), "utf8"))
@@ -785,10 +801,18 @@ export function createEngine(deps: EngineDeps): Engine {
         r.ackedRev = meta.ackedRev ?? 0
       }
       if (existsSync(queuePath(st, r.url))) {
-        r.pending = readFileSync(queuePath(st, r.url), "utf8")
-          .split("\n")
-          .filter((l) => l.trim())
-          .map((l) => JSON.parse(l))
+        // append-only spool: a crash mid-append can tear the LAST line —
+        // keep the valid prefix instead of dropping the whole queue
+        r.pending = []
+        for (const line of readFileSync(queuePath(st, r.url), "utf8").split("\n")) {
+          if (!line.trim()) continue
+          try {
+            r.pending.push(JSON.parse(line))
+          } catch {
+            log(`spool load: dropped torn tail line for ${st.sid.slice(0, 18)}`)
+            break
+          }
+        }
       }
     } catch {
       r.pending = []
@@ -830,14 +854,35 @@ export function createEngine(deps: EngineDeps): Engine {
     return true
   }
 
-  /** Sync frames are chunked (~1MB WS cap on CF; a 5000-message backfill
-   * must ride several frames — worker apply is keyed-idempotent, chunks
-   * just bump rev). Status rides each chunk; last write wins. */
-  const SYNC_CHUNK = 200
+  /** Sync frames are chunked by BOTH item count and serialized bytes.
+   * Count-only chunking could pack 200 large tool outputs into a frame
+   * that exceeds the server's WS receive cap (CF 32 MiB, Bun 16 MB
+   * default) and die wholesale. Budget keeps every frame cheap to apply
+   * and rebroadcast; worker apply is keyed-idempotent, so chunks just
+   * bump rev. An item larger than the whole budget rides alone in its
+   * own frame (the worker fits oversize items to its storage cap).
+   * Status rides each chunk; last write wins. */
+  const chunkItems = (items: unknown[], maxItems: number, maxBytes: number): unknown[][] => {
+    const chunks: unknown[][] = []
+    let cur: unknown[] = []
+    let curBytes = 0
+    for (const it of items) {
+      const n = (JSON.stringify(it) ?? "null").length
+      if (cur.length && (cur.length >= maxItems || curBytes + n > maxBytes)) {
+        chunks.push(cur)
+        cur = []
+        curBytes = 0
+      }
+      cur.push(it)
+      curBytes += n
+    }
+    if (cur.length) chunks.push(cur)
+    return chunks
+  }
   const sendSync = (r: RemoteState, f: { items: unknown[]; status: string }) => {
     if (!f.items.length) return wsSend(r, { op: "sync", items: [], status: f.status })
-    for (let i = 0; i < f.items.length; i += SYNC_CHUNK) {
-      wsSend(r, { op: "sync", items: f.items.slice(i, i + SYNC_CHUNK), status: f.status })
+    for (const chunk of chunkItems(f.items, 200, 512 * 1024)) {
+      wsSend(r, { op: "sync", items: chunk, status: f.status })
     }
     return true
   }
@@ -1323,6 +1368,10 @@ export function createEngine(deps: EngineDeps): Engine {
 
   // ---- flush -------------------------------------------------------------
   const frameFrom = (st: SessionState) => {
+    // stamps run at frame time: the whole family's data is indexed by now
+    // (child prompts are created during the task call, well inside the
+    // flush debounce), and any re-enqueued message lands in this frame
+    stampsPass()
     const items = Array.from(st.queue.values())
     st.queue.clear()
     const statusChanged = st.status !== st.lastSentStatus
@@ -1351,7 +1400,7 @@ export function createEngine(deps: EngineDeps): Engine {
       // sync dies as "unknown op" (live-caught: post-drop reconnects
       // lost whole turns). The init-ok handler flushes pending itself.
       r.pending.push(f)
-      spoolSave(st, r)
+      spoolAppend(st, r, f)
       if (r.ws && !r.wsReady) continue
       if (r.wsReady) {
         sendSync(r, f)
@@ -1377,18 +1426,23 @@ export function createEngine(deps: EngineDeps): Engine {
       if (f.status) status = f.status
     }
     const cred = credOf(r.url)
-    const res = await fetch(`${r.url}/api/share/${r.shareId}/sync`, {
-      method: "POST",
-      headers: { "content-type": "application/json", ...(cred.credential ? { authorization: `Bearer ${cred.credential}` } : {}) },
-      body: JSON.stringify({ secret: r.secret ?? "", data: items, status }),
-      signal: AbortSignal.timeout(15000),
-    }).catch(() => null)
-    if (res && res.ok) {
+    // chunked like WS frames: one unbounded body is a whole-backlog
+    // bomb after a mid-backfill socket drop (backfill = full history).
+    // Failure stops the loop with pending intact — replaying already-
+    // applied chunks is idempotent.
+    for (const chunk of chunkItems(items, 500, 4 * 1024 * 1024)) {
+      const res = await fetch(`${r.url}/api/share/${r.shareId}/sync`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...(cred.credential ? { authorization: `Bearer ${cred.credential}` } : {}) },
+        body: JSON.stringify({ secret: r.secret ?? "", data: chunk, status }),
+        signal: AbortSignal.timeout(15000),
+      }).catch(() => null)
+      if (!res || !res.ok) return
       const body = (await res.json().catch(() => ({}))) as { rev?: number }
       r.ackedRev = body.rev ?? r.ackedRev
-      r.pending = []
-      spoolSave(st, r)
     }
+    r.pending = []
+    spoolSave(st, r)
   }
 
   const scheduleFlush = (st: SessionState) => {
@@ -1410,12 +1464,283 @@ export function createEngine(deps: EngineDeps): Engine {
   const enqueue = (st: SessionState, entry: ItemEntry | undefined) => {
     if (!st || !entry) return
     st.queue.set(entry.key, entry.item)
+    indexMessage(entry)
     if (debugEvents) log(`enqueue sid=${st.sid.slice(0, 18)} ${entry.item.type} queue=${st.queue.size}`)
     touch(st)
     ensureConnected(st)
     scheduleFlush(st)
   }
 
+  // ---- authoritative stamps ----------------------------------------------
+  // The viewer renders stamped facts and never re-derives them (owner
+  // directive). Both stamps are computed at frame time across the whole
+  // share family - the engine sees every session of the family regardless
+  // of host generation, so this is the only place with the full picture.
+
+  type IndexedMessage = {
+    sid: string
+    role: string
+    agent?: string
+    created: number
+    data: Record<string, unknown>
+  }
+  const msgIndex = new Map<string, IndexedMessage>() // `${sid}:${messageID}`
+
+  const indexMessage = (entry: ItemEntry) => {
+    if (entry.item.type !== "message") return
+    const d = entry.item.data as Record<string, any> | undefined
+    if (!d || typeof d.id !== "string") return
+    const role = String(d.type ?? "")
+    if (role !== "user" && role !== "assistant") return
+    const key = `${entry.item.sessionID}:${d.id}`
+    const prev = msgIndex.get(key)
+    msgIndex.set(key, {
+      sid: String(entry.item.sessionID ?? ""),
+      role: role as string,
+      agent:
+        role === "assistant"
+          ? typeof d.agent === "string"
+            ? d.agent
+            : prev?.agent
+          : typeof d.metadata?.agent === "string"
+            ? d.metadata.agent
+            : prev?.agent,
+      created: Number(d.time?.created ?? prev?.created ?? 0),
+      data: d as Record<string, unknown>,
+    })
+  }
+
+  const sessionStateOf = (sid: string): SessionState | undefined =>
+    sessions.get(childToParent.get(sid) ?? sid)
+
+  const reEnqueueMessage = (m: IndexedMessage) => {
+    const st = sessionStateOf(m.sid)
+    if (st) enqueue(st, itemFor("message", m.data, m.sid))
+  }
+
+  /** segment agent for a user prompt: the prompt's own recorded agent (v1
+   * hosts stamp it on every user message), else the first assistant
+   * response inside the segment (v2 hosts), else carry-forward. */
+  const segmentAgent = (ordered: IndexedMessage[], at: number): string | undefined => {
+    const own = ordered[at]?.agent
+    if (own) return own
+    for (let i = at + 1; i < ordered.length; i++) {
+      if (ordered[i].role === "assistant" && ordered[i].agent) return ordered[i].agent
+      if (ordered[i].role === "user") break // next segment already began
+    }
+    return undefined
+  }
+
+  /** user messages whose segment runs a DIFFERENT agent than the previous
+   * segment carry metadata.agentSwitch = <agent> - the viewer renders the
+   * transition chip from the stamp alone. */
+  const stampAgentSwitches = () => {
+    const bySession = new Map<string, IndexedMessage[]>()
+    for (const m of msgIndex.values()) {
+      const list = bySession.get(m.sid)
+      if (list) list.push(m)
+      else bySession.set(m.sid, [m])
+    }
+    for (const [, list] of bySession) {
+      list.sort((a, b) => a.created - b.created)
+      const users = list.map((m, i) => (m.role === "user" ? i : -1)).filter((i) => i >= 0)
+      let prev: string | undefined
+      for (let k = 0; k < users.length; k++) {
+        const agent = segmentAgent(list, users[k])
+        const d = list[users[k]].data as Record<string, any>
+        const meta = (d.metadata ??= {}) as Record<string, unknown>
+        const want = k > 0 && agent && prev && agent !== prev ? agent : undefined
+        if (want !== (meta.agentSwitch as string | undefined)) {
+          if (want) meta.agentSwitch = want
+          else delete meta.agentSwitch
+          reEnqueueMessage(list[users[k]])
+        }
+        if (agent) prev = agent
+      }
+    }
+  }
+
+  /** task/subagent tool calls get metadata.agent = the agent that actually
+   * ran for THAT call: the child's first prompt created at/after the call
+   * started (v1 prompts carry the agent; v2 resolves via the response).
+   * Rank-free pairing - a resumed child's second call lands on its second
+   * prompt by construction time. */
+  const stampTaskAgents = () => {
+    const bySession = new Map<string, IndexedMessage[]>()
+    for (const m of msgIndex.values()) {
+      const list = bySession.get(m.sid)
+      if (list) list.push(m)
+      else bySession.set(m.sid, [m])
+    }
+    for (const list of bySession.values()) list.sort((a, b) => a.created - b.created)
+    for (const m of msgIndex.values()) {
+      if (m.role !== "assistant") continue
+      const content = (m.data as any).content
+      if (!Array.isArray(content)) continue
+      let mutated = false
+      for (const part of content) {
+        if (!part || part.type !== "tool") continue
+        if (part.name !== "task" && part.name !== "subagent") continue
+        const state = part.state
+        const meta = state?.metadata
+        const childSid = typeof meta?.sessionID === "string" ? meta.sessionID : undefined
+        if (!childSid || typeof meta.agent === "string") continue
+        const partStart = Number(part.time?.created ?? 0)
+        const child = bySession.get(childSid)
+        if (!child) continue
+        let agent: string | undefined
+        for (const c of child) {
+          if (c.created < partStart) continue
+          if (c.role === "user" && c.agent) {
+            agent = c.agent
+            break
+          }
+        }
+        if (!agent) {
+          for (const c of child) {
+            if (c.created < partStart) continue
+            if (c.role === "assistant" && c.agent) {
+              agent = c.agent
+              break
+            }
+          }
+        }
+        if (agent) {
+          meta.agent = agent
+          mutated = true
+        }
+      }
+      if (mutated) reEnqueueMessage(m)
+    }
+  }
+
+  /** file tools get metadata.language (shiki lang id, from the path the
+   * call touched) - the viewer highlights from the stamp and never guesses
+   * (owner directive; the viewer's extension map is an old-share fallback) */
+  const LANG_BY_EXT: Record<string, string> = {
+    ts: "typescript", tsx: "tsx", mts: "typescript", cts: "typescript",
+    js: "javascript", jsx: "jsx", mjs: "javascript", cjs: "javascript",
+    json: "json", jsonc: "json", md: "markdown", mdx: "mdx",
+    py: "python", rs: "rust", go: "go", java: "java", rb: "ruby",
+    css: "css", scss: "scss", html: "html", xml: "xml", yaml: "yaml", yml: "yaml",
+    toml: "toml", sh: "shellscript", bash: "shellscript", ps1: "powershell",
+    sql: "sql", c: "c", h: "c", cpp: "cpp", hpp: "cpp", cs: "csharp",
+    swift: "swift", kt: "kotlin", php: "php", lua: "lua", vue: "vue", svelte: "svelte",
+  }
+  const FILE_TOOLS = new Set(["read", "write", "edit", "patch"])
+  const stampFileLanguages = () => {
+    for (const m of msgIndex.values()) {
+      if (m.role !== "assistant") continue
+      const content = (m.data as any).content
+      if (!Array.isArray(content)) continue
+      let mutated = false
+      for (const part of content) {
+        if (!part || part.type !== "tool") continue
+        if (!FILE_TOOLS.has(part.name)) continue
+        const state = part.state
+        const meta = state?.metadata
+        if (!meta) continue
+        const raw = state.input?.path ?? state.input?.filePath
+        // language stamp (shiki id from the path)
+        if (typeof meta.language !== "string" && typeof raw === "string") {
+          const ext = raw.split(".").pop()?.toLowerCase() ?? ""
+          const lang = LANG_BY_EXT[ext]
+          if (lang) {
+            meta.language = lang
+            mutated = true
+          }
+        }
+        // lineStart stamp: reads sliced from an offset keep REAL file line
+        // numbers in the viewer's unified file card (pierre numbers from 1;
+        // the viewer shifts by this stamp, authoritatively)
+        if (typeof meta.lineStart !== "number" && part.name === "read") {
+          const off = state.input?.offset
+          if (typeof off === "number" && off >= 0 && off > 0) {
+            meta.lineStart = off + 1
+            mutated = true
+          }
+        }
+      }
+      if (mutated) reEnqueueMessage(m)
+    }
+  }
+
+  const stampsPass = () => {
+    stampAgentSwitches()
+    stampTaskAgents()
+    stampFileLanguages()
+  }
+
+  // ---- contract v2 message assembly --------------------------------------
+  // v1 hosts stream parts as separate events; the v2 item embeds content.
+  // The engine keeps the assembled view per message and re-emits the
+  // normalized whole (the keyed queue dedupes across a debounce window,
+  // so intermediate re-emissions collapse).
+
+  const mergeEntry = (st: SessionState, messageID: string) => {
+    let e = st.merged.get(messageID)
+    if (!e) {
+      e = { parts: new Map() }
+      st.merged.set(messageID, e)
+    }
+    return e
+  }
+
+  /** (Re-)emit the v2 message item for a merged v1 message. */
+  const emitMerged = (st: SessionState, sid: string, messageID: string) => {
+    const e = st.merged.get(messageID)
+    if (!e?.info) return // parts arriving before their message: wait
+    const res = normalizeV1Message(e.info, [...e.parts.values()])
+    if (!res) return
+    if ("refill" in res) {
+      // v1 compaction summary assistant → rewrite the parent compaction
+      // message with the summary text; the summary message itself is not
+      // emitted as its own item
+      const parent = st.merged.get(res.refill)
+      if (parent?.info) {
+        const compaction = normalizeV1Message(parent.info, [...parent.parts.values()])
+        if (compaction && "message" in compaction) {
+          const msg = compaction.message as Record<string, unknown>
+          msg.summary = res.summary
+          enqueue(st, itemFor("message", msg, sid))
+        }
+      }
+      return
+    }
+    enqueue(st, itemFor("message", res.message, sid))
+  }
+
+  /** message.updated / part.updated ingestion for v1 hosts; v2 hosts call
+   * with v2-native messages (pass-through, no merge). */
+  const ingestMessageInfo = (st: SessionState, sid: string, info: Record<string, unknown>) => {
+    if (isV2NativeMessage(info)) {
+      enqueue(st, itemFor("message", info, sid))
+      return
+    }
+    if (typeof info?.id !== "string") return
+    const e = mergeEntry(st, info.id)
+    e.info = info
+    emitMerged(st, sid, info.id)
+  }
+
+  const ingestPart = (st: SessionState, sid: string, part: Record<string, unknown>) => {
+    if (typeof part?.id !== "string" || typeof part.messageID !== "string") return
+    const e = mergeEntry(st, part.messageID)
+    e.parts.set(part.id, part)
+    emitMerged(st, sid, part.messageID)
+  }
+
+  const dropMergedMessage = (st: SessionState, messageID: string) => {
+    st.merged.delete(messageID)
+  }
+
+  const dropMergedPart = (st: SessionState, sid: string, messageID: string, partID: string) => {
+    const e = st.merged.get(messageID)
+    if (!e) return
+    e.parts.delete(partID)
+    if (e.info) emitMerged(st, sid, messageID)
+  }
+
   const remove = (st: SessionState) => {
     st.closed = true
     st.activated = false
@@ -1496,7 +1821,7 @@ export function createEngine(deps: EngineDeps): Engine {
 
   const query = () => (deps.directory ? { directory: deps.directory } : {})
 
-  async function fetchMessages(client: ClientApi, sid: string): Promise<Message[]> {
+  async function fetchMessages(client: ClientApi, sid: string, onPage?: (page: Message[]) => void): Promise<Message[]> {
     if (typeof client.session.messages !== "function") return []
     const out: Message[] = []
     let before: string | undefined
@@ -1511,11 +1836,26 @@ export function createEngine(deps: EngineDeps): Engine {
       )
       if (!Array.isArray(result) || result.length === 0) break
       out.push(...(result as Message[]))
+      // stream pages as they arrive: enqueue (and the rate-limited flush)
+      // starts with page 1 while later pages are still loading — a huge
+      // session backfills progressively instead of after a full collect
+      if (onPage) {
+        try {
+          onPage(result as Message[])
+        } catch {}
+      }
       if (result.length < PAGE_SIZE) break
       const last = result[result.length - 1] as Message
-      const nextBefore =
-        typeof last?.info?.id === "string" ? (last.info.id as string) : typeof (last as unknown as { id?: string })?.id === "string" ? ((last as unknown as { id: string }).id as string) : undefined
-      if (!nextBefore || nextBefore === before) break
+      const lastInfo = (last?.info ?? last) as Record<string, unknown> | undefined
+      const lastID = typeof lastInfo?.id === "string" ? lastInfo.id : undefined
+      // `before` is an OPAQUE cursor: base64url({id, time}) of the page
+      // tail (message-v2.ts codec). A bare message id 400s on hosts with
+      // cursor pagination — every v1 backfill silently truncated to one
+      // 100-message page (live-caught).
+      const lastTime = (lastInfo?.time as Record<string, unknown> | undefined)?.created
+      if (!lastID || typeof lastTime !== "number") break
+      const nextBefore = cursorFor(lastID, lastTime)
+      if (nextBefore === before) break
       before = nextBefore
     }
     return out
@@ -1525,27 +1865,32 @@ export function createEngine(deps: EngineDeps): Engine {
     const sessionInfoValue = info ?? (await sessionInfo(client, sid))
     if (sessionInfoValue) enqueue(st, itemFor("session", redact(sessionInfoValue), sid))
 
-    const messages = await fetchMessages(client, sid)
     let modelSeen = false
-    for (const message of messages) {
-      const m = (message.info ?? message) as MessageInfo
-      if (!m || typeof m.id !== "string") continue
-      enqueue(st, itemFor("message", m, sid))
-      if (m.role === "user" && m.model) {
-        modelSeen = true
-        const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, m.model)
-        enqueue(
-          st,
-          itemFor("model", [{ id: m.model.modelID, providerID: m.model.providerID, name: label }], sid),
-        )
-      }
-      for (const part of message.parts ?? []) {
-        const p = part as PartInfo
-        if (!p || typeof p.id !== "string" || typeof p.messageID !== "string") continue
-        if (p.state?.status === "error") st.badSignal = true
-        enqueue(st, itemFor("part", p, sid))
+    const consume = (messages: Message[]) => {
+      for (const message of messages) {
+        const m = ((message.info ?? message) as MessageInfo) as Record<string, unknown> | undefined
+        if (!m || typeof m.id !== "string") continue
+        // seed the merge state, then emit the assembled v2 message
+        const e = mergeEntry(st, m.id)
+        e.info = m
+        for (const rawPart of (message.parts ?? []) as Array<Record<string, unknown>>) {
+          const p = rawPart as PartInfo
+          if (!p || typeof p.id !== "string" || typeof p.messageID !== "string") continue
+          if (p.state?.status === "error") st.badSignal = true
+          e.parts.set(p.id, p as Record<string, unknown>)
+        }
+        emitMerged(st, sid, m.id)
+        if (m.role === "user" && m.model) {
+          modelSeen = true
+          const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, m.model as SessionModel)
+          enqueue(
+            st,
+            itemFor("model", [{ id: (m.model as SessionModel).modelID, providerID: (m.model as SessionModel).providerID, name: label }], sid),
+          )
+        }
       }
     }
+    const messages = await fetchMessages(client, sid, (page) => consume(page))
     if (!modelSeen && sessionInfoValue?.model) {
       // hosts whose user messages carry no model (v2): label from the
       // session's own model
@@ -1842,19 +2187,20 @@ export function createEngine(deps: EngineDeps): Engine {
           // opencode undo: revert() only marks the session (the viewer
           // hides the range); the NEXT prompt hard-deletes the reverted
           // messages/parts via cleanup() and publishes these events.
-          // The worker's store is upsert-only, so without an explicit
-          // tombstone the deleted items live forever and reappear the
-          // moment the revert marker clears (live-caught in production).
+          // A message tombstone removes the whole v2 message (content is
+          // embedded); a part removal re-emits the merged message minus
+          // the part.
           const st = stFor(sid)
           if (!st || !st.activated || st.closed) return
           const messageID = p.messageID as string | undefined
           if (!messageID) return
           if (t === "message.removed") {
-            enqueue(st, { key: `message/${messageID}`, item: { type: "message", del: true, data: { id: messageID } } })
+            dropMergedMessage(st, messageID)
+            enqueue(st, { key: `message/${messageID}`, item: messageTombstone(st.sid, messageID) })
           } else {
             const partID = p.partID as string | undefined
             if (!partID) return
-            enqueue(st, { key: `part/${messageID}/${partID}`, item: { type: "part", del: true, data: { id: partID, messageID } } })
+            dropMergedPart(st, sid, messageID, partID)
           }
         } else if (t === "message.updated") {
           // resumed sessions may emit the user message BEFORE any session.*
@@ -1907,7 +2253,7 @@ export function createEngine(deps: EngineDeps): Engine {
             }
           }
           if (!st || !st.activated || st.closed) return
-          enqueue(st, itemFor("message", p.info, sid))
+          ingestMessageInfo(st, sid, p.info as Record<string, unknown>)
           const info = p.info as MessageInfo
           if (info?.role === "user" && info?.model) {
             const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, info.model)
@@ -1916,8 +2262,9 @@ export function createEngine(deps: EngineDeps): Engine {
           // an assistant message that DIED (finish:"error") — e.g. all
           // retries exhausted — surfaces as a 200 response with an errored
           // message, NOT as session.error (live-caught in the suite); the
-          // share must still say error
-          if (info?.role === "assistant" && (info as { finish?: string }).finish === "error") {
+          // share must still say error. Works for v2-native messages too
+          // (finish lives on the message itself).
+          if ((info as { finish?: string; role?: string })?.finish === "error") {
             st.badSignal = true
           }
         } else if (t === "message.part.updated") {
@@ -1925,11 +2272,11 @@ export function createEngine(deps: EngineDeps): Engine {
           if (!st || !st.activated || st.closed) return
           const part = p.part as PartInfo
           if (part?.state?.status === "error") st.badSignal = true
-          enqueue(st, itemFor("part", part, sid))
+          ingestPart(st, sid, part as Record<string, unknown>)
         } else if (t === "session.diff") {
           const st = stFor(sid)
           if (!st || !st.activated || st.closed) return
-          enqueue(st, itemFor("session_diff", p.diff, sid))
+          enqueue(st, itemFor("session_diff", normalizeV1Diff(p.diff), sid))
         } else if (t === "session.deleted") {
           // a CHILD session ending (task done, gc) must NEVER take the
           // parent's share down with it — the page keeps the subagent's