@code-yeongyu/senpi 2026.8.30 → 2026.9.2-3

package/dist/core/session-manager.js

@@ -497,6 +497,15 @@ export function findMostRecentSession(sessionDir, cwd) {
  * Use buildSessionContext() to get the resolved message list for the LLM, which
  * handles compaction summaries and follows the path from root to current leaf.
  */
+let sessionEntryLoader = loadEntriesFromFile;
+/** Test seam for observing disk reloads without mocking ESM filesystem exports. */
+export function setSessionEntryLoaderForTesting(loader) {
+    const previous = sessionEntryLoader;
+    sessionEntryLoader = loader;
+    return () => {
+        sessionEntryLoader = previous;
+    };
+}
 export class SessionManager {
     constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
         this.sessionId = "";
@@ -513,6 +522,8 @@ export class SessionManager {
         this.labelTimestampsById = new Map();
         this.leafId = null;
         this.residentStore = new ResidentStringStore();
+        this.mirrorTrimmed = false;
+        this.compactEntriesCache = null;
         // Monotonic counter bumped by every mutator; memoized materialized views are
         // keyed on it so read hot paths (footer, RPC) never re-materialize unchanged sessions.
         this.mutationCount = 0;
@@ -567,6 +578,7 @@ export class SessionManager {
     }
     _setSessionFile(sessionFile, preloadedFileEntries) {
         this.sessionFile = resolvePath(sessionFile);
+        this.mirrorTrimmed = false;
         this.residentStore.clear();
         if (existsSync(this.sessionFile)) {
             this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
@@ -614,6 +626,7 @@ export class SessionManager {
             parentSession: options?.parentSession,
         };
         this.fileEntries = [header];
+        this.mirrorTrimmed = false;
         this.residentStore.clear();
         this.byId.clear();
         this.entryOrdersById.clear();
@@ -776,7 +789,18 @@ export class SessionManager {
         }
     }
     _materializeEntry(entry) {
-        const materialized = this.residentStore.materialize(entry);
+        let missingResidentString = false;
+        const materialized = this.residentStore.materialize(entry, () => {
+            missingResidentString = true;
+            return undefined;
+        });
+        // The resident store is a bounded cache. The JSONL remains authoritative
+        // when an evicted blob is needed by a branch or read operation.
+        if (missingResidentString && this.sessionFile) {
+            const persisted = loadEntriesFromFile(this.sessionFile).find((candidate) => candidate.id === entry.id);
+            if (persisted)
+                return persisted;
+        }
         if (materialized.type === "message") {
             const order = this.entryOrdersById.get(materialized.id);
             if (order !== undefined) {
@@ -886,9 +910,36 @@ export class SessionManager {
             fromHook,
         };
         this._appendEntry(entry);
+        this._trimMirrorAfterCompaction(entry);
         return entry.id;
     }
-    /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
+    _trimMirrorAfterCompaction(compaction) {
+        if (!this.persist)
+            return;
+        const firstKeptIndex = this.fileEntries.findIndex((entry) => entry.id === compaction.firstKeptEntryId);
+        const compactionIndex = this.fileEntries.findIndex((entry) => entry.id === compaction.id);
+        if (firstKeptIndex < 0 || compactionIndex < firstKeptIndex)
+            return;
+        const header = this.fileEntries.find((entry) => entry.type === "session");
+        const retained = [
+            ...this.fileEntries.slice(0, firstKeptIndex).filter((entry) => entry.type !== "message"),
+            ...this.fileEntries.slice(firstKeptIndex, compactionIndex + 1),
+        ];
+        let parentId = null;
+        for (const entry of retained) {
+            if (entry.type !== "session")
+                entry.parentId = parentId;
+            parentId = entry.type === "session" ? null : entry.id;
+        }
+        this.residentStore.clear();
+        this.mirrorTrimmed = true;
+        this.fileEntries = [header, ...retained]
+            .filter((entry) => entry !== undefined)
+            .map((entry) => this.residentStore.externalize(entry));
+        this._buildIndex();
+        this.mutationCount++;
+    }
+    /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. */
     appendCustomEntry(customType, data) {
         const entry = {
             type: "custom",
@@ -956,7 +1007,13 @@ export class SessionManager {
     }
     getEntry(id) {
         const entry = this.byId.get(id);
-        return entry ? this._materializeEntry(entry) : undefined;
+        if (entry)
+            return this._materializeEntry(entry);
+        if (this.mirrorTrimmed && this.sessionFile) {
+            const persisted = this._loadFullHistoryEntries().find((candidate) => candidate.id === id);
+            return persisted ? this.residentStore.materialize(persisted) : undefined;
+        }
+        return undefined;
     }
     /**
      * Get all direct children of an entry.
@@ -1020,10 +1077,16 @@ export class SessionManager {
         }
         const path = [];
         const startId = fromId ?? this.leafId;
-        let current = startId ? this.byId.get(startId) : undefined;
+        let entriesById = this.byId;
+        if (fromId !== undefined && !entriesById.has(fromId) && this.mirrorTrimmed && this.sessionFile) {
+            entriesById = new Map(this._loadFullHistoryEntries()
+                .filter((entry) => entry.type !== "session")
+                .map((entry) => [entry.id, this.residentStore.materialize(entry)]));
+        }
+        let current = startId ? entriesById.get(startId) : undefined;
         while (current) {
             path.unshift(this._materializeEntry(current));
-            current = current.parentId ? this.byId.get(current.parentId) : undefined;
+            current = current.parentId ? entriesById.get(current.parentId) : undefined;
         }
         if (fromId === undefined) {
             this.branchCache = { leafId: this.leafId, mutation: this.mutationCount, entries: path };
@@ -1035,14 +1098,14 @@ export class SessionManager {
      * Uses tree traversal from current leaf.
      */
     buildContextEntries() {
-        return buildContextEntries(this.getEntries(), this.leafId);
+        return buildContextEntries(this._getCompactEntries(), this.leafId);
     }
     /**
      * Build the session context (what gets sent to the LLM).
      * Uses tree traversal from current leaf.
      */
     buildSessionContext() {
-        return buildSessionContext(this.getEntries(), this.leafId);
+        return buildSessionContext(this._getCompactEntries(), this.leafId);
     }
     hasContextMessages() {
         return this.hasBranchEntry((entry) => entry.type === "message" ||
@@ -1088,6 +1151,11 @@ export class SessionManager {
      * you need to filter/reorder.
      */
     getEntries() {
+        if (this.mirrorTrimmed && this.sessionFile) {
+            return this._loadFullHistoryEntries()
+                .filter((e) => e.type !== "session")
+                .map((entry) => this.residentStore.materialize(entry));
+        }
         if (this.entriesCache !== null && this.entriesCache.mutation === this.mutationCount) {
             return this.entriesCache.entries;
         }
@@ -1097,6 +1165,45 @@ export class SessionManager {
         this.entriesCache = { mutation: this.mutationCount, entries };
         return entries;
     }
+    _getCompactEntries() {
+        if (this.compactEntriesCache?.mutation !== this.mutationCount) {
+            this.compactEntriesCache = {
+                mutation: this.mutationCount,
+                entries: this.fileEntries.filter((e) => e.type !== "session"),
+            };
+        }
+        const entries = this.compactEntriesCache.entries;
+        const missingEntryIds = new Set();
+        for (const entry of entries) {
+            this.residentStore.materialize(entry, () => {
+                missingEntryIds.add(entry.id);
+                return undefined;
+            });
+        }
+        if (missingEntryIds.size > 0 && this.sessionFile) {
+            const persistedById = new Map(this._loadFullHistoryEntries().map((entry) => [entry.id, entry]));
+            for (let index = 0; index < entries.length; index++) {
+                const entry = entries[index];
+                if (!missingEntryIds.has(entry.id))
+                    continue;
+                const persisted = persistedById.get(entry.id);
+                if (persisted)
+                    entries[index] = this.residentStore.externalize(persisted);
+            }
+        }
+        const materialized = entries.map((entry) => this.residentStore.materialize(entry));
+        for (const entry of materialized) {
+            if (entry.type !== "message")
+                continue;
+            const order = this.entryOrdersById.get(entry.id);
+            if (order !== undefined)
+                this.messageEntryPositions.set(entry.message, { entryId: entry.id, order });
+        }
+        return materialized;
+    }
+    _loadFullHistoryEntries() {
+        return this.sessionFile ? sessionEntryLoader(this.sessionFile) : this.fileEntries;
+    }
     /**
      * Get the session as a tree structure. Returns a shallow defensive copy of all entries.
      * A well-formed session has exactly one root (first entry with parentId === null).
@@ -1149,6 +1256,9 @@ export class SessionManager {
      * are not modified or deleted.
      */
     branch(branchFromId) {
+        if (!this.byId.has(branchFromId) && this.sessionFile) {
+            this.reloadFromDisk();
+        }
         if (!this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1250,6 +1360,7 @@ export class SessionManager {
                 parentId = labelEntry.id;
             }
             this.residentStore.clear();
+            this.mirrorTrimmed = false;
             this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries].map((entry) => this.residentStore.externalize(entry));
             this.sessionId = newSessionId;
             this.sessionFile = newSessionFile;