@bakapiano/ccsm 0.10.3 → 0.11.0

package/lib/localCliSessions.js

@@ -1,177 +1,489 @@
-'use strict';
-
-// Discover existing CLI sessions on this machine and surface them so
-// ccsm can "adopt" them — i.e. create a persistedSessions record that
-// resumes the same upstream conversation later.
-//
-// Per CLI:
-//   claude  · ~/.claude/projects/<slug>/<uuid>.jsonl   (uuid = id)
-//   codex   · ~/.codex/sessions/**/<uuid>.jsonl        (uuid = id)
-//   copilot · ~/.copilot/session-state/<uuid>/         (uuid = dir name;
-//              cwd + summary in workspace.yaml)
-//
-// Each session is reported as:
-//   { cliType, cliSessionId, cwd, mtime, summary }
-//
-// Heuristic for `summary`: the first user message text (claude/codex)
-// or the YAML `summary:` line (copilot). Truncated to 120 chars.
-
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-const os = require('node:os');
-const readline = require('node:readline');
-
-const SUMMARY_MAX = 120;
-
-async function listClaude() {
-  const root = path.join(os.homedir(), '.claude', 'projects');
-  let slugs;
-  try { slugs = await fsp.readdir(root, { withFileTypes: true }); }
-  catch { return []; }
-  const out = [];
-  for (const slug of slugs) {
-    if (!slug.isDirectory()) continue;
-    const slugDir = path.join(root, slug.name);
-    let files;
-    try { files = await fsp.readdir(slugDir, { withFileTypes: true }); }
-    catch { continue; }
-    for (const f of files) {
-      if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
-      const filepath = path.join(slugDir, f.name);
-      const id = f.name.replace(/\.jsonl$/, '');
-      let st; try { st = await fsp.stat(filepath); } catch { continue; }
-      const { cwd, summary } = await parseClaudeJsonl(filepath);
-      if (!cwd) continue;
-      out.push({
-        cliType: 'claude',
-        cliSessionId: id,
-        cwd,
-        mtime: st.mtimeMs,
-        summary,
-      });
-    }
-  }
-  return out;
-}
-
-async function listCodex() {
-  const root = path.join(os.homedir(), '.codex', 'sessions');
-  const out = [];
-  await walkFiles(root, async (filepath) => {
-    if (!filepath.endsWith('.jsonl')) return;
-    const base = path.basename(filepath);
-    const m = base.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
-    if (!m) return;
-    let st; try { st = await fsp.stat(filepath); } catch { return; }
-    const { cwd, summary } = await parseClaudeJsonl(filepath); // same shape
-    if (!cwd) return;
-    out.push({
-      cliType: 'codex',
-      cliSessionId: m[1],
-      cwd,
-      mtime: st.mtimeMs,
-      summary,
-    });
-  });
-  return out;
-}
-
-async function listCopilot() {
-  const root = path.join(os.homedir(), '.copilot', 'session-state');
-  let dirs;
-  try { dirs = await fsp.readdir(root, { withFileTypes: true }); }
-  catch { return []; }
-  const out = [];
-  for (const d of dirs) {
-    if (!d.isDirectory()) continue;
-    const id = d.name;
-    if (!/^[0-9a-f-]+$/i.test(id)) continue;
-    const dirpath = path.join(root, id);
-    let st; try { st = await fsp.stat(dirpath); } catch { continue; }
-    const yaml = path.join(dirpath, 'workspace.yaml');
-    let txt;
-    try { txt = await fsp.readFile(yaml, 'utf8'); }
-    catch { continue; }
-    const cwd = (txt.match(/^\s*cwd\s*:\s*(.+?)\s*$/m) || [])[1] || null;
-    const summary = (txt.match(/^\s*summary\s*:\s*(.+?)\s*$/m) || [])[1] || '';
-    const updated = (txt.match(/^\s*updated_at\s*:\s*(.+?)\s*$/m) || [])[1];
-    if (!cwd) continue;
-    out.push({
-      cliType: 'copilot',
-      cliSessionId: id,
-      cwd: cwd.trim(),
-      mtime: updated ? Date.parse(updated) || st.mtimeMs : st.mtimeMs,
-      summary: truncate(summary, SUMMARY_MAX),
-    });
-  }
-  return out;
-}
-
-async function listForType(cliType) {
-  if (cliType === 'claude')  return listClaude();
-  if (cliType === 'codex')   return listCodex();
-  if (cliType === 'copilot') return listCopilot();
-  return [];
-}
-
-module.exports = { listForType, listClaude, listCodex, listCopilot };
-
-// ── helpers ─────────────────────────────────────────────────────────
-
-async function walkFiles(root, visit) {
-  let entries;
-  try { entries = await fsp.readdir(root, { withFileTypes: true }); }
-  catch { return; }
-  for (const e of entries) {
-    const p = path.join(root, e.name);
-    if (e.isDirectory()) await walkFiles(p, visit);
-    else await visit(p);
-  }
-}
-
-function truncate(s, n) {
-  if (!s) return '';
-  const t = String(s).replace(/\s+/g, ' ').trim();
-  return t.length > n ? t.slice(0, n - 1) + '…' : t;
-}
-
-// Returns { cwd, summary } from the first ~30 lines of a claude/codex
-// jsonl. Looks for the first object with a `cwd` field, plus the first
-// user message text content for a 1-line preview.
-async function parseClaudeJsonl(filepath) {
-  return new Promise((resolve) => {
-    let stream;
-    try { stream = fs.createReadStream(filepath, { encoding: 'utf8' }); }
-    catch { resolve({ cwd: null, summary: '' }); return; }
-    const rl = readline.createInterface({ input: stream });
-    let count = 0;
-    let cwd = null;
-    let summary = '';
-    let settled = false;
-    const done = () => {
-      if (settled) return;
-      settled = true;
-      try { rl.close(); } catch {}
-      try { stream.destroy(); } catch {}
-      resolve({ cwd, summary });
-    };
-    rl.on('line', (line) => {
-      count++;
-      try {
-        const obj = JSON.parse(line);
-        if (!cwd && obj && obj.cwd) cwd = obj.cwd;
-        if (!summary && obj) {
-          // First user text wins.
-          if (obj.type === 'user' && obj.message?.content) {
-            const c = obj.message.content;
-            if (typeof c === 'string') summary = truncate(c, SUMMARY_MAX);
-          }
-        }
-      } catch {}
-      if (count >= 30 || (cwd && summary)) done();
-    });
-    rl.on('close', done);
-    rl.on('error', done);
-  });
-}
+'use strict';
+
+// Discover existing CLI sessions on this machine and surface them so
+// ccsm can "adopt" them — i.e. create a persistedSessions record that
+// resumes the same upstream conversation later.
+//
+// Per CLI:
+//   claude  · ~/.claude/projects/<slug>/<uuid>.jsonl   (uuid = id)
+//   codex   · ~/.codex/sessions/**/<uuid>.jsonl        (uuid = id)
+//   copilot · ~/.copilot/session-state/<uuid>/         (uuid = dir name;
+//              cwd + summary in workspace.yaml)
+//
+// Each session is reported as:
+//   { cliType, cliSessionId, cwd, mtime, summary }
+//
+// Heuristic for `summary`: the first user message text (claude/codex)
+// or the YAML `summary:` line (copilot). Truncated to 120 chars.
+//
+// Performance:
+//   - We read each jsonl's HEAD (first 16KB) directly via fd.read instead
+//     of going through readline+stream — readline init is the dominant
+//     cost when scanning hundreds of small files.
+//   - Files are parsed in parallel with a small concurrency cap (16) so
+//     the OS scheduler stays useful but we don't fire 300+ syscalls at
+//     once.
+//   - An in-process LRU caches parse results keyed by (filepath, mtime).
+//     Unchanged files on subsequent scans are O(1).
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+const SUMMARY_MAX = 120;
+const HEAD_BYTES = 16 * 1024;       // enough to catch cwd + first user msg
+const CONCURRENCY = 16;             // parallel parses per scan
+const PARSE_CACHE_MAX = 5000;
+const parseCache = new Map();       // `${path}|${mtimeMs}` → { cwd, summary }
+
+function cacheGet(filepath, mtimeMs) {
+  return parseCache.get(`${filepath}|${mtimeMs}`);
+}
+function cachePut(filepath, mtimeMs, value) {
+  if (parseCache.size >= PARSE_CACHE_MAX) {
+    // Drop oldest insertion (Map keeps insertion order).
+    const firstKey = parseCache.keys().next().value;
+    parseCache.delete(firstKey);
+  }
+  parseCache.set(`${filepath}|${mtimeMs}`, value);
+}
+
+// Run `tasks` with a max concurrency cap. Each task is a `() => Promise`.
+async function pmap(tasks, concurrency) {
+  const results = new Array(tasks.length);
+  let next = 0;
+  async function worker() {
+    while (true) {
+      const i = next++;
+      if (i >= tasks.length) return;
+      try { results[i] = await tasks[i](); }
+      catch { results[i] = null; }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, tasks.length) }, worker));
+  return results;
+}
+
+// ── Discover phase · cheap, just stat the files ─────────────────────
+// Returns [{ id, filepath, mtimeMs }] for all jsonls under ~/.claude/projects,
+// sorted by mtime desc. No content read, no parsing. Used both as the
+// "list of candidates" for pagination AND as the source of truth for
+// "what jsonl ids exist on disk".
+async function discoverClaude() {
+  const root = path.join(os.homedir(), '.claude', 'projects');
+  let slugs;
+  try { slugs = await fsp.readdir(root, { withFileTypes: true }); }
+  catch { return []; }
+  const statTasks = [];
+  for (const slug of slugs) {
+    if (!slug.isDirectory()) continue;
+    const slugDir = path.join(root, slug.name);
+    statTasks.push(async () => {
+      let files;
+      try { files = await fsp.readdir(slugDir, { withFileTypes: true }); }
+      catch { return []; }
+      const inDir = [];
+      for (const f of files) {
+        if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
+        const filepath = path.join(slugDir, f.name);
+        let st; try { st = await fsp.stat(filepath); } catch { continue; }
+        inDir.push({
+          id: f.name.replace(/\.jsonl$/, ''),
+          filepath,
+          mtimeMs: st.mtimeMs,
+        });
+      }
+      return inDir;
+    });
+  }
+  const grouped = await pmap(statTasks, CONCURRENCY);
+  const all = grouped.flat().filter(Boolean);
+  all.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return all;
+}
+
+async function discoverCodex() {
+  const root = path.join(os.homedir(), '.codex', 'sessions');
+  const candidates = [];
+  await walkFiles(root, async (filepath, st) => {
+    if (!filepath.endsWith('.jsonl')) return;
+    const base = path.basename(filepath);
+    const m = base.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+    if (!m) return;
+    candidates.push({ id: m[1], filepath, mtimeMs: st.mtimeMs });
+  });
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return candidates;
+}
+
+// Hydrate a list of {id, filepath, mtimeMs} candidates into full session
+// records by parsing each jsonl head. cliType is the discriminator in the
+// returned record.
+async function hydrateJsonl(candidates, cliType) {
+  const parseTasks = candidates.map((c) => async () => {
+    const { cwd, summary } = await parseJsonlHead(c.filepath, c.mtimeMs);
+    if (!cwd) return null;
+    return {
+      cliType,
+      cliSessionId: c.id,
+      cwd,
+      mtime: c.mtimeMs,
+      summary,
+    };
+  });
+  const parsed = await pmap(parseTasks, CONCURRENCY);
+  return parsed.filter(Boolean);
+}
+
+// Full-load variants (no pagination). Kept for back-compat callers /
+// codex+copilot where the dataset is small.
+async function listClaude() {
+  return hydrateJsonl(await discoverClaude(), 'claude');
+}
+async function listCodex() {
+  return hydrateJsonl(await discoverCodex(), 'codex');
+}
+
+async function listCopilot() {
+  const root = path.join(os.homedir(), '.copilot', 'session-state');
+  let dirs;
+  try { dirs = await fsp.readdir(root, { withFileTypes: true }); }
+  catch { return []; }
+  const out = [];
+  for (const d of dirs) {
+    if (!d.isDirectory()) continue;
+    const id = d.name;
+    if (!/^[0-9a-f-]+$/i.test(id)) continue;
+    const dirpath = path.join(root, id);
+    let st; try { st = await fsp.stat(dirpath); } catch { continue; }
+    const yaml = path.join(dirpath, 'workspace.yaml');
+    let txt;
+    try { txt = await fsp.readFile(yaml, 'utf8'); }
+    catch { continue; }
+    const cwd = (txt.match(/^\s*cwd\s*:\s*(.+?)\s*$/m) || [])[1] || null;
+    const summary = (txt.match(/^\s*summary\s*:\s*(.+?)\s*$/m) || [])[1] || '';
+    const updated = (txt.match(/^\s*updated_at\s*:\s*(.+?)\s*$/m) || [])[1];
+    if (!cwd) continue;
+    out.push({
+      cliType: 'copilot',
+      cliSessionId: id,
+      cwd: cwd.trim(),
+      mtime: updated ? Date.parse(updated) || st.mtimeMs : st.mtimeMs,
+      summary: truncate(summary, SUMMARY_MAX),
+    });
+  }
+  return out;
+}
+
+async function listForType(cliType) {
+  if (cliType === 'claude')  return listClaude();
+  if (cliType === 'codex')   return listCodex();
+  if (cliType === 'copilot') return listCopilot();
+  return [];
+}
+
+// ── Active-session detection ───────────────────────────────────────
+// "Active" = a cli process is currently running with this session loaded.
+// Claude: definitive — ~/.claude/sessions/<pid>.json has {pid, sessionId},
+//         cross-check pid is alive via tasklist /FI "IMAGENAME eq claude.exe".
+// Codex / Copilot: no per-process session manifest we can read, so we
+//         fall back to mtime heuristic (jsonl/yaml touched in the last
+//         RECENT_MS = a session being actively written to is "active").
+const RECENT_MS = 5 * 60 * 1000;
+
+// tasklist is the expensive one — ~500ms on Windows for "list every
+// process named claude.exe". Strategy:
+//
+//   1. Module-level cache keyed by procName.
+//   2. A background refresh loop runs every LIVE_PIDS_REFRESH_MS while
+//      anyone has asked for the pids in the recent past. The foreground
+//      call ALWAYS returns the cached value immediately — it never waits
+//      for tasklist. Stale-while-revalidate, in other words.
+//   3. First call ever (cache miss) blocks until tasklist returns once.
+//
+// Net effect: import-modal cold open shows the page in tens of ms, and
+// the "active" markers are at most LIVE_PIDS_REFRESH_MS old.
+
+const LIVE_PIDS_REFRESH_MS = 15_000;
+const livePidsByProc = new Map(); // procName → { pids: Set<pid>, ts: number }
+const livePidsRefresh = new Map(); // procName → setInterval handle
+const livePidsInflight = new Map(); // procName → Promise<Set<pid>>
+
+async function tasklistOnce(procName) {
+  if (process.platform !== 'win32') return new Set();
+  return new Promise((resolve) => {
+    const { exec } = require('node:child_process');
+    exec(`tasklist /FI "IMAGENAME eq ${procName}" /FO CSV /NH`,
+      { windowsHide: true, maxBuffer: 4 * 1024 * 1024 },
+      (err, stdout) => {
+        const pids = new Set();
+        if (!err && stdout) {
+          for (const line of stdout.split(/\r?\n/)) {
+            const m = line.match(/^"[^"]+","(\d+)"/);
+            if (m) pids.add(Number(m[1]));
+          }
+        }
+        resolve(pids);
+      });
+  });
+}
+
+function startRefreshLoop(procName) {
+  if (livePidsRefresh.has(procName)) return;
+  // unref so it doesn't keep the process alive.
+  const handle = setInterval(async () => {
+    try {
+      const pids = await tasklistOnce(procName);
+      livePidsByProc.set(procName, { pids, ts: Date.now() });
+    } catch {}
+  }, LIVE_PIDS_REFRESH_MS);
+  if (typeof handle.unref === 'function') handle.unref();
+  livePidsRefresh.set(procName, handle);
+}
+
+// Non-blocking lookup. Returns whatever the cache holds, even if empty.
+// If there's no fresh data, kicks off a refresh in the background — the
+// next request a few seconds later will see populated results. This is a
+// deliberate tradeoff: tasklist on this machine sometimes spikes to
+// 30+s, and we absolutely will not let import-modal cold-open inherit
+// that latency. Worst case the first paint has `active: false` on every
+// row and the second paint (after frontend re-fetches) has the correct
+// markers — at most LIVE_PIDS_REFRESH_MS stale.
+function getLivePids(procName) {
+  startRefreshLoop(procName);  // idempotent — keeps cache fresh
+  const cached = livePidsByProc.get(procName);
+  if (cached) return cached.pids;
+
+  // Cache miss — kick off a tasklist if no one already has, but DON'T
+  // await it. Return empty for now; future calls will see the populated
+  // cache once it lands.
+  if (!livePidsInflight.has(procName)) {
+    const inflight = tasklistOnce(procName).then((pids) => {
+      livePidsByProc.set(procName, { pids, ts: Date.now() });
+      livePidsInflight.delete(procName);
+      return pids;
+    }).catch(() => { livePidsInflight.delete(procName); return new Set(); });
+    livePidsInflight.set(procName, inflight);
+  }
+  return new Set();  // immediate, empty
+}
+
+// Prewarm — called from server boot so the first user request to the
+// import modal already hits the warm cache.
+function prewarmLivePids(procNames = ['claude.exe']) {
+  for (const p of procNames) {
+    getLivePids(p).catch(() => {});
+  }
+}
+
+async function activeClaudeIds() {
+  const dir = path.join(os.homedir(), '.claude', 'sessions');
+  let files;
+  try { files = await fsp.readdir(dir); }
+  catch { return new Set(); }
+  // Non-blocking — if tasklist cache is cold, returns empty Set and
+  // schedules a background refresh. First-paint may miss live markers;
+  // subsequent re-fetches pick them up.
+  const livePids = getLivePids('claude.exe');
+  const ids = new Set();
+  await pmap(
+    files.filter((f) => f.endsWith('.json')).map((f) => async () => {
+      let raw; try { raw = await fsp.readFile(path.join(dir, f), 'utf8'); }
+      catch { return; }
+      try {
+        const obj = JSON.parse(raw);
+        if (obj && obj.sessionId && livePids.has(Number(obj.pid))) {
+          ids.add(obj.sessionId);
+        }
+      } catch {}
+    }),
+    CONCURRENCY,
+  );
+  return ids;
+}
+
+// Compute per-type active set. Returns Set<cliSessionId>.
+async function getActiveIds(cliType) {
+  if (cliType === 'claude') return activeClaudeIds();
+  // codex / copilot: no manifest. Returning empty here; the caller falls
+  // back to mtime-recency in listForTypeWithActive below.
+  return new Set();
+}
+
+// Annotate listForType output with `active: bool`. Centralises the logic
+// so server.js doesn't have to know about per-CLI quirks.
+async function listForTypeWithActive(cliType) {
+  const [items, activeIds] = await Promise.all([
+    listForType(cliType),
+    getActiveIds(cliType),
+  ]);
+  const now = Date.now();
+  return items.map((it) => ({
+    ...it,
+    active: activeIds.has(it.cliSessionId)
+      // Fallback: any session touched within RECENT_MS is treated as
+      // active. Catches codex/copilot which don't expose a pid mapping.
+      || (now - it.mtime) < RECENT_MS,
+  }));
+}
+
+// Paginated list — the fast path used by the import modal.
+//
+// Strategy:
+//   1. Discover phase = stat all candidates. Cheap, even at 1000+ files.
+//   2. Compute active set in parallel.
+//   3. ALWAYS hydrate every active candidate (they go first, never paged
+//      out — user explicitly wants live sessions visible up top).
+//   4. For non-active, hydrate only `[offset, offset+limit)` sorted mtime
+//      desc. "Load more" = call again with the next offset.
+//
+// Returns: { sessions, totalActive, totalNonActive, offset, limit, hasMore }
+async function listPaginated(cliType, { offset = 0, limit = 30 } = {}) {
+  // copilot's "discover" is also the parse (no separate jsonl head to read
+  // cheaply), so for now we just list all of it. Codex/Claude get the
+  // proper two-phase treatment.
+  if (cliType === 'copilot') {
+    const all = await listForTypeWithActive('copilot');
+    all.sort((a, b) => {
+      if (a.active !== b.active) return a.active ? -1 : 1;
+      return b.mtime - a.mtime;
+    });
+    return {
+      sessions: all,
+      totalActive: all.filter((x) => x.active).length,
+      totalNonActive: all.filter((x) => !x.active).length,
+      offset: 0,
+      limit: all.length,
+      hasMore: false,
+    };
+  }
+
+  const discover = cliType === 'codex' ? discoverCodex : discoverClaude;
+  const [candidates, activeIds] = await Promise.all([
+    discover(),
+    getActiveIds(cliType),
+  ]);
+  // Already sorted mtime desc inside discover.
+  const now = Date.now();
+  const isActiveCand = (c) =>
+    activeIds.has(c.id) || (now - c.mtimeMs) < RECENT_MS;
+  const active = candidates.filter(isActiveCand);
+  const rest = candidates.filter((c) => !isActiveCand(c));
+
+  // Slice non-active to the requested page.
+  const slice = rest.slice(offset, offset + limit);
+
+  // Hydrate active (always all) + slice of non-active.
+  // First page: hydrate both. Later pages: only the slice — frontend
+  // already has the active set from page 0.
+  const toHydrate = offset === 0 ? [...active, ...slice] : slice;
+  const hydrated = await hydrateJsonl(toHydrate, cliType);
+
+  // Stamp active flag back on. Doing it post-hydrate so we don't have
+  // to thread it through hydrateJsonl.
+  const activeIdSet = new Set(active.map((c) => c.id));
+  for (const s of hydrated) {
+    s.active = activeIdSet.has(s.cliSessionId)
+      || activeIds.has(s.cliSessionId)
+      || (now - s.mtime) < RECENT_MS;
+  }
+
+  return {
+    sessions: hydrated,
+    totalActive: active.length,
+    totalNonActive: rest.length,
+    offset,
+    limit,
+    hasMore: offset + limit < rest.length,
+  };
+}
+
+module.exports = {
+  listForType,
+  listForTypeWithActive,
+  listPaginated,
+  listClaude,
+  listCodex,
+  listCopilot,
+  getActiveIds,
+  prewarmLivePids,
+};
+
+// ── helpers ─────────────────────────────────────────────────────────
+
+async function walkFiles(root, visit) {
+  let entries;
+  try { entries = await fsp.readdir(root, { withFileTypes: true }); }
+  catch { return; }
+  const tasks = entries.map((e) => async () => {
+    const p = path.join(root, e.name);
+    if (e.isDirectory()) {
+      await walkFiles(p, visit);
+    } else {
+      let st; try { st = await fsp.stat(p); } catch { return; }
+      await visit(p, st);
+    }
+  });
+  await pmap(tasks, CONCURRENCY);
+}
+
+function truncate(s, n) {
+  if (!s) return '';
+  const t = String(s).replace(/\s+/g, ' ').trim();
+  return t.length > n ? t.slice(0, n - 1) + '…' : t;
+}
+
+// Returns { cwd, summary } from a claude/codex jsonl by reading just the
+// first 16KB directly. Way faster than readline+stream when scanning
+// hundreds of files. Cached by (filepath, mtimeMs) so a repeat scan of
+// unchanged files is O(1).
+//
+// cwd lives in the head of every jsonl (it's part of the per-message
+// envelope), so 16KB is more than enough. First user text usually too;
+// if it's beyond the head we just don't preview, that's fine.
+async function parseJsonlHead(filepath, mtimeMs) {
+  const cached = cacheGet(filepath, mtimeMs);
+  if (cached) return cached;
+
+  let fh;
+  try { fh = await fsp.open(filepath, 'r'); }
+  catch { return { cwd: null, summary: '' }; }
+  const buf = Buffer.allocUnsafe(HEAD_BYTES);
+  let bytesRead = 0;
+  try {
+    const r = await fh.read(buf, 0, HEAD_BYTES, 0);
+    bytesRead = r.bytesRead || 0;
+  } catch {
+    /* leave bytesRead = 0 */
+  } finally {
+    try { await fh.close(); } catch {}
+  }
+  if (bytesRead === 0) {
+    const v = { cwd: null, summary: '' };
+    cachePut(filepath, mtimeMs, v);
+    return v;
+  }
+
+  const text = buf.slice(0, bytesRead).toString('utf8');
+  // Drop the trailing partial line — JSON.parse on it will fail anyway.
+  const lines = text.split('\n');
+  if (bytesRead === HEAD_BYTES) lines.pop();
+
+  let cwd = null;
+  let summary = '';
+  for (const line of lines) {
+    if (cwd && summary) break;
+    if (!line) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    if (!cwd && obj && obj.cwd) cwd = obj.cwd;
+    if (!summary && obj && obj.type === 'user' && obj.message?.content) {
+      const c = obj.message.content;
+      if (typeof c === 'string') summary = truncate(c, SUMMARY_MAX);
+    }
+  }
+  const v = { cwd, summary };
+  cachePut(filepath, mtimeMs, v);
+  return v;
+}