@code-yeongyu/senpi 2026.7.20 → 2026.7.22

package/dist/core/session-manager.js

@@ -166,14 +166,27 @@ function buildSessionPath(entries, leafId, byId) {
 function getSessionContextSettings(path) {
     let thinkingLevel = "off";
     let model = null;
+    let isInFallbackWindow = false;
     for (const entry of path) {
         if (entry.type === "thinking_level_change") {
             thinkingLevel = entry.thinkingLevel;
         }
         else if (entry.type === "model_change") {
-            model = { provider: entry.provider, modelId: entry.modelId };
+            if (entry.reason === "fallback") {
+                if (!isInFallbackWindow && entry.originalProvider && entry.originalModelId) {
+                    model = { provider: entry.originalProvider, modelId: entry.originalModelId };
+                }
+                isInFallbackWindow = true;
+            }
+            else if (entry.reason === "fallback-revert") {
+                isInFallbackWindow = false;
+            }
+            else {
+                isInFallbackWindow = false;
+                model = { provider: entry.provider, modelId: entry.modelId };
+            }
         }
-        else if (entry.type === "message" && entry.message.role === "assistant") {
+        else if (entry.type === "message" && entry.message.role === "assistant" && !isInFallbackWindow) {
             model = { provider: entry.message.provider, modelId: entry.message.model };
         }
     }
@@ -585,6 +598,24 @@ export class SessionManager {
         this.labelTimestampsById = new Map();
         this.leafId = null;
         this.residentStore = new ResidentStringStore();
+        // 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;
+        this.entriesCache = null;
+        this.branchCache = null;
+        this.sessionNameCache = undefined;
+        // Running usage totals over ALL entries (not branch-scoped), maintained
+        // incrementally on assistant-message append and rebuilt from scratch in
+        // _buildIndex()/newSession. Usage fields are numeric and unaffected by
+        // string externalization, so the resident form can be read directly.
+        this.usageTotals = {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            cost: 0,
+            latestCacheHitRate: undefined,
+        };
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
         this.persist = persist;
@@ -624,6 +655,7 @@ export class SessionManager {
             }
             this.fileEntries = this.fileEntries.map((entry) => this.residentStore.externalize(entry));
             this._buildIndex();
+            this.mutationCount++;
             this.flushed = true;
         }
         else {
@@ -652,6 +684,16 @@ export class SessionManager {
         this.labelsById.clear();
         this.labelTimestampsById.clear();
         this.leafId = null;
+        this.sessionNameCache = undefined;
+        this.usageTotals = {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            cost: 0,
+            latestCacheHitRate: undefined,
+        };
+        this.mutationCount++;
         this.flushed = false;
         if (this.persist) {
             const fileTimestamp = timestamp.replace(/[:.]/g, "-");
@@ -664,11 +706,25 @@ export class SessionManager {
         this.labelsById.clear();
         this.labelTimestampsById.clear();
         this.leafId = null;
+        this.sessionNameCache = undefined;
+        this.usageTotals = {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            cost: 0,
+            latestCacheHitRate: undefined,
+        };
         for (const entry of this.fileEntries) {
             if (entry.type === "session")
                 continue;
             this.byId.set(entry.id, entry);
             this.leafId = entry.id;
+            this._accumulateUsage(entry);
+            if (entry.type === "session_info") {
+                // Empty names explicitly clear the session title.
+                this.sessionNameCache = entry.name?.trim() || undefined;
+            }
             if (entry.type === "label") {
                 if (entry.label) {
                     this.labelsById.set(entry.targetId, entry.label);
@@ -751,8 +807,38 @@ export class SessionManager {
         this.fileEntries.push(residentEntry);
         this.byId.set(residentEntry.id, residentEntry);
         this.leafId = residentEntry.id;
+        this._accumulateUsage(residentEntry);
+        this.mutationCount++;
         this._persist(residentEntry);
     }
+    /**
+     * Fold one entry into the running usage totals. Totals iterate ALL entries
+     * (not branch-scoped), matching the footer hot path's historical semantics.
+     */
+    _accumulateUsage(entry) {
+        if (entry.type !== "message" || entry.message.role !== "assistant")
+            return;
+        const usage = entry.message.usage;
+        // Assistant messages persisted without usage (e.g. aborted/error turns in
+        // older session files) contribute nothing to the running totals.
+        if (!usage)
+            return;
+        this.usageTotals.input += usage.input;
+        this.usageTotals.output += usage.output;
+        this.usageTotals.cacheRead += usage.cacheRead;
+        this.usageTotals.cacheWrite += usage.cacheWrite;
+        this.usageTotals.cost += usage.cost?.total ?? 0;
+        const latestPromptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+        this.usageTotals.latestCacheHitRate =
+            latestPromptTokens > 0 ? (usage.cacheRead / latestPromptTokens) * 100 : undefined;
+    }
+    /**
+     * O(1) running usage totals across ALL session entries (not branch-scoped).
+     * Maintained incrementally; identical to summing usage over getEntries().
+     */
+    getUsageTotals() {
+        return this.usageTotals;
+    }
     /** Append a message as child of current leaf, then advance leaf. Returns entry id.
      * Does not allow writing CompactionSummaryMessage and BranchSummaryMessage directly.
      * Reason: we want these to be top-level entries in the session, not message session entries,
@@ -783,7 +869,7 @@ export class SessionManager {
         return entry.id;
     }
     /** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
-    appendModelChange(provider, modelId) {
+    appendModelChange(provider, modelId, reason, originalProvider, originalModelId) {
         const entry = {
             type: "model_change",
             id: generateId(this.byId),
@@ -791,6 +877,9 @@ export class SessionManager {
             timestamp: new Date().toISOString(),
             provider,
             modelId,
+            reason,
+            originalProvider,
+            originalModelId,
         };
         this._appendEntry(entry);
         return entry.id;
@@ -834,21 +923,16 @@ export class SessionManager {
             timestamp: new Date().toISOString(),
             name: sanitizedName,
         };
+        this.sessionNameCache = sanitizedName || undefined;
         this._appendEntry(entry);
         return entry.id;
     }
-    /** Get the current session name from the latest session_info entry, if any. */
+    /**
+     * Get the current session name from the latest session_info entry, if any.
+     * O(1): the value is maintained incrementally on appendSessionInfo() and index rebuilds.
+     */
     getSessionName() {
-        // Walk entries in reverse to find the latest session_info entry.
-        // Empty names explicitly clear the session title.
-        const entries = this.getEntries();
-        for (let i = entries.length - 1; i >= 0; i--) {
-            const entry = entries[i];
-            if (entry.type === "session_info") {
-                return entry.name?.trim() || undefined;
-            }
-        }
-        return undefined;
+        return this.sessionNameCache;
     }
     /**
      * Append a custom message entry (for extensions) that participates in LLM context.
@@ -938,6 +1022,14 @@ export class SessionManager {
      * Use buildSessionContext() to get the resolved messages for the LLM.
      */
     getBranch(fromId) {
+        // No-arg reads (the common hot path) are memoized on (leafId, mutationCount);
+        // explicit fromId lookups bypass the cache.
+        if (fromId === undefined &&
+            this.branchCache !== null &&
+            this.branchCache.leafId === this.leafId &&
+            this.branchCache.mutation === this.mutationCount) {
+            return this.branchCache.entries;
+        }
         const path = [];
         const startId = fromId ?? this.leafId;
         let current = startId ? this.byId.get(startId) : undefined;
@@ -945,6 +1037,9 @@ export class SessionManager {
             path.unshift(this.residentStore.materialize(current));
             current = current.parentId ? this.byId.get(current.parentId) : undefined;
         }
+        if (fromId === undefined) {
+            this.branchCache = { leafId: this.leafId, mutation: this.mutationCount, entries: path };
+        }
         return path;
     }
     /**
@@ -995,14 +1090,24 @@ export class SessionManager {
         return h ? this.residentStore.materialize(h) : null;
     }
     /**
-     * Get all session entries (excludes header). Returns a shallow copy.
+     * Get all session entries (excludes header).
      * The session is append-only: use appendXXX() to add entries, branch() to
      * change the leaf pointer. Entries cannot be modified or deleted.
+     *
+     * The result is memoized behind the session mutation counter: repeated calls
+     * without an intervening mutation return the SAME shared array instance.
+     * Callers must not mutate the returned array or its entries; copy first if
+     * you need to filter/reorder.
      */
     getEntries() {
-        return this.fileEntries
+        if (this.entriesCache !== null && this.entriesCache.mutation === this.mutationCount) {
+            return this.entriesCache.entries;
+        }
+        const entries = this.fileEntries
             .filter((e) => e.type !== "session")
             .map((entry) => this.residentStore.materialize(entry));
+        this.entriesCache = { mutation: this.mutationCount, entries };
+        return entries;
     }
     /**
      * Get the session as a tree structure. Returns a shallow defensive copy of all entries.
@@ -1060,6 +1165,7 @@ export class SessionManager {
             throw new Error(`Entry ${branchFromId} not found`);
         }
         this.leafId = branchFromId;
+        this.mutationCount++;
     }
     /**
      * Reset the leaf pointer to null (before any entries).
@@ -1068,6 +1174,7 @@ export class SessionManager {
      */
     resetLeaf() {
         this.leafId = null;
+        this.mutationCount++;
     }
     /**
      * Start a new branch with a summary of the abandoned path.
@@ -1157,6 +1264,7 @@ export class SessionManager {
             this.sessionId = newSessionId;
             this.sessionFile = newSessionFile;
             this._buildIndex();
+            this.mutationCount++;
             // Only write the file now if it contains an assistant message.
             // Otherwise defer to _persist(), which creates the file on the
             // first assistant response, matching the newSession() contract
@@ -1191,6 +1299,7 @@ export class SessionManager {
         this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries].map((entry) => this.residentStore.externalize(entry));
         this.sessionId = newSessionId;
         this._buildIndex();
+        this.mutationCount++;
         return undefined;
     }
     /**