@wrongstack/core 0.306.4 → 0.307.0

package/dist/session-catalog/index.js

@@ -735,9 +735,9 @@ function hasProjectSessionRegistry(globalRoot) {
 }
 
 // src/session-catalog/store.ts
-import { createHash as createHash2, randomBytes, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 
 // src/coordination/sqlite-mailbox-schema.ts
 import { createRequire } from "node:module";
@@ -1233,6 +1233,10 @@ function isPidAlive(pid) {
   }
 }
 
+// src/session-catalog/store-rebuild.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+
 // src/utils/session-scoped-path.ts
 var SESSION_SIDECAR_JSONL_SUFFIXES = [
   ".replay.jsonl",
@@ -1249,7 +1253,8 @@ function isSessionTranscriptFileName(name) {
   return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => name.endsWith(suffix));
 }
 
-// src/session-catalog/store.ts
+// src/session-catalog/store-schema.ts
+import { createHash as createHash2, timingSafeEqual } from "node:crypto";
 var SCHEMA_VERSION = 1;
 var MAX_LEASE_MS = 12e4;
 var MAX_RESERVATION_MS = 6e4;
@@ -1294,12 +1299,192 @@ function boundPresenceValue(value, depth) {
   }
   return result;
 }
+function configureCatalogDatabase(db) {
+  db.exec(
+    "PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000; PRAGMA synchronous=NORMAL;"
+  );
+}
+function initializeCatalogSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS catalog_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS sessions (
+      session_id TEXT PRIMARY KEY,
+      transcript_relative_path TEXT NOT NULL,
+      summary_relative_path TEXT NOT NULL,
+      summary_json TEXT NOT NULL,
+      transcript_size INTEGER NOT NULL DEFAULT 0,
+      transcript_mtime_ms REAL NOT NULL DEFAULT 0,
+      summary_revision INTEGER NOT NULL DEFAULT 1,
+      indexed_at TEXT NOT NULL,
+      damaged INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS session_leases (
+      session_id TEXT PRIMARY KEY,
+      lease_id TEXT NOT NULL UNIQUE,
+      lease_secret_hash TEXT NOT NULL,
+      owner_instance_id TEXT NOT NULL,
+      owner_pid INTEGER NOT NULL,
+      owner_started_at TEXT NOT NULL,
+      entry_json TEXT NOT NULL,
+      agent_revision INTEGER NOT NULL DEFAULT 0,
+      status TEXT NOT NULL,
+      last_heartbeat_at INTEGER NOT NULL,
+      lease_expires_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS resume_reservations (
+      reservation_id TEXT PRIMARY KEY,
+      target_session_id TEXT NOT NULL UNIQUE,
+      requester_instance_id TEXT NOT NULL,
+      current_session_id TEXT,
+      created_at INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS maintenance_leases (
+      session_id TEXT PRIMARY KEY,
+      operation TEXT NOT NULL,
+      holder_id TEXT NOT NULL,
+      lease_id TEXT NOT NULL UNIQUE,
+      acquired_at INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_sessions_activity ON sessions(indexed_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_leases_expiry ON session_leases(lease_expires_at);
+    CREATE INDEX IF NOT EXISTS idx_reservations_expiry ON resume_reservations(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_maintenance_expiry ON maintenance_leases(expires_at);
+  `);
+  db.prepare("INSERT INTO catalog_meta(key,value) VALUES (?,?) ON CONFLICT(key) DO NOTHING").run("schema_version", String(SCHEMA_VERSION));
+  db.prepare("INSERT INTO catalog_meta(key,value) VALUES (?,?) ON CONFLICT(key) DO NOTHING").run("generation", "0");
+  const row = db.prepare("SELECT value FROM catalog_meta WHERE key=?").get("schema_version");
+  if (Number(row.value) !== SCHEMA_VERSION)
+    throw new Error(`Unsupported session catalog schema ${row.value}`);
+}
+
+// src/session-catalog/store-rebuild.ts
+function walkSessionFiles(root, suffix) {
+  const result = [];
+  const visit = (dir) => {
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (entry.name !== "_cas" && entry.name !== "_trash") visit(path4.join(dir, entry.name));
+      } else if (entry.isFile() && entry.name.endsWith(suffix))
+        result.push(path4.join(dir, entry.name));
+    }
+  };
+  visit(root);
+  return result;
+}
+function summarizeTranscriptFile(transcriptFilePath, id) {
+  const lines = fs4.readFileSync(transcriptFilePath, "utf8").split(/\r?\n/);
+  let start;
+  let endedAt;
+  let lastActivityAt;
+  let messageCount = 0;
+  let iterationCount = 0;
+  let toolCallCount = 0;
+  let compactionCount = 0;
+  let tokenTotal = 0;
+  for (const line of lines) {
+    if (!line) continue;
+    let event;
+    try {
+      event = parseJson(line);
+    } catch {
+      continue;
+    }
+    lastActivityAt = event.ts;
+    if (event.type === "session_start") start = event;
+    if (event.type === "session_end") endedAt = event.ts;
+    if (event.type === "message_appended" && (event.message.role === "user" || event.message.role === "assistant"))
+      messageCount++;
+    if (event.type === "llm_response") {
+      iterationCount++;
+      tokenTotal += event.usage.input + event.usage.output + (event.usage.cacheRead ?? 0) + (event.usage.cacheWrite ?? 0);
+    }
+    if (event.type === "tool_call_end") toolCallCount++;
+    if (event.type === "compaction") compactionCount++;
+  }
+  if (!start) throw new Error("missing session_start");
+  return {
+    id,
+    title: id,
+    startedAt: start.ts,
+    ...endedAt ? { endedAt } : {},
+    model: start.model,
+    provider: start.provider,
+    tokenTotal,
+    ...lastActivityAt ? { lastActivityAt } : {},
+    messageCount,
+    iterationCount,
+    toolCallCount,
+    compactionCount
+  };
+}
+function rebuildCatalogIndex(db, sessionsDir, containedPathFn, transactionFn, bumpGenerationFn) {
+  const summaries = walkSessionFiles(sessionsDir, ".summary.json");
+  const transcripts = walkSessionFiles(sessionsDir, ".jsonl").filter(
+    (file) => isSessionTranscriptFileName(path4.basename(file))
+  );
+  const ids = /* @__PURE__ */ new Set();
+  for (const file of [...summaries, ...transcripts]) {
+    const relative2 = path4.relative(sessionsDir, file).replaceAll("\\", "/");
+    ids.add(relative2.replace(/\.summary\.json$|\.jsonl$/, ""));
+  }
+  let indexed = 0;
+  let damaged = 0;
+  transactionFn(() => {
+    db.prepare("DELETE FROM sessions").run();
+    for (const id of ids) {
+      try {
+        const summaryFile = containedPathFn(`${id}.summary.json`);
+        const summary = fs4.existsSync(summaryFile) ? parseJson(fs4.readFileSync(summaryFile, "utf8")) : summarizeTranscriptFile(containedPathFn(`${id}.jsonl`), id);
+        if (!summary || summary.id !== id) throw new Error("summary identity mismatch");
+        const transcript = containedPathFn(`${id}.jsonl`);
+        const stat = fs4.existsSync(transcript) ? fs4.statSync(transcript) : void 0;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        db.prepare(
+          "INSERT INTO sessions(session_id,transcript_relative_path,summary_relative_path,summary_json,transcript_size,transcript_mtime_ms,summary_revision,indexed_at,damaged) VALUES (?,?,?,?,?,?,?,?,0)"
+        ).run(
+          id,
+          `${id}.jsonl`,
+          `${id}.summary.json`,
+          JSON.stringify(summary),
+          stat?.size ?? 0,
+          stat?.mtimeMs ?? 0,
+          1,
+          now
+        );
+        indexed++;
+      } catch {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const fallback = {
+          id,
+          title: id,
+          startedAt: now,
+          model: "",
+          provider: "",
+          tokenTotal: 0
+        };
+        db.prepare(
+          "INSERT INTO sessions(session_id,transcript_relative_path,summary_relative_path,summary_json,summary_revision,indexed_at,damaged) VALUES (?,?,?,?,1,?,1)"
+        ).run(id, `${id}.jsonl`, `${id}.summary.json`, JSON.stringify(fallback), now);
+        damaged++;
+      }
+    }
+    db.prepare(
+      "INSERT INTO catalog_meta(key,value) VALUES ('last_reconciliation',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value"
+    ).run((/* @__PURE__ */ new Date()).toISOString());
+    bumpGenerationFn();
+  });
+  return { indexed, damaged };
+}
+
+// src/session-catalog/store.ts
 var SessionCatalogStore = class {
   constructor(projectDir) {
     this.projectDir = projectDir;
-    this.sessionsDir = path4.join(projectDir, "sessions");
-    fs4.mkdirSync(this.sessionsDir, { recursive: true, mode: 448 });
-    this.databasePath = path4.join(this.sessionsDir, "catalog.sqlite");
+    this.sessionsDir = path5.join(projectDir, "sessions");
+    fs5.mkdirSync(this.sessionsDir, { recursive: true, mode: 448 });
+    this.databasePath = path5.join(this.sessionsDir, "catalog.sqlite");
     const Database = loadDatabaseSync();
     this.db = new Database(this.databasePath);
     try {
@@ -1316,12 +1501,12 @@ var SessionCatalogStore = class {
       this.db.close();
       const quarantine = `${this.databasePath}.corrupt-${Date.now()}`;
       try {
-        fs4.renameSync(this.databasePath, quarantine);
+        fs5.renameSync(this.databasePath, quarantine);
       } catch {
       }
       for (const suffix of ["-wal", "-shm"]) {
         try {
-          fs4.renameSync(`${this.databasePath}${suffix}`, `${quarantine}${suffix}`);
+          fs5.renameSync(`${this.databasePath}${suffix}`, `${quarantine}${suffix}`);
         } catch {
         }
       }
@@ -1333,7 +1518,7 @@ var SessionCatalogStore = class {
     const rowCount = Number(
       this.db.prepare("SELECT COUNT(*) AS count FROM sessions").get().count
     );
-    if (rowCount === 0 && this.walkFiles(this.sessionsDir, ".jsonl").some((file) => !file.endsWith("_index.jsonl"))) {
+    if (rowCount === 0 && walkSessionFiles(this.sessionsDir, ".jsonl").some((file) => !file.endsWith("_index.jsonl"))) {
       this.rebuildCatalog();
     }
   }
@@ -1343,66 +1528,13 @@ var SessionCatalogStore = class {
   db;
   scrubber = new DefaultSecretScrubber();
   configureDatabase() {
-    this.db.exec(
-      "PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000; PRAGMA synchronous=NORMAL;"
-    );
+    configureCatalogDatabase(this.db);
   }
   close() {
     this.db.close();
   }
   initialize() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS catalog_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS sessions (
-        session_id TEXT PRIMARY KEY,
-        transcript_relative_path TEXT NOT NULL,
-        summary_relative_path TEXT NOT NULL,
-        summary_json TEXT NOT NULL,
-        transcript_size INTEGER NOT NULL DEFAULT 0,
-        transcript_mtime_ms REAL NOT NULL DEFAULT 0,
-        summary_revision INTEGER NOT NULL DEFAULT 1,
-        indexed_at TEXT NOT NULL,
-        damaged INTEGER NOT NULL DEFAULT 0
-      );
-      CREATE TABLE IF NOT EXISTS session_leases (
-        session_id TEXT PRIMARY KEY,
-        lease_id TEXT NOT NULL UNIQUE,
-        lease_secret_hash TEXT NOT NULL,
-        owner_instance_id TEXT NOT NULL,
-        owner_pid INTEGER NOT NULL,
-        owner_started_at TEXT NOT NULL,
-        entry_json TEXT NOT NULL,
-        agent_revision INTEGER NOT NULL DEFAULT 0,
-        status TEXT NOT NULL,
-        last_heartbeat_at INTEGER NOT NULL,
-        lease_expires_at INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS resume_reservations (
-        reservation_id TEXT PRIMARY KEY,
-        target_session_id TEXT NOT NULL UNIQUE,
-        requester_instance_id TEXT NOT NULL,
-        current_session_id TEXT,
-        created_at INTEGER NOT NULL,
-        expires_at INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS maintenance_leases (
-        session_id TEXT PRIMARY KEY,
-        operation TEXT NOT NULL,
-        holder_id TEXT NOT NULL,
-        lease_id TEXT NOT NULL UNIQUE,
-        acquired_at INTEGER NOT NULL,
-        expires_at INTEGER NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_sessions_activity ON sessions(indexed_at DESC);
-      CREATE INDEX IF NOT EXISTS idx_leases_expiry ON session_leases(lease_expires_at);
-      CREATE INDEX IF NOT EXISTS idx_reservations_expiry ON resume_reservations(expires_at);
-      CREATE INDEX IF NOT EXISTS idx_maintenance_expiry ON maintenance_leases(expires_at);
-    `);
-    this.db.prepare("INSERT INTO catalog_meta(key,value) VALUES (?,?) ON CONFLICT(key) DO NOTHING").run("schema_version", String(SCHEMA_VERSION));
-    this.db.prepare("INSERT INTO catalog_meta(key,value) VALUES (?,?) ON CONFLICT(key) DO NOTHING").run("generation", "0");
-    const row = this.db.prepare("SELECT value FROM catalog_meta WHERE key=?").get("schema_version");
-    if (Number(row.value) !== SCHEMA_VERSION)
-      throw new Error(`Unsupported session catalog schema ${row.value}`);
+    initializeCatalogSchema(this.db);
   }
   transaction(run) {
     this.db.exec("BEGIN IMMEDIATE");
@@ -1443,21 +1575,6 @@ var SessionCatalogStore = class {
   leaseRow(sessionId) {
     return this.db.prepare("SELECT * FROM session_leases WHERE session_id=?").get(sessionId);
   }
-  /**
-   * True when `sessionId` has a live `session_leases` row owned by a
-   * different OS process than the *caller*. Used by
-   * `acquireMaintenance` to distinguish "another running wstack" (which
-   * must be fenced off) from "this very TUI owning its own session"
-   * (which is allowed to claim a non-destructive maintenance lease on
-   * its own transcript).
-   *
-   * `callerPid` must be the pid of the process that asked for the lease,
-   * NOT `process.pid`. In the built runtime this store lives inside the
-   * detached project-catalog daemon, so `process.pid` is the daemon's and
-   * would mark every lease — including the caller's own session — foreign,
-   * making `/clear` and `/rewind` fail with "Session … is live". Callers
-   * that run the store in-process may omit it.
-   */
   foreignLiveLease(sessionId, callerPid = process.pid) {
     const live = this.leaseRow(sessionId);
     return Boolean(live) && live.owner_pid !== callerPid;
@@ -1547,7 +1664,7 @@ var SessionCatalogStore = class {
       if (this.maintenanceExists(targetSessionId))
         throw conflict(`Session ${targetSessionId} is under maintenance`);
       const catalog = this.db.prepare("SELECT 1 AS yes FROM sessions WHERE session_id=?").get(targetSessionId);
-      if (!catalog && !fs4.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
+      if (!catalog && !fs5.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
         throw new Error(`Session not found: ${targetSessionId}`);
       const reservationId = randomUUID2();
       const now = Date.now();
@@ -1675,9 +1792,9 @@ var SessionCatalogStore = class {
   }
   containedPath(relative2) {
     assertId(relative2.replace(/\.(jsonl|summary\.json)$/, ""), "session path");
-    const root = path4.resolve(this.sessionsDir);
-    const candidate = path4.resolve(root, relative2);
-    const prefix = `${root}${path4.sep}`;
+    const root = path5.resolve(this.sessionsDir);
+    const candidate = path5.resolve(root, relative2);
+    const prefix = `${root}${path5.sep}`;
     if (candidate !== root && !(process.platform === "win32" ? candidate.toLowerCase().startsWith(prefix.toLowerCase()) : candidate.startsWith(prefix)))
       throw new TypeError("Session path escapes sessions directory");
     return candidate;
@@ -1693,7 +1810,7 @@ var SessionCatalogStore = class {
     transcriptRelativePath = normalizedTranscript;
     summaryRelativePath = normalizedSummary;
     const transcript = this.containedPath(transcriptRelativePath);
-    const stat = fs4.existsSync(transcript) ? fs4.statSync(transcript) : void 0;
+    const stat = fs5.existsSync(transcript) ? fs5.statSync(transcript) : void 0;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     return this.transaction(() => {
       const prior = this.db.prepare("SELECT summary_revision FROM sessions WHERE session_id=?").get(summary.id);
@@ -1816,7 +1933,7 @@ var SessionCatalogStore = class {
     if (trimmed) summary.name = this.scrubber.scrub(trimmed).slice(0, 500);
     else delete summary.name;
     const summaryPath = this.containedPath(current.summaryRelativePath);
-    fs4.mkdirSync(path4.dirname(summaryPath), { recursive: true, mode: 448 });
+    fs5.mkdirSync(path5.dirname(summaryPath), { recursive: true, mode: 448 });
     await atomicWrite(summaryPath, `${JSON.stringify(summary)}
 `, { mode: 384 });
     try {
@@ -1876,16 +1993,16 @@ var SessionCatalogStore = class {
       this.containedPath(`${sessionId}.plan.json`),
       this.containedPath(`${sessionId}.tasks.json`),
       this.containedPath(`${sessionId}.todos.json`),
-      path4.join(path4.dirname(transcript), path4.basename(sessionId))
+      path5.join(path5.dirname(transcript), path5.basename(sessionId))
     ];
-    const trashRoot = path4.join(this.sessionsDir, "_trash", lease.leaseId);
-    fs4.mkdirSync(trashRoot, { recursive: true, mode: 448 });
+    const trashRoot = path5.join(this.sessionsDir, "_trash", lease.leaseId);
+    fs5.mkdirSync(trashRoot, { recursive: true, mode: 448 });
     const moved = [];
     try {
       artifacts.forEach((artifact, index) => {
-        if (!fs4.existsSync(artifact)) return;
-        const target = path4.join(trashRoot, `${index}-${path4.basename(artifact)}`);
-        fs4.renameSync(artifact, target);
+        if (!fs5.existsSync(artifact)) return;
+        const target = path5.join(trashRoot, `${index}-${path5.basename(artifact)}`);
+        fs5.renameSync(artifact, target);
         moved.push({ from: artifact, to: target });
       });
       this.transaction(() => {
@@ -1900,17 +2017,17 @@ var SessionCatalogStore = class {
     } catch (error) {
       for (const item of moved.reverse()) {
         try {
-          fs4.mkdirSync(path4.dirname(item.from), { recursive: true, mode: 448 });
-          fs4.renameSync(item.to, item.from);
+          fs5.mkdirSync(path5.dirname(item.from), { recursive: true, mode: 448 });
+          fs5.renameSync(item.to, item.from);
         } catch {
         }
       }
       throw error;
     }
     try {
-      fs4.rmSync(trashRoot, { recursive: true, force: true });
-      const trashParent = path4.dirname(trashRoot);
-      if (fs4.readdirSync(trashParent).length === 0) fs4.rmdirSync(trashParent);
+      fs5.rmSync(trashRoot, { recursive: true, force: true });
+      const trashParent = path5.dirname(trashRoot);
+      if (fs5.readdirSync(trashParent).length === 0) fs5.rmdirSync(trashParent);
     } catch {
     }
   }
@@ -1931,122 +2048,13 @@ var SessionCatalogStore = class {
     return deleted;
   }
   rebuildCatalog() {
-    const summaries = this.walkFiles(this.sessionsDir, ".summary.json");
-    const transcripts = this.walkFiles(this.sessionsDir, ".jsonl").filter(
-      (file) => isSessionTranscriptFileName(path4.basename(file))
+    return rebuildCatalogIndex(
+      this.db,
+      this.sessionsDir,
+      (rel) => this.containedPath(rel),
+      (run) => this.transaction(run),
+      () => this.bumpGeneration()
     );
-    const ids = /* @__PURE__ */ new Set();
-    for (const file of [...summaries, ...transcripts]) {
-      const relative2 = path4.relative(this.sessionsDir, file).replaceAll("\\", "/");
-      ids.add(relative2.replace(/\.summary\.json$|\.jsonl$/, ""));
-    }
-    let indexed = 0;
-    let damaged = 0;
-    this.transaction(() => {
-      this.db.prepare("DELETE FROM sessions").run();
-      for (const id of ids) {
-        try {
-          const summaryFile = this.containedPath(`${id}.summary.json`);
-          const summary = fs4.existsSync(summaryFile) ? parseJson(fs4.readFileSync(summaryFile, "utf8")) : this.summarizeTranscript(id);
-          if (!summary || summary.id !== id) throw new Error("summary identity mismatch");
-          const transcript = this.containedPath(`${id}.jsonl`);
-          const stat = fs4.existsSync(transcript) ? fs4.statSync(transcript) : void 0;
-          const now = (/* @__PURE__ */ new Date()).toISOString();
-          this.db.prepare(
-            "INSERT INTO sessions(session_id,transcript_relative_path,summary_relative_path,summary_json,transcript_size,transcript_mtime_ms,summary_revision,indexed_at,damaged) VALUES (?,?,?,?,?,?,?,?,0)"
-          ).run(
-            id,
-            `${id}.jsonl`,
-            `${id}.summary.json`,
-            JSON.stringify(summary),
-            stat?.size ?? 0,
-            stat?.mtimeMs ?? 0,
-            1,
-            now
-          );
-          indexed++;
-        } catch {
-          const now = (/* @__PURE__ */ new Date()).toISOString();
-          const fallback = {
-            id,
-            title: id,
-            startedAt: now,
-            model: "",
-            provider: "",
-            tokenTotal: 0
-          };
-          this.db.prepare(
-            "INSERT INTO sessions(session_id,transcript_relative_path,summary_relative_path,summary_json,summary_revision,indexed_at,damaged) VALUES (?,?,?,?,1,?,1)"
-          ).run(id, `${id}.jsonl`, `${id}.summary.json`, JSON.stringify(fallback), now);
-          damaged++;
-        }
-      }
-      this.db.prepare(
-        "INSERT INTO catalog_meta(key,value) VALUES ('last_reconciliation',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value"
-      ).run((/* @__PURE__ */ new Date()).toISOString());
-      this.bumpGeneration();
-    });
-    return { indexed, damaged };
-  }
-  walkFiles(root, suffix) {
-    const result = [];
-    const visit = (dir) => {
-      for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-          if (entry.name !== "_cas" && entry.name !== "_trash") visit(path4.join(dir, entry.name));
-        } else if (entry.isFile() && entry.name.endsWith(suffix))
-          result.push(path4.join(dir, entry.name));
-      }
-    };
-    visit(root);
-    return result;
-  }
-  summarizeTranscript(id) {
-    const file = this.containedPath(`${id}.jsonl`);
-    const lines = fs4.readFileSync(file, "utf8").split(/\r?\n/);
-    let start;
-    let endedAt;
-    let lastActivityAt;
-    let messageCount = 0;
-    let iterationCount = 0;
-    let toolCallCount = 0;
-    let compactionCount = 0;
-    let tokenTotal = 0;
-    for (const line of lines) {
-      if (!line) continue;
-      let event;
-      try {
-        event = parseJson(line);
-      } catch {
-        continue;
-      }
-      lastActivityAt = event.ts;
-      if (event.type === "session_start") start = event;
-      if (event.type === "session_end") endedAt = event.ts;
-      if (event.type === "message_appended" && (event.message.role === "user" || event.message.role === "assistant"))
-        messageCount++;
-      if (event.type === "llm_response") {
-        iterationCount++;
-        tokenTotal += event.usage.input + event.usage.output + (event.usage.cacheRead ?? 0) + (event.usage.cacheWrite ?? 0);
-      }
-      if (event.type === "tool_call_end") toolCallCount++;
-      if (event.type === "compaction") compactionCount++;
-    }
-    if (!start) throw new Error("missing session_start");
-    return {
-      id,
-      title: id,
-      startedAt: start.ts,
-      ...endedAt ? { endedAt } : {},
-      model: start.model,
-      provider: start.provider,
-      tokenTotal,
-      ...lastActivityAt ? { lastActivityAt } : {},
-      messageCount,
-      iterationCount,
-      toolCallCount,
-      compactionCount
-    };
   }
   health(base) {
     this.reapExpired();