@caupulican/pi-agent-core 0.81.27 → 0.81.30

package/dist/session/session-manager.js

@@ -6,6 +6,7 @@ import { createInterface } from "node:readline";
 import { StringDecoder } from "node:string_decoder";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
+import { StreamingLineDecoder } from "../utils/streaming-lines.js";
 import { uuidv7 } from "../uuid.js";
 import { compactToolResultDetailsForRetention } from "./message-retention.js";
 export const CURRENT_SESSION_VERSION = 3;
@@ -145,13 +146,14 @@ export function buildSessionContext(entries, leafId, byId) {
     if (!leaf) {
         return { messages: [], thinkingLevel: "off", model: null };
     }
-    // Walk from leaf to root, collecting path
+    // Walk from leaf to root, then reverse once. Repeated front insertion makes long branches quadratic.
     const path = [];
     let current = leaf;
     while (current) {
-        path.unshift(current);
+        path.push(current);
         current = current.parentId ? byId.get(current.parentId) : undefined;
     }
+    path.reverse();
     // Extract settings and find compaction
     let thinkingLevel = "off";
     let model = null;
@@ -273,45 +275,28 @@ export function loadEntriesFromFile(filePath, options) {
     const fd = openSync(resolvedFilePath, "r");
     try {
         const decoder = new StringDecoder("utf8");
+        const lines = new StreamingLineDecoder(maxLineChars, { overflow: "skip", lineEndings: "lf" });
         const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
-        let pending = "";
-        let skippingOversizedLine = false;
         while (true) {
             const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
             if (bytesRead === 0)
                 break;
-            pending += decoder.write(buffer.subarray(0, bytesRead));
-            if (skippingOversizedLine) {
-                const resumeIndex = pending.indexOf("\n");
-                if (resumeIndex === -1) {
-                    pending = "";
-                    continue;
-                }
-                pending = pending.slice(resumeIndex + 1);
-                skippingOversizedLine = false;
-            }
-            let lineStart = 0;
-            let newlineIndex = pending.indexOf("\n", lineStart);
-            while (newlineIndex !== -1) {
-                if (newlineIndex - lineStart <= maxLineChars) {
-                    const entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
-                    if (entry)
-                        entries.push(entry);
-                }
-                lineStart = newlineIndex + 1;
-                newlineIndex = pending.indexOf("\n", lineStart);
-            }
-            pending = pending.slice(lineStart);
-            if (pending.length > maxLineChars) {
-                skippingOversizedLine = true;
-                pending = "";
+            for (const line of lines.push(decoder.write(buffer.subarray(0, bytesRead)))) {
+                const entry = parseSessionEntryLine(line);
+                if (entry)
+                    entries.push(entry);
             }
         }
-        pending += decoder.end();
-        if (!skippingOversizedLine && pending.length <= maxLineChars) {
-            const finalEntry = parseSessionEntryLine(pending);
-            if (finalEntry)
-                entries.push(finalEntry);
+        for (const line of lines.push(decoder.end())) {
+            const entry = parseSessionEntryLine(line);
+            if (entry)
+                entries.push(entry);
+        }
+        const finalLine = lines.finish();
+        if (finalLine !== undefined) {
+            const entry = parseSessionEntryLine(finalLine);
+            if (entry)
+                entries.push(entry);
         }
     }
     finally {
@@ -326,6 +311,87 @@ export function loadEntriesFromFile(filePath, options) {
     }
     return entries;
 }
+const ENTRY_ID_PREFIX_BYTES = 64 * 1024;
+const COMPACTED_PAYLOAD_RELEASE_MIN_CHARS = 16 * 1024;
+function indexSessionEntryFileLocations(filePath, startOffset, locations, retainedIds) {
+    const fd = openSync(filePath, "r");
+    const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+    let position = startOffset;
+    let lineOffset = startOffset;
+    let lineLength = 0;
+    let prefixLength = 0;
+    let prefixParts = [];
+    const finishLine = () => {
+        if (prefixLength > 0) {
+            const prefix = prefixParts.length === 1
+                ? prefixParts[0].toString("utf8")
+                : Buffer.concat(prefixParts, prefixLength).toString("utf8");
+            const id = /"id"\s*:\s*"([A-Za-z0-9_-]+)"/.exec(prefix)?.[1];
+            if (id && retainedIds.has(id))
+                locations.set(id, { offset: lineOffset, length: lineLength });
+        }
+        lineLength = 0;
+        prefixLength = 0;
+        prefixParts = [];
+    };
+    try {
+        while (true) {
+            const bytesRead = readSync(fd, buffer, 0, buffer.length, position);
+            if (bytesRead === 0)
+                break;
+            const chunkOffset = position;
+            position += bytesRead;
+            let segmentStart = 0;
+            while (segmentStart < bytesRead) {
+                const newlineIndex = buffer.indexOf(0x0a, segmentStart);
+                const segmentEnd = newlineIndex === -1 || newlineIndex >= bytesRead ? bytesRead : newlineIndex;
+                const segmentLength = segmentEnd - segmentStart;
+                lineLength += segmentLength;
+                const prefixRemaining = ENTRY_ID_PREFIX_BYTES - prefixLength;
+                if (prefixRemaining > 0 && segmentLength > 0) {
+                    const retainedLength = Math.min(prefixRemaining, segmentLength);
+                    prefixParts.push(Buffer.from(buffer.subarray(segmentStart, segmentStart + retainedLength)));
+                    prefixLength += retainedLength;
+                }
+                if (newlineIndex === -1 || newlineIndex >= bytesRead)
+                    break;
+                finishLine();
+                lineOffset = chunkOffset + newlineIndex + 1;
+                segmentStart = newlineIndex + 1;
+            }
+        }
+        if (lineLength > 0)
+            finishLine();
+        return position;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function retainedStringChars(value, stopAfter) {
+    const pending = [value];
+    const seen = new WeakSet();
+    let chars = 0;
+    while (pending.length > 0) {
+        const item = pending.pop();
+        if (typeof item === "string") {
+            chars += item.length;
+            if (chars >= stopAfter)
+                return chars;
+            continue;
+        }
+        if (!item || typeof item !== "object" || seen.has(item))
+            continue;
+        seen.add(item);
+        if (Array.isArray(item)) {
+            pending.push(...item);
+        }
+        else {
+            pending.push(...Object.values(item));
+        }
+    }
+    return chars;
+}
 function readSessionHeader(filePath) {
     try {
         const fd = openSync(filePath, "r");
@@ -603,10 +669,14 @@ export class SessionManager {
     persist;
     flushed = false;
     fileEntries = [];
+    entries = [];
     byId = new Map();
     labelsById = new Map();
     labelTimestampsById = new Map();
     leafId = null;
+    entryFileLocations = new Map();
+    coldPayloadEntryIds = new Set();
+    indexedSessionFileBytes = 0;
     constructor(cwd, sessionDir, sessionFile, persist, agentDir, newSessionOptions) {
         this.cwd = resolvePath(cwd);
         this.sessionDir = normalizePath(sessionDir);
@@ -624,6 +694,7 @@ export class SessionManager {
     }
     /** Switch to a different session file (used for resume and branching) */
     setSessionFile(sessionFile) {
+        this._resetEntryFileIndex(true);
         this.sessionFile = resolvePath(sessionFile);
         if (existsSync(this.sessionFile)) {
             this.fileEntries = loadEntriesFromFile(this.sessionFile);
@@ -650,6 +721,7 @@ export class SessionManager {
             }
             this._buildIndex();
             this.flushed = true;
+            this._releaseExistingCompactedMessagePayloads();
         }
         else {
             const explicitPath = this.sessionFile;
@@ -672,17 +744,27 @@ export class SessionManager {
             parentSession: options?.parentSession,
         };
         this.fileEntries = [header];
+        this.entries = [];
         this.byId.clear();
         this.labelsById.clear();
+        this.labelTimestampsById.clear();
         this.leafId = null;
         this.flushed = false;
+        this._resetEntryFileIndex(true);
         if (this.persist) {
             const fileTimestamp = timestamp.replace(/[:.]/g, "-");
             this.sessionFile = join(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
         }
         return this.sessionFile;
     }
+    _resetEntryFileIndex(clearColdPayloads = false) {
+        this.entryFileLocations.clear();
+        this.indexedSessionFileBytes = 0;
+        if (clearColdPayloads)
+            this.coldPayloadEntryIds.clear();
+    }
     _buildIndex() {
+        this.entries = [];
         this.byId.clear();
         this.labelsById.clear();
         this.labelTimestampsById.clear();
@@ -690,6 +772,7 @@ export class SessionManager {
         for (const entry of this.fileEntries) {
             if (entry.type === "session")
                 continue;
+            this.entries.push(entry);
             this.byId.set(entry.id, entry);
             this.leafId = entry.id;
             if (entry.type === "label") {
@@ -703,14 +786,18 @@ export class SessionManager {
                 }
             }
         }
+        for (const id of this.coldPayloadEntryIds) {
+            if (!this.byId.has(id))
+                this.coldPayloadEntryIds.delete(id);
+        }
     }
-    _rewriteFile() {
-        if (!this.persist || !this.sessionFile)
+    _rewriteFile(targetFile = this.sessionFile) {
+        if (!this.persist || !targetFile)
             return;
         // Write-then-rename keeps the session file valid at every instant: truncating
         // in place leaves a torn-file window for crashes or a concurrent process
         // appending to the same session.
-        const tempFile = `${this.sessionFile}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+        const tempFile = `${targetFile}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
         const fd = openSync(tempFile, "wx");
         try {
             for (const entry of this.fileEntries) {
@@ -720,7 +807,9 @@ export class SessionManager {
         finally {
             closeSync(fd);
         }
-        renameSync(tempFile, this.sessionFile);
+        renameSync(tempFile, targetFile);
+        if (targetFile === this.sessionFile)
+            this._resetEntryFileIndex();
     }
     isPersisted() {
         return this.persist;
@@ -740,6 +829,132 @@ export class SessionManager {
     getSessionFile() {
         return this.sessionFile;
     }
+    _ensureEntryFileLocations(retainedIds) {
+        if (!this.sessionFile || !existsSync(this.sessionFile))
+            return;
+        const fileBytes = statSync(this.sessionFile).size;
+        if (fileBytes < this.indexedSessionFileBytes)
+            this._resetEntryFileIndex();
+        if (fileBytes === this.indexedSessionFileBytes)
+            return;
+        const idsToIndex = new Set(this.coldPayloadEntryIds);
+        for (const id of retainedIds)
+            idsToIndex.add(id);
+        this.indexedSessionFileBytes = indexSessionEntryFileLocations(this.sessionFile, this.indexedSessionFileBytes, this.entryFileLocations, idsToIndex);
+    }
+    _readCompactedMessageProperty(entryId, property) {
+        if (!this.sessionFile)
+            throw new Error(`Compacted session payload ${entryId} is unavailable`);
+        let location = this.entryFileLocations.get(entryId);
+        if (!location) {
+            this._resetEntryFileIndex();
+            this._ensureEntryFileLocations(new Set([entryId]));
+            location = this.entryFileLocations.get(entryId);
+        }
+        if (!location)
+            throw new Error(`Compacted session payload ${entryId} is unavailable`);
+        const fd = openSync(this.sessionFile, "r");
+        const buffer = Buffer.allocUnsafe(location.length);
+        let bytesRead = 0;
+        try {
+            while (bytesRead < buffer.length) {
+                const count = readSync(fd, buffer, bytesRead, buffer.length - bytesRead, location.offset + bytesRead);
+                if (count === 0)
+                    break;
+                bytesRead += count;
+            }
+        }
+        finally {
+            closeSync(fd);
+        }
+        const entry = parseSessionEntryLine(buffer.subarray(0, bytesRead).toString("utf8"));
+        if (!entry || entry.type !== "message" || entry.id !== entryId) {
+            throw new Error(`Compacted session payload ${entryId} could not be restored`);
+        }
+        return entry.message[property];
+    }
+    _releaseMessageProperty(entry, property) {
+        const message = entry.message;
+        const descriptor = Object.getOwnPropertyDescriptor(message, property);
+        if (!descriptor || descriptor.get || !("value" in descriptor))
+            return;
+        if (retainedStringChars(descriptor.value, COMPACTED_PAYLOAD_RELEASE_MIN_CHARS) <
+            COMPACTED_PAYLOAD_RELEASE_MIN_CHARS) {
+            return;
+        }
+        const entryId = entry.id;
+        const enumerable = descriptor.enumerable;
+        this.coldPayloadEntryIds.add(entryId);
+        Object.defineProperty(message, property, {
+            configurable: true,
+            enumerable,
+            get: () => this._readCompactedMessageProperty(entryId, property),
+            set: (value) => {
+                Object.defineProperty(message, property, {
+                    configurable: true,
+                    enumerable,
+                    writable: true,
+                    value,
+                });
+            },
+        });
+    }
+    _releaseExistingCompactedMessagePayloads() {
+        let current = this.leafId ? this.byId.get(this.leafId) : undefined;
+        while (current) {
+            if (current.type === "compaction") {
+                this._releaseCompactedMessagePayloads(current.firstKeptEntryId, current.parentId);
+                return;
+            }
+            current = current.parentId ? this.byId.get(current.parentId) : undefined;
+        }
+    }
+    _releaseCompactedMessagePayloads(firstKeptEntryId, compactionParentId) {
+        if (!this.persist || !this.flushed || !this.sessionFile)
+            return;
+        const keptEntryIds = new Set();
+        let currentId = compactionParentId;
+        let foundFirstKept = false;
+        while (currentId) {
+            keptEntryIds.add(currentId);
+            if (currentId === firstKeptEntryId) {
+                foundFirstKept = true;
+                break;
+            }
+            currentId = this.byId.get(currentId)?.parentId ?? null;
+        }
+        if (!foundFirstKept)
+            return;
+        const retainedIds = new Set();
+        const releases = [];
+        for (const entry of this.entries) {
+            if (entry.type !== "message")
+                continue;
+            const message = entry.message;
+            const properties = [];
+            for (const property of ["content", "output"]) {
+                const descriptor = Object.getOwnPropertyDescriptor(message, property);
+                if (descriptor &&
+                    !descriptor.get &&
+                    "value" in descriptor &&
+                    retainedStringChars(descriptor.value, COMPACTED_PAYLOAD_RELEASE_MIN_CHARS) >=
+                        COMPACTED_PAYLOAD_RELEASE_MIN_CHARS) {
+                    retainedIds.add(entry.id);
+                    if (!keptEntryIds.has(entry.id))
+                        properties.push(property);
+                }
+            }
+            if (properties.length > 0)
+                releases.push({ entry, properties });
+        }
+        this._ensureEntryFileLocations(retainedIds);
+        for (const release of releases) {
+            if (!this.entryFileLocations.has(release.entry.id))
+                continue;
+            for (const property of release.properties)
+                this._releaseMessageProperty(release.entry, property);
+        }
+    }
     _persist(entry) {
         if (!this.persist || !this.sessionFile)
             return;
@@ -772,6 +987,7 @@ export class SessionManager {
     }
     _appendEntry(entry) {
         this.fileEntries.push(entry);
+        this.entries.push(entry);
         this.byId.set(entry.id, entry);
         this.leafId = entry.id;
         this._persist(entry);
@@ -820,10 +1036,11 @@ export class SessionManager {
     }
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
     appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+        const compactionParentId = this.leafId;
         const entry = {
             type: "compaction",
             id: generateId(this.byId),
-            parentId: this.leafId,
+            parentId: compactionParentId,
             timestamp: new Date().toISOString(),
             summary,
             firstKeptEntryId,
@@ -832,6 +1049,7 @@ export class SessionManager {
             fromHook,
         };
         this._appendEntry(entry);
+        this._releaseCompactedMessagePayloads(firstKeptEntryId, compactionParentId);
         return entry.id;
     }
     /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
@@ -988,11 +1206,16 @@ export class SessionManager {
      * change the leaf pointer. Entries cannot be modified or deleted.
      */
     getEntries() {
-        return this.fileEntries.filter((e) => e.type !== "session");
+        return this.entries.slice();
+    }
+    /** Entries appended at or after `startIndex`, returned as a defensive shallow slice. */
+    getEntriesSince(startIndex) {
+        const normalizedStart = Number.isFinite(startIndex) ? Math.max(0, Math.floor(startIndex)) : 0;
+        return this.entries.slice(normalizedStart);
     }
     /** Return current session entry count without allocating a defensive entries array. */
     getEntryCount() {
-        return this.byId.size;
+        return this.entries.length;
     }
     /**
      * Return recent user-entered prompt text for input recall, oldest entry first.
@@ -1170,7 +1393,6 @@ export class SessionManager {
             }
             this.fileEntries = [header, ...pathWithoutLabels, ...labelEntries];
             this.sessionId = newSessionId;
-            this.sessionFile = newSessionFile;
             this._buildIndex();
             // Only write the file now if it contains an assistant message.
             // Otherwise defer to _persist(), which creates the file on the
@@ -1179,12 +1401,15 @@ export class SessionManager {
             // no-assistant guard later resets flushed to false.
             const hasAssistant = this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant");
             if (hasAssistant) {
-                this._rewriteFile();
+                // Keep the source file active while cold compacted getters are serialized into the branch.
+                this._rewriteFile(newSessionFile);
                 this.flushed = true;
             }
             else {
                 this.flushed = false;
             }
+            this.sessionFile = newSessionFile;
+            this._resetEntryFileIndex();
             return newSessionFile;
         }
         // In-memory mode: replace current session with the path + labels
@@ -1226,9 +1451,8 @@ export class SessionManager {
      */
     static open(path, agentDir, sessionDir, cwdOverride) {
         const resolvedPath = resolvePath(path);
-        // Extract cwd from session header if possible, otherwise use process.cwd()
-        const entries = loadEntriesFromFile(resolvedPath);
-        const header = entries.find((e) => e.type === "session");
+        // Read only the header here; the constructor performs the one full session load.
+        const header = readSessionHeader(resolvedPath);
         const cwd = cwdOverride ?? header?.cwd ?? process.cwd();
         // If no sessionDir provided, derive from file's parent directory
         const dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");