rterm-backend 3.8.2 → 3.8.3

package/bin/gybackend.cjs

@@ -258480,6 +258480,9 @@ var HistorySqliteStore_exports = {};
 __export(HistorySqliteStore_exports, {
   HistorySqliteStore: () => HistorySqliteStore
 });
+function digestFor(message) {
+  return `${message.type}\0${message.dataJson ?? ""}`;
+}
 var import_node_fs5, import_node_path8, HistorySqliteStore;
 var init_HistorySqliteStore = __esm({
   "../../packages/backend/src/services/history/HistorySqliteStore.ts"() {
@@ -258656,9 +258659,135 @@ var init_HistorySqliteStore = __esm({
           (session) => session !== null
         );
       }
+      /**
+       * Session meta WITHOUT messages.
+       *
+       * Two fixed-cost hot-path bugs this closes:
+       *
+       *  1. `ChatHistoryService.saveSession` called `loadChatSession()` purely to
+       *     learn `createdAt`. That JSON.parse'd the ENTIRE session — measured
+       *     ~117 MB / ~1.5 s of parse for a 6k-message session — and threw every
+       *     parsed message away, on every save.
+       *  2. `AgentService_v2.trySaveSessionFromCheckpoint` called `loadSession()`
+       *     for a default it never used, because `updateSessionFromMessages()`
+       *     rebuilds `session.messages` from scratch. Dropping that call outright
+       *     would have reset the session TITLE to "New Session" on every restore,
+       *     so the title is read here too.
+       */
+      getChatSessionMeta(sessionId) {
+        const row = this.db.prepare("SELECT created_at, title FROM chat_sessions WHERE id = ?").get(sessionId);
+        return row ? { createdAt: row.created_at, title: row.title } : null;
+      }
+      /** Created-at scalar only — a single indexed row, never a message parse. */
+      getChatSessionCreatedAt(sessionId) {
+        return this.getChatSessionMeta(sessionId)?.createdAt;
+      }
+      /**
+       * Existing message bodies as RAW TEXT, ordered by position, WITHOUT parsing.
+       *
+       * The raw `message_data_json` is needed for a byte-exact comparison against
+       * the newly serialized body. Deliberately NOT JSON.parse'd: the parse is the
+       * expensive half of the freeze (~1.5 s / 117 MB measured) and is unnecessary
+       * for an equality test.
+       *
+       * (An earlier revision compared only `substr(json, 1, 200)`. That was WRONG:
+       * a message whose content grows past the first 200 characters — exactly what
+       * streaming does to the last AI message — leaves the prefix untouched, so the
+       * row would be skipped and the persisted history would silently stay STALE.
+       * Full-text comparison is what makes "unchanged => skip" safe.)
+       */
+      loadSessionMessageState(sessionId) {
+        const rows = this.db.prepare(
+          `SELECT message_id, message_type, position, message_data_json
+         FROM chat_session_messages
+         WHERE session_id = ?
+         ORDER BY position ASC`
+        ).all(sessionId);
+        return rows.map((row) => ({
+          id: row.message_id,
+          type: row.message_type,
+          position: row.position,
+          jsonText: row.message_data_json ?? ""
+        }));
+      }
+      /**
+       * Incremental write: touch only the rows that actually moved.
+       *
+       * The old path ran `DELETE ALL` + `INSERT ALL` on every save, rewriting the
+       * whole session payload each time. Here, unchanged messages stay on disk
+       * untouched; messages that are genuinely absent (compaction, rollback) are
+       * removed individually.
+       */
+      applyChatSessionDelta(sessionId, desired, existingDigests, writeAll) {
+        const desiredIds = /* @__PURE__ */ new Set();
+        for (const m2 of desired) {
+          desiredIds.add(m2.id);
+        }
+        const changed = writeAll ? desired : desired.filter((m2) => existingDigests.get(m2.id) !== digestFor(m2));
+        const toRemove = [];
+        for (const id of existingDigests.keys()) {
+          if (!desiredIds.has(id)) {
+            toRemove.push(id);
+          }
+        }
+        if (changed.length === 0 && toRemove.length === 0) {
+          return;
+        }
+        const upsert = this.db.prepare(
+          `INSERT INTO chat_session_messages (
+         session_id, position, message_id, message_type, message_data_json
+       ) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(session_id, message_id) DO UPDATE SET
+         position = excluded.position,
+         message_type = excluded.message_type,
+         message_data_json = excluded.message_data_json`
+        );
+        const removeOne = this.db.prepare(
+          "DELETE FROM chat_session_messages WHERE session_id = ? AND message_id = ?"
+        );
+        this.db.transaction(() => {
+          for (const id of toRemove) {
+            removeOne.run(sessionId, id);
+          }
+          for (const m2 of changed) {
+            upsert.run(sessionId, m2.position, m2.id, m2.type, m2.dataJson);
+          }
+        })();
+      }
+      /**
+       * Full positional rewrite. Positions are `PRIMARY KEY (session_id,
+       * position)`, so an in-place UPDATE cannot express a reorder without a
+       * transient collision — the order guard in saveChatSession routes here when
+       * (and only when) the surviving ids changed relative order.
+       *
+       * Therefore this really does DELETE + INSERT rather than upsert. An
+       * `ON CONFLICT(session_id, message_id)` upsert looks like it would work but
+       * does NOT: reassigning `position` collides on the (session_id, position)
+       * PRIMARY KEY against a row that has not moved yet, and that conflict is not
+       * absorbed by an ON CONFLICT clause targeting a different key —
+       *   SqliteError: UNIQUE constraint failed:
+       *     chat_session_messages.session_id, chat_session_messages.position
+       * Clearing first (inside the same transaction) sidesteps the ordering
+       * problem entirely. This path is rare by design, so the rewrite is cheap
+       * enough, and it matches the old DELETE-ALL/INSERT-ALL semantics exactly.
+       */
+      replaceAllMessages(sessionId, desired) {
+        const removeAll = this.db.prepare(
+          "DELETE FROM chat_session_messages WHERE session_id = ?"
+        );
+        const insert = this.db.prepare(
+          `INSERT INTO chat_session_messages (
+         session_id, position, message_id, message_type, message_data_json
+       ) VALUES (?, ?, ?, ?, ?)`
+        );
+        this.db.transaction(() => {
+          removeAll.run(sessionId);
+          desired.forEach((m2, index2) => {
+            insert.run(sessionId, index2, m2.id, m2.type, m2.dataJson);
+          });
+        })();
+      }
       saveChatSession(session) {
-        const existingCreatedAt = this.db.prepare("SELECT created_at FROM chat_sessions WHERE id = ?").get(session.id);
-        const createdAt = existingCreatedAt?.created_at ?? session.createdAt;
         const upsertSession = this.db.prepare(
           `INSERT INTO chat_sessions (
          id, title, last_checkpoint_offset, last_profile_max_tokens, created_at, updated_at
@@ -258671,34 +258800,45 @@ var init_HistorySqliteStore = __esm({
          last_profile_max_tokens = excluded.last_profile_max_tokens,
          updated_at = excluded.updated_at`
         );
-        const deleteMessages = this.db.prepare(
-          "DELETE FROM chat_session_messages WHERE session_id = ?"
-        );
-        const insertMessage = this.db.prepare(
-          `INSERT INTO chat_session_messages (
-         session_id, position, message_id, message_type, message_data_json
-       ) VALUES (?, ?, ?, ?, ?)`
-        );
         this.db.transaction(() => {
           upsertSession.run({
             id: session.id,
             title: session.title,
             lastCheckpointOffset: session.lastCheckpointOffset,
             lastProfileMaxTokens: session.lastProfileMaxTokens ?? null,
-            createdAt,
+            createdAt: session.createdAt,
             updatedAt: session.updatedAt
           });
-          deleteMessages.run(session.id);
-          session.messages.forEach((message, index2) => {
-            insertMessage.run(
-              session.id,
-              index2,
-              message.id,
-              message.type,
-              JSON.stringify(message.data)
-            );
-          });
         })();
+        const desired = session.messages.map(
+          (message, index2) => ({
+            id: message.id,
+            type: message.type,
+            position: index2,
+            dataJson: JSON.stringify(message.data)
+          })
+        );
+        const existingState = this.loadSessionMessageState(session.id);
+        const existingDigests = /* @__PURE__ */ new Map();
+        for (const row of existingState) {
+          existingDigests.set(
+            row.id,
+            digestFor({ type: row.type, dataJson: row.jsonText })
+          );
+        }
+        const storedOrder = existingState.map((row) => row.id);
+        const desiredOrderOfStored = [];
+        for (const m2 of desired) {
+          if (existingDigests.has(m2.id)) {
+            desiredOrderOfStored.push(m2.id);
+          }
+        }
+        const reordered = storedOrder.length !== desiredOrderOfStored.length || storedOrder.some((id, i) => id !== desiredOrderOfStored[i]);
+        if (reordered) {
+          this.replaceAllMessages(session.id, desired);
+          return;
+        }
+        this.applyChatSessionDelta(session.id, desired, existingDigests, false);
       }
       deleteChatSessions(sessionIds) {
         const ids = Array.from(
@@ -371635,9 +371775,11 @@ ${reminder}`;
         messages = [...messages, this.lastAbortedMessage];
         this.lastAbortedMessage = null;
       }
-      const session = this.chatHistoryService.loadSession(sessionId) || {
+      const sessionMeta = this.chatHistoryService.getSessionMeta(sessionId);
+      const session = {
         id: sessionId,
-        title: "New Session",
+        title: sessionMeta?.title || "New Session",
+        // Placeholder only — replaced by updateSessionFromMessages() below.
         messages: /* @__PURE__ */ new Map(),
         lastCheckpointOffset: 0,
         lastProfileMaxTokens: this.getEffectiveMaxTokensForSession(sessionId)
@@ -373138,7 +373280,7 @@ var ChatHistoryService = class {
     this.store = options?.store || new HistorySqliteStore();
   }
   saveSession(session) {
-    const existing = this.store.loadChatSession(session.id);
+    const createdAt = this.store.getChatSessionCreatedAt(session.id);
     const now = Date.now();
     this.store.saveChatSession({
       id: session.id,
@@ -373150,10 +373292,18 @@ var ChatHistoryService = class {
       })),
       lastCheckpointOffset: session.lastCheckpointOffset,
       lastProfileMaxTokens: session.lastProfileMaxTokens,
-      createdAt: existing?.createdAt || now,
+      createdAt: createdAt || now,
       updatedAt: now
     });
   }
+  /**
+   * Session row only (title/createdAt) — never parses stored messages.
+   * Used on the checkpoint save path, which previously paid a full session
+   * parse just to preserve the title.
+   */
+  getSessionMeta(sessionId) {
+    return this.store.getChatSessionMeta(sessionId);
+  }
   loadSession(sessionId) {
     const storedSession = this.store.loadChatSession(sessionId);
     if (!storedSession) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rterm-backend",
-  "version": "3.8.2",
+  "version": "3.8.3",
   "description": "AI-native terminal & agentic-AI operations platform for Forward Deployed Engineers & SREs: AIOps closed-loop remediation, AI SRE, self-healing infrastructure, runbook automation, ChatOps; executes over SSH/WinRM/serial under policy with tamper-evident audit.",
   "keywords": [
     "forward-deployed-engineer",