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

package/ci/openshare.js

@@ -345,7 +345,226 @@ function resolveShareMode(cfg, input) {
 
 // src/core.ts
 import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { createHash } from "node:crypto";
 import { join as join2 } from "node:path";
+
+// src/contract.ts
+function messageTombstone(sessionID, messageID) {
+  return { type: "message", del: true, sessionID, data: { id: messageID } };
+}
+function isV2NativeMessage(x) {
+  if (!x || typeof x !== "object")
+    return false;
+  const r = x;
+  return typeof r.type === "string" && r.type !== "" && r.role === undefined && typeof r.id === "string";
+}
+var TOOL_NAME_MAP = {
+  bash: "shell",
+  task: "subagent"
+};
+var INPUT_KEY_MAP = {
+  filePath: "path",
+  subagent_type: "agent"
+};
+function normalizeToolInput(input, title) {
+  const out = {};
+  for (const [k, v] of Object.entries(input ?? {}))
+    out[INPUT_KEY_MAP[k] ?? k] = v;
+  if (title && out.description === undefined)
+    out.description = title;
+  return out;
+}
+function normalizeToolMetadata(meta) {
+  const out = {};
+  for (const [k, v] of Object.entries(meta ?? {})) {
+    if (k === "filediff")
+      out.files = [v];
+    else if (k === "sessionId")
+      out.sessionID = v;
+    else
+      out[k] = v;
+  }
+  return out;
+}
+function toolContent(output) {
+  const text = typeof output === "string" ? output : "";
+  return [{ type: "text", text: text || " " }];
+}
+function normalizeToolState(state) {
+  const status = String(state?.status ?? "pending");
+  if (status === "pending") {
+    return { status: "streaming", input: typeof state.raw === "string" ? state.raw : JSON.stringify(state.input ?? {}) };
+  }
+  if (status === "running") {
+    return { status: "running", input: normalizeToolInput(state.input ?? {}, state.title), metadata: normalizeToolMetadata(state.metadata) };
+  }
+  if (status === "completed") {
+    return { status: "completed", input: normalizeToolInput(state.input ?? {}, state.title), content: toolContent(state.output), metadata: normalizeToolMetadata(state.metadata) };
+  }
+  return {
+    status: "error",
+    input: normalizeToolInput(state.input ?? {}),
+    error: { type: "unknown", message: typeof state.error === "string" ? state.error : "tool failed" },
+    metadata: normalizeToolMetadata(state.metadata)
+  };
+}
+function normalizeFilePart(p) {
+  const url = typeof p.url === "string" ? p.url : "";
+  if (!url)
+    return;
+  const inline = url.startsWith("data:");
+  const comma = url.indexOf(",");
+  return {
+    data: inline ? url.slice(comma + 1) : url,
+    mime: typeof p.mime === "string" ? p.mime : "application/octet-stream",
+    source: inline ? { type: "inline" } : { type: "uri", uri: url },
+    ...typeof p.filename === "string" ? { name: p.filename } : {}
+  };
+}
+function normalizeV1Message(info, parts) {
+  if (!info || typeof info.id !== "string")
+    return;
+  const id = info.id;
+  const created = info.time?.created ?? 0;
+  if (info.role === "user") {
+    const compaction = parts.find((p) => p?.type === "compaction");
+    if (compaction) {
+      const message = {
+        id,
+        type: "compaction",
+        status: "completed",
+        reason: compaction.auto === false ? "manual" : "auto",
+        summary: "",
+        recent: "",
+        time: { created }
+      };
+      return { message };
+    }
+    const text = parts.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
+`);
+    const files = parts.filter((p) => p?.type === "file").map(normalizeFilePart).filter((f) => f !== undefined);
+    const agents = parts.filter((p) => p?.type === "agent").map((p) => ({ name: String(p.name ?? "") })).filter((a) => a.name);
+    const model = info.model;
+    const message = {
+      id,
+      type: "user",
+      time: { created },
+      text,
+      ...files.length ? { files } : {},
+      ...agents.length ? { agents } : {},
+      metadata: {
+        ...info.agent !== undefined ? { agent: String(info.agent) } : {},
+        ...model ? { model: { id: String(model.modelID ?? ""), providerID: String(model.providerID ?? "") } } : {}
+      }
+    };
+    return { message };
+  }
+  if (info.role === "assistant") {
+    const time = info.time;
+    if (info.summary === true && info.mode === "compaction") {
+      const summary = parts.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join(`
+`);
+      return { refill: String(info.parentID ?? ""), summary };
+    }
+    const content = [];
+    let cost = typeof info.cost === "number" ? info.cost : 0;
+    let tokens;
+    let retry;
+    for (const p of parts) {
+      switch (p?.type) {
+        case "text":
+          content.push({ type: "text", text: String(p.text ?? "") });
+          break;
+        case "reasoning": {
+          const rt = p.time;
+          content.push({ type: "reasoning", text: String(p.text ?? ""), time: { created: rt?.start ?? undefined, completed: rt?.end ?? undefined } });
+          break;
+        }
+        case "tool": {
+          const st = p.state;
+          const tt = st?.time ?? {};
+          content.push({
+            type: "tool",
+            id: String(p.id ?? ""),
+            name: TOOL_NAME_MAP[String(p.tool ?? "unknown")] ?? String(p.tool ?? "unknown"),
+            state: normalizeToolState(st ?? {}),
+            time: { created: tt.start ?? undefined, completed: tt.end ?? undefined }
+          });
+          break;
+        }
+        case "retry": {
+          const err = p.error;
+          retry = {
+            attempt: Number(p.attempt ?? 0),
+            at: p.time?.created ?? 0,
+            error: { type: "unknown", message: String(err?.message ?? err?.name ?? "retry") }
+          };
+          break;
+        }
+        case "step-finish": {
+          if (typeof p.cost === "number")
+            cost += p.cost;
+          if (p.tokens && typeof p.tokens === "object")
+            tokens = p.tokens;
+          break;
+        }
+      }
+    }
+    const finish = typeof info.finish === "string" ? info.finish : undefined;
+    const errObj = info.error;
+    const message = {
+      id,
+      type: "assistant",
+      agent: String(info.agent ?? "build"),
+      model: { id: String(info.modelID ?? ""), providerID: String(info.providerID ?? "") },
+      time: { created, streamed: time?.started ?? undefined, completed: time?.completed ?? undefined },
+      content,
+      cost,
+      ...tokens ? { tokens } : {},
+      ...finish ? { finish } : {},
+      ...errObj ? { error: { type: String(errObj.name ?? "UnknownError"), message: String(errObj.message ?? "turn failed") } } : {},
+      ...retry ? { retry } : {}
+    };
+    return { message };
+  }
+  return;
+}
+function normalizeV1Diff(diff) {
+  if (!Array.isArray(diff))
+    return diff;
+  return diff.map((d) => {
+    if (!d || typeof d !== "object")
+      return d;
+    const r = d;
+    if (typeof r.additions === "number" && typeof r.deletions === "number")
+      return r;
+    const patch = typeof r.patch === "string" ? r.patch : "";
+    let additions = 0;
+    let deletions = 0;
+    for (const line of patch.split(`
+`)) {
+      if (line.startsWith("+") && !line.startsWith("+++"))
+        additions++;
+      else if (line.startsWith("-") && !line.startsWith("---"))
+        deletions++;
+    }
+    return { ...r, additions: typeof r.additions === "number" ? r.additions : additions, deletions: typeof r.deletions === "number" ? r.deletions : deletions };
+  });
+}
+function cursorFor(id, time) {
+  return Buffer.from(JSON.stringify({ id, time })).toString("base64url");
+}
+
+// src/binding-queue.ts
+var queues = new Map;
+function queueBindingWrite(sid, fn) {
+  const prev = queues.get(sid) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  queues.set(sid, run.catch(() => {}));
+  return run;
+}
+
+// src/core.ts
 var DEFAULT_POLICY = {
   mode: "persistent",
   turnGraceMs: 120000,
@@ -381,11 +600,9 @@ 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 } };
   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;
@@ -542,6 +759,8 @@ function createEngine(deps) {
         initTimer: null,
         initWasAttach: false,
         backoff: 1000,
+        backoffResetTimer: null,
+        spoolSaveTimer: null,
         reconnectTimer: null,
         intentionalClose: false,
         connectQueued: false,
@@ -599,10 +818,14 @@ function createEngine(deps) {
       if (b && typeof b === "object" && b.policy) {
         applyPolicy(b.policy, url);
       }
+      if (b && typeof b === "object" && b.frameAuth) {
+        frameAuthUrls.add(url);
+      }
     }).catch(() => {
       policyAsked.delete(url);
     });
   };
+  const frameAuthUrls = new Set;
   const wsUrl = (url) => url.replace(/^http/, "ws");
   let spoolRoot = spoolDirFor(cfg);
   try {
@@ -637,7 +860,9 @@ function createEngine(deps) {
     opts: undefined,
     activated: false,
     wroteBinding: false,
-    everConnected: false
+    everConnected: false,
+    merged: new Map,
+    sentHash: new Map
   });
   const refreshConfig = () => {
     const next = loadConfig(deps.pluginDir, deps.options);
@@ -670,6 +895,7 @@ function createEngine(deps) {
     }
     st.activated = true;
     st.opts = opts;
+    st.sentHash.clear();
     const gated = mode === "manual" || opts2?.gated === true;
     if (gated) {
       chain = chain.then(() => seedManualStatus(st)).then(() => backfill(st, info)).then(() => queueConnectAll(st)).catch((e) => logError("activation error", e?.message || e));
@@ -721,24 +947,26 @@ function createEngine(deps) {
   async function writeMetadata(st, value) {
     if (!st.client)
       return;
-    try {
-      const info = unwrap(await st.client.session.get({
-        path: { id: st.sid },
-        ...deps.directory ? { query: { directory: deps.directory } } : {}
-      }));
-      const metadata = { ...info?.metadata ?? {} };
-      if (value === null)
-        delete metadata[METADATA_KEY];
-      else
-        metadata[METADATA_KEY] = value;
-      unwrap(await st.client.session.update({
-        path: { id: st.sid },
-        body: { metadata },
-        ...deps.directory ? { query: { directory: deps.directory } } : {}
-      }));
-    } catch (e) {
-      log("metadata write failed (spool still covers reconnects):", e?.message || e);
-    }
+    await queueBindingWrite(st.sid, async () => {
+      try {
+        const info = unwrap(await st.client.session.get({
+          path: { id: st.sid },
+          ...deps.directory ? { query: { directory: deps.directory } } : {}
+        }));
+        const metadata = { ...info?.metadata ?? {} };
+        if (value === null)
+          delete metadata[METADATA_KEY];
+        else
+          metadata[METADATA_KEY] = value;
+        unwrap(await st.client.session.update({
+          path: { id: st.sid },
+          body: { metadata },
+          ...deps.directory ? { query: { directory: deps.directory } } : {}
+        }));
+      } catch (e) {
+        log("metadata write failed (spool still covers reconnects):", e?.message || e);
+      }
+    });
   }
   const parseBinding = (record) => {
     const out = new Map;
@@ -842,13 +1070,33 @@ function createEngine(deps) {
   const spoolSave = (st, r) => {
     try {
       writeFileSync2(metaPath(st, r.url), JSON.stringify({ shareId: r.shareId, secret: r.secret, ackedRev: r.ackedRev, sid: st.sid, url: r.url }));
-      writeFileSync2(queuePath(st, r.url), r.pending.map((f) => JSON.stringify(f)).join(`
+      writeFileSync2(queuePath(st, r.url), r.pending.map((f) => f.wire ?? JSON.stringify(f)).join(`
 `) + (r.pending.length ? `
 ` : ""));
+      rmSync(legacyMetaPath(st), { force: true });
+      rmSync(legacyQueuePath(st), { force: true });
     } catch (e) {
       logError("spool save failed", e?.message || e);
     }
   };
+  const spoolAppend = (st, r, f) => {
+    try {
+      appendFileSync(queuePath(st, r.url), (f.wire ?? JSON.stringify(f)) + `
+`);
+    } catch (e) {
+      r.spoolAppendFailed = true;
+      logError("spool append failed", e?.message || e);
+    }
+  };
+  const scheduleSpoolSave = (st, r) => {
+    if (r.spoolSaveTimer)
+      return;
+    r.spoolSaveTimer = setTimeout(() => {
+      r.spoolSaveTimer = null;
+      if (!st.closed)
+        spoolSave(st, r);
+    }, 300);
+  };
   const spoolLoad = (st, r) => {
     try {
       const meta = JSON.parse(readFileSync2(metaPath(st, r.url), "utf8"));
@@ -857,13 +1105,33 @@ function createEngine(deps) {
         r.secret = meta.secret;
         r.ackedRev = meta.ackedRev ?? 0;
       }
+    } catch {}
+    try {
       if (existsSync2(queuePath(st, r.url))) {
-        r.pending = readFileSync2(queuePath(st, r.url), "utf8").split(`
-`).filter((l) => l.trim()).map((l) => JSON.parse(l));
+        const disk = [];
+        for (const line of readFileSync2(queuePath(st, r.url), "utf8").split(`
+`)) {
+          if (!line.trim())
+            continue;
+          try {
+            disk.push(JSON.parse(line));
+          } catch {
+            log(`spool load: dropped torn tail line for ${st.sid.slice(0, 18)}`);
+            break;
+          }
+        }
+        for (const f of disk) {
+          if (typeof f.seq !== "number")
+            f.seq = ++nextSeq;
+          else if (f.seq >= nextSeq)
+            nextSeq = f.seq + 1;
+        }
+        if (!r.spoolAppendFailed)
+          r.pending = disk;
+        else
+          r.spoolAppendFailed = false;
       }
-    } catch {
-      r.pending = [];
-    }
+    } catch {}
     if (!r.shareId && targets[0]?.url === r.url) {
       try {
         const meta = JSON.parse(readFileSync2(legacyMetaPath(st), "utf8"));
@@ -882,10 +1150,17 @@ function createEngine(deps) {
   };
   const spoolClear = (st, r) => {
     try {
+      if (r.spoolSaveTimer) {
+        clearTimeout(r.spoolSaveTimer);
+        r.spoolSaveTimer = null;
+      }
       rmSync(metaPath(st, r.url), { force: true });
       rmSync(queuePath(st, r.url), { force: true });
+      rmSync(legacyMetaPath(st), { force: true });
+      rmSync(legacyQueuePath(st), { force: true });
     } catch {}
   };
+  let nextSeq = 0;
   const wsSend = (r, obj) => {
     if (debugEvents)
       log(`ws ${r.url.slice(0, 24)} #${r.socketSeq} send ${obj?.op} (ready=${r.wsReady})`);
@@ -896,13 +1171,50 @@ function createEngine(deps) {
     }
     return true;
   };
-  const SYNC_CHUNK = 200;
+  const chunkedFrames = (items, maxItems, maxBytes) => {
+    const chunks = [];
+    let cur = [];
+    let curJson = [];
+    let curBytes = 0;
+    for (const it of items) {
+      const j = JSON.stringify(it) ?? "null";
+      if (cur.length && (cur.length >= maxItems || curBytes + j.length > maxBytes)) {
+        chunks.push({ items: cur, json: "[" + curJson.join(",") + "]" });
+        cur = [];
+        curJson = [];
+        curBytes = 0;
+      }
+      cur.push(it);
+      curJson.push(j);
+      curBytes += j.length;
+    }
+    if (cur.length)
+      chunks.push({ items: cur, json: "[" + curJson.join(",") + "]" });
+    return chunks;
+  };
+  const chunkItems = (items, maxItems, maxBytes) => chunkedFrames(items, maxItems, maxBytes).map((c) => c.items);
+  const syncFrameStr = (itemsJson, status, seq) => `{"op":"sync","items":${itemsJson},"status":${JSON.stringify(status)}${seq !== undefined ? `,"seq":${seq}` : ""}}`;
+  const wsSendRaw = (r, s) => {
+    if (debugEvents)
+      log(`ws ${r.url.slice(0, 24)} #${r.socketSeq} send raw (${Math.round(s.length / 1024)}KB, ready=${r.wsReady})`);
+    try {
+      r.ws?.send(s);
+    } catch {
+      return false;
+    }
+    return true;
+  };
   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 });
-    }
+      return wsSend(r, { op: "sync", items: [], status: f.status, seq: f.seq });
+    if (f.wire)
+      return wsSendRaw(r, f.wire);
+    const itemsJson = JSON.stringify(f.items);
+    if (f.items.length <= 200 && itemsJson.length <= 512 * 1024) {
+      return wsSendRaw(r, syncFrameStr(itemsJson, f.status, f.seq));
+    }
+    for (const c of chunkedFrames(f.items, 200, 512 * 1024))
+      wsSendRaw(r, syncFrameStr(c.json, f.status, f.seq));
     return true;
   };
   const announceUrl = (st, r) => {
@@ -1044,7 +1356,8 @@ function createEngine(deps) {
         logError(`sharing to ${r.url} disabled (no credential): ${cred.error}`);
         return;
       }
-      const ws = new WebSocket(`${wsUrl(r.url)}/api/ws?token=${encodeURIComponent(token ?? "")}`);
+      const useFrameAuth = !!token && frameAuthUrls.has(r.url);
+      const ws = new WebSocket(`${wsUrl(r.url)}/api/ws${useFrameAuth ? "" : `?token=${encodeURIComponent(token ?? "")}`}`);
       r.ws = ws;
       await new Promise((resolve, reject) => {
         const t = setTimeout(() => reject(new Error("ws open timeout")), 15000);
@@ -1080,6 +1393,27 @@ function createEngine(deps) {
         if (!st.closed)
           scheduleReconnect(st, r);
       });
+      if (useFrameAuth) {
+        wsSend(r, { op: "auth", token });
+        const authed = await new Promise((resolve) => {
+          const t = setTimeout(() => resolve(false), 3000);
+          r.authWaiter = () => {
+            clearTimeout(t);
+            resolve(true);
+          };
+        });
+        r.authWaiter = undefined;
+        if (!authed) {
+          logError(`ws ${r.url.slice(0, 24)}: frame-auth ack timeout - reconnecting with query token`);
+          frameAuthUrls.delete(r.url);
+          try {
+            ws.close(4000, "auth timeout");
+          } catch {}
+          if (!st.closed)
+            scheduleReconnect(st, r);
+          return;
+        }
+      }
       if (r.initWasAttach) {
         wsSend(r, { op: "init", attach: { id: r.shareId, secret: r.secret, ...authFrame(st) } });
       } else {
@@ -1108,7 +1442,7 @@ function createEngine(deps) {
   const scheduleReconnect = (st, r) => {
     if (st.closed || r.reconnectTimer)
       return;
-    const wait = r.backoff;
+    const wait = Math.max(250, Math.round(r.backoff * (0.8 + Math.random() * 0.4)));
     r.backoff = Math.min(r.backoff * 2, 60000);
     r.reconnectTimer = setTimeout(() => {
       r.reconnectTimer = null;
@@ -1190,6 +1524,11 @@ function createEngine(deps) {
     }
   };
   const handleFrame = async (st, r, frame) => {
+    if (frame.op === "authed") {
+      r.authWaiter?.();
+      r.authWaiter = undefined;
+      return;
+    }
     if (frame.op === "init") {
       if (!frame.ok) {
         const err = String(frame.error ?? "");
@@ -1228,6 +1567,16 @@ function createEngine(deps) {
             queueConnect(st, r);
           return;
         }
+        if (/limit|too many|rate/i.test(err)) {
+          logError(`${r.url}: create refused:`, frame.error, "- retrying with backoff");
+          r.connecting = false;
+          try {
+            r.ws?.close(4000, "rate limited");
+          } catch {}
+          if (!st.closed)
+            scheduleReconnect(st, r);
+          return;
+        }
         logError(`${r.url}: init refused:`, frame.error, "- creating fresh share");
         deleteAbandoned(r);
         r.shareId = null;
@@ -1256,11 +1605,19 @@ function createEngine(deps) {
       r.connecting = false;
       r.initWasAttach = false;
       r.collided = null;
+      if (r.frozenRemote && !frame.error)
+        r.frozenRemote = false;
       if (r.initTimer) {
         clearTimeout(r.initTimer);
         r.initTimer = null;
       }
-      r.backoff = 1000;
+      if (r.backoffResetTimer)
+        clearTimeout(r.backoffResetTimer);
+      r.backoffResetTimer = setTimeout(() => {
+        r.backoffResetTimer = null;
+        if (r.wsReady && !r.reconnectTimer)
+          r.backoff = 1000;
+      }, 30000);
       st.everConnected = true;
       if (frame.policy)
         applyPolicy(frame.policy, r.url);
@@ -1280,18 +1637,49 @@ function createEngine(deps) {
         flush(st);
       }
       if (wasFanoutCreate) {
+        st.sentHash.clear();
         chain = chain.then(() => backfill(st)).catch((e) => logError("fan-out backfill error", e?.message || e));
       }
       return;
     }
     if (frame.op === "ack") {
       r.ackedRev = frame.rev ?? r.ackedRev;
-      r.pending = [];
-      spoolSave(st, r);
+      if (r.backoffResetTimer) {
+        clearTimeout(r.backoffResetTimer);
+        r.backoffResetTimer = null;
+        r.backoff = 1000;
+      }
+      if (typeof frame.seq === "number") {
+        r.pending = r.pending.filter((p) => p.seq !== frame.seq);
+      } else {
+        r.pending = [];
+      }
+      scheduleSpoolSave(st, r);
       scheduleBindingWrite(st);
       return;
     }
     if (frame.op === "nack" || frame.op === "error") {
+      const errText = String(frame.error ?? "");
+      if (frame.op === "nack") {
+        if (/not found|gone/i.test(errText)) {
+          logError(`${r.url}: share vanished server-side (nack: ${errText}) - recreating`);
+          deleteAbandoned(r);
+          r.shareId = null;
+          r.secret = null;
+          r.ackedRev = 0;
+          try {
+            r.ws?.close(4000, "share gone");
+          } catch {}
+          if (!st.closed)
+            queueConnect(st, r);
+          return;
+        }
+        if (/frozen/i.test(errText)) {
+          r.frozenRemote = true;
+          logError(`${r.url}: share frozen by the hoster - edits refused; contact the server admin`);
+          return;
+        }
+      }
       logError(`${r.url}: worker refused frame:`, JSON.stringify(frame).slice(0, 200));
       if (frame.op === "error" && r.wsReady && !st.closed) {
         r.wsReady = false;
@@ -1314,6 +1702,7 @@ function createEngine(deps) {
     queueConnect(st, r);
   };
   const frameFrom = (st) => {
+    stampsPass(st);
     const items = Array.from(st.queue.values());
     st.queue.clear();
     const statusChanged = st.status !== st.lastSentStatus;
@@ -1333,14 +1722,32 @@ function createEngine(deps) {
     const f = frameFrom(st);
     if (!f)
       return;
+    const chunks = f.items.length ? chunkedFrames(f.items, 200, 512 * 1024) : [];
     let httpWork;
     for (const r of st.remotes.values()) {
-      r.pending.push(f);
-      spoolSave(st, r);
+      if (r.frozenRemote)
+        continue;
+      const fresh = [];
+      if (chunks.length) {
+        for (const c of chunks) {
+          const seq = ++nextSeq;
+          const cf = { items: c.items, status: f.status, seq, wire: syncFrameStr(c.json, f.status, seq) };
+          fresh.push(cf);
+          r.pending.push(cf);
+          spoolAppend(st, r, cf);
+        }
+      } else {
+        const seq = ++nextSeq;
+        const cf = { items: [], status: f.status, seq };
+        fresh.push(cf);
+        r.pending.push(cf);
+        spoolAppend(st, r, cf);
+      }
       if (r.ws && !r.wsReady)
         continue;
       if (r.wsReady) {
-        sendSync(r, f);
+        for (const cf of fresh)
+          sendSync(r, cf);
         continue;
       }
       const viaHttp = flushViaHttp(st, r);
@@ -1349,32 +1756,68 @@ function createEngine(deps) {
     }
     if (st.remotes.size)
       st.lastFlushAt = Date.now();
+    if (httpWork)
+      httpWork.catch((e) => logError("http flush error", e?.message || e));
     return httpWork;
   };
+  const httpDedupeKey = (it) => {
+    if (!it || typeof it !== "object")
+      return null;
+    const o = it;
+    switch (o.type) {
+      case "session":
+        return "session/" + (o.data?.id ?? "");
+      case "session_diff":
+        return "session_diff/" + (o.sessionID ?? o.data?.sessionID ?? "");
+      case "message":
+        return "message/" + (o.data?.id ?? "");
+      case "part":
+        return "part/" + (o.data?.messageID ?? "") + "/" + (o.data?.id ?? "");
+      case "model":
+        return "model/" + (o.sessionID ?? o.data?.sessionID ?? "");
+      case "prefs":
+        return "prefs";
+      default:
+        return null;
+    }
+  };
   const flushViaHttp = async (st, r) => {
     if (!r.shareId || !r.pending.length)
       return;
-    const items = [];
+    const byKey = new Map;
+    const unkeyed = [];
     let status;
+    const sentSeqs = new Set;
     for (const f of r.pending) {
-      for (const it of f.items)
-        items.push(it);
+      for (const it of f.items) {
+        const k = httpDedupeKey(it);
+        if (k)
+          byKey.set(k, it);
+        else
+          unkeyed.push(it);
+      }
       if (f.status)
         status = f.status;
+      if (typeof f.seq === "number")
+        sentSeqs.add(f.seq);
     }
+    const items = [...byKey.values(), ...unkeyed];
     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) {
+    const chunks = items.length ? chunkItems(items, 500, 4 * 1024 * 1024) : [[]];
+    for (const chunk of chunks) {
+      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 = r.pending.filter((p) => !sentSeqs.has(p.seq));
+    scheduleSpoolSave(st, r);
   };
   const scheduleFlush = (st) => {
     if (st.timer)
@@ -1385,19 +1828,316 @@ function createEngine(deps) {
       st.timer = null;
       if (debugEvents)
         log(`flush timer fired sid=${st.sid.slice(0, 18)} queue=${st.queue.size} remotes=${st.remotes.size}`);
-      chain = chain.then(() => flush(st)).catch((e) => logError("flush error", e?.message || e));
+      chain = chain.then(() => {
+        flush(st);
+      }).catch((e) => logError("flush error", e?.message || e));
     }, wait);
   };
   const enqueue = (st, entry) => {
     if (!st || !entry)
       return;
+    let h;
+    try {
+      h = createHash("sha256").update(JSON.stringify(entry.item)).digest("hex");
+    } catch {
+      h = "";
+    }
+    if (h && st.sentHash.get(entry.key) === h) {
+      if (debugEvents)
+        log(`enqueue dedupe ${entry.item.type} ${entry.key.slice(0, 40)}`);
+      return;
+    }
+    if (h)
+      st.sentHash.set(entry.key, h);
     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;
+  const tombstoned = new Set;
+  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,
+      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) => {
+    if (tombstoned.has(`${m.sid}:${m.data.id}`))
+      return;
+    const st = sessionStateOf(m.sid);
+    if (st)
+      enqueue(st, itemFor("message", m.data, m.sid));
+  };
+  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;
+    }
+    return;
+  };
+  const stampAgentSwitches = (bySession) => {
+    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 want = k > 0 && agent && prev && agent !== prev ? agent : undefined;
+        if (want !== d.metadata?.agentSwitch) {
+          if (want) {
+            const meta = d.metadata ??= {};
+            meta.agentSwitch = want;
+          } else if (d.metadata) {
+            delete d.metadata.agentSwitch;
+          }
+          reEnqueueMessage(list[users[k]]);
+        }
+        if (agent)
+          prev = agent;
+      }
+    }
+  };
+  const stampTaskAgents = (bySession) => {
+    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);
+    }
+  };
+  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;
+        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;
+          }
+        }
+        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 = (st) => {
+    let any = false;
+    for (const it of st.queue.values()) {
+      if (it.type === "message") {
+        any = true;
+        break;
+      }
+    }
+    if (!any)
+      return;
+    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);
+    stampAgentSwitches(bySession);
+    stampTaskAgents(bySession);
+    stampFileLanguages();
+  };
+  const mergeEntry = (st, messageID) => {
+    let e = st.merged.get(messageID);
+    if (!e) {
+      e = { parts: new Map };
+      st.merged.set(messageID, e);
+    }
+    return e;
+  };
+  const emitMerged = (st, sid, messageID) => {
+    const e = st.merged.get(messageID);
+    if (!e?.info)
+      return;
+    const res = normalizeV1Message(e.info, [...e.parts.values()]);
+    if (!res)
+      return;
+    if ("refill" in res) {
+      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));
+  };
+  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, evSid) => {
+    const sid = evSid ?? st.sid;
+    st.merged.delete(messageID);
+    msgIndex.delete(`${sid}:${messageID}`);
+    tombstoned.add(`${sid}:${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;
@@ -1416,6 +2156,10 @@ function createEngine(deps) {
         clearTimeout(r.initTimer);
         r.initTimer = null;
       }
+      if (r.backoffResetTimer) {
+        clearTimeout(r.backoffResetTimer);
+        r.backoffResetTimer = null;
+      }
       if (r.reconnectTimer) {
         clearTimeout(r.reconnectTimer);
         r.reconnectTimer = null;
@@ -1425,9 +2169,21 @@ function createEngine(deps) {
         clearTimeout(r.idleDropTimer);
         r.idleDropTimer = null;
       }
-      if (r.wsReady)
+      if (r.wsReady && r.shareId) {
         wsSend(r, { op: "delete" });
-      else if (r.shareId && r.secret) {
+        if (r.shareId && r.secret) {
+          const sid = r.shareId;
+          const sec = r.secret;
+          setTimeout(() => {
+            fetch(`${r.url}/api/share/${sid}`, {
+              method: "DELETE",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ secret: sec }),
+              signal: AbortSignal.timeout(8000)
+            }).catch(() => {});
+          }, 2000);
+        }
+      } else if (r.shareId && r.secret) {
         fetch(`${r.url}/api/share/${r.shareId}`, {
           method: "DELETE",
           headers: { "content-type": "application/json" },
@@ -1445,6 +2201,17 @@ function createEngine(deps) {
     }, 1000);
     for (const r of st.remotes.values())
       spoolClear(st, r);
+    const stSid = st.sid;
+    const pfx = `${stSid}:`;
+    for (const k of msgIndex.keys())
+      if (k.startsWith(pfx))
+        msgIndex.delete(k);
+    for (const k of tombstoned)
+      if (k.startsWith(pfx))
+        tombstoned.delete(k);
+    for (const [child, parent] of childToParent)
+      if (parent === stSid || child === stSid)
+        childToParent.delete(child);
     sessions.delete(st.sid);
     try {
       chain = chain.then(async () => {
@@ -1470,7 +2237,7 @@ 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 = [];
@@ -1486,41 +2253,58 @@ function createEngine(deps) {
       if (!Array.isArray(result) || result.length === 0)
         break;
       out.push(...result);
+      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;
+      const lastTime = lastInfo?.time?.created;
+      if (!lastID || typeof lastTime !== "number")
+        break;
+      const nextBefore = cursorFor(lastID, lastTime);
+      if (nextBefore === before)
         break;
       before = nextBefore;
     }
+    if (out.length >= MAX_PAGES * PAGE_SIZE) {
+      logError(`backfill truncated at ${out.length} messages (page cap) for ${sid.slice(0, 18)} — oldest history not shared`);
+    }
     return out;
   }
   const backfillSession = async (st, client, sid, info) => {
     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));
+        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) {
       const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, sessionInfoValue.model);
       enqueue(st, itemFor("model", [{ id: sessionInfoValue.model.modelID, providerID: sessionInfoValue.model.providerID, name: label }], sid));
@@ -1734,7 +2518,9 @@ function createEngine(deps) {
             if (st.timer)
               clearTimeout(st.timer);
             st.timer = null;
-            chain = chain.then(() => flush(st)).catch((e) => logError("idle flush error", e?.message || e));
+            chain = chain.then(() => {
+              flush(st);
+            }).catch((e) => logError("idle flush error", e?.message || e));
             const epoch = st.statusEpoch;
             const settle = () => {
               st.status = st.badSignal ? "error" : "completed";
@@ -1742,7 +2528,9 @@ function createEngine(deps) {
               if (st.timer)
                 clearTimeout(st.timer);
               st.timer = null;
-              chain = chain.then(() => flush(st)).then(() => {
+              chain = chain.then(() => {
+                flush(st);
+              }).then(() => {
                 armSettleDrop(st);
               }).catch((e) => logError("settle flush error", e?.message || e));
             };
@@ -1773,12 +2561,13 @@ 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, sid);
+            enqueue(st, { key: `message/${messageID}`, item: messageTombstone(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") {
           const main = childToParent.get(sid) ?? sid;
@@ -1819,13 +2608,13 @@ 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);
             enqueue(st, itemFor("model", [{ id: info.model.modelID, providerID: info.model.providerID, name: label }], sid));
           }
-          if (info?.role === "assistant" && info.finish === "error") {
+          if (info?.finish === "error") {
             st.badSignal = true;
           }
         } else if (t === "message.part.updated") {
@@ -1835,12 +2624,12 @@ 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") {
           const isChild = childToParent.has(sid);
           if (isChild) {
@@ -1884,6 +2673,13 @@ function createEngine(deps) {
               await flushViaHttp(st, r).catch(() => {});
             }
           }
+          for (const r of st.remotes.values()) {
+            if (r.spoolSaveTimer) {
+              clearTimeout(r.spoolSaveTimer);
+              r.spoolSaveTimer = null;
+              spoolSave(st, r);
+            }
+          }
           if (st.metaTimer)
             clearTimeout(st.metaTimer);
           st.metaTimer = null;
@@ -1904,116 +2700,6 @@ function createEngine(deps) {
 // src/v2-server.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
-function toolContentText(content) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    return content.map((item) => {
-      if (typeof item === "string")
-        return item;
-      if (item && typeof item === "object") {
-        const record = item;
-        if (typeof record.text === "string")
-          return record.text;
-      }
-      return "";
-    }).join("");
-  }
-  return "";
-}
-function convertToolState(state) {
-  if (!state || typeof state !== "object")
-    return { status: "pending" };
-  const record = state;
-  const status = String(record.status ?? "pending");
-  const mapped = {};
-  if (status === "streaming" || status === "running")
-    mapped.status = "running";
-  else if (status === "completed")
-    mapped.status = "completed";
-  else if (status === "failed" || status === "error")
-    mapped.status = "error";
-  else
-    mapped.status = "pending";
-  if (record.input !== undefined)
-    mapped.input = record.input;
-  if (record.output !== undefined)
-    mapped.output = toolContentText(record.output);
-  if (record.error !== undefined)
-    mapped.error = record.error;
-  if (record.time !== undefined)
-    mapped.time = record.time;
-  return mapped;
-}
-function convertV2Message(message, sessionID) {
-  if (!message || typeof message.id !== "string")
-    return;
-  const base = {
-    id: message.id,
-    sessionID
-  };
-  if (message.type === "user") {
-    return {
-      info: {
-        ...base,
-        role: "user",
-        time: { created: message.time?.created ?? 0 },
-        text: message.text ?? ""
-      },
-      parts: []
-    };
-  }
-  if (message.type === "assistant") {
-    const parts = [];
-    const content = Array.isArray(message.content) ? message.content : [];
-    content.forEach((block, index) => {
-      const record = block;
-      const kind = String(record.type ?? "");
-      if (kind === "text") {
-        parts.push({
-          id: `${message.id}_t${index}`,
-          messageID: message.id,
-          sessionID,
-          type: "text",
-          text: String(record.text ?? ""),
-          synthetic: false,
-          time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 }
-        });
-      } else if (kind === "reasoning") {
-        parts.push({
-          id: `${message.id}_r${index}`,
-          messageID: message.id,
-          sessionID,
-          type: "reasoning",
-          text: String(record.text ?? ""),
-          synthetic: false,
-          time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 }
-        });
-      } else if (kind === "tool") {
-        parts.push({
-          id: String(record.id ?? `${message.id}_tool${index}`),
-          messageID: message.id,
-          sessionID,
-          type: "tool",
-          tool: String(record.name ?? "unknown"),
-          state: convertToolState(record.state),
-          synthetic: false
-        });
-      }
-    });
-    return {
-      info: {
-        ...base,
-        role: "assistant",
-        agent: message.agent,
-        model: message.model ? { providerID: message.model.providerID, modelID: message.model.modelID ?? message.model.id } : undefined,
-        time: { created: message.time?.created ?? 0, completed: message.time?.completed ?? 0 }
-      },
-      parts
-    };
-  }
-  return;
-}
 function adaptSessionClient(session, message, directory) {
   if (!session)
     return;
@@ -2044,9 +2730,9 @@ function adaptSessionClient(session, message, directory) {
       if (!Array.isArray(data))
         break;
       for (const raw of data) {
-        const converted = convertV2Message(raw, sessionID);
-        if (converted)
-          out.push(converted);
+        if (raw && typeof raw === "object" && typeof raw.id === "string") {
+          out.push({ info: raw, parts: [] });
+        }
       }
       const next = res?.cursor?.next ?? undefined;
       if (!next || data.length === 0)
@@ -2146,6 +2832,7 @@ function createV2ServerSetup() {
       return () => {};
     }
     const pendingRefresh = new Map;
+    const queuedInbox = new Map;
     const refresh = (sessionID) => {
       let timer = pendingRefresh.get(sessionID);
       if (timer)
@@ -2160,7 +2847,10 @@ function createV2ServerSetup() {
             });
             const messages = await client.session.messages?.({ path: { id: sessionID } });
             const list = messages?.data ?? [];
+            const held = queuedInbox.get(sessionID);
             for (const message of list) {
+              if (held?.has(message.info.id))
+                continue;
               await engine.hooks.event({
                 event: { type: "message.updated", properties: { sessionID, info: message.info } }
               });
@@ -2193,6 +2883,33 @@ function createV2ServerSetup() {
               await engine.hooks.event({ event: { type, properties: { sessionID: sid } } });
               continue;
             }
+            if (type.startsWith("session.inbox.")) {
+              const data = event.data ?? {};
+              const inboxID = data.inboxID;
+              if (inboxID) {
+                let set = queuedInbox.get(sid);
+                if (!set) {
+                  set = new Set;
+                  queuedInbox.set(sid, set);
+                }
+                if (type === "session.inbox.enqueued" && data.item?.delivery === "queue") {
+                  set.add(inboxID);
+                } else if (type === "session.inbox.delivered") {
+                  set.delete(inboxID);
+                  refresh(sid);
+                } else if (type === "session.inbox.cancelled") {
+                  set.add(inboxID);
+                } else if (type === "session.inbox.delivery.changed") {
+                  if (data.item?.delivery === "queue")
+                    set.add(inboxID);
+                  else {
+                    set.delete(inboxID);
+                    refresh(sid);
+                  }
+                }
+              }
+              continue;
+            }
             if (type === "message.removed" || type === "message.part.removed") {
               const data = event.data ?? {};
               await engine.hooks.event({