pi-fast-resume 1.1.2 → 1.1.3

package/README.md

@@ -4,7 +4,7 @@
 
 **Instant session picker for [pi](https://github.com/earendil-works/pi-coding-agent)**
 
-_Reads 16KB per file instead of the full JSONL — first results in **6ms**._
+_Reads the head + tail of each file instead of the full JSONL — first results in **6ms**._
 
 [![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
 [![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
@@ -16,7 +16,7 @@ _Reads 16KB per file instead of the full JSONL — first results in **6ms**._
 > **`/resume` takes 5.6 seconds** when you have 1,700+ sessions.
 > pi-fast-resume's `/fast-resume` takes **6 milliseconds**.
 
-Same picker UI and keybindings as `/resume`. The difference is pi-fast-resume never reads beyond the first 16KB of any session file. Headers, names, first messages — they all live in the first few lines. Everything after that is full message history the picker never shows. Search matches against the first message only (see [Known Limitations](#known-limitations)).
+Same picker UI and keybindings as `/resume`. The difference is pi-fast-resume reads at most ~24KB of each file (a 16KB head + up to 8KB tail) instead of the full JSONL. The head carries the header and first user message; the tail recovers the latest session name, which pi appends at EOF on `/rename`. Everything between is full message history the picker never shows. Search matches against the first message only (see [Known Limitations](#known-limitations)).
 
 ```
 ──────────────────────────────────────────────────────────
@@ -180,7 +180,7 @@ stat() all .jsonl files ──────► sort by mtime ──────
 
 1. **`stat()` all session files** — collect paths and mtimes (~100 ms for 1,700 files)
 2. **Sort by mtime descending** — most recent sessions first
-3. **Read first 16KB** of the top 30 files — extract header, name, first user message (~6 ms)
+3. **Read head (16KB) + tail (≤8KB)** of the top 30 files — extract header, first user message, and latest session name (~6 ms)
 4. **Show picker** — user can navigate, filter, and select immediately
 5. **Background load** — remaining sessions stream in batches of 50, non-blocking
 6. **Tab to switch scope** — filter to current project or show everything

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fast-resume",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Fast session picker for pi — reads headers + first messages from 16KB partial reads instead of full-file parsing",
   "type": "module",
   "author": "Tom X Nguyen",
@@ -29,13 +29,6 @@
     "src/",
     "README.md"
   ],
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint:dead": "knip --no-gitignore"
-  },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.79.4",
     "@earendil-works/pi-tui": "0.79.4",
@@ -52,5 +45,12 @@
   },
   "overrides": {
     "brace-expansion": "5.0.6"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint:dead": "knip --no-gitignore"
   }
-}
+}

package/src/scanner.ts

@@ -23,6 +23,25 @@ export interface SessionFileMeta {
 
 const PARTIAL_READ_SIZE = 16_384;
 
+// Size of the trailing read used to recover session_info entries (session
+// names set via /rename or programmatically). These are appended at EOF by
+// SessionManager.appendSessionInfo, so for any session larger than the head
+// window the latest name lands past the partial read and would be invisible —
+// showing "(no messages)" for renamed large sessions. The tail read recovers
+// it, matching pi-core's getSessionName() semantics (latest session_info wins,
+// including explicit name clears).
+const TAIL_READ_SIZE = 8_192;
+
+// Result of scanning a file tail for session_info entries.
+//   found: false  → no session_info seen in the tail; fall back to the head's name.
+//   found: true   → a session_info was seen (later in file order than anything
+//                   in the head, since the tail starts past the head window);
+//                   name is undefined if that entry explicitly cleared the name.
+export interface TailSessionInfo {
+  found: boolean;
+  name?: string;
+}
+
 function extractTextFromContent(
   content: string | Array<{ type: string; text?: string }>,
 ): string {
@@ -39,6 +58,7 @@ export function parseSessionFromBuffer(
   filePath: string,
   mtimeMs: number,
   partial = false,
+  tailInfo?: TailSessionInfo,
 ): SessionHeader | null {
   const decoder = new StringDecoder("utf8");
   const text = decoder.write(buf.subarray(0, bytesRead)) + decoder.end();
@@ -117,6 +137,11 @@ export function parseSessionFromBuffer(
           : new Date(mtimeMs);
   }
 
+  // The tail scan (if any) sees session_info entries at EOF, which are later
+  // in file order than anything in the head window — so it wins over the
+  // head-derived name, including explicit clears (empty name → undefined).
+  const finalName = tailInfo?.found ? tailInfo.name : name;
+
   return {
     path: filePath,
     id: header.id,
@@ -126,10 +151,40 @@ export function parseSessionFromBuffer(
     modified,
     messageCount: msgCount,
     firstMessage: firstUserMsg || "(no messages)",
-    name,
+    name: finalName,
   };
 }
 
+// Scan a tail chunk (read from near EOF) for session_info entries and return
+// the latest name, matching pi-core's getSessionName() semantics: the latest
+// session_info in file order wins, including explicit clears (empty name).
+// The tail's first line may be a partial line cut off at the read-start
+// boundary — it is skipped naturally when JSON.parse fails.
+export function scanTailForSessionInfo(
+  buf: Buffer,
+  bytesRead: number,
+): TailSessionInfo {
+  const decoder = new StringDecoder("utf8");
+  const text = decoder.write(buf.subarray(0, bytesRead)) + decoder.end();
+  const lines = text.split("\n");
+  let found = false;
+  let name: string | undefined;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.type === "session_info") {
+        found = true;
+        name = entry.name?.trim() || undefined;
+      }
+    } catch {
+      // Partial line at tail boundary — skip
+    }
+  }
+  return { found, name };
+}
+
 const HOME = homedir();
 const DEFAULT_SESSIONS_DIR = join(HOME, ".pi", "agent", "sessions");
 
@@ -221,7 +276,35 @@ export function loadSessionHeader(
     const readSize = Math.min(PARTIAL_READ_SIZE, meta.size);
     const buf = Buffer.alloc(readSize);
     const bytesRead = readSync(fd, buf, 0, readSize, 0);
-    return parseSessionFromBuffer(buf, bytesRead, meta.path, meta.mtimeMs, meta.size > PARTIAL_READ_SIZE);
+
+    // Recover the latest session name from EOF. session_info entries are
+    // appended at EOF by SessionManager.appendSessionInfo, so for any session
+    // larger than the head window they live past the 16KB read and would be
+    // invisible. The tail read covers `meta.size - PARTIAL_READ_SIZE` bytes
+    // (capped at TAIL_READ_SIZE), starting past the head window so it never
+    // overlaps. A failure here must not lose the whole header — fall back to
+    // head-only parsing by leaving tailInfo undefined.
+    let tailInfo: TailSessionInfo | undefined;
+    if (meta.size > PARTIAL_READ_SIZE) {
+      try {
+        const tailReadSize = Math.min(TAIL_READ_SIZE, meta.size - PARTIAL_READ_SIZE);
+        const tailBuf = Buffer.alloc(tailReadSize);
+        const tailOffset = meta.size - tailReadSize;
+        const tailBytesRead = readSync(fd, tailBuf, 0, tailReadSize, tailOffset);
+        tailInfo = scanTailForSessionInfo(tailBuf, tailBytesRead);
+      } catch {
+        // Tail read failed — fall back to head-only parse
+      }
+    }
+
+    return parseSessionFromBuffer(
+      buf,
+      bytesRead,
+      meta.path,
+      meta.mtimeMs,
+      meta.size > PARTIAL_READ_SIZE,
+      tailInfo,
+    );
   } catch {
     return null;
   } finally {