pi-fast-resume 1.2.0 → 1.4.0

package/README.md

@@ -47,6 +47,8 @@ Tested with **1,771 sessions, 1.46 GB** of JSONL data on disk.
 | **pi-fast-resume (partial read)** | **6 ms**     | ~580 ms   |
 | DuckDB NDJSON full scan           | 2,560 ms     | 2,560 ms  |
 
+> The all-dirs `stat()` pass (~100 ms at scale) now runs **after** first paint, so first paint no longer depends on total session count — only on the current project's session dir.
+
 <details>
 <summary><strong>Full benchmark table</strong></summary>
 
@@ -165,8 +167,8 @@ Press `Tab` to switch to **all sessions** — shows every session pi knows about
 ## How it works
 
 ```
-stat() all .jsonl files ──────► sort by mtime ──────► stream top 30 forward
-      (~100ms)                   (recent first)          (~6ms)
+stat() current dir's .jsonl ──► sort by mtime ──► stream top 30 forward
+      (~cheap, one dir)          (recent first)        (~6ms)
                                                             │
                                                             ▼
                                                     ┌─────────────────┐
@@ -174,15 +176,18 @@ stat() all .jsonl files ──────► sort by mtime ──────
                                                     │  immediately    │
                                                     └────────┬────────┘
                                                              │
-                                              Background: load rest in batches of 50
-                                              (non-blocking via setImmediate)
+                          Background (after first paint):
+                          1. stream the rest of the current dir in batches of 50 (rows appear as they load)
+                          2. stat() ALL session dirs (~100ms at scale) — deferred off the critical path
+                          3. forward-load all-scope headers in batches of 50 (non-blocking via setImmediate)
+                          4. resolve rename names in the background (skip header-only files; bound each tail read)
 ```
 
-1. **`stat()` all session files** — collect paths and mtimes (~100 ms for 1,700 files)
+1. **`stat()` the current project's session dir** — collect paths and mtimes (cheap, one directory)
 2. **Sort by mtime descending** — most recent sessions first
-3. **Stream each file forward** line by line until the first user message, then read a bounded tail at EOF for the latest rename name (~6 ms)
+3. **Stream the top 30 forward** line by line until the first user message (~6 ms for the first screen)
 4. **Show picker** — user can navigate, filter, and select immediately
-5. **Background load** — remaining sessions stream in batches of 50, non-blocking
+5. **Background load** — after first paint, stream the remaining current-scope sessions in batches of 50, then stat every session dir and forward-load the all-scope headers, non-blocking
 6. **Tab to switch scope** — filter to current project or show everything
 
 No indexing. No database. No persistent state. Just reads the files on disk.

package/fast-resume.ts

@@ -72,6 +72,8 @@ import {
   scanAllSessionDirs,
   scanSessionDir,
   loadSessionHeaders,
+  loadSessionHeadersForward,
+  resolveSessionNamesDeferred,
   sortByModified,
   sortByModifiedDesc,
   filterByCwd,
@@ -82,6 +84,7 @@ import {
 import {
   parseSearchQuery,
   matchSession,
+  invalidateSessionSearchText,
   hasSessionName,
   filterAndSortSessions,
   buildSessionTree,
@@ -95,6 +98,13 @@ import {
 
 const HOME = homedir();
 
+// #2 — Top-N immediate current-scope load. Forward-load this many most-recent
+// sessions before first paint; the rest stream in from the background in
+// batches of 50. 30 covers the visible page (maxVisible=10) with a scroll
+// buffer. Projects with fewer sessions load fully in the immediate pass and
+// never start the background current load.
+const IMMEDIATE_CURRENT_COUNT = 30;
+
 // Config — read from ~/.pi/agent/extensions/pi-fast-resume.json
 // Example: { "hijackResume": false, "shortcut": "alt+u" }
 // By default hijackResume is true — /resume opens the fast picker
@@ -123,23 +133,30 @@ export interface FastResumeResult {
 
 type StatusMessage = { type: "info" | "error"; message: string };
 
-// Session loading helpers — mirror SessionManager.list / listAll behavior
-// while keeping partial reads.
-
-function loadCurrentSessionsImmediate(
+// #2 — Load the current-scope sessions in two phases: forward-load the top-N
+// most-recent headers immediately (the first paint), and return the remaining
+// metas for the picker's background current-scope load. `allMetas` is every
+// current-scope meta (used to seed the path→meta lookup for rename-name
+// resolution). For custom session dirs, headers are filtered to the current cwd
+// (matching SessionManager.list); the cwd filter is re-applied to the
+// background batches so the streamed rows stay cwd-correct.
+function loadCurrentSessionsTopN(
   cwd: string,
   sessionDir: string | undefined,
   usesDefaultSessionDir: boolean,
-): SessionHeader[] {
-  if (!sessionDir) return [];
-  const metas = sortByModifiedDesc(scanSessionDir(sessionDir));
-  let headers = loadSessionHeaders(metas);
+  immediateCount: number,
+): { headers: SessionHeader[]; remaining: SessionFileMeta[]; allMetas: SessionFileMeta[] } {
+  if (!sessionDir) return { headers: [], remaining: [], allMetas: [] };
+  const allMetas = sortByModifiedDesc(scanSessionDir(sessionDir));
+  const immediateMetas = allMetas.slice(0, immediateCount);
+  const remaining = allMetas.slice(immediateCount);
+  let headers = loadSessionHeadersForward(immediateMetas);
   if (!usesDefaultSessionDir) {
     // Custom session dirs may contain sessions from multiple cwds; filter to
     // the current one, matching SessionManager.list behavior.
     headers = filterByCwd(headers, cwd);
   }
-  return sortByModified(headers);
+  return { headers: sortByModified(headers), remaining, allMetas };
 }
 
 function loadAllSessionMetas(
@@ -347,6 +364,17 @@ class FastResumeSessionList implements Component {
   nameFilter: NameFilter = "all";
   confirmingDeletePath: string | null = null;
   maxVisible = 10;
+
+  // #4 — Cache for the threaded-mode tree (no-query path). The tree's shape and
+  // order depend only on parentSessionPath (immutable), modified (stable after
+  // load), and the session set — NOT on `name`. So a tree built for a given
+  // session-array reference stays valid across in-place name mutations (rename
+  // resolution) and across query typing/clearing, as long as the array ref is
+  // stable. Keyed on the `nameFilter==="all"` array (=== this.allSessions);
+  // the "named" subset depends on names and is never cached. setSessions passes
+  // a new ref on load/scope/mutation (cache misses → rebuild) and the same ref
+  // on name-resolution batches (cache hits → skip rebuild).
+  private _treeCache: { sessionsRef: SessionHeader[]; flat: FlatSessionNode[] } | null = null;
   currentSessionCanonicalPath: string | undefined;
 
   onSelect?: (sessionPath: string) => void;
@@ -402,6 +430,15 @@ class FastResumeSessionList implements Component {
     this.filterSessions(this.searchInput.getValue());
   }
 
+  // #5 — Drop the threaded-tree cache so the next filterSessions rebuilds it.
+  // The background loads reuse one growing session array (same ref) and append
+  // batches in place; without invalidation the ref-keyed cache would hit and
+  // serve a stale tree missing the new rows. Call before setSessions whenever
+  // the array's CONTENT changed but its REFERENCE did not.
+  invalidateTreeCache(): void {
+    this._treeCache = null;
+  }
+
   setConfirmingDeletePath(path: string | null): void {
     this.confirmingDeletePath = path;
     this.onDeleteConfirmationChange?.(path);
@@ -430,11 +467,23 @@ class FastResumeSessionList implements Component {
     const trimmed = query.trim();
 
     if (this.sortMode === "threaded" && !trimmed) {
-      // Threaded mode without search: show tree structure
-      const roots = buildSessionTree(nameFiltered);
-      this.filteredNodes = flattenSessionTree(roots);
+      // Threaded mode without search: show tree structure. Cache it when the
+      // nameFiltered array is the stable all-sessions ref (nameFilter==="all")
+      // — the tree doesn't depend on names, so it survives in-place name
+      // mutations and query typing/clearing until the session set changes.
+      const canCache = this.nameFilter === "all"; // nameFiltered === this.allSessions
+      if (canCache && this._treeCache !== null && this._treeCache.sessionsRef === nameFiltered) {
+        this.filteredNodes = this._treeCache.flat;
+      } else {
+        const roots = buildSessionTree(nameFiltered);
+        const flat = flattenSessionTree(roots);
+        this.filteredNodes = flat;
+        if (canCache) this._treeCache = { sessionsRef: nameFiltered, flat };
+      }
     } else {
-      // Other modes or with search: flat list via filterAndSortSessions
+      // Other modes or with search: flat list via filterAndSortSessions. Leave
+      // the tree cache in place — a later "threaded + no query" reuses it as
+      // long as the session array ref is stable.
       const filtered = filterAndSortSessions(nameFiltered, query, this.sortMode);
       this.filteredNodes = filtered.map((session) => ({
         session,
@@ -674,6 +723,21 @@ class FastResumePicker extends Container {
   private allMetas: SessionFileMeta[] = [];
   private loadingAbort: AbortController | null = null;
   private allLoadSeq = 0;
+  private currentLoadSeq = 0;
+  // #2 — Current-scope metas not yet forward-loaded (beyond the top-N immediate
+  // pass). The background current load drains these in batches of 50.
+  private remainingCurrentMetas: SessionFileMeta[] = [];
+
+  // Deferred rename-name resolution. The picker displays rows immediately
+  // with forward-only headers (fast: ~80ms for 2.5k sessions); the latest rename
+  // name (which pi appends at EOF, past the forward stop) is resolved per file
+  // in the background and applied in-place, so a row's name pops in without
+  // blocking the initial render. See resolveSessionNamesDeferred in scanner.ts.
+  private metaByPath = new Map<string, SessionFileMeta>();
+  private nameResolveQueue: SessionHeader[] = [];
+  private nameResolveScheduled = false;
+  private nameResolveSeq = 0;
+  private nameResolvedPaths = new Set<string>();
 
   private mode: "list" | "rename" = "list";
   private renameTargetPath: string | null = null;
@@ -715,8 +779,8 @@ class FastResumePicker extends Container {
     usesDefaultSessionDir: boolean,
     currentSessionPath: string | undefined,
     initialCurrentSessions: SessionHeader[],
-    allMetas: SessionFileMeta[],
-    allSessions: SessionHeader[] | null,
+    remainingCurrentMetas: SessionFileMeta[],
+    currentMetas: SessionFileMeta[],
     done: (result: FastResumeResult) => void,
     tuiRequestRender: () => void,
     initialQuery?: string,
@@ -725,7 +789,9 @@ class FastResumePicker extends Container {
     this.theme = theme;
     this.done = done;
     this.tuiRequestRender = tuiRequestRender;
-    this.allMetas = allMetas;
+    // allMetas is populated in the background (the all-dirs stat is deferred
+    // off the first-paint critical path); seeded here with current-scope metas.
+    this.allMetas = [];
     this.cwd = currentCwd;
     this.sessionDir = sessionDir;
     this.usesDefaultSessionDir = usesDefaultSessionDir;
@@ -742,7 +808,7 @@ class FastResumePicker extends Container {
     // Create session list
     this.sessionList = new FastResumeSessionList(theme, currentSessionPath);
     this.currentSessions = initialCurrentSessions;
-    this.allSessions = allSessions;
+    this.allSessions = null; // loaded in the background by startAllLoadBackground
 
     // Set initial data into the list
     this.sessionList.setSessions(initialCurrentSessions, false);
@@ -757,16 +823,19 @@ class FastResumePicker extends Container {
     this.sessionList.onSelect = (sessionPath) => {
       this.header.clearStatusTimeout();
       this.loadingAbort?.abort();
+      this.nameResolveSeq++; // cancel any pending name-resolution ticks
       this.done({ sessionPath, cancelled: false });
     };
     this.sessionList.onCancel = () => {
       this.header.clearStatusTimeout();
       this.loadingAbort?.abort();
+      this.nameResolveSeq++;
       this.done({ cancelled: true });
     };
     this.sessionList.onExit = () => {
       this.header.clearStatusTimeout();
       this.loadingAbort?.abort();
+      this.nameResolveSeq++;
       this.done({ cancelled: true });
     };
     this.sessionList.onToggleScope = () => this.toggleScope();
@@ -818,14 +887,28 @@ class FastResumePicker extends Container {
     // Build layout
     this.buildBaseLayout(this.sessionList);
 
-    // Start loading current sessions (mark as loaded since we already have them)
-    this.currentLoading = false;
+    // Seed the path → meta lookup from the current-scope metas (cheap — one
+    // dir). The all-scope metas are merged in by the background all-load. Rows
+    // are already visible with the correct firstMessage; rename names populate
+    // in-place as their tails resolve.
+    for (const m of currentMetas) this.metaByPath.set(m.path, m);
+    this.enqueueNameResolution(initialCurrentSessions);
+
+    // #2 — Current scope shows the top-N headers immediately; the rest stream
+    // in from the background (silent: header stays on "◉ Current Folder",
+    // rows appear as batches complete). currentLoading tracks this for the
+    // rename guard and refresh cancellation; header.loading is NOT flipped so
+    // the initial view doesn't flash a loading state over visible rows.
+    this.remainingCurrentMetas = remainingCurrentMetas;
+    this.currentLoading = remainingCurrentMetas.length > 0;
+    if (this.currentLoading) this.startCurrentLoadBackground();
     this.header.loading = false;
 
-    // If we don't have all sessions yet, pre-load them in the background
-    if (allSessions === null && allMetas.length > 0) {
-      this.startAllLoadBackground();
-    }
+    // Pre-load the all-scope metas + headers in the background. This stats all
+    // session dirs (the ~100ms-at-scale cost that used to block first paint)
+    // off the critical path, then forward-loads headers in cooperative batches
+    // so switching to "all" scope is instant.
+    this.startAllLoadBackground();
   }
 
   private enterRenameMode(sessionPath: string, currentName?: string): void {
@@ -899,9 +982,14 @@ class FastResumePicker extends Container {
   private async refreshSessionsAfterMutation(): Promise<void> {
     // Rescan from disk so renames, deletes, and newly created sessions are
     // reflected in the list. This mirrors upstream's loadScope(scope, "refresh").
-    // Bump the sequence number first so any in-progress background all-load
-    // stops before it can overwrite the rescanned data.
+    // Bump the sequence numbers first so any in-progress background loads
+    // (current top-N remainder or all-scope) stop before they can overwrite
+    // the rescanned data. rescanCurrentScope/AllScope do a full load (combined
+    // forward+tail) so the refreshed names are accurate.
     this.allLoadSeq++;
+    this.currentLoadSeq++;
+    this.currentLoading = false;
+    this.remainingCurrentMetas = [];
     try {
       if (this.scope === "current") {
         this.currentSessions = this.rescanCurrentScope();
@@ -924,26 +1012,158 @@ class FastResumePicker extends Container {
     }
   }
 
+  // #2 — Background current-scope load: forward-load the remaining current
+  // metas (those beyond the top-N immediate pass) in cooperative batches of
+  // 50, merging into currentSessions (re-sorted by modified) and streaming
+  // rows into the visible list when the user is on current scope. Silent — no
+  // header loading indicator (rows are already visible). Idempotent; cancelled
+  // by currentLoadSeq bumps (refresh) or loadingAbort (select/cancel/exit).
+  private startCurrentLoadBackground(): void {
+    if (this.remainingCurrentMetas.length === 0) {
+      this.currentLoading = false;
+      return;
+    }
+    this.currentLoading = true;
+    const seq = ++this.currentLoadSeq;
+    const sorted = this.remainingCurrentMetas;
+    setImmediate(() => this.runCurrentLoadHeaders(seq, sorted));
+  }
+
+  // #5 — Background current-scope load. Seeds the accumulator with a snapshot
+  // of the top-N immediate headers (one copy, ~30 elements), appends each
+  // batch's cwd-filtered headers in place (no per-batch array copy or re-sort),
+  // and sorts once at completion. Reuses one growing array ref for display, so
+  // the threaded-tree cache is invalidated before each setSessions to rebuild
+  // with the new rows. Intermediate order is insertion order ≈ mtime desc
+  // (batches arrive pre-sorted by mtime). Fixes the prior per-batch
+  // merge that duplicated earlier batches' headers.
+  private runCurrentLoadHeaders(seq: number, sorted: SessionFileMeta[]): void {
+    const BATCH_SIZE = 50;
+    let offset = 0;
+    // Seed with a copy of the immediate top-N headers so appending batches
+    // can't mutate the list's current array out from under a prior render, and
+    // so the accumulator owns its storage independently.
+    const acc: SessionHeader[] = (this.currentSessions ?? []).slice();
+
+    const show = () => {
+      this.currentSessions = acc;
+      if (this.scope === "current") {
+        this.sessionList.invalidateTreeCache();
+        this.sessionList.setSessions(acc, false);
+        this.tuiRequestRender();
+      }
+    };
+
+    const loadBatch = () => {
+      if (seq !== this.currentLoadSeq) { this.currentLoading = false; return; } // stale
+      if (this.loadingAbort?.signal.aborted) { this.currentLoading = false; return; }
+
+      const batch = sorted.slice(offset, offset + BATCH_SIZE);
+      if (batch.length === 0) {
+        this.currentLoading = false;
+        sortByModified(acc); // final sort in place (sortByModified returns acc)
+        show();
+        return;
+      }
+
+      let headers: SessionHeader[];
+      try {
+        headers = loadSessionHeadersForward(batch);
+      } catch (err) {
+        this.currentLoading = false;
+        this.handleCurrentLoadError(seq, err);
+        return;
+      }
+
+      if (!this.usesDefaultSessionDir) headers = filterByCwd(headers, this.cwd);
+      acc.push(...headers);
+      this.enqueueNameResolution(headers);
+      show();
+
+      offset += BATCH_SIZE;
+      setImmediate(loadBatch);
+    };
+
+    setImmediate(loadBatch);
+  }
+
+  private handleCurrentLoadError(seq: number, err: unknown): void {
+    if (seq !== this.currentLoadSeq) return;
+    const message = err instanceof Error ? err.message : String(err);
+    if (this.scope === "current") {
+      this.header.setStatusMessage({ type: "error", message: `Failed to load sessions: ${message}` }, 4000);
+      this.tuiRequestRender();
+    }
+  }
+
+  // Kick off the background all-scope load: first stat all session dirs (the
+  // ~100ms-at-scale cost deferred off the first-paint critical path), then
+  // forward-load headers in cooperative batches. Idempotent — a no-op if a
+  // load is already running or already complete. The constructor calls this
+  // once so switching to "all" scope is instant; toggleScope relies on it.
   private startAllLoadBackground(): void {
+    if (this.allLoading) return;        // already running
+    if (this.allSessions !== null) return; // already complete
     this.allLoading = true;
     const seq = ++this.allLoadSeq;
+    setImmediate(() => this.runAllLoadMetas(seq));
+  }
+
+  // Phase 1: stat all session dirs in the background, merge into metaByPath,
+  // then dispatch phase 2 (header batches). Releases allLoading and aborts if
+  // superseded by a newer load (e.g. a refresh).
+  private runAllLoadMetas(seq: number): void {
+    if (seq !== this.allLoadSeq) { this.allLoading = false; return; }
+    if (this.loadingAbort?.signal.aborted) { this.allLoading = false; return; }
+
+    let allMetas: SessionFileMeta[];
+    try {
+      allMetas = loadAllSessionMetas(this.sessionDir, this.usesDefaultSessionDir);
+    } catch (err) {
+      this.allLoading = false;
+      this.handleAllLoadError(seq, err);
+      return;
+    }
+    if (seq !== this.allLoadSeq) { this.allLoading = false; return; }
+    this.allMetas = allMetas;
+    for (const m of allMetas) {
+      if (!this.metaByPath.has(m.path)) this.metaByPath.set(m.path, m);
+    }
+    this.runAllLoadHeaders(seq, sortByModifiedDesc(allMetas));
+  }
+
+  // Phase 2: forward-load all-scope headers in cooperative batches of 50,
+  // enqueuing each batch for background rename-name resolution. Updates the
+  // active list + progress only while the user is viewing "all" scope.
+  // #5 — Background all-scope header load. Appends each batch into a single
+  // growing array (no per-batch array copy or re-sort) and sorts once at
+  // completion. Reuses one array ref for display, so the threaded-tree cache
+  // is invalidated before each setSessions to rebuild with the new rows.
+  // Intermediate order is insertion order ≈ mtime desc (batches arrive
+  // pre-sorted by mtime; the threaded tree re-sorts internally regardless).
+  private runAllLoadHeaders(seq: number, sorted: SessionFileMeta[]): void {
     const BATCH_SIZE = 50;
-    const sorted = sortByModifiedDesc([...this.allMetas]);
     let offset = 0;
     const allParsed: SessionHeader[] = [];
 
+    if (this.scope === "all") {
+      this.header.loadProgress = { loaded: 0, total: sorted.length };
+      this.tuiRequestRender();
+    }
+
     const loadBatch = () => {
-      if (seq !== this.allLoadSeq) return; // Stale
-      if (this.loadingAbort?.signal.aborted) return;
+      if (seq !== this.allLoadSeq) { this.allLoading = false; return; } // stale — release
+      if (this.loadingAbort?.signal.aborted) { this.allLoading = false; return; }
 
       const batch = sorted.slice(offset, offset + BATCH_SIZE);
       if (batch.length === 0) {
         this.allLoading = false;
-        this.allSessions = sortByModified(allParsed);
+        this.allSessions = sortByModified(allParsed); // final sort in place
 
         // If we're currently showing "all" scope, update the list
         if (this.scope === "all") {
           this.header.loading = false;
+          this.sessionList.invalidateTreeCache();
           this.sessionList.setSessions(this.allSessions, true);
           this.tuiRequestRender();
 
@@ -957,24 +1177,30 @@ class FastResumePicker extends Container {
 
       let headers: SessionHeader[];
       try {
-        headers = loadSessionHeaders(batch);
+        // Forward-only: the rename name resolves in the background via
+        // resolveSessionNamesDeferred (enqueued below), so rows appear with the
+        // correct firstMessage immediately and names populate in-place.
+        headers = loadSessionHeadersForward(batch);
       } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
         this.allLoading = false;
-        if (this.scope === "all") {
-          this.header.loading = false;
-          this.header.setStatusMessage({ type: "error", message: `Failed to load sessions: ${message}` }, 4000);
-          this.tuiRequestRender();
-        }
+        this.handleAllLoadError(seq, err);
         return;
       }
 
       allParsed.push(...headers);
-
-      // If we're currently showing "all" scope, update progress
+      // Enqueue this batch's headers (carrying forward-pass bookkeeping) for
+      // background rename-name resolution. Names populate in-place as they
+      // resolve; if the user is viewing "all" scope, newly-named rows reflect
+      // in the active list.
+      this.enqueueNameResolution(headers);
+
+      // If we're currently showing "all" scope, update progress. Reuse the
+      // growing allParsed ref (insertion order ≈ mtime desc); invalidate the
+      // tree cache so it rebuilds with the appended rows.
       if (this.scope === "all") {
         this.header.loadProgress = { loaded: allParsed.length, total: sorted.length };
-        this.allSessions = sortByModified([...allParsed]);
+        this.allSessions = allParsed;
+        this.sessionList.invalidateTreeCache();
         this.sessionList.setSessions(this.allSessions, true);
         this.tuiRequestRender();
       }
@@ -986,22 +1212,110 @@ class FastResumePicker extends Container {
     setImmediate(loadBatch);
   }
 
+  private handleAllLoadError(seq: number, err: unknown): void {
+    if (seq !== this.allLoadSeq) return;
+    const message = err instanceof Error ? err.message : String(err);
+    if (this.scope === "all") {
+      this.header.loading = false;
+      this.header.setStatusMessage({ type: "error", message: `Failed to load sessions: ${message}` }, 4000);
+      this.tuiRequestRender();
+    }
+  }
+
+  // Enqueue forward-loaded headers for background rename-name resolution.
+  // Each path is resolved at most once (deduped via nameResolvedPaths). A
+  // header whose forward pass reached EOF already has its final name — it's
+  // marked resolved and skipped (no tail read). The rest carry the forward
+  // pass's consumed bytes as a lower bound so the tail read never re-reads
+  // already-covered bytes. Safe to call for the current-scope sessions at
+  // construction and for each batch of the all-scope background load.
+  private enqueueNameResolution(headers: SessionHeader[]): void {
+    for (const h of headers) {
+      if (this.nameResolvedPaths.has(h.path)) continue;
+      this.nameResolvedPaths.add(h.path);
+      if (h._fwdReachedEof) continue; // forward pass saw every session_info
+      this.nameResolveQueue.push(h);
+    }
+    this.scheduleNameResolution();
+  }
+
+  private scheduleNameResolution(): void {
+    if (this.nameResolveScheduled) return;
+    this.nameResolveScheduled = true;
+    setImmediate(() => this.drainNameResolution());
+  }
+
+  // Resolve one cooperative batch of rename names (up to 50 per tick), apply
+  // any found names in-place, and re-render once for the whole batch. Yields
+  // between batches so input stays responsive even while thousands of tail
+  // reads resolve. Aborts cleanly on select/cancel/exit via nameResolveSeq.
+  private drainNameResolution(): void {
+    this.nameResolveScheduled = false;
+    if (this.loadingAbort?.signal.aborted) return;
+    const seq = this.nameResolveSeq;
+    const BATCH = 50;
+    const batch = this.nameResolveQueue.splice(0, BATCH);
+    if (batch.length === 0) return;
+
+    // Pure core: skip reached-EOF headers, bound each tail by the forward
+    // pass's consumed bytes. Returns only paths whose tail found a session_info.
+    const updates = resolveSessionNamesDeferred(batch, this.metaByPath);
+
+    let updatedAny = false;
+    for (const [path, name] of updates) {
+      if (seq !== this.nameResolveSeq) return; // stale — picker exited/aborted
+      if (this.applyNameUpdate(path, name)) updatedAny = true;
+    }
+
+    if (updatedAny) {
+      const sessions = this.scope === "all" ? (this.allSessions ?? []) : (this.currentSessions ?? []);
+      const showCwd = this.scope === "all";
+      this.sessionList.setSessions(sessions, showCwd);
+      this.tuiRequestRender();
+    }
+
+    if (this.nameResolveQueue.length > 0) this.scheduleNameResolution();
+  }
+
+  // Apply a resolved name to the session with the given path in both the
+  // current- and all-scope caches. The same logical session may appear as
+  // distinct objects in the two caches, so both are updated. Returns whether a
+  // session was found and updated (so the caller can batch re-renders).
+  private applyNameUpdate(path: string, name: string | undefined): boolean {
+    let updated = false;
+    const updateArr = (arr: SessionHeader[] | null) => {
+      if (!arr) return;
+      for (const s of arr) {
+        if (s.path === path) {
+          s.name = name;
+          // #4 — name is part of the cached search blob; drop it so the next
+          // matchSession rebuilds with the new name.
+          invalidateSessionSearchText(s);
+          updated = true;
+        }
+      }
+    };
+    updateArr(this.currentSessions);
+    updateArr(this.allSessions);
+    return updated;
+  }
+
   private toggleScope(): void {
     if (this.scope === "current") {
       this.scope = "all";
       this.header.scope = "all";
 
       if (this.allSessions !== null) {
+        // All-scope headers are already loaded — show them.
         this.header.loading = false;
         this.sessionList.setSessions(this.allSessions, true);
-      } else if (!this.allLoading) {
-        // Start loading all sessions
-        this.allLoading = true;
-        this.header.loading = true;
-        this.header.loadProgress = null;
-        this.startAllLoadBackground();
       } else {
+        // All-scope load is in progress (started at construction: metas stat
+        // → header batches). Show the loading indicator until it lands; the
+        // background load updates the list as batches complete. startAllLoadBackground
+        // is idempotent, so this also restarts the load if a refresh cancelled it.
         this.header.loading = true;
+        this.startAllLoadBackground();
       }
     } else {
       this.scope = "current";
@@ -1052,15 +1366,21 @@ async function showFastResumePicker(
 
   const t0 = Date.now();
 
-  // Load the current-scope sessions immediately, and collect metadata for the
-  // incremental "all" scope load that happens in the background.
-  const currentSessions = loadCurrentSessionsImmediate(cwd, sessionDir, usesDefaultSessionDir);
-  const allMetas = loadAllSessionMetas(sessionDir, usesDefaultSessionDir);
+  // #2 — Forward-load only the top-N most-recent current-scope sessions before
+  // first paint; the rest stream in from the background. The current-scope
+  // stat is cheap (one dir); the all-dirs stat (~100ms at scale) is deferred
+  // off the first-paint critical path — the picker stats all dirs in the
+  // background before it starts the all-scope header load.
+  const {
+    headers: currentSessions,
+    remaining: remainingCurrentMetas,
+    allMetas: currentMetas,
+  } = loadCurrentSessionsTopN(cwd, sessionDir, usesDefaultSessionDir, IMMEDIATE_CURRENT_COUNT);
 
   const loadTime = Date.now() - t0;
 
   ctx.ui.notify(
-    `Fast resume: ${currentSessions.length} current, ${allMetas.length} total in ${loadTime}ms`,
+    `Fast resume: ${currentSessions.length} current${remainingCurrentMetas.length > 0 ? " (streaming)" : ""}, all-scope in background in ${loadTime}ms`,
     "info",
   );
 
@@ -1073,8 +1393,8 @@ async function showFastResumePicker(
         usesDefaultSessionDir,
         ctx.sessionManager.getSessionFile(),
         currentSessions,
-        allMetas,
-        null, // allSessions not yet loaded — will load in background
+        remainingCurrentMetas,
+        currentMetas,
         (result) => done(result),
         () => _tui.requestRender(),
         initialQuery,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fast-resume",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "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",
@@ -50,6 +50,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "bench": "vitest bench",
     "typecheck": "tsc --noEmit",
     "lint:dead": "knip --no-gitignore"
   }

package/src/index.ts

@@ -1,8 +1,26 @@
-export { parseSessionFromBuffer, loadSessionHeader, loadSessionHeaders, scanAllSessionDirs, scanSessionDir, sortByModified, sortByModifiedDesc, filterByCwd, matchQuery, canonicalizePath } from "./scanner.js";
-export type { SessionHeader, SessionFileMeta } from "./scanner.js";
+export {
+  parseSessionFromBuffer,
+  scanTailForSessionInfo,
+  loadSessionHeader,
+  loadSessionHeaderForward,
+  loadSessionHeaders,
+  loadSessionHeadersForward,
+  resolveSessionName,
+  resolveSessionNamesDeferred,
+  scanAllSessionDirs,
+  scanSessionDir,
+  sortByModified,
+  sortByModifiedDesc,
+  filterByCwd,
+  matchQuery,
+  canonicalizePath,
+  clearCanonicalPathCache,
+} from "./scanner.js";
+export type { SessionHeader, SessionFileMeta, TailSessionInfo } from "./scanner.js";
 export {
   parseSearchQuery,
   matchSession,
+  invalidateSessionSearchText,
   hasSessionName,
   filterAndSortSessions,
   buildSessionTree,

package/src/scanner.ts

@@ -13,6 +13,17 @@ export interface SessionHeader {
   messageCount: number;
   firstMessage: string;
   name?: string;
+  // Internal forward-pass bookkeeping for the deferred rename-name resolver.
+  // Not part of the public contract; only loadSessionHeaderForward sets these.
+  /** @internal forward pass consumed the whole file — forward name is final; the deferred tail resolver skips it. */
+  _fwdReachedEof?: boolean;
+  /** @internal bytes the forward pass consumed — lower bound for the deferred tail read so it never re-reads covered bytes. */
+  _fwdConsumedBytes?: number;
+  // Internal lazy cache for the search blob (id + name + firstMessage + cwd).
+  // Built on first matchSession call, invalidated when `name` mutates (rename
+  // resolution). Keeps per-keystroke search from re-concatenating per session.
+  /** @internal */
+  _searchText?: string;
 }
 
 export interface SessionFileMeta {
@@ -240,6 +251,14 @@ export function scanTailForSessionInfo(
   for (const line of lines) {
     const trimmed = line.trim();
     if (!trimmed) continue;
+    // #7 — Cheap pre-filter: only session_info entries matter here, so skip
+    // JSON.parse for the (common) message lines without a full parse. The
+    // quoted marker is conservative — a message whose content literally
+    // contains "session_info" false-positives into one parse (harmless); a
+    // real session_info entry always carries it. Partial lines at the
+    // read-start boundary lack the marker and skip cheaply (JSON.parse would
+    // have thrown and been caught anyway).
+    if (!trimmed.includes('"session_info"')) continue;
     try {
       const entry = JSON.parse(trimmed);
       if (typeof entry === "object" && entry !== null && entry.type === "session_info") {
@@ -271,7 +290,10 @@ function forEachLineForward(
   onLine: (line: string) => boolean | void,
 ): { reachedEof: boolean; consumedBytes: number } {
   const decoder = new StringDecoder("utf8");
-  const chunk = Buffer.alloc(READ_CHUNK_SIZE);
+  // #8 — allocUnsafe: readSync fully overwrites [0, bytesRead) before the
+  // buffer is read (via decoder.write(subarray(0, bytesRead))), so the
+  // zero-fill of Buffer.alloc is wasted work. Skips a 16 KB memset per file.
+  const chunk = Buffer.allocUnsafe(READ_CHUNK_SIZE);
   let lineBuf = "";
   let offset = 0;
   let consumedBytes = 0;
@@ -397,20 +419,117 @@ export function scanSessionDir(
   return results;
 }
 
-// Load a session header from disk using a streaming forward read plus a bounded
-// tail read — no fixed head window.
+// Forward-only load: reads complete lines from the start and stops at the
+// first user message (which is all the title row needs). This reads exactly as
+// many bytes as the first user message requires — a few KB for a normal
+// session, ~19KB for a <skill> injection, more for a base64 image — and never
+// truncates a line mid-JSON the way a fixed byte window would. So oversized
+// first user messages (the cases that used to show "(no messages)") are parsed
+// correctly.
 //
-// Forward pass: reads complete lines from the start and stops at the first user
-// message (which is all the title row needs). This reads exactly as many bytes
-// as the first user message requires — a few KB for a normal session, ~19KB
-// for a <skill> injection, more for a base64 image — and never truncates a line
-// mid-JSON the way a fixed byte window would. So oversized first user messages
-// (the cases that used to show "(no messages)") are now parsed correctly.
+// No tail read — the returned header's name reflects only session_info entries
+// seen within the forward window. For sessions whose latest rename lives past
+// the forward stop point (the common case for renamed large sessions), pair
+// this with resolveSessionName() run in the background; the name then populates
+// in-place without blocking the picker's initial render.
+export function loadSessionHeaderForward(
+  meta: SessionFileMeta,
+): SessionHeader | null {
+  let fd: number | undefined;
+  try {
+    fd = openSync(meta.path, "r");
+    const acc = newAccumulator();
+    const { reachedEof, consumedBytes } = forEachLineForward(fd, meta.size, (line) => {
+      processEntry(acc, line);
+      if (acc.header && acc.foundFirstUser) return false;
+      return true;
+    });
+    const header = buildHeader(acc, meta.path, meta.mtimeMs, reachedEof);
+    if (header) {
+      // Carry forward-pass bookkeeping so the deferred rename-name resolver can
+      // skip files whose forward pass reached EOF (name already final) and bound
+      // its tail read below by the consumed bytes (never re-reads covered bytes).
+      header._fwdReachedEof = reachedEof;
+      header._fwdConsumedBytes = consumedBytes;
+    }
+    return header;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+// Resolve the latest session_info (the rename name) from a bounded tail at EOF,
+// independent of any forward pass. Returns found:false when no session_info
+// lives in the tail region (keep whatever name the forward pass produced);
+// found:true means a session_info was seen — its name (or explicit clear)
+// overrides the forward name (it is later in file order).
 //
-// Tail pass (only when the forward pass stopped before EOF): reads up to
-// TAIL_READ_SIZE bytes from EOF and recovers the latest session_info (the
-// rename name), bounded below by the forward stop offset so it never re-reads
-// covered bytes. See TAIL_READ_SIZE for the documented tradeoff.
+// This is the deferred half of loadSessionHeader, exposed so callers can show
+// a row immediately with the forward name and resolve the rename name in the
+// background. Reading up to TAIL_READ_SIZE bytes from EOF may overlap the
+// forward region for small files. Pass `consumedBytesLowerBound` (the forward
+// pass's consumedBytes) so the tail starts at/after the bytes the forward pass
+// already parsed — avoiding a redundant re-read and re-parse of that range.
+// When the bound equals the file size (the forward pass reached EOF) there are
+// no bytes left to read and this returns found:false; callers that already
+// know the forward pass reached EOF should skip the call entirely (see
+// resolveSessionNamesDeferred).
+export function resolveSessionName(
+  meta: SessionFileMeta,
+  options?: { consumedBytesLowerBound?: number },
+): TailSessionInfo {
+  if (meta.size <= 0) return { found: false };
+  // Bound the tail below by the forward pass's consumed bytes so it never
+  // re-reads bytes the forward pass already covered. Matches the combined
+  // loadSessionHeader path's tail math: tailReadSize = min(TAIL, size - bound),
+  // tailOffset = size - tailReadSize (>= bound).
+  const lowerBound = Math.max(0, Math.min(options?.consumedBytesLowerBound ?? 0, meta.size));
+  const tailReadSize = Math.min(TAIL_READ_SIZE, meta.size - lowerBound);
+  if (tailReadSize <= 0) return { found: false };
+  let fd: number | undefined;
+  try {
+    fd = openSync(meta.path, "r");
+    // #8 — allocUnsafe: readSync overwrites [0, bytesRead) before use.
+    const tailBuf = Buffer.allocUnsafe(tailReadSize);
+    const tailOffset = meta.size - tailReadSize;
+    const tailBytesRead = readSync(fd, tailBuf, 0, tailReadSize, tailOffset);
+    return scanTailForSessionInfo(tailBuf, tailBytesRead);
+  } catch {
+    return { found: false };
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+// Resolve rename names for a batch of forward-loaded headers, the pure core of
+// the picker's cooperative name-resolution drain. Skips headers whose forward
+// pass reached EOF (their name is already final — no tail read needed) and
+// bounds each remaining tail read below by the forward pass's consumed bytes
+// (never re-reads already-covered bytes). Returns only paths whose tail found
+// a session_info (name may be undefined for an explicit clear), for the caller
+// to apply in-place. Exposed for direct testing and benchmarking.
+export function resolveSessionNamesDeferred(
+  headers: SessionHeader[],
+  metaByPath: Map<string, SessionFileMeta>,
+): Map<string, string | undefined> {
+  const updates = new Map<string, string | undefined>();
+  for (const h of headers) {
+    if (h._fwdReachedEof) continue; // forward pass saw every session_info
+    const meta = metaByPath.get(h.path);
+    if (!meta) continue;
+    const tail = resolveSessionName(meta, { consumedBytesLowerBound: h._fwdConsumedBytes });
+    if (tail.found) updates.set(h.path, tail.name);
+  }
+  return updates;
+}
+
+// Load a session header using a streaming forward read plus a bounded tail read
+// — forward + tail in one shared fd. Equivalent to loadSessionHeaderForward
+// followed by resolveSessionName, but bounds the tail below by the forward stop
+// offset so it never re-reads already-covered bytes. Use this when the full
+// header (including rename name) is needed synchronously.
 export function loadSessionHeader(
   meta: SessionFileMeta,
 ): SessionHeader | null {
@@ -438,7 +557,8 @@ export function loadSessionHeader(
     if (!forwardReachedEof) {
       try {
         const tailReadSize = Math.min(TAIL_READ_SIZE, meta.size - consumedBytes);
-        const tailBuf = Buffer.alloc(tailReadSize);
+        // #8 — allocUnsafe: readSync overwrites [0, bytesRead) before use.
+        const tailBuf = Buffer.allocUnsafe(tailReadSize);
         const tailOffset = meta.size - tailReadSize;
         const tailBytesRead = readSync(fd, tailBuf, 0, tailReadSize, tailOffset);
         tailInfo = scanTailForSessionInfo(tailBuf, tailBytesRead);
@@ -466,6 +586,20 @@ export function loadSessionHeaders(
   return results;
 }
 
+// Forward-only batch load — see loadSessionHeaderForward. Use for the picker's
+// immediate display path: rows appear instantly with the correct firstMessage,
+// and rename names resolve in the background via resolveSessionName().
+export function loadSessionHeadersForward(
+  metas: SessionFileMeta[],
+): SessionHeader[] {
+  const results: SessionHeader[] = [];
+  for (const meta of metas) {
+    const header = loadSessionHeaderForward(meta);
+    if (header) results.push(header);
+  }
+  return results;
+}
+
 export function sortByModified(sessions: SessionHeader[]): SessionHeader[] {
   return sessions.sort(
     (a, b) => b.modified.getTime() - a.modified.getTime(),
@@ -491,16 +625,37 @@ export function filterByCwd(
   });
 }
 
+// Process-lifetime memo of realpath results. canonicalizePath is called
+// 2–3× per session per tree build (buildSessionTree) and once per visible row
+// per render (isCurrentSessionPath), and the tree is rebuilt on every keystroke
+// in threaded mode. realpathSync is a syscall (~µs each); memoizing collapses
+// thousands of syscalls per keystroke to Map lookups. This is pure memoization
+// (no persistent file, no staleness to manage) — realpath of a path is stable
+// for the process lifetime unless a symlink target changes, which doesn't
+// happen to session files under ~/.pi/agent/sessions. Call
+// clearCanonicalPathCache() to reset (used by tests/benches).
+const canonicalPathCache = new Map<string, string>();
+
 /**
- * Canonicalize a file path by resolving symlinks.
+ * Canonicalize a file path by resolving symlinks, memoized per process.
  * Matches pi-core's canonicalizePath behavior (realpathSync with fallback).
  */
 export function canonicalizePath(path: string): string {
+  const cached = canonicalPathCache.get(path);
+  if (cached !== undefined) return cached;
+  let result: string;
   try {
-    return realpathSync(path);
+    result = realpathSync(path);
   } catch {
-    return path;
+    result = path;
   }
+  canonicalPathCache.set(path, result);
+  return result;
+}
+
+/** Clear the canonicalizePath memo. Intended for tests/benches. */
+export function clearCanonicalPathCache(): void {
+  canonicalPathCache.clear();
 }
 
 export function matchQuery(

package/src/search.ts

@@ -45,9 +45,22 @@ function normalizeWhitespaceLower(text: string): string {
  * matches are unaffected.
  *
  * See README "Known Limitations" section for the user-facing explanation.
+ *
+ * Memoized on the session (`_searchText`): matchSession is called per session
+ * per token per keystroke, so the concatenation is built once on first search
+ * and reused thereafter. Invalidate via invalidateSessionSearchText when
+ * `name` mutates (the picker's rename-name resolution updates names in place).
  */
 function getSessionSearchText(session: SessionHeader): string {
-  return `${session.id} ${session.name ?? ""} ${session.firstMessage} ${session.cwd}`;
+  if (session._searchText !== undefined) return session._searchText;
+  const text = `${session.id} ${session.name ?? ""} ${session.firstMessage} ${session.cwd}`;
+  session._searchText = text;
+  return text;
+}
+
+/** Drop the cached search blob so the next getSessionSearchText rebuilds it. */
+export function invalidateSessionSearchText(session: SessionHeader): void {
+  session._searchText = undefined;
 }
 
 export function parseSearchQuery(query: string): ParsedSearch {

package/vitest.config.ts

@@ -9,7 +9,10 @@ export default defineConfig({
     coverage: {
       provider: "v8",
       reporter: ["text", "json", "html"],
-      exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts"],
+      exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts", "**/*.bench.ts"],
     },
   },
+  // `vitest bench` discovers bench files via its default glob
+  // (**/*.{bench,benchmark}.*); `vitest run` only uses test.include above, so
+  // __tests__/perf.bench.ts is benchmark-only and never runs as a test.
 });