@wrongstack/core 0.306.3 → 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";
@@ -777,6 +777,24 @@ function loadDatabaseSync() {
 }
 
 // src/security/secret-scrubber.ts
+var JSON_CREDENTIAL_KEY_ANCHORS = [
+  'Key"',
+  'key"',
+  'KEY"',
+  'token"',
+  'Token"',
+  'TOKEN"',
+  'secret"',
+  'Secret"',
+  'SECRET"',
+  'password"',
+  'Password"',
+  'PASSWORD"',
+  'authorization"',
+  'Authorization"',
+  'bearer"',
+  'Bearer"'
+];
 var PATTERNS = [
   // Anchored at the start where possible so partial matches inside larger
   // strings don't trigger false positives.
@@ -879,6 +897,30 @@ var PATTERNS = [
     regex: /(^|\s)([A-Z_]{4,}(?:KEY|TOKEN|SECRET|PASSWORD|PWD))\s*[:=]\s*['"]?([A-Za-z0-9_/+=-]{20,512})['"]?(?=\s|$)/g,
     anchor: ["KEY", "TOKEN", "SECRET", "PASSWORD", "PWD"]
   },
+  {
+    type: "json_credential_key",
+    // The JSON counterpart to `high_entropy_env`, and the pattern that the
+    // now-deleted `JSON_KEY_ANCHORS` list was written for. Without it those
+    // anchors only widened the cheap pre-scan — `hasCredentialAnchors` said
+    // "this text may hold a secret", every pattern then declined to match, and
+    // the value went out verbatim. `high_entropy_env` cannot cover these: it
+    // requires an UPPERCASE unquoted key (`API_KEY=…`), so `{"apiKey":"…"}`
+    // never matched.
+    //
+    // Tool results are routinely serialised as JSON, and a credential with no
+    // recognisable prefix (Azure, self-hosted gateways, Anthropic/Codex OAuth)
+    // has no other pattern that can catch it — this is the only thing standing
+    // between such a value and the session JSONL, chronicle, HQ broadcast and
+    // the model's own context.
+    //
+    // The key may carry a prefix (`"anthropicApiKey"`), but the credential word
+    // must END the key: `"tokenCount"` and `"maxTokens"` do not match, because
+    // the closing quote has to follow the word immediately.
+    // Value floor of 8 chars keeps enum-ish values (`"authorization":"none"`)
+    // out. Capture groups: 1=key + punctuation, 2=value, 3=closing quote.
+    regex: /("[A-Za-z0-9_]*(?:apiKey|api_key|token|secret|password|authorization|bearer|private_key|access_token|refresh_token|client_secret)"\s*:\s*")([^"\\]{8,512})(")/gi,
+    anchor: JSON_CREDENTIAL_KEY_ANCHORS
+  },
   // ── Ported from packages/plugins credential-patterns.ts (WS-034) ─────────
   // The plugin runtime carried 37 patterns while this scrubber — the one that
   // guards session JSONL, chronicle, HQ broadcast, WebUI events and the auth
@@ -961,9 +1003,12 @@ var PATTERNS = [
     anchor: "GOCSPX-"
   }
 ];
-var SIMPLE_PATTERNS = PATTERNS.filter((p) => p.type !== "high_entropy_env");
+var SIMPLE_PATTERNS = PATTERNS.filter(
+  (p) => p.type !== "high_entropy_env" && p.type !== "json_credential_key"
+);
 var COMBINED_REGEX = new RegExp(SIMPLE_PATTERNS.map((p) => `(${p.regex.source})`).join("|"), "g");
 var HIGH_ENTROPY_REGEX = PATTERNS.find((p) => p.type === "high_entropy_env").regex;
+var JSON_CREDENTIAL_REGEX = PATTERNS.find((p) => p.type === "json_credential_key").regex;
 var COMBINED_REPLACEMENTS = SIMPLE_PATTERNS.map((p) => `[REDACTED:${p.type}]`);
 var SCRUB_CHUNK_BYTES = 64 * 1024;
 var SCRUB_OVERLAP_BYTES = 1024;
@@ -974,20 +1019,7 @@ var PATTERN_ANCHORS = [
     )
   )
 ];
-var JSON_KEY_ANCHORS = [
-  '"apiKey"',
-  '"api_key"',
-  '"token"',
-  '"secret"',
-  '"password"',
-  '"authorization"',
-  '"bearer"',
-  '"private_key"',
-  '"access_token"',
-  '"refresh_token"',
-  '"client_secret"'
-];
-var ALL_ANCHORS = [...PATTERN_ANCHORS, ...JSON_KEY_ANCHORS];
+var ALL_ANCHORS = PATTERN_ANCHORS;
 function hasCredentialAnchors(text) {
   for (const anchor of ALL_ANCHORS) {
     if (text.includes(anchor)) return true;
@@ -1036,6 +1068,9 @@ var DefaultSecretScrubber = class {
     out = out.replace(HIGH_ENTROPY_REGEX, (_match, lead, key, _value) => {
       return `${lead}${key}=[REDACTED:high_entropy_env]`;
     });
+    out = out.replace(JSON_CREDENTIAL_REGEX, (_match, keyPrefix, _value, closingQuote) => {
+      return `${keyPrefix}[REDACTED:json_credential_key]${closingQuote}`;
+    });
     return out;
   }
   /**
@@ -1198,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",
@@ -1214,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;
@@ -1259,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 {
@@ -1281,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 {
         }
       }
@@ -1298,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();
     }
   }
@@ -1308,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");
@@ -1408,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;
@@ -1512,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();
@@ -1640,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;
@@ -1658,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);
@@ -1781,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 {
@@ -1841,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(() => {
@@ -1865,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 {
     }
   }
@@ -1896,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();