@ganglion/xacpx-relay 0.14.1 → 0.14.2-beta.0

package/dist/cli.js

@@ -7397,7 +7397,10 @@ function initSchema(db) {
       queue_item_id TEXT,
       queue_fallback INTEGER NOT NULL DEFAULT 0,
       origin_queue_item_id TEXT,
-      prompt_request_id TEXT
+      prompt_request_id TEXT,
+      started_at INTEGER,
+      slot_after_id INTEGER,
+      started_after_seq INTEGER
     );
     CREATE INDEX IF NOT EXISTS idx_messages_session ON messages (instance_id, session_alias, id);
     CREATE TABLE IF NOT EXISTS recovery_receipts (
@@ -7406,6 +7409,16 @@ function initSchema(db) {
       created_at TEXT NOT NULL,
       PRIMARY KEY (instance_id, recovery_id)
     );
+    CREATE TABLE IF NOT EXISTS turn_slot_anchors (
+      instance_id TEXT NOT NULL,
+      session_alias TEXT NOT NULL,
+      recovery_id TEXT NOT NULL DEFAULT '',
+      slot_after_id INTEGER NOT NULL,
+      started_at INTEGER,
+      started_after_seq INTEGER,
+      PRIMARY KEY (instance_id, recovery_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_turn_slot_anchors_session ON turn_slot_anchors (instance_id, session_alias);
     CREATE TABLE IF NOT EXISTS pending_completion_routes (
       request_message_id TEXT PRIMARY KEY,
       account_id TEXT NOT NULL,
@@ -7449,6 +7462,15 @@ function initSchema(db) {
   if (!messageCols.some((c) => c.name === "prompt_request_id")) {
     db.exec("ALTER TABLE messages ADD COLUMN prompt_request_id TEXT");
   }
+  if (!messageCols.some((c) => c.name === "started_at")) {
+    db.exec("ALTER TABLE messages ADD COLUMN started_at INTEGER");
+  }
+  if (!messageCols.some((c) => c.name === "slot_after_id")) {
+    db.exec("ALTER TABLE messages ADD COLUMN slot_after_id INTEGER");
+  }
+  if (!messageCols.some((c) => c.name === "started_after_seq")) {
+    db.exec("ALTER TABLE messages ADD COLUMN started_after_seq INTEGER");
+  }
   const instanceCols = db.all("PRAGMA table_info(instances)");
   if (!instanceCols.some((c) => c.name === "capabilities_json")) {
     db.exec("ALTER TABLE instances ADD COLUMN capabilities_json TEXT");
@@ -7597,6 +7619,7 @@ class AccountStore {
     this.db.exec("BEGIN");
     try {
       this.db.run("DELETE FROM messages WHERE instance_id IN (SELECT id FROM instances WHERE account_id = ?)", [accountId]);
+      this.db.run("DELETE FROM turn_slot_anchors WHERE instance_id IN (SELECT id FROM instances WHERE account_id = ?)", [accountId]);
       this.db.run("DELETE FROM instances WHERE account_id = ?", [accountId]);
       this.db.run("DELETE FROM pairing_tokens WHERE account_id = ?", [accountId]);
       this.db.run("DELETE FROM web_sessions WHERE account_id = ?", [accountId]);
@@ -7761,6 +7784,7 @@ class InstanceStore {
   remove(instanceId, accountId) {
     if (!this.getOwned(instanceId, accountId))
       return false;
+    this.db.run("DELETE FROM turn_slot_anchors WHERE instance_id = ?", [instanceId]);
     this.db.run("DELETE FROM instances WHERE id = ?", [instanceId]);
     return true;
   }
@@ -7809,6 +7833,9 @@ function toDto(r) {
     text: r.text,
     createdAt: r.created_at,
     ...r.queue_item_id ? { queueItemId: r.queue_item_id } : {},
+    ...typeof r.started_at === "number" ? { startedAt: r.started_at } : {},
+    ...typeof r.slot_after_id === "number" ? { slotAfterId: r.slot_after_id } : {},
+    ...typeof r.started_after_seq === "number" ? { startedAfterSeq: r.started_after_seq } : {},
     ...r.structured ? { structured: JSON.parse(r.structured) } : {},
     ...r.attachments ? { attachments: JSON.parse(r.attachments) } : {}
   };
@@ -7821,8 +7848,8 @@ class MessageStore {
     this.db = db;
     this.now = now;
   }
-  append(instanceId, sessionAlias, direction, text, structured, attachments, promptRequestId, createdAt) {
-    this.db.run("INSERT INTO messages (instance_id, session_alias, direction, text, created_at, structured, attachments, prompt_request_id) VALUES (?,?,?,?,?,?,?,?)", [
+  append(instanceId, sessionAlias, direction, text, structured, attachments, promptRequestId, createdAt, startedAt, slotAfterId, startedAfterSeq) {
+    this.db.run("INSERT INTO messages (instance_id, session_alias, direction, text, created_at, structured, attachments, prompt_request_id, started_at, slot_after_id, started_after_seq) VALUES (?,?,?,?,?,?,?,?,?,?,?)", [
       instanceId,
       sessionAlias,
       direction,
@@ -7830,7 +7857,10 @@ class MessageStore {
       createdAt ?? this.now().toISOString(),
       structured ? JSON.stringify(structured) : null,
       attachments && attachments.length > 0 ? JSON.stringify(attachments) : null,
-      promptRequestId ?? null
+      promptRequestId ?? null,
+      startedAt ?? null,
+      slotAfterId ?? null,
+      startedAfterSeq ?? null
     ]);
     return this.db.get("SELECT last_insert_rowid() AS id").id;
   }
@@ -7938,7 +7968,7 @@ class MessageStore {
   listBySession(accountId, instanceId, sessionAlias, opts = {}) {
     const limit = opts.limit ?? 100;
     const before = opts.before ?? null;
-    const rows = this.db.all(`SELECT m.id, m.instance_id, m.session_alias, m.direction, m.text, m.created_at, m.structured, m.attachments, m.queue_item_id
+    const rows = this.db.all(`SELECT m.id, m.instance_id, m.session_alias, m.direction, m.text, m.created_at, m.structured, m.attachments, m.queue_item_id, m.started_at, m.slot_after_id, m.started_after_seq
        FROM messages m JOIN instances i ON i.id = m.instance_id
        WHERE i.account_id = ? AND m.instance_id = ? AND m.session_alias = ?
          AND (? IS NULL OR m.id < ?)
@@ -7951,11 +7981,14 @@ class MessageStore {
     };
   }
   getById(accountId, instanceId, sessionAlias, id) {
-    const row = this.db.get(`SELECT m.id, m.instance_id, m.session_alias, m.direction, m.text, m.created_at, m.structured, m.attachments, m.queue_item_id
+    const row = this.db.get(`SELECT m.id, m.instance_id, m.session_alias, m.direction, m.text, m.created_at, m.structured, m.attachments, m.queue_item_id, m.started_at, m.slot_after_id, m.started_after_seq
        FROM messages m JOIN instances i ON i.id = m.instance_id
        WHERE i.account_id = ? AND m.instance_id = ? AND m.session_alias = ? AND m.id = ?`, [accountId, instanceId, sessionAlias, id]);
     return row ? toDto(row) : null;
   }
+  lastId(instanceId, sessionAlias) {
+    return this.db.get("SELECT id FROM messages WHERE instance_id = ? AND session_alias = ? ORDER BY id DESC LIMIT 1", [instanceId, sessionAlias])?.id;
+  }
   deleteBySession(instanceId, sessionAlias) {
     const before = this.db.get("SELECT COUNT(*) AS n FROM messages WHERE instance_id = ? AND session_alias = ?", [instanceId, sessionAlias]);
     this.db.run("DELETE FROM messages WHERE instance_id = ? AND session_alias = ?", [instanceId, sessionAlias]);
@@ -8065,6 +8098,75 @@ class RecoveryReceiptStore {
   }
 }
 
+// packages/relay/src/stores/turn-slot-anchors.ts
+var LEGACY_RECOVERY_ID_PREFIX = "\x00legacy:";
+function canonicalRecoveryId(sessionAlias, recoveryId) {
+  return typeof recoveryId === "string" && recoveryId.length > 0 ? recoveryId : `${LEGACY_RECOVERY_ID_PREFIX}${sessionAlias}`;
+}
+
+class TurnSlotAnchorStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  put(row) {
+    this.db.run(`INSERT INTO turn_slot_anchors (
+         instance_id, session_alias, recovery_id, slot_after_id, started_at, started_after_seq
+       ) VALUES (?,?,?,?,?,?)
+       ON CONFLICT(instance_id, recovery_id) DO UPDATE SET
+         session_alias = excluded.session_alias,
+         slot_after_id = excluded.slot_after_id,
+         started_at = excluded.started_at,
+         started_after_seq = excluded.started_after_seq`, [
+      row.instanceId,
+      row.sessionAlias,
+      row.recoveryId,
+      row.slotAfterId,
+      row.startedAt ?? null,
+      row.startedAfterSeq ?? null
+    ]);
+  }
+  get(instanceId, recoveryId) {
+    return this.toAnchor(this.db.get(`SELECT instance_id, session_alias, recovery_id, slot_after_id, started_at, started_after_seq
+       FROM turn_slot_anchors WHERE instance_id = ? AND recovery_id = ?`, [instanceId, recoveryId]));
+  }
+  take(instanceId, sessionAlias, recoveryId) {
+    const id = canonicalRecoveryId(sessionAlias, recoveryId);
+    const row = this.get(instanceId, id);
+    if (!row)
+      return;
+    this.db.run("DELETE FROM turn_slot_anchors WHERE instance_id = ? AND recovery_id = ?", [row.instanceId, row.recoveryId]);
+    return row;
+  }
+  retain(instanceId, keepRecoveryIds) {
+    if (keepRecoveryIds.size === 0) {
+      this.db.run("DELETE FROM turn_slot_anchors WHERE instance_id = ?", [instanceId]);
+      return;
+    }
+    const ids = [...keepRecoveryIds];
+    const placeholders = ids.map(() => "?").join(",");
+    this.db.run(`DELETE FROM turn_slot_anchors WHERE instance_id = ? AND recovery_id NOT IN (${placeholders})`, [instanceId, ...ids]);
+  }
+  deleteBySession(instanceId, sessionAlias) {
+    this.db.run("DELETE FROM turn_slot_anchors WHERE instance_id = ? AND session_alias = ?", [instanceId, sessionAlias]);
+  }
+  deleteByInstance(instanceId) {
+    this.db.run("DELETE FROM turn_slot_anchors WHERE instance_id = ?", [instanceId]);
+  }
+  toAnchor(row) {
+    if (!row)
+      return;
+    return {
+      instanceId: row.instance_id,
+      sessionAlias: row.session_alias,
+      recoveryId: row.recovery_id,
+      slotAfterId: row.slot_after_id,
+      ...typeof row.started_at === "number" ? { startedAt: row.started_at } : {},
+      ...typeof row.started_after_seq === "number" ? { startedAfterSeq: row.started_after_seq } : {}
+    };
+  }
+}
+
 // packages/relay/src/gateway/instance-gateway.ts
 import {
   MSG,
@@ -10107,7 +10209,10 @@ function createApp(deps) {
   });
   app.delete("/api/instances/:id", (c) => {
     const account = c.get("account");
-    const removed = deps.instances.remove(c.req.param("id"), account.id);
+    const instanceId = c.req.param("id");
+    const removed = deps.instances.remove(instanceId, account.id);
+    if (removed)
+      deps.turnSlotAnchors?.deleteByInstance(instanceId);
     return removed ? c.json({ ok: true }) : c.json({ error: "not-found" }, 404);
   });
   app.get("/api/agent-directory", (c) => {
@@ -10286,6 +10391,7 @@ function createApp(deps) {
       }
       if (removeInput && !isErrorPayload2(result)) {
         deps.messages.deleteBySession(instance.id, removeInput.alias);
+        deps.turnSlotAnchors?.deleteBySession(instance.id, removeInput.alias);
       }
       if (body.type === MSG3.commandExecute) {
         const p = payload;
@@ -10523,6 +10629,7 @@ async function createRelayRuntime(dbPath, options = {}) {
     }
   };
   const recoveryReceipts = new RecoveryReceiptStore(db);
+  const slotAnchors = new TurnSlotAnchorStore(db);
   const sessionUsage = new Map;
   const listSessionUsage = (instanceId) => {
     const prefix = `${instanceId}\x00`;
@@ -10556,7 +10663,8 @@ async function createRelayRuntime(dbPath, options = {}) {
         sessionAlias: k.slice(prefix.length),
         parts: a.parts,
         status: a.text ? "streaming" : "working",
-        startedAt: a.startedAt
+        startedAt: a.startedAt,
+        ...typeof a.slotAfterId === "number" ? { slotAfterId: a.slotAfterId } : {}
       });
     }
     return out;
@@ -10668,6 +10776,48 @@ async function createRelayRuntime(dbPath, options = {}) {
           messages.append(instanceId, sessionAlias, "in", opts.prompt, opts.scheduled ? { scheduled: opts.scheduled } : undefined);
         }
       };
+      const rememberAnchor = (sessionAlias, slot, recoveryId) => {
+        slotAnchors.put({
+          instanceId,
+          sessionAlias,
+          recoveryId: canonicalRecoveryId(sessionAlias, recoveryId),
+          slotAfterId: slot.slotAfterId,
+          ...slot.startedAt !== undefined ? { startedAt: slot.startedAt } : {},
+          ...slot.startedAfterSeq !== undefined ? { startedAfterSeq: slot.startedAfterSeq } : {}
+        });
+      };
+      const snapshotSlotAfterReconcile = (sessionAlias, extras = {}) => ({
+        slotAfterId: messages.lastId(instanceId, sessionAlias) ?? 0,
+        ...extras.startedAt !== undefined ? { startedAt: extras.startedAt } : {},
+        ...extras.startedAfterSeq !== undefined ? { startedAfterSeq: extras.startedAfterSeq } : {}
+      });
+      const resolveFinishSlot = (sessionAlias, opts) => {
+        const stored = slotAnchors.take(instanceId, sessionAlias, opts.recoveryId);
+        if (stored) {
+          return {
+            slotAfterId: stored.slotAfterId,
+            startedAt: stored.startedAt ?? opts.startedAt,
+            startedAfterSeq: stored.startedAfterSeq ?? opts.startedAfterSeq
+          };
+        }
+        return snapshotSlotAfterReconcile(sessionAlias, { startedAt: opts.startedAt, startedAfterSeq: opts.startedAfterSeq });
+      };
+      const restoreRunningSlot = (sessionAlias, turn) => {
+        const stored = slotAnchors.get(instanceId, canonicalRecoveryId(sessionAlias, turn.recoveryId));
+        if (stored) {
+          return {
+            slotAfterId: stored.slotAfterId,
+            startedAt: stored.startedAt ?? turn.startedAt,
+            startedAfterSeq: stored.startedAfterSeq ?? turn.startedAfterSeq
+          };
+        }
+        const slot = snapshotSlotAfterReconcile(sessionAlias, { startedAt: turn.startedAt, startedAfterSeq: turn.startedAfterSeq });
+        rememberAnchor(sessionAlias, slot, turn.recoveryId);
+        return slot;
+      };
+      const appendAssistantOut = (sessionAlias, text, structured, slot) => {
+        messages.append(instanceId, sessionAlias, "out", text, structured, undefined, undefined, undefined, slot.startedAt, slot.slotAfterId, slot.startedAfterSeq);
+      };
       try {
         if (envelope.type === MSG4.instanceEvent) {
           const raw = envelope.payload?.event;
@@ -10682,7 +10832,7 @@ async function createRelayRuntime(dbPath, options = {}) {
             const e = raw;
             return e.type === "tool-event" ? { ...e, step: capToolStep(e.step) } : e;
           })();
-          webGateway.broadcast(accountId, { kind: "control-event", instanceId, event });
+          let outbound = event;
           if (event.type === "turn-started") {
             const k = key(instanceId, event.sessionAlias);
             let notification;
@@ -10699,21 +10849,35 @@ async function createRelayRuntime(dbPath, options = {}) {
               }
             }
             try {
-              reconcileInboundPrompt(event.sessionAlias, { prompt: event.prompt, queueItemId: event.queueItemId, scheduled: event.scheduled, promptRequestId: event.promptRequestId }, true);
+              let slot;
+              db.transaction(() => {
+                reconcileInboundPrompt(event.sessionAlias, { prompt: event.prompt, queueItemId: event.queueItemId, scheduled: event.scheduled, promptRequestId: event.promptRequestId }, true);
+                slot = snapshotSlotAfterReconcile(event.sessionAlias, {
+                  startedAt: nowMs(),
+                  startedAfterSeq: event.startedAfterSeq
+                });
+                rememberAnchor(event.sessionAlias, slot, event.recoveryId);
+              });
+              const startedAt = slot.startedAt ?? nowMs();
               turnBuffers.set(k, {
                 text: "",
                 steps: new Map,
                 reasoning: "",
                 parts: [],
-                startedAt: nowMs(),
+                startedAt,
+                slotAfterId: slot.slotAfterId,
+                ...slot.startedAfterSeq !== undefined ? { startedAfterSeq: slot.startedAfterSeq } : {},
                 ...notification ? { notification } : {}
               });
+              outbound = { ...event, slotAfterId: slot.slotAfterId };
             } catch (err) {
               turnBuffers.delete(k);
               gateway.disconnect(instanceId);
               throw err;
             }
-          } else if (event.type === "turn-output") {
+          }
+          webGateway.broadcast(accountId, { kind: "control-event", instanceId, event: outbound });
+          if (event.type === "turn-output") {
             const a = turnBuffers.get(key(instanceId, event.sessionAlias));
             if (a) {
               a.text += event.chunk;
@@ -10738,10 +10902,19 @@ async function createRelayRuntime(dbPath, options = {}) {
             const promptRequestId = a?.notification?.promptRequestId;
             const flush = () => {
               if (!a) {
+                if (event.silent && (event.text === undefined || event.text === "")) {
+                  slotAnchors.take(instanceId, event.sessionAlias, event.recoveryId);
+                  return;
+                }
+                const slot = resolveFinishSlot(event.sessionAlias, {
+                  recoveryId: event.recoveryId,
+                  startedAfterSeq: event.startedAfterSeq,
+                  startedAt: event.startedAt
+                });
                 if (event.text !== undefined) {
-                  messages.append(instanceId, event.sessionAlias, "out", event.text);
+                  appendAssistantOut(event.sessionAlias, event.text, undefined, slot);
                 } else if (!event.ok && event.errorMessage !== undefined) {
-                  messages.append(instanceId, event.sessionAlias, "out", event.errorMessage);
+                  appendAssistantOut(event.sessionAlias, event.errorMessage, undefined, slot);
                 } else {
                   logger.warn("relay.event.turn_finished_without_content", "turn finished with no buffered content", {
                     instanceId,
@@ -10754,9 +10927,20 @@ async function createRelayRuntime(dbPath, options = {}) {
               const hasReasoning = a.reasoning.trim().length > 0;
               const hasStructured = steps.length > 0 || hasReasoning;
               const text = a.text || (!event.ok && event.errorMessage !== undefined ? event.errorMessage : a.text);
+              if (event.silent && !hasStructured && text === "") {
+                slotAnchors.take(instanceId, event.sessionAlias, event.recoveryId);
+                return;
+              }
               if (hasStructured || text !== "" || event.ok) {
                 const structured = hasStructured ? { toolSteps: steps, ...hasReasoning ? { reasoning: a.reasoning } : {}, ...a.parts.length ? { parts: a.parts } : {}, ...a.truncated ? { truncated: true } : {} } : a.truncated ? { truncated: true } : undefined;
-                messages.append(instanceId, event.sessionAlias, "out", text, structured);
+                slotAnchors.take(instanceId, event.sessionAlias, event.recoveryId);
+                appendAssistantOut(event.sessionAlias, text, structured, {
+                  slotAfterId: a.slotAfterId,
+                  startedAt: a.startedAt,
+                  startedAfterSeq: a.startedAfterSeq
+                });
+              } else {
+                slotAnchors.take(instanceId, event.sessionAlias, event.recoveryId);
               }
             };
             const recoveryId = event.recoveryId;
@@ -10879,7 +11063,14 @@ async function createRelayRuntime(dbPath, options = {}) {
                   }, false);
                 }
                 if (text !== undefined && !alreadyPersisted) {
-                  messages.append(instanceId, finished.sessionAlias, "out", text, finished.truncated ? { truncated: true } : undefined);
+                  const slot = resolveFinishSlot(finished.sessionAlias, {
+                    recoveryId: finished.recoveryId,
+                    startedAfterSeq: finished.startedAfterSeq,
+                    startedAt: finished.startedAt
+                  });
+                  appendAssistantOut(finished.sessionAlias, text, finished.truncated ? { truncated: true } : undefined, slot);
+                } else {
+                  slotAnchors.take(instanceId, finished.sessionAlias, finished.recoveryId);
                 }
               };
               if (recoveryId) {
@@ -10963,6 +11154,17 @@ async function createRelayRuntime(dbPath, options = {}) {
                 reasoning,
                 parts,
                 startedAt: turn.startedAt,
+                ...(() => {
+                  const slot = restoreRunningSlot(turn.sessionAlias, {
+                    recoveryId: turn.recoveryId,
+                    startedAfterSeq: turn.startedAfterSeq,
+                    startedAt: turn.startedAt
+                  });
+                  return {
+                    slotAfterId: slot.slotAfterId,
+                    ...slot.startedAfterSeq !== undefined ? { startedAfterSeq: slot.startedAfterSeq } : {}
+                  };
+                })(),
                 ...turn.truncated ? { truncated: true } : {},
                 ...notification ? { notification } : {}
               });
@@ -10973,6 +11175,12 @@ async function createRelayRuntime(dbPath, options = {}) {
             for (const entry of sync.commands) {
               sessionCommands.set(key(instanceId, entry.sessionAlias), entry.commands);
             }
+            const keepAnchors = new Set;
+            for (const turn of sync.turns)
+              keepAnchors.add(canonicalRecoveryId(turn.sessionAlias, turn.recoveryId));
+            for (const finished of sync.finishedOffline)
+              keepAnchors.add(canonicalRecoveryId(finished.sessionAlias, finished.recoveryId));
+            slotAnchors.retain(instanceId, keepAnchors);
             webGateway.broadcast(accountId, { kind: "state-snapshot", instanceId, ...stateSnapshot(instanceId) });
           } catch (err) {
             gateway.disconnect(instanceId);
@@ -11022,7 +11230,8 @@ async function createRelayRuntime(dbPath, options = {}) {
     },
     onWebPromptSessionCleared: (instanceId, sessionAlias) => {
       clearPendingForSession(instanceId, sessionAlias);
-    }
+    },
+    turnSlotAnchors: slotAnchors
   });
   const completionRouteSweepTimer = setInterval(() => gateway.sweepExpiredCompletionRoutes(), 60 * 60000);
   completionRouteSweepTimer.unref?.();
@@ -11032,6 +11241,7 @@ async function createRelayRuntime(dbPath, options = {}) {
     instances,
     messages,
     recoveryReceipts,
+    slotAnchors,
     pushSubscriptions,
     pushNotifier,
     gateway,

package/dist/http/app.d.ts

@@ -3,6 +3,7 @@ import { type LiveTurnSnapshotDto, type PublishedAgentEndpointDto, type SessionC
 import type { AccountRow, AccountStore } from "../stores/accounts.js";
 import type { InstanceStore } from "../stores/instances.js";
 import type { MessageStore } from "../stores/messages.js";
+import type { TurnSlotAnchorStore } from "../stores/turn-slot-anchors.js";
 import type { PushSubscriptionStore } from "../stores/push-subscriptions.js";
 import type { RelayLogger } from "../logging.js";
 import { type UpdateCheck } from "../version.js";
@@ -17,6 +18,8 @@ export interface AppDeps {
     instances: InstanceStore;
     gateway: GatewayForApp;
     messages: MessageStore;
+    /** Live-slot anchors; cleared when a session or instance is deleted. */
+    turnSlotAnchors?: TurnSlotAnchorStore;
     /** Snapshot the in-flight turns for an instance (for the active-turns endpoint). */
     activeTurns?: (instanceId: string) => LiveTurnSnapshotDto[];
     /** Snapshot the latest per-session context-usage for an instance (for the active-turns endpoint). */

package/dist/http/compact-history.d.ts

@@ -6,5 +6,7 @@ export declare const COMPACT_DETAIL_PREVIEW = 240;
  * `parts` already carries them, and strip bulky tool bodies (diffs, command output,
  * file previews). Collapsed cards keep titles/status plus a short subagent snippet.
  * The full row is available from `GET .../messages/:id`.
+ * Top-level fields such as `startedAt`, `slotAfterId`, and `startedAfterSeq` are
+ * copied through unchanged — compact must not drop the durable slot anchor.
  */
 export declare function compactHistoryMessage(row: MessageRecordDto): MessageRecordDto;