@code-yeongyu/senpi 2026.7.23 → 2026.7.24

package/dist/core/session-manager.js

@@ -28,6 +28,17 @@ function uuidv7() {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
 }
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
+const contextMessageEntryIds = new WeakMap();
+/** Request-local field carried across context hooks; never persisted or sent to providers. */
+export const SESSION_CONTEXT_ENTRY_ID = "__piSessionContextEntryId";
+function withContextEntryId(entryId, message) {
+    contextMessageEntryIds.set(message, entryId);
+    return message;
+}
+/** Entry identity for a transient message projected from session history. */
+export function getSessionContextEntryId(message) {
+    return contextMessageEntryIds.get(message);
+}
 export const CURRENT_SESSION_VERSION = 3;
 function createSessionId() {
     return uuidv7();
@@ -203,20 +214,22 @@ export function sessionEntryToContextMessages(entry) {
         // hand-edited files can contain messages with null/missing content.
         if ((message.role === "user" || message.role === "assistant" || message.role === "toolResult") &&
             message.content == null) {
-            return [{ ...message, content: [] }];
+            return [withContextEntryId(entry.id, { ...message, content: [] })];
         }
-        return [message];
+        return [withContextEntryId(entry.id, message)];
     }
     if (entry.type === "custom_message") {
         return [
-            createCustomMessage(entry.customType, entry.content ?? [], entry.display, entry.details, entry.timestamp),
+            withContextEntryId(entry.id, createCustomMessage(entry.customType, entry.content ?? [], entry.display, entry.details, entry.timestamp)),
         ];
     }
     if (entry.type === "branch_summary" && entry.summary) {
-        return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
+        return [withContextEntryId(entry.id, createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp))];
     }
     if (entry.type === "compaction") {
-        return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp, entry.details)];
+        return [
+            withContextEntryId(entry.id, createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp, entry.details)),
+        ];
     }
     return [];
 }
@@ -247,6 +260,11 @@ export function buildContextEntries(entries, leafId, byId) {
     let foundFirstKept = false;
     for (let i = 0; i < compactionIdx; i++) {
         const entry = path[i];
+        // The latest summary supersedes every older compaction summary. Older
+        // entries selected by firstKeptEntryId remain verbatim, but nesting a
+        // prior summary here would double-count it in the model context.
+        if (entry.type === "compaction")
+            continue;
         if (entry.id === compaction.firstKeptEntryId) {
             foundFirstKept = true;
         }
@@ -286,8 +304,15 @@ export function getDefaultSessionDir(cwd, agentDir = getDefaultAgentDir()) {
     return sessionDir;
 }
 const SESSION_READ_BUFFER_SIZE = 1024 * 1024;
-const SESSION_HEADER_READ_BUFFER_SIZE = 4 * 1024;
-const SESSION_HEADER_MAX_BYTES = SESSION_READ_BUFFER_SIZE;
+const SESSION_HEADER_READ_BUFFER_SIZE = 4096;
+/** Bound synchronous header discovery while allowing large cwd and custom metadata fields. */
+const MAX_SESSION_HEADER_SCAN_BYTES = 1024 * 1024;
+class SessionHeaderScanLimitError extends Error {
+    constructor(filePath) {
+        super(`Session header exceeds ${MAX_SESSION_HEADER_SCAN_BYTES}-byte scan limit: ${filePath}`);
+        this.name = "SessionHeaderScanLimitError";
+    }
+}
 function parseSessionEntryLine(line) {
     if (!line.trim())
         return null;
@@ -343,54 +368,72 @@ export function loadEntriesFromFile(filePath) {
     }
     return entries;
 }
+/**
+ * Inspect a physical line while searching for the first parsed session entry.
+ * Blank and malformed lines are skipped to match loadEntriesFromFile().
+ * Returns undefined to keep scanning, null for a parsed non-header entry, or the header.
+ */
+function parseSessionHeaderCandidate(line) {
+    if (!line.trim())
+        return undefined;
+    const entry = parseSessionEntryLine(line);
+    if (!entry)
+        return undefined;
+    if (entry.type !== "session" || typeof entry.id !== "string")
+        return null;
+    return entry;
+}
 function readSessionHeader(filePath) {
-    let fd;
+    const fd = openSync(filePath, "r");
     try {
-        fd = openSync(filePath, "r");
         const decoder = new StringDecoder("utf8");
         const buffer = Buffer.allocUnsafe(SESSION_HEADER_READ_BUFFER_SIZE);
-        let pending = "";
-        let firstLine;
-        let totalBytesRead = 0;
-        while (firstLine === undefined) {
-            const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+        const lineChunks = [];
+        let scannedBytes = 0;
+        while (scannedBytes < MAX_SESSION_HEADER_SCAN_BYTES) {
+            const readLength = Math.min(buffer.length, MAX_SESSION_HEADER_SCAN_BYTES - scannedBytes);
+            const bytesRead = readSync(fd, buffer, 0, readLength, null);
             if (bytesRead === 0) {
-                firstLine = pending + decoder.end();
-                break;
+                lineChunks.push(decoder.end());
+                return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
             }
-            totalBytesRead += bytesRead;
-            pending += decoder.write(buffer.subarray(0, bytesRead));
-            const newlineIndex = pending.indexOf("\n");
-            if (newlineIndex !== -1) {
-                firstLine = pending.slice(0, newlineIndex);
-            }
-            else if (totalBytesRead >= SESSION_HEADER_MAX_BYTES) {
-                return null;
+            scannedBytes += bytesRead;
+            const chunk = decoder.write(buffer.subarray(0, bytesRead));
+            let lineStart = 0;
+            let newlineIndex = chunk.indexOf("\n", lineStart);
+            while (newlineIndex !== -1) {
+                lineChunks.push(chunk.slice(lineStart, newlineIndex));
+                const header = parseSessionHeaderCandidate(lineChunks.join(""));
+                if (header !== undefined)
+                    return header;
+                lineChunks.length = 0;
+                lineStart = newlineIndex + 1;
+                newlineIndex = chunk.indexOf("\n", lineStart);
             }
+            lineChunks.push(chunk.slice(lineStart));
         }
-        if (!firstLine.trim())
-            return null;
-        const header = JSON.parse(firstLine);
-        if (header.type !== "session" || typeof header.id !== "string") {
-            return null;
+        // Probe for EOF so a final header without a newline is allowed when it ends
+        // exactly at the scan limit. Any additional byte exceeds the bounded scan.
+        const probe = Buffer.allocUnsafe(1);
+        if (readSync(fd, probe, 0, probe.length, null) === 0) {
+            lineChunks.push(decoder.end());
+            return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
         }
-        return {
-            type: "session",
-            id: header.id,
-            timestamp: typeof header.timestamp === "string" ? header.timestamp : "",
-            cwd: typeof header.cwd === "string" ? header.cwd : "",
-            ...(typeof header.version === "number" ? { version: header.version } : {}),
-            ...(typeof header.parentSession === "string" ? { parentSession: header.parentSession } : {}),
-        };
+        throw new SessionHeaderScanLimitError(filePath);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function readSessionHeaderForDiscovery(filePath) {
+    try {
+        return readSessionHeader(filePath);
     }
     catch {
+        // Discovery is best-effort: unreadable or oversized files are not sessions,
+        // and one corrupt file must not prevent other sessions from being found.
         return null;
     }
-    finally {
-        if (fd !== undefined) {
-            closeSync(fd);
-        }
-    }
 }
 function getSessionHeaderCwd(header) {
     const cwd = header.cwd;
@@ -407,7 +450,7 @@ export function findMostRecentSession(sessionDir, cwd) {
         const files = readdirSync(resolvedSessionDir)
             .filter((f) => f.endsWith(".jsonl"))
             .map((f) => join(resolvedSessionDir, f))
-            .map((path) => ({ path, header: readSessionHeader(path) }))
+            .map((path) => ({ path, header: readSessionHeaderForDiscovery(path) }))
             .filter((file) => file.header !== null &&
             (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
             .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
@@ -415,6 +458,7 @@ export function findMostRecentSession(sessionDir, cwd) {
         return files[0]?.path || null;
     }
     catch {
+        // Directory access and stat races make recent-session discovery unavailable.
         return null;
     }
 }
@@ -589,11 +633,17 @@ async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progress
  * handles compaction summaries and follows the path from root to current leaf.
  */
 export class SessionManager {
-    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions) {
+    constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
         this.sessionId = "";
         this.flushed = false;
         this.fileEntries = [];
         this.byId = new Map();
+        // Runtime-only identity tracking lets AgentSession compare messages to a
+        // compaction boundary by append order rather than provider timestamps.
+        // Materialized persisted messages are bound as they are read; only pending
+        // messages that have not reached a session entry use AgentSession's fallback.
+        this.entryOrdersById = new Map();
+        this.messageEntryPositions = new WeakMap();
         this.labelsById = new Map();
         this.labelTimestampsById = new Map();
         this.leafId = null;
@@ -623,7 +673,7 @@ export class SessionManager {
             mkdirSync(this.sessionDir, { recursive: true });
         }
         if (sessionFile) {
-            this.setSessionFile(sessionFile);
+            this._setSessionFile(sessionFile, preloadedFileEntries);
         }
         else {
             this.newSession(newSessionOptions);
@@ -631,10 +681,13 @@ export class SessionManager {
     }
     /** Switch to a different session file (used for resume and branching) */
     setSessionFile(sessionFile) {
+        this._setSessionFile(sessionFile);
+    }
+    _setSessionFile(sessionFile, preloadedFileEntries) {
         this.sessionFile = resolvePath(sessionFile);
         this.residentStore.clear();
         if (existsSync(this.sessionFile)) {
-            this.fileEntries = loadEntriesFromFile(this.sessionFile);
+            this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
             // If file was empty, initialize it with a valid session header. If it was
             // non-empty but did not parse as a pi session, fail without modifying it.
             if (this.fileEntries.length === 0) {
@@ -681,6 +734,8 @@ export class SessionManager {
         this.fileEntries = [header];
         this.residentStore.clear();
         this.byId.clear();
+        this.entryOrdersById.clear();
+        this.messageEntryPositions = new WeakMap();
         this.labelsById.clear();
         this.labelTimestampsById.clear();
         this.leafId = null;
@@ -703,6 +758,8 @@ export class SessionManager {
     }
     _buildIndex() {
         this.byId.clear();
+        this.entryOrdersById.clear();
+        this.messageEntryPositions = new WeakMap();
         this.labelsById.clear();
         this.labelTimestampsById.clear();
         this.leafId = null;
@@ -715,10 +772,11 @@ export class SessionManager {
             cost: 0,
             latestCacheHitRate: undefined,
         };
-        for (const entry of this.fileEntries) {
+        for (const [order, entry] of this.fileEntries.entries()) {
             if (entry.type === "session")
                 continue;
             this.byId.set(entry.id, entry);
+            this.entryOrdersById.set(entry.id, order);
             this.leafId = entry.id;
             this._accumulateUsage(entry);
             if (entry.type === "session_info") {
@@ -806,11 +864,22 @@ export class SessionManager {
         const residentEntry = this.residentStore.externalize(entry);
         this.fileEntries.push(residentEntry);
         this.byId.set(residentEntry.id, residentEntry);
+        this.entryOrdersById.set(residentEntry.id, this.fileEntries.length - 1);
         this.leafId = residentEntry.id;
         this._accumulateUsage(residentEntry);
         this.mutationCount++;
         this._persist(residentEntry);
     }
+    _materializeEntry(entry) {
+        const materialized = this.residentStore.materialize(entry);
+        if (materialized.type === "message") {
+            const order = this.entryOrdersById.get(materialized.id);
+            if (order !== undefined) {
+                this.messageEntryPositions.set(materialized.message, { entryId: materialized.id, order });
+            }
+        }
+        return materialized;
+    }
     /**
      * Fold one entry into the running usage totals. Totals iterate ALL entries
      * (not branch-scoped), matching the footer hot path's historical semantics.
@@ -854,8 +923,20 @@ export class SessionManager {
             message,
         };
         this._appendEntry(entry);
+        const order = this.entryOrdersById.get(entry.id);
+        if (order !== undefined) {
+            this.messageEntryPositions.set(message, { entryId: entry.id, order });
+        }
         return entry.id;
     }
+    /** Runtime append position for this exact persisted message object, if known. */
+    getMessageEntryPosition(message) {
+        return this.messageEntryPositions.get(message);
+    }
+    /** Runtime/file append position for an entry, used with getMessageEntryPosition(). */
+    getEntryOrder(entryId) {
+        return this.entryOrdersById.get(entryId);
+    }
     /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
     appendThinkingLevelChange(thinkingLevel) {
         const entry = {
@@ -885,7 +966,7 @@ export class SessionManager {
         return entry.id;
     }
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
-    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
         const entry = {
             type: "compaction",
             id: generateId(this.byId),
@@ -895,6 +976,7 @@ export class SessionManager {
             firstKeptEntryId,
             tokensBefore,
             details,
+            usage,
             fromHook,
         };
         this._appendEntry(entry);
@@ -964,11 +1046,11 @@ export class SessionManager {
     }
     getLeafEntry() {
         const entry = this.leafId ? this.byId.get(this.leafId) : undefined;
-        return entry ? this.residentStore.materialize(entry) : undefined;
+        return entry ? this._materializeEntry(entry) : undefined;
     }
     getEntry(id) {
         const entry = this.byId.get(id);
-        return entry ? this.residentStore.materialize(entry) : undefined;
+        return entry ? this._materializeEntry(entry) : undefined;
     }
     /**
      * Get all direct children of an entry.
@@ -977,7 +1059,7 @@ export class SessionManager {
         const children = [];
         for (const entry of this.byId.values()) {
             if (entry.parentId === parentId) {
-                children.push(this.residentStore.materialize(entry));
+                children.push(this._materializeEntry(entry));
             }
         }
         return children;
@@ -1034,7 +1116,7 @@ export class SessionManager {
         const startId = fromId ?? this.leafId;
         let current = startId ? this.byId.get(startId) : undefined;
         while (current) {
-            path.unshift(this.residentStore.materialize(current));
+            path.unshift(this._materializeEntry(current));
             current = current.parentId ? this.byId.get(current.parentId) : undefined;
         }
         if (fromId === undefined) {
@@ -1105,7 +1187,7 @@ export class SessionManager {
         }
         const entries = this.fileEntries
             .filter((e) => e.type !== "session")
-            .map((entry) => this.residentStore.materialize(entry));
+            .map((entry) => this._materializeEntry(entry));
         this.entriesCache = { mutation: this.mutationCount, entries };
         return entries;
     }
@@ -1181,7 +1263,7 @@ export class SessionManager {
      * Same as branch(), but also appends a branch_summary entry that captures
      * context from the abandoned conversation path.
      */
-    branchWithSummary(branchFromId, summary, details, fromHook) {
+    branchWithSummary(branchFromId, summary, details, fromHook, usage) {
         if (branchFromId !== null && !this.byId.has(branchFromId)) {
             throw new Error(`Entry ${branchFromId} not found`);
         }
@@ -1194,6 +1276,7 @@ export class SessionManager {
             fromId: branchFromId ?? "root",
             summary,
             details,
+            usage,
             fromHook,
         };
         this._appendEntry(entry);
@@ -1319,12 +1402,26 @@ export class SessionManager {
      */
     static open(path, sessionDir, cwdOverride) {
         const resolvedPath = resolvePath(path);
-        // Extract cwd from session header if possible, otherwise use process.cwd()
-        const header = readSessionHeader(resolvedPath);
-        const cwd = cwdOverride ?? header?.cwd ?? process.cwd();
+        let header = null;
+        let preloadedFileEntries;
+        if (cwdOverride === undefined && existsSync(resolvedPath)) {
+            try {
+                header = readSessionHeader(resolvedPath);
+            }
+            catch (error) {
+                if (!(error instanceof SessionHeaderScanLimitError))
+                    throw error;
+                // The bounded scan is only a discovery optimization. A full load remains
+                // authoritative for legacy files with very large headers or prefixes.
+                preloadedFileEntries = loadEntriesFromFile(resolvedPath);
+                const firstEntry = preloadedFileEntries[0];
+                header = firstEntry?.type === "session" ? firstEntry : null;
+            }
+        }
+        const cwd = cwdOverride ?? (header ? getSessionHeaderCwd(header) : undefined) ?? process.cwd();
         // If no sessionDir provided, derive from file's parent directory
         const dir = sessionDir ? normalizePath(sessionDir) : resolve(resolvedPath, "..");
-        return new SessionManager(cwd, dir, resolvedPath, true);
+        return new SessionManager(cwd, dir, resolvedPath, true, undefined, preloadedFileEntries);
     }
     /**
      * Continue the most recent session, or create new if none.