@code-yeongyu/senpi 2026.9.15-2 → 2026.9.16-2

package/dist/core/session-manager.js

@@ -1,5 +1,5 @@
 import { randomBytes, randomUUID } from "crypto";
-import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync, } from "fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync, writeFileSync, } from "fs";
 import { readdir } from "fs/promises";
 import { join, resolve } from "path";
 import { StringDecoder } from "string_decoder";
@@ -8,7 +8,7 @@ import { normalizePath, resolvePath } from "../utils/paths.js";
 import { listSessionInfos, listSessionsFromDir } from "./session-discovery.js";
 import { materializeSessionEntries } from "./session-entry-materializer.js";
 import { ResidentStringStore } from "./session-resident-store.js";
-import { registerSessionWriter, reserveSessionWrite } from "./session-write-reservation.js";
+import { hasOtherLiveSessionWriter, registerSessionWriter, reserveSessionWrite, unregisterSessionWriter, } from "./session-write-reservation.js";
 // Fork change: inlined UUIDv7 (upstream uses the `uuid` npm package). Keeps this
 // package self-contained so consumers don't need a transitive `uuid` install.
 function uuidv7() {
@@ -587,6 +587,12 @@ export class SessionManager {
         if (persist && this.sessionDir && !existsSync(this.sessionDir)) {
             mkdirSync(this.sessionDir, { recursive: true });
         }
+        // Lazily resolved: the session id only exists once the header loads or
+        // newSession() runs. Unpersisted sessions disable eviction entirely —
+        // dropping strings with no backing would lose them.
+        this.residentStore.configure({
+            blobsDir: () => this.persist && this.sessionId ? join(this.sessionDir, "resident-blobs", this.sessionId) : undefined,
+        });
         if (sessionFile) {
             this._setSessionFile(sessionFile, preloadedFileEntries);
         }
@@ -646,6 +652,10 @@ export class SessionManager {
             this.fileEntries = entries;
             const header = this.fileEntries.find((e) => e.type === "session");
             this.sessionId = header?.id ?? createSessionId();
+            // Blobs left under this id by a process that is gone are a disposable cache:
+            // the JSONL is the authority for every entry and this store rewrites what it
+            // evicts, so clearing them bounds the directory to one process lifetime.
+            this._releaseBlobsDirUnlessShared();
             if (migrateToCurrentVersion(this.fileEntries)) {
                 this._rewriteFile();
             }
@@ -674,6 +684,10 @@ export class SessionManager {
         if (options?.id !== undefined) {
             assertValidSessionId(options.id);
         }
+        // Capture the previous backing before the id changes: the blobsDir
+        // provider resolves against the new id after this assignment, so clear()
+        // below would otherwise leak the old session's blob directory on disk.
+        const previousBlobsDir = this.residentStore.resolvedBlobsDir();
         this.sessionId = options?.id ?? createSessionId();
         const timestamp = new Date().toISOString();
         const header = {
@@ -688,6 +702,9 @@ export class SessionManager {
         this.mirrorTrimmed = false;
         this.fullEntryCount = 0;
         this.residentStore.clear();
+        if (previousBlobsDir) {
+            this._removeBlobsDir(previousBlobsDir);
+        }
         this.byId.clear();
         this.entryOrdersById.clear();
         this.messageEntryPositions = new WeakMap();
@@ -803,6 +820,13 @@ export class SessionManager {
     getSessionFile() {
         return this.sessionFile;
     }
+    /**
+     * Exposes the resident store for out-of-band string lifecycles such as the
+     * agent's runtime message state (tokenized while idle, hydrated per turn).
+     */
+    getResidentStore() {
+        return this.residentStore;
+    }
     getResidentStoreStats() {
         return this.residentStore.stats();
     }
@@ -1024,6 +1048,35 @@ export class SessionManager {
         this._trimMirrorAfterCompaction(entry);
         return entry.id;
     }
+    /**
+     * Release what outlives this manager in the process: the shared host's write
+     * grant and the blob directory backing its resident mirror. The session JSONL
+     * is untouched - it is the authority the next reader loads from. Idempotent.
+     */
+    dispose() {
+        unregisterSessionWriter(this);
+        this._releaseBlobsDirUnlessShared();
+    }
+    /**
+     * The blob directory is keyed by session id, so every live manager over the same
+     * session file hydrates from it. Removing it while one of them is still reading
+     * would cost that manager a full JSONL recovery per evicted string, so the last
+     * owner to let go is the one that clears it.
+     */
+    _releaseBlobsDirUnlessShared() {
+        const blobsDir = this.residentStore.resolvedBlobsDir();
+        if (!blobsDir)
+            return;
+        if (this.sessionFile && hasOtherLiveSessionWriter(this.sessionFile, this))
+            return;
+        this._removeBlobsDir(blobsDir);
+    }
+    _removeBlobsDir(dir) {
+        try {
+            rmSync(dir, { force: true, recursive: true });
+        }
+        catch { }
+    }
     _trimMirrorAfterCompaction(compaction) {
         if (!this.persist)
             return;
@@ -1042,7 +1095,7 @@ export class SessionManager {
                 entry.parentId = parentId;
             parentId = entry.type === "session" ? null : entry.id;
         }
-        this.residentStore.clear();
+        this.residentStore.spillResident();
         this.mirrorTrimmed = true;
         this.fileEntries = [header, ...retained]
             .filter((entry) => entry !== undefined)
@@ -1280,6 +1333,17 @@ export class SessionManager {
     getEntryCount() {
         return this.fullEntryCount;
     }
+    /**
+     * Release the memoized materialized views. Materialized entries hold the full
+     * persisted strings, so views kept between turns pin the whole session text
+     * in memory even while nothing runs. The next read rebuilds them from the
+     * bounded resident store.
+     */
+    dropMaterializedCaches() {
+        this.entriesCache = null;
+        this.branchCache = null;
+        this.compactEntriesCache = null;
+    }
     _materializeEntries(entries) {
         return materializeSessionEntries(entries, {
             residentStore: this.residentStore,
@@ -1503,11 +1567,19 @@ export class SessionManager {
                 parentId = labelEntry.id;
             }
             reserveSessionWrite(newSessionFile);
+            // Materialize the branched entries while the previous backing is still
+            // readable, then clear: re-externalizing tokenized entries after clear()
+            // would bake sentinel tokens into the new branched JSONL.
+            const branchedEntries = this._materializeEntries([...pathWithoutLabels, ...labelEntries]);
+            const previousBlobsDir = this.residentStore.resolvedBlobsDir();
             this.residentStore.clear();
+            if (previousBlobsDir) {
+                this._removeBlobsDir(previousBlobsDir);
+            }
             this.mirrorTrimmed = false;
-            this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries].map((entry) => this.residentStore.externalize(entry));
             this.sessionId = newSessionId;
             this.sessionFile = newSessionFile;
+            this.fileEntries = [header, ...branchedEntries.map((entry) => this.residentStore.externalize(entry))];
             this._buildIndex();
             this.mutationCount++;
             // Only write the file now if it contains an assistant message.
@@ -1540,8 +1612,9 @@ export class SessionManager {
             labelEntries.push(labelEntry);
             parentId = labelEntry.id;
         }
+        const branchedEntries = this._materializeEntries([...pathWithoutLabels, ...labelEntries]);
         this.residentStore.clear();
-        this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries].map((entry) => this.residentStore.externalize(entry));
+        this.fileEntries = [header, ...branchedEntries.map((entry) => this.residentStore.externalize(entry))];
         this.sessionId = newSessionId;
         this._buildIndex();
         this.mutationCount++;