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

package/dist/core.js

@@ -44,6 +44,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 } from "./config.js";
+import { cursorFor, isV2NativeMessage, messageTombstone, normalizeV1Diff, normalizeV1Message } from "./contract.js";
 const DEFAULT_POLICY = {
     mode: "persistent",
     turnGraceMs: 120000,
@@ -93,11 +94,12 @@ function itemFor(type, data, sessionID) {
     if (type === "prefs")
         return { key: "prefs", item: { type, data } };
     if (type === "session")
-        return { key: `session/${data?.id ?? ""}`, item: { type, data } };
+        return { key: `session/${data?.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?.id ?? ""}`, item: { type, data } };
-    if (type === "part")
-        return { key: `part/${data?.messageID ?? ""}/${data?.id ?? ""}`, item: { type, data } };
+        return { key: `message/${data?.id ?? ""}`, item: { type, sessionID, data } };
     if (type === "session_diff")
         return { key: `session_diff/${sessionID}`, item: { type, sessionID, data } };
     return undefined;
@@ -380,6 +382,7 @@ export function createEngine(deps) {
         activated: false,
         wroteBinding: false,
         everConnected: false,
+        merged: new Map(),
     });
     const refreshConfig = () => {
         // settings may change between activations (the TUI writes the config
@@ -638,6 +641,16 @@ export function createEngine(deps) {
             logError("spool save failed", e?.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, r, f) => {
+        try {
+            appendFileSync(queuePath(st, r.url), JSON.stringify(f) + "\n");
+        }
+        catch (e) {
+            logError("spool append failed", e?.message || e);
+        }
+    };
     const spoolLoad = (st, r) => {
         try {
             const meta = JSON.parse(readFileSync(metaPath(st, r.url), "utf8"));
@@ -648,10 +661,20 @@ export function createEngine(deps) {
                 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 {
@@ -696,15 +719,37 @@ export function createEngine(deps) {
         }
         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, maxItems, maxBytes) => {
+        const chunks = [];
+        let cur = [];
+        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, f) => {
         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;
     };
@@ -1227,6 +1272,10 @@ export function createEngine(deps) {
     };
     // ---- flush -------------------------------------------------------------
     const frameFrom = (st) => {
+        // 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;
@@ -1258,7 +1307,7 @@ export function createEngine(deps) {
             // 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) {
@@ -1289,18 +1338,24 @@ export function createEngine(deps) {
                 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(() => ({})));
             r.ackedRev = body.rev ?? r.ackedRev;
-            r.pending = [];
-            spoolSave(st, r);
         }
+        r.pending = [];
+        spoolSave(st, r);
     };
     const scheduleFlush = (st) => {
         if (st.timer)
@@ -1323,12 +1378,288 @@ export function createEngine(deps) {
         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);
     };
+    const msgIndex = new Map(); // `${sid}:${messageID}`
+    const indexMessage = (entry) => {
+        if (entry.item.type !== "message")
+            return;
+        const d = entry.item.data;
+        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,
+            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,
+        });
+    };
+    const sessionStateOf = (sid) => sessions.get(childToParent.get(sid) ?? sid);
+    const reEnqueueMessage = (m) => {
+        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, at) => {
+        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();
+        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;
+            for (let k = 0; k < users.length; k++) {
+                const agent = segmentAgent(list, users[k]);
+                const d = list[users[k]].data;
+                const meta = (d.metadata ??= {});
+                const want = k > 0 && agent && prev && agent !== prev ? agent : undefined;
+                if (want !== meta.agentSwitch) {
+                    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();
+        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.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;
+                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 = {
+        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.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, messageID) => {
+        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, sid, messageID) => {
+        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;
+                    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, sid, info) => {
+        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, sid, part) => {
+        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, messageID) => {
+        st.merged.delete(messageID);
+    };
+    const dropMergedPart = (st, sid, messageID, partID) => {
+        const e = st.merged.get(messageID);
+        if (!e)
+            return;
+        e.parts.delete(partID);
+        if (e.info)
+            emitMerged(st, sid, messageID);
+    };
     const remove = (st) => {
         st.closed = true;
         st.activated = false;
@@ -1413,7 +1744,7 @@ export function createEngine(deps) {
     const PAGE_SIZE = 100;
     const MAX_PAGES = 50;
     const query = () => (deps.directory ? { directory: deps.directory } : {});
-    async function fetchMessages(client, sid) {
+    async function fetchMessages(client, sid, onPage) {
         if (typeof client.session.messages !== "function")
             return [];
         const out = [];
@@ -1429,11 +1760,29 @@ export function createEngine(deps) {
             if (!Array.isArray(result) || result.length === 0)
                 break;
             out.push(...result);
+            // 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);
+                }
+                catch { }
+            }
             if (result.length < PAGE_SIZE)
                 break;
             const last = result[result.length - 1];
-            const nextBefore = typeof last?.info?.id === "string" ? last.info.id : typeof last?.id === "string" ? last.id : undefined;
-            if (!nextBefore || nextBefore === before)
+            const lastInfo = (last?.info ?? last);
+            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?.created;
+            if (!lastID || typeof lastTime !== "number")
+                break;
+            const nextBefore = cursorFor(lastID, lastTime);
+            if (nextBefore === before)
                 break;
             before = nextBefore;
         }
@@ -1443,27 +1792,32 @@ export function createEngine(deps) {
         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);
-            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;
-                if (!p || typeof p.id !== "string" || typeof p.messageID !== "string")
+        const consume = (messages) => {
+            for (const message of messages) {
+                const m = (message.info ?? message);
+                if (!m || typeof m.id !== "string")
                     continue;
-                if (p.state?.status === "error")
-                    st.badSignal = true;
-                enqueue(st, itemFor("part", p, sid));
+                // 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 ?? [])) {
+                    const p = rawPart;
+                    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);
+                }
+                emitMerged(st, sid, m.id);
+                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));
+                }
             }
-        }
+        };
+        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
@@ -1773,9 +2127,9 @@ export function createEngine(deps) {
                     // 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;
@@ -1783,13 +2137,14 @@ export function createEngine(deps) {
                     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;
                         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") {
@@ -1844,7 +2199,7 @@ export function createEngine(deps) {
                     }
                     if (!st || !st.activated || st.closed)
                         return;
-                    enqueue(st, itemFor("message", p.info, sid));
+                    ingestMessageInfo(st, sid, p.info);
                     const info = p.info;
                     if (info?.role === "user" && info?.model) {
                         const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, info.model);
@@ -1853,8 +2208,9 @@ export function createEngine(deps) {
                     // 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.finish === "error") {
+                    // share must still say error. Works for v2-native messages too
+                    // (finish lives on the message itself).
+                    if (info?.finish === "error") {
                         st.badSignal = true;
                     }
                 }
@@ -1865,13 +2221,13 @@ export function createEngine(deps) {
                     const part = p.part;
                     if (part?.state?.status === "error")
                         st.badSignal = true;
-                    enqueue(st, itemFor("part", part, sid));
+                    ingestPart(st, sid, part);
                 }
                 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