neuralos 3.8.8 → 3.8.9

package/bin/gybackend.cjs

@@ -346328,6 +346328,7 @@ var AgentRunLedger = class {
 var CHECKPOINT_STRING_CAP = 8 * 1024;
 var CHECKPOINT_BYTES_CAP = 16 * 1024 * 1024;
 var CHECKPOINT_MAX_MESSAGES = 40;
+var CHECKPOINT_RETENTION = 8;
 function truncateString(input, max = CHECKPOINT_STRING_CAP) {
   if (input.length <= max) return input;
   const omitted = input.length - max;
@@ -346395,8 +346396,18 @@ function isAllocationError(error40) {
 var SafeMemorySaver = class extends MemorySaver {
   async put(config2, checkpoint, metadata) {
     const pruned = pruneCheckpointForSaver(checkpoint);
+    const threadId = config2?.configurable?.thread_id;
+    const ns = config2?.configurable?.checkpoint_ns ?? "";
+    const checkpointId = checkpoint?.id;
+    if (threadId && checkpointId) {
+      const order = this.putOrderFor(threadId, ns);
+      order.push(checkpointId);
+      this.setPutOrder(threadId, ns, order.slice(-CHECKPOINT_RETENTION * 4));
+    }
     try {
-      return await super.put(config2, pruned, pruneValue(metadata));
+      const result = await super.put(config2, pruned, pruneValue(metadata));
+      this.evictOldCheckpoints(config2);
+      return result;
     } catch (error40) {
       if (!isAllocationError(error40)) throw error40;
       console.warn(
@@ -346409,12 +346420,15 @@ var SafeMemorySaver = class extends MemorySaver {
           channels.messages = channels.messages.slice(-8);
         }
         tighter.channel_values = channels;
-        return await super.put(config2, tighter, { source: "oom-pruned" });
+        const result = await super.put(config2, tighter, { source: "oom-pruned" });
+        this.evictOldCheckpoints(config2);
+        return result;
       } catch (retryError) {
         if (!isAllocationError(retryError)) throw retryError;
         console.warn(
           "[SafeMemorySaver] checkpoint still too large \u2014 skipping persist so the run can finish"
         );
+        this.evictOldCheckpoints(config2);
         return {
           configurable: {
             thread_id: config2?.configurable?.thread_id,
@@ -346425,6 +346439,46 @@ var SafeMemorySaver = class extends MemorySaver {
       }
     }
   }
+  /**
+   * Keep only the newest CHECKPOINT_RETENTION checkpoints for the thread/ns
+   * in this config. MemorySaver stores them as
+   * storage[threadId][ns][checkpointId] = [serializedCheckpoint, metadata,
+   * parentId]; there is no timestamp, but checkpoint ids from langgraph are
+   * UUIDv4-orderable-ish in practice and — more reliably — the number of
+   * entries is what matters for memory. We cannot know insertion order from
+   * the object shape alone, so we track it ourselves: the ids we just put
+   * are recorded, and anything beyond the newest window is dropped.
+   */
+  evictOldCheckpoints(config2) {
+    try {
+      const threadId = config2?.configurable?.thread_id;
+      const ns = config2?.configurable?.checkpoint_ns ?? "";
+      if (!threadId) return;
+      const storage = this.storage;
+      const nsMap = storage?.[threadId]?.[ns];
+      if (!nsMap) return;
+      const ids = Object.keys(nsMap);
+      if (ids.length <= CHECKPOINT_RETENTION) return;
+      const order = this.putOrderFor(threadId, ns);
+      const keep = new Set(order.slice(-CHECKPOINT_RETENTION));
+      for (const id of ids) {
+        if (!keep.has(id) && !order.includes(id)) keep.add(id);
+      }
+      for (const id of ids) {
+        if (!keep.has(id)) delete nsMap[id];
+      }
+      const remaining = order.filter((id) => id in nsMap);
+      this.setPutOrder(threadId, ns, remaining.slice(-CHECKPOINT_RETENTION * 2));
+    } catch {
+    }
+  }
+  putOrders = /* @__PURE__ */ new Map();
+  putOrderFor(threadId, ns) {
+    return this.putOrders.get(`${threadId}\0${ns}`) ?? [];
+  }
+  setPutOrder(threadId, ns, ids) {
+    this.putOrders.set(`${threadId}\0${ns}`, ids);
+  }
   async putWrites(config2, writes, taskId) {
     const prunedWrites = Array.isArray(writes) ? writes.map((w) => {
       if (Array.isArray(w) && w.length >= 2) {
@@ -371792,6 +371846,23 @@ ${reminder}`;
       baseMessages = mapStoredMessagesToChatMessages(
         sanitizedStoredMessages.messages
       );
+      const interruptedRun = this.chatHistoryService.getRunMarker(sessionId);
+      if (interruptedRun) {
+        const minutesAgo = Math.max(
+          0,
+          Math.round((Date.now() - (interruptedRun.startedAt || 0)) / 6e4)
+        );
+        baseMessages.push(
+          new SystemMessage(
+            `[INTERRUPTION NOTICE] The previous task on this session was interrupted ${minutesAgo > 0 ? `${minutesAgo} minutes ` : ""}ago (the application stopped before the response completed \u2014 likely a force quit or crash). The last assistant response above may be PARTIAL: it can end mid-sentence, mid-tool-call, or before the task was actually finished. ` + (interruptedRun.inputPreview ? `The interrupted task began with: "${interruptedRun.inputPreview}"
+` : "") + `Do not assume the prior task completed. If the user's next message relates to it, offer to continue or finish the interrupted work rather than starting from scratch.`
+          )
+        );
+        this.chatHistoryService.clearRunMarker(sessionId);
+        console.warn(
+          `[AgentService_v2] Restored session ${sessionId} after an interrupted run (${interruptedRun.runId}); injected interruption notice into context.`
+        );
+      }
     }
     const runExperimentalFlags = resolveRunExperimentalFlags(
       context2,
@@ -371811,6 +371882,11 @@ ${reminder}`;
       execCommandActionModelEnabled: runExperimentalFlags.execCommandActionModelEnabled,
       writeStdinActionModelEnabled: runExperimentalFlags.writeStdinActionModelEnabled
     };
+    this.chatHistoryService.setRunMarker(sessionId, {
+      runId: ledgerRunId,
+      startedAt: Date.now(),
+      inputPreview: ledgerInputPreview.slice(0, 500)
+    });
     try {
       const result = await this.graph.invoke(initialState, {
         recursionLimit,
@@ -371869,6 +371945,7 @@ ${reminder}`;
       this.currentRunIdBySession.delete(sessionId);
       this.agentRunLedger?.finishRun(ledgerRunId, ledgerExitStatus, ledgerExitError);
       void this.recordCompoundingLessons(sessionId, ledgerRunId, ledgerExitStatus, ledgerExitError);
+      this.chatHistoryService.clearRunMarker(sessionId);
       await this.clearCheckpoint(sessionId);
     }
   }
@@ -373440,9 +373517,11 @@ var ChatHistoryService = class {
   saveSession(session) {
     const createdAt = this.store.getChatSessionCreatedAt(session.id);
     const now = Date.now();
+    const storedMeta = this.store.getChatSessionMeta(session.id);
+    const title = storedMeta?.title ?? session.title;
     this.store.saveChatSession({
       id: session.id,
-      title: session.title,
+      title,
       messages: Array.from(session.messages.entries()).map(([id, message]) => ({
         id,
         type: message._getType ? message._getType() : "unknown",
@@ -373462,6 +373541,32 @@ var ChatHistoryService = class {
   getSessionMeta(sessionId) {
     return this.store.getChatSessionMeta(sessionId);
   }
+  // ─── v3.8.9: run interruption markers ─────────────────────────────────────
+  // A marker is SET at run start and CLEARED in the run's finally block.
+  // Only a hard kill (force quit, crash, power loss) skips the finally —
+  // so a leftover marker is a durable, restart-surviving record that the
+  // session's previous run was interrupted. Stored in the history_meta
+  // table (plain SQLite, survives anything short of disk loss).
+  runMarkerKey(sessionId) {
+    return `run-marker:${sessionId}`;
+  }
+  setRunMarker(sessionId, marker) {
+    this.store.setMeta(this.runMarkerKey(sessionId), JSON.stringify(marker));
+  }
+  getRunMarker(sessionId) {
+    const raw = this.store.getMeta(this.runMarkerKey(sessionId));
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed?.runId === "string") return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  clearRunMarker(sessionId) {
+    this.store.setMeta(this.runMarkerKey(sessionId), "");
+  }
   loadSession(sessionId) {
     const storedSession = this.store.loadChatSession(sessionId);
     if (!storedSession) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuralos",
-  "version": "3.8.8",
+  "version": "3.8.9",
   "description": "Standalone neuralOS backend (rterm-backend): AI-native terminal & agentic-AI operations platform.",
   "keywords": [
     "forward-deployed-engineer",