@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-27QIURLN.js

@@ -0,0 +1,1073 @@
+import {
+  shouldSkipSessionDirectoryEntry
+} from "./chunk-JMULFFLN.js";
+import {
+  SESSION_CATALOG_DEFAULT_LEASE_MS,
+  SESSION_CATALOG_DEFAULT_RESERVATION_MS,
+  SESSION_CATALOG_MAX_AGENTS
+} from "./chunk-AYW5YINX.js";
+import {
+  isSessionTranscriptFileName
+} from "./chunk-5BMIE7QG.js";
+import {
+  loadDatabaseSync
+} from "./chunk-IRUTEHCE.js";
+import {
+  DefaultSecretScrubber
+} from "./chunk-QSTSJOCK.js";
+import {
+  isPidAlive
+} from "./chunk-TRT2HRWZ.js";
+import {
+  atomicWrite
+} from "./chunk-OSGLYW5J.js";
+import {
+  totalUsageTokens
+} from "./chunk-3ECENVHL.js";
+
+// src/session-catalog/session-agents.ts
+function deriveSessionAgents(events) {
+  const rows = /* @__PURE__ */ new Map();
+  const upsert = (agentId) => {
+    let row = rows.get(agentId);
+    if (!row) {
+      row = { agentId, status: "running", interleavedEventCount: 0 };
+      rows.set(agentId, row);
+    }
+    return row;
+  };
+  for (const event of events) {
+    if (event.agentId !== void 0 && event.agentId !== "") {
+      const isLifecycle = event.type === "agent_spawned" || event.type === "agent_session_linked" || event.type === "agent_stopped" || event.type === "agent_error";
+      const row = upsert(event.agentId);
+      if (!isLifecycle) row.interleavedEventCount += 1;
+    }
+    switch (event.type) {
+      case "agent_spawned": {
+        const row = upsert(event.agentId);
+        row.role = event.role;
+        row.spawnedAt ??= event.ts;
+        break;
+      }
+      case "agent_session_linked": {
+        const row = upsert(event.agentId);
+        row.agentSessionId = event.agentSessionId;
+        if (event.transcriptPath !== void 0) row.transcriptPath = event.transcriptPath;
+        if (event.provider !== void 0) row.provider = event.provider;
+        if (event.model !== void 0) row.model = event.model;
+        if (event.parentAgentId !== void 0) row.parentAgentId = event.parentAgentId;
+        row.spawnedAt ??= event.ts;
+        break;
+      }
+      case "agent_stopped": {
+        const row = upsert(event.agentId);
+        row.endedAt = event.ts;
+        if (row.status !== "failed") {
+          row.status = event.reason === "failed" || event.reason === "aborted" ? "failed" : "completed";
+        }
+        if (event.usage !== void 0) row.usage = event.usage;
+        break;
+      }
+      case "agent_error": {
+        const row = upsert(event.agentId);
+        row.status = "failed";
+        row.error = event.error;
+        row.endedAt ??= event.ts;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return [...rows.values()];
+}
+
+// src/session-catalog/store.ts
+import { randomBytes, randomUUID } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/session-catalog/store-rebuild.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/session-catalog/store-schema.ts
+import { createHash, timingSafeEqual } from "node:crypto";
+var SCHEMA_VERSION = 1;
+var MAX_LEASE_MS = 12e4;
+var MAX_RESERVATION_MS = 6e4;
+var MAX_MAINTENANCE_MS = 5 * 6e4;
+var MAX_PAGE = 1e3;
+function hashSecret(secret) {
+  return createHash("sha256").update(secret).digest("hex");
+}
+function secretMatches(secret, expectedHex) {
+  const actual = Buffer.from(hashSecret(secret), "hex");
+  const expected = Buffer.from(expectedHex, "hex");
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function boundedMs(value, fallback, max) {
+  return Math.min(max, Math.max(1e3, Number.isFinite(value) ? Math.floor(value) : fallback));
+}
+function parseJson(value) {
+  return JSON.parse(value);
+}
+function conflict(message) {
+  const error = new Error(message);
+  error.name = "SessionOwnershipConflictError";
+  return error;
+}
+function assertId(value, label = "session id") {
+  if (!value || value.length > 256 || value.includes("\\") || value.startsWith("/") || value.includes("..")) {
+    throw new TypeError(`Invalid ${label}`);
+  }
+}
+function boundPresenceValue(value, depth) {
+  if (typeof value === "string") {
+    return value.length <= 6e3 ? value : `${value.slice(0, 5988)}\u2026[truncated]`;
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= 8) return "[truncated depth]";
+  if (Array.isArray(value)) {
+    return value.slice(0, 64).map((item) => boundPresenceValue(item, depth + 1));
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value).slice(0, 64)) {
+    result[key] = boundPresenceValue(item, depth + 1);
+  }
+  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 TABLE IF NOT EXISTS session_agents (
+      session_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      role TEXT,
+      provider TEXT,
+      model TEXT,
+      agent_session_id TEXT,
+      transcript_path TEXT,
+      parent_agent_id TEXT,
+      spawned_at TEXT,
+      ended_at TEXT,
+      status TEXT NOT NULL,
+      error TEXT,
+      interleaved_event_count INTEGER NOT NULL DEFAULT 0,
+      usage_json TEXT,
+      ordinal INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (session_id, agent_id)
+    );
+    CREATE TABLE IF NOT EXISTS session_agent_index (
+      session_id TEXT PRIMARY KEY,
+      transcript_size INTEGER NOT NULL,
+      transcript_mtime_ms REAL NOT NULL,
+      derived_at TEXT 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 fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (entry.name === "_cas" || entry.name === "_trash") continue;
+        if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
+        visit(path.join(dir, entry.name));
+      } else if (entry.isFile() && entry.name.endsWith(suffix))
+        result.push(path.join(dir, entry.name));
+    }
+  };
+  visit(root);
+  return result;
+}
+function summarizeTranscriptFile(transcriptFilePath, id) {
+  const lines = fs.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;
+  let routedModel;
+  let routedProvider;
+  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 += totalUsageTokens(event.usage);
+      if (event.model) routedModel = event.model;
+      if (event.provider) routedProvider = event.provider;
+    }
+    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: routedModel ?? start.model,
+    provider: routedProvider ?? 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(path.basename(file))
+  );
+  const ids = /* @__PURE__ */ new Set();
+  for (const file of [...summaries, ...transcripts]) {
+    const relative2 = path.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 = fs.existsSync(summaryFile) ? parseJson(fs.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 = fs.existsSync(transcript) ? fs.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 = path2.join(projectDir, "sessions");
+    fs2.mkdirSync(this.sessionsDir, { recursive: true, mode: 448 });
+    this.databasePath = path2.join(this.sessionsDir, "catalog.sqlite");
+    const Database = loadDatabaseSync();
+    this.db = new Database(this.databasePath);
+    try {
+      this.configureDatabase();
+      this.initialize();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!/SQLITE_CORRUPT|SQLITE_NOTADB|database disk image is malformed|file is not a database/i.test(
+        message
+      )) {
+        this.db.close();
+        throw error;
+      }
+      this.db.close();
+      const quarantine = `${this.databasePath}.corrupt-${Date.now()}`;
+      try {
+        fs2.renameSync(this.databasePath, quarantine);
+      } catch {
+      }
+      for (const suffix of ["-wal", "-shm"]) {
+        try {
+          fs2.renameSync(`${this.databasePath}${suffix}`, `${quarantine}${suffix}`);
+        } catch {
+        }
+      }
+      this.db = new Database(this.databasePath);
+      this.configureDatabase();
+      this.initialize();
+    }
+    this.reapExpired();
+    const rowCount = Number(
+      this.db.prepare("SELECT COUNT(*) AS count FROM sessions").get().count
+    );
+    if (rowCount === 0 && walkSessionFiles(this.sessionsDir, ".jsonl").some((file) => !file.endsWith("_index.jsonl"))) {
+      this.rebuildCatalog();
+    }
+  }
+  projectDir;
+  databasePath;
+  sessionsDir;
+  db;
+  scrubber = new DefaultSecretScrubber();
+  configureDatabase() {
+    configureCatalogDatabase(this.db);
+  }
+  close() {
+    this.db.close();
+  }
+  initialize() {
+    initializeCatalogSchema(this.db);
+  }
+  transaction(run) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = run();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  bumpGeneration() {
+    this.db.prepare("UPDATE catalog_meta SET value=CAST(value AS INTEGER)+1 WHERE key='generation'").run();
+    return this.generation();
+  }
+  generation() {
+    const row = this.db.prepare("SELECT value FROM catalog_meta WHERE key='generation'").get();
+    return Number(row.value) || 0;
+  }
+  reapExpired(now = Date.now()) {
+    this.db.prepare("DELETE FROM resume_reservations WHERE expires_at<=?").run(now);
+    this.db.prepare("DELETE FROM maintenance_leases WHERE expires_at<=?").run(now);
+    const rows = this.db.prepare("SELECT * FROM session_leases WHERE lease_expires_at<=?").all(now);
+    for (const row of rows) {
+      if (!isPidAlive(row.owner_pid)) {
+        this.db.prepare("DELETE FROM session_leases WHERE session_id=? AND lease_id=?").run(row.session_id, row.lease_id);
+      } else if (row.status !== "lost") {
+        this.db.prepare("UPDATE session_leases SET status='lost' WHERE session_id=? AND lease_id=?").run(row.session_id, row.lease_id);
+      }
+    }
+  }
+  maintenanceExists(sessionId) {
+    return Boolean(
+      this.db.prepare("SELECT 1 AS yes FROM maintenance_leases WHERE session_id=? AND expires_at>?").get(sessionId, Date.now())
+    );
+  }
+  leaseRow(sessionId) {
+    return this.db.prepare("SELECT * FROM session_leases WHERE session_id=?").get(sessionId);
+  }
+  foreignLiveLease(sessionId, callerPid = process.pid) {
+    const live = this.leaseRow(sessionId);
+    return Boolean(live) && live.owner_pid !== callerPid;
+  }
+  verifyCredential(credential) {
+    assertId(credential.sessionId);
+    const row = this.leaseRow(credential.sessionId);
+    if (!row || row.lease_id !== credential.leaseId || row.owner_instance_id !== credential.ownerInstanceId || !secretMatches(credential.leaseSecret, row.lease_secret_hash)) {
+      throw conflict(`Session ${credential.sessionId} lease proof is invalid or no longer owned`);
+    }
+    return row;
+  }
+  createLease(entry, ownerInstanceId, leaseMs) {
+    assertId(entry.sessionId);
+    if (!ownerInstanceId || ownerInstanceId.length > 256)
+      throw new TypeError("Invalid owner instance id");
+    if (!Number.isSafeInteger(entry.pid) || entry.pid <= 0)
+      throw new TypeError("Invalid owner pid");
+    const now = Date.now();
+    const leaseId = randomUUID();
+    const leaseSecret = randomBytes(32).toString("hex");
+    const expiresAt = now + boundedMs(leaseMs, SESSION_CATALOG_DEFAULT_LEASE_MS, MAX_LEASE_MS);
+    this.db.prepare(`INSERT INTO session_leases(
+      session_id,lease_id,lease_secret_hash,owner_instance_id,owner_pid,owner_started_at,
+      entry_json,agent_revision,status,last_heartbeat_at,lease_expires_at
+    ) VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(
+      entry.sessionId,
+      leaseId,
+      hashSecret(leaseSecret),
+      ownerInstanceId,
+      entry.pid,
+      entry.startedAt,
+      JSON.stringify(entry),
+      0,
+      entry.status,
+      now,
+      expiresAt
+    );
+    return { sessionId: entry.sessionId, leaseId, leaseSecret, ownerInstanceId, expiresAt };
+  }
+  claimNew(entry, ownerInstanceId, leaseMs) {
+    return this.transaction(() => {
+      this.reapExpired();
+      const existing = this.leaseRow(entry.sessionId);
+      if (existing)
+        throw conflict(
+          `Session ${entry.sessionId} is already open in another running wstack (pid ${existing.owner_pid}).`
+        );
+      if (this.maintenanceExists(entry.sessionId))
+        throw conflict(`Session ${entry.sessionId} is under maintenance`);
+      const reserved = this.db.prepare(
+        "SELECT 1 AS yes FROM resume_reservations WHERE target_session_id=? AND expires_at>?"
+      ).get(entry.sessionId, Date.now());
+      if (reserved) throw conflict(`Session ${entry.sessionId} is reserved for resume`);
+      const credential = this.createLease(entry, ownerInstanceId, leaseMs);
+      this.bumpGeneration();
+      return credential;
+    });
+  }
+  reconnectLease(credential) {
+    return this.transaction(() => {
+      const row = this.verifyCredential(credential);
+      if (row.owner_pid !== process.pid && !isPidAlive(row.owner_pid))
+        throw conflict(`Session ${credential.sessionId} owner process is no longer alive`);
+      const expiresAt = Date.now() + SESSION_CATALOG_DEFAULT_LEASE_MS;
+      this.db.prepare(
+        "UPDATE session_leases SET lease_expires_at=?,last_heartbeat_at=?,status=? WHERE session_id=? AND lease_id=?"
+      ).run(
+        expiresAt,
+        Date.now(),
+        row.status === "lost" ? "idle" : row.status,
+        row.session_id,
+        row.lease_id
+      );
+      return { ...credential, expiresAt };
+    });
+  }
+  reserveResume(targetSessionId, requesterInstanceId, currentSessionId, reservationMs) {
+    assertId(targetSessionId);
+    return this.transaction(() => {
+      this.reapExpired();
+      const live = this.leaseRow(targetSessionId);
+      if (live)
+        throw conflict(
+          `Session ${targetSessionId} is already open in another running wstack (pid ${live.owner_pid}).`
+        );
+      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 && !fs2.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
+        throw new Error(`Session not found: ${targetSessionId}`);
+      const reservationId = randomUUID();
+      const now = Date.now();
+      const expiresAt = now + boundedMs(reservationMs, SESSION_CATALOG_DEFAULT_RESERVATION_MS, MAX_RESERVATION_MS);
+      try {
+        this.db.prepare(
+          "INSERT INTO resume_reservations(reservation_id,target_session_id,requester_instance_id,current_session_id,created_at,expires_at) VALUES (?,?,?,?,?,?)"
+        ).run(
+          reservationId,
+          targetSessionId,
+          requesterInstanceId,
+          currentSessionId ?? null,
+          now,
+          expiresAt
+        );
+      } catch {
+        throw conflict(`Session ${targetSessionId} is already reserved for resume`);
+      }
+      this.bumpGeneration();
+      return { reservationId, targetSessionId, requesterInstanceId, expiresAt };
+    });
+  }
+  activateReservation(reservation, entry, leaseMs) {
+    return this.transaction(() => {
+      this.reapExpired();
+      const row = this.db.prepare("SELECT * FROM resume_reservations WHERE reservation_id=?").get(reservation.reservationId);
+      if (!row || row.target_session_id !== reservation.targetSessionId || row.requester_instance_id !== reservation.requesterInstanceId || row.expires_at <= Date.now())
+        throw conflict("Resume reservation expired or is not owned by this requester");
+      if (entry.sessionId !== row.target_session_id)
+        throw new TypeError("Reservation target and session entry differ");
+      if (this.leaseRow(entry.sessionId) || this.maintenanceExists(entry.sessionId))
+        throw conflict(`Session ${entry.sessionId} can no longer be activated`);
+      const credential = this.createLease(entry, reservation.requesterInstanceId, leaseMs);
+      this.db.prepare("DELETE FROM resume_reservations WHERE reservation_id=?").run(row.reservation_id);
+      this.bumpGeneration();
+      return credential;
+    });
+  }
+  /**
+   * Extend a live reservation the requester still owns.
+   *
+   * Deliberately does NOT call `reapExpired()` first: reaping would delete an
+   * already-expired row and turn the accurate "expired" answer into the
+   * indistinguishable "not owned by this requester". The caller needs to know
+   * which of the two happened.
+   */
+  renewReservation(reservationId, requesterInstanceId, reservationMs) {
+    return this.transaction(() => {
+      const row = this.db.prepare("SELECT * FROM resume_reservations WHERE reservation_id=?").get(reservationId);
+      if (!row || row.requester_instance_id !== requesterInstanceId)
+        throw conflict("Resume reservation is not owned by this requester");
+      if (row.expires_at <= Date.now()) throw conflict("Resume reservation expired");
+      const expiresAt = Date.now() + boundedMs(reservationMs, SESSION_CATALOG_DEFAULT_RESERVATION_MS, MAX_RESERVATION_MS);
+      this.db.prepare("UPDATE resume_reservations SET expires_at=? WHERE reservation_id=?").run(expiresAt, reservationId);
+      return {
+        reservationId,
+        targetSessionId: row.target_session_id,
+        requesterInstanceId,
+        expiresAt
+      };
+    });
+  }
+  cancelReservation(reservationId, requesterInstanceId) {
+    this.db.prepare("DELETE FROM resume_reservations WHERE reservation_id=? AND requester_instance_id=?").run(reservationId, requesterInstanceId);
+  }
+  heartbeat(credential, status) {
+    return this.transaction(() => {
+      const row = this.verifyCredential(credential);
+      const expiresAt = Date.now() + SESSION_CATALOG_DEFAULT_LEASE_MS;
+      const nextStatus = status ?? (row.status === "closing" ? "closing" : row.status === "lost" ? "idle" : row.status);
+      const entry = parseJson(row.entry_json);
+      entry.status = nextStatus;
+      entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.db.prepare(
+        "UPDATE session_leases SET status=?,entry_json=?,last_heartbeat_at=?,lease_expires_at=? WHERE session_id=? AND lease_id=?"
+      ).run(
+        nextStatus,
+        JSON.stringify(entry),
+        Date.now(),
+        expiresAt,
+        row.session_id,
+        row.lease_id
+      );
+      return { ...credential, expiresAt };
+    });
+  }
+  publishAgents(credential, revision, agents) {
+    if (!Number.isSafeInteger(revision) || revision < 0)
+      throw new TypeError("Invalid presence revision");
+    if (!Array.isArray(agents) || agents.length > SESSION_CATALOG_MAX_AGENTS)
+      throw new TypeError(`Agent snapshot exceeds ${SESSION_CATALOG_MAX_AGENTS} agents`);
+    const boundedAgents = boundPresenceValue(
+      this.scrubber.scrubObject(agents),
+      0
+    );
+    const encoded = JSON.stringify(boundedAgents);
+    if (encoded.length > 1024 * 1024) throw new TypeError("Agent snapshot exceeds 1 MiB");
+    return this.transaction(() => {
+      const row = this.verifyCredential(credential);
+      if (revision <= row.agent_revision) return { accepted: false, revision: row.agent_revision };
+      const entry = parseJson(row.entry_json);
+      entry.agents = boundedAgents;
+      entry.agentCount = boundedAgents.length;
+      entry.status = boundedAgents.some((agent) => agent.status !== "idle") ? "active" : "idle";
+      entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.db.prepare(
+        "UPDATE session_leases SET entry_json=?,agent_revision=?,status=?,last_heartbeat_at=? WHERE session_id=? AND lease_id=?"
+      ).run(
+        JSON.stringify(entry),
+        revision,
+        entry.status,
+        Date.now(),
+        row.session_id,
+        row.lease_id
+      );
+      this.bumpGeneration();
+      return { accepted: true, revision };
+    });
+  }
+  markClosing(credential) {
+    const row = this.verifyCredential(credential);
+    const entry = parseJson(row.entry_json);
+    entry.status = "closing";
+    entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(
+      "UPDATE session_leases SET status='closing',entry_json=?,last_heartbeat_at=? WHERE session_id=? AND lease_id=?"
+    ).run(JSON.stringify(entry), Date.now(), row.session_id, row.lease_id);
+    this.bumpGeneration();
+  }
+  release(credential) {
+    this.transaction(() => {
+      const row = this.verifyCredential(credential);
+      this.db.prepare("DELETE FROM session_leases WHERE session_id=? AND lease_id=?").run(row.session_id, row.lease_id);
+      this.bumpGeneration();
+    });
+  }
+  listLive() {
+    this.reapExpired();
+    return this.db.prepare(
+      "SELECT entry_json,status,last_heartbeat_at FROM session_leases ORDER BY last_heartbeat_at DESC"
+    ).all().map((row) => ({
+      ...parseJson(row.entry_json),
+      status: row.status,
+      lastHeartbeatAt: new Date(row.last_heartbeat_at).toISOString()
+    }));
+  }
+  getLive(sessionId) {
+    return this.listLive().find((entry) => entry.sessionId === sessionId) ?? null;
+  }
+  containedPath(relative2) {
+    assertId(relative2.replace(/\.(jsonl|summary\.json)$/, ""), "session path");
+    const root = path2.resolve(this.sessionsDir);
+    const candidate = path2.resolve(root, relative2);
+    const prefix = `${root}${path2.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;
+  }
+  upsertSummary(summary, transcriptRelativePath = `${summary.id}.jsonl`, summaryRelativePath = `${summary.id}.summary.json`) {
+    assertId(summary.id);
+    summary = this.scrubber.scrubObject(summary);
+    const normalizedTranscript = transcriptRelativePath.replaceAll("\\", "/");
+    const normalizedSummary = summaryRelativePath.replaceAll("\\", "/");
+    if (normalizedTranscript !== `${summary.id}.jsonl` || normalizedSummary !== `${summary.id}.summary.json`) {
+      throw new TypeError("Session catalog paths must match the canonical session identity");
+    }
+    transcriptRelativePath = normalizedTranscript;
+    summaryRelativePath = normalizedSummary;
+    const transcript = this.containedPath(transcriptRelativePath);
+    const stat = fs2.existsSync(transcript) ? fs2.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);
+      const revision = (prior?.summary_revision ?? 0) + 1;
+      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) ON CONFLICT(session_id) DO UPDATE SET transcript_relative_path=excluded.transcript_relative_path,summary_relative_path=excluded.summary_relative_path,summary_json=excluded.summary_json,transcript_size=excluded.transcript_size,transcript_mtime_ms=excluded.transcript_mtime_ms,summary_revision=excluded.summary_revision,indexed_at=excluded.indexed_at,damaged=0`).run(
+        summary.id,
+        transcriptRelativePath,
+        summaryRelativePath,
+        JSON.stringify(summary),
+        stat?.size ?? 0,
+        stat?.mtimeMs ?? 0,
+        revision,
+        now
+      );
+      this.bumpGeneration();
+      return {
+        ...summary,
+        transcriptRelativePath,
+        summaryRelativePath,
+        transcriptSize: stat?.size ?? 0,
+        transcriptMtimeMs: stat?.mtimeMs ?? 0,
+        summaryRevision: revision,
+        indexedAt: now,
+        damaged: false
+      };
+    });
+  }
+  catalogRecord(row) {
+    return {
+      ...parseJson(row.summary_json),
+      transcriptRelativePath: row.transcript_relative_path,
+      summaryRelativePath: row.summary_relative_path,
+      transcriptSize: row.transcript_size,
+      transcriptMtimeMs: row.transcript_mtime_ms,
+      summaryRevision: row.summary_revision,
+      indexedAt: row.indexed_at,
+      damaged: row.damaged !== 0
+    };
+  }
+  listCatalog(criteria = {}) {
+    const requestedLimit = criteria.limit ?? 100;
+    if (!Number.isFinite(requestedLimit)) throw new TypeError("Invalid session catalog limit");
+    const bounded = Math.min(MAX_PAGE, Math.max(1, Math.floor(requestedLimit)));
+    const clauses = [];
+    const values = [];
+    const jsonText = (field) => `CASE WHEN json_valid(summary_json) THEN json_extract(summary_json,'$.${field}') END`;
+    const literalLike = (value) => `%${value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+    const search = criteria.search?.trim();
+    if (search) {
+      const pattern = literalLike(search);
+      clauses.push(
+        `(session_id LIKE ? ESCAPE '\\' OR ${jsonText("title")} LIKE ? ESCAPE '\\' OR ${jsonText("name")} LIKE ? ESCAPE '\\')`
+      );
+      values.push(pattern, pattern, pattern);
+    }
+    if (criteria.since) {
+      clauses.push(`${jsonText("startedAt")}>=?`);
+      values.push(criteria.since);
+    }
+    if (criteria.until) {
+      clauses.push(`${jsonText("startedAt")}<=?`);
+      values.push(criteria.until);
+    }
+    if (criteria.provider) {
+      clauses.push(`${jsonText("provider")}=?`);
+      values.push(criteria.provider);
+    }
+    if (criteria.model) {
+      clauses.push(`${jsonText("model")}=?`);
+      values.push(criteria.model);
+    }
+    if (criteria.minTokens !== void 0) {
+      if (!Number.isFinite(criteria.minTokens)) throw new TypeError("Invalid minimum token count");
+      clauses.push(`CAST(COALESCE(${jsonText("tokenTotal")},0) AS REAL)>=?`);
+      values.push(criteria.minTokens);
+    }
+    if (criteria.titleContains) {
+      clauses.push(`${jsonText("title")} LIKE ? ESCAPE '\\'`);
+      values.push(literalLike(criteria.titleContains.toLocaleLowerCase()));
+    }
+    const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+    const rows = this.db.prepare(
+      `SELECT * FROM sessions${where} ORDER BY COALESCE(${jsonText("lastActivityAt")},${jsonText("endedAt")},${jsonText("startedAt")}) DESC,${jsonText("startedAt")} DESC,session_id ASC LIMIT ?`
+    ).all(...values, bounded);
+    return rows.map((row) => this.catalogRecord(row));
+  }
+  getSummary(sessionId) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE session_id=?").get(sessionId);
+    return row ? this.catalogRecord(row) : null;
+  }
+  /**
+   * The agent roster of one session, derived from its journal.
+   *
+   * Cached in `session_agents`, keyed to the transcript's size and mtime: the
+   * journal is the authority, so the cache is a memo of a pure function over
+   * it rather than a second place agents get recorded. When the file has grown
+   * (the usual case — a live session) the rows are re-derived from scratch, so
+   * a partial read can never leave a half-updated roster behind.
+   *
+   * Returns `[]` for a session with no transcript on disk. A caller cannot
+   * distinguish that from "a real session that spawned nothing", and should
+   * not need to: both mean there is no agent to show.
+   */
+  listSessionAgents(sessionId) {
+    assertId(sessionId);
+    const summary = this.getSummary(sessionId);
+    if (!summary) return [];
+    const file = path2.join(this.sessionsDir, summary.transcriptRelativePath);
+    let stat;
+    try {
+      stat = fs2.statSync(file);
+    } catch {
+      return [];
+    }
+    const cached = this.db.prepare(
+      "SELECT transcript_size, transcript_mtime_ms FROM session_agent_index WHERE session_id=?"
+    ).get(sessionId);
+    if (cached && Number(cached.transcript_size) === stat.size && Number(cached.transcript_mtime_ms) === stat.mtimeMs) {
+      return this.readSessionAgentRows(sessionId);
+    }
+    let raw;
+    try {
+      raw = fs2.readFileSync(file, "utf8");
+    } catch {
+      return [];
+    }
+    const events = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        events.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    const derived = deriveSessionAgents(events);
+    this.writeSessionAgentRows(sessionId, derived, stat.size, stat.mtimeMs);
+    return derived;
+  }
+  readSessionAgentRows(sessionId) {
+    const rows = this.db.prepare("SELECT * FROM session_agents WHERE session_id=? ORDER BY ordinal ASC").all(sessionId);
+    return rows.map((row) => ({
+      agentId: row.agent_id,
+      ...row.role !== null ? { role: row.role } : {},
+      ...row.provider !== null ? { provider: row.provider } : {},
+      ...row.model !== null ? { model: row.model } : {},
+      ...row.agent_session_id !== null ? { agentSessionId: row.agent_session_id } : {},
+      ...row.transcript_path !== null ? { transcriptPath: row.transcript_path } : {},
+      ...row.parent_agent_id !== null ? { parentAgentId: row.parent_agent_id } : {},
+      ...row.spawned_at !== null ? { spawnedAt: row.spawned_at } : {},
+      ...row.ended_at !== null ? { endedAt: row.ended_at } : {},
+      status: row.status,
+      ...row.error !== null ? { error: row.error } : {},
+      interleavedEventCount: Number(row.interleaved_event_count),
+      ...row.usage_json !== null ? { usage: parseJson(row.usage_json) } : {}
+    }));
+  }
+  writeSessionAgentRows(sessionId, records, size, mtimeMs) {
+    this.transaction(() => {
+      this.db.prepare("DELETE FROM session_agents WHERE session_id=?").run(sessionId);
+      const insert = this.db.prepare(
+        `INSERT INTO session_agents(session_id,agent_id,role,provider,model,agent_session_id,transcript_path,parent_agent_id,spawned_at,ended_at,status,error,interleaved_event_count,usage_json,ordinal)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`
+      );
+      records.forEach((record, ordinal) => {
+        insert.run(
+          sessionId,
+          record.agentId,
+          record.role ?? null,
+          record.provider ?? null,
+          record.model ?? null,
+          record.agentSessionId ?? null,
+          record.transcriptPath ?? null,
+          record.parentAgentId ?? null,
+          record.spawnedAt ?? null,
+          record.endedAt ?? null,
+          record.status,
+          record.error ?? null,
+          record.interleavedEventCount,
+          record.usage ? JSON.stringify(record.usage) : null,
+          ordinal
+        );
+      });
+      this.db.prepare(
+        `INSERT INTO session_agent_index(session_id,transcript_size,transcript_mtime_ms,derived_at)
+           VALUES (?,?,?,?) ON CONFLICT(session_id) DO UPDATE SET transcript_size=excluded.transcript_size,transcript_mtime_ms=excluded.transcript_mtime_ms,derived_at=excluded.derived_at`
+      ).run(sessionId, size, mtimeMs, (/* @__PURE__ */ new Date()).toISOString());
+    });
+  }
+  resolveId(query) {
+    const normalized = query.trim();
+    if (!normalized) throw new Error("Session not found: (empty query)");
+    if (this.getSummary(normalized)) return normalized;
+    const rows = this.db.prepare(
+      "SELECT session_id FROM sessions WHERE session_id LIKE ? OR session_id LIKE ? LIMIT 3"
+    ).all(`%/${normalized}`, `${normalized}%`);
+    const ids = [...new Set(rows.map((row) => row.session_id))];
+    if (ids.length === 1) return ids[0];
+    if (ids.length === 0) throw new Error(`Session not found: ${query}`);
+    throw new Error(`Ambiguous session id "${query}": ${ids.join(", ")}`);
+  }
+  async rename(sessionId, name) {
+    const current = this.getSummary(this.resolveId(sessionId));
+    if (!current) throw new Error(`Session not found: ${sessionId}`);
+    const trimmed = name.trim();
+    const summary = { ...current };
+    for (const key of [
+      "transcriptRelativePath",
+      "summaryRelativePath",
+      "transcriptSize",
+      "transcriptMtimeMs",
+      "summaryRevision",
+      "indexedAt",
+      "damaged"
+    ])
+      delete summary[key];
+    const previous = { ...summary };
+    if (trimmed) summary.name = this.scrubber.scrub(trimmed).slice(0, 500);
+    else delete summary.name;
+    const summaryPath = this.containedPath(current.summaryRelativePath);
+    fs2.mkdirSync(path2.dirname(summaryPath), { recursive: true, mode: 448 });
+    await atomicWrite(summaryPath, `${JSON.stringify(summary)}
+`, { mode: 384 });
+    try {
+      return this.upsertSummary(
+        summary,
+        current.transcriptRelativePath,
+        current.summaryRelativePath
+      );
+    } catch (error) {
+      await atomicWrite(summaryPath, `${JSON.stringify(previous)}
+`, { mode: 384 }).catch(
+        () => void 0
+      );
+      throw error;
+    }
+  }
+  acquireMaintenance(sessionId, operation, holderId, leaseMs, holderPid) {
+    assertId(sessionId);
+    return this.transaction(() => {
+      this.reapExpired();
+      const live = this.leaseRow(sessionId);
+      if (live && (operation === "delete" || this.foreignLiveLease(sessionId, holderPid))) {
+        throw conflict(`Session ${sessionId} is live`);
+      }
+      const reservation = this.db.prepare(
+        "SELECT 1 AS yes FROM resume_reservations WHERE target_session_id=? AND expires_at>?"
+      ).get(sessionId, Date.now());
+      if (reservation) throw conflict(`Session ${sessionId} is reserved for resume`);
+      const leaseId = randomUUID();
+      const now = Date.now();
+      const expiresAt = now + boundedMs(leaseMs, 6e4, MAX_MAINTENANCE_MS);
+      try {
+        this.db.prepare(
+          "INSERT INTO maintenance_leases(session_id,operation,holder_id,lease_id,acquired_at,expires_at) VALUES (?,?,?,?,?,?)"
+        ).run(sessionId, operation, holderId, leaseId, now, expiresAt);
+      } catch {
+        throw conflict(`Session ${sessionId} already has maintenance in progress`);
+      }
+      return { sessionId, operation, holderId, leaseId, expiresAt };
+    });
+  }
+  releaseMaintenance(lease) {
+    this.db.prepare("DELETE FROM maintenance_leases WHERE session_id=? AND lease_id=? AND holder_id=?").run(lease.sessionId, lease.leaseId, lease.holderId);
+  }
+  delete(sessionId, lease) {
+    const row = this.db.prepare(
+      "SELECT * FROM maintenance_leases WHERE session_id=? AND lease_id=? AND holder_id=? AND operation=? AND expires_at>?"
+    ).get(sessionId, lease.leaseId, lease.holderId, lease.operation, Date.now());
+    if (!row || lease.operation !== "delete")
+      throw conflict("A valid delete maintenance lease is required");
+    const record = this.getSummary(sessionId);
+    if (!record) throw new Error(`Session not found: ${sessionId}`);
+    const transcript = this.containedPath(record.transcriptRelativePath);
+    const artifacts = [
+      transcript,
+      this.containedPath(record.summaryRelativePath),
+      this.containedPath(`${sessionId}.plan.json`),
+      this.containedPath(`${sessionId}.tasks.json`),
+      this.containedPath(`${sessionId}.todos.json`),
+      path2.join(path2.dirname(transcript), path2.basename(sessionId))
+    ];
+    const trashRoot = path2.join(this.sessionsDir, "_trash", lease.leaseId);
+    fs2.mkdirSync(trashRoot, { recursive: true, mode: 448 });
+    const moved = [];
+    try {
+      artifacts.forEach((artifact, index) => {
+        if (!fs2.existsSync(artifact)) return;
+        const target = path2.join(trashRoot, `${index}-${path2.basename(artifact)}`);
+        fs2.renameSync(artifact, target);
+        moved.push({ from: artifact, to: target });
+      });
+      this.transaction(() => {
+        const current = this.db.prepare(
+          "SELECT 1 AS yes FROM maintenance_leases WHERE session_id=? AND lease_id=? AND holder_id=? AND operation=? AND expires_at>?"
+        ).get(sessionId, lease.leaseId, lease.holderId, "delete", Date.now());
+        if (!current) throw conflict("Delete maintenance lease expired while staging artifacts");
+        this.db.prepare("DELETE FROM sessions WHERE session_id=?").run(sessionId);
+        this.db.prepare("DELETE FROM maintenance_leases WHERE session_id=?").run(sessionId);
+        this.bumpGeneration();
+      });
+    } catch (error) {
+      for (const item of moved.reverse()) {
+        try {
+          fs2.mkdirSync(path2.dirname(item.from), { recursive: true, mode: 448 });
+          fs2.renameSync(item.to, item.from);
+        } catch {
+        }
+      }
+      throw error;
+    }
+    try {
+      fs2.rmSync(trashRoot, { recursive: true, force: true });
+      const trashParent = path2.dirname(trashRoot);
+      if (fs2.readdirSync(trashParent).length === 0) fs2.rmdirSync(trashParent);
+    } catch {
+    }
+  }
+  prune(maxAgeDays, holderId) {
+    if (!Number.isFinite(maxAgeDays) || maxAgeDays < 0) throw new TypeError("Invalid prune age");
+    const cutoff = Date.now() - maxAgeDays * 864e5;
+    const candidates = this.db.prepare("SELECT session_id FROM sessions WHERE transcript_mtime_ms<?").all(cutoff);
+    let deleted = 0;
+    for (const { session_id: id } of candidates) {
+      try {
+        const lease = this.acquireMaintenance(id, "delete", holderId);
+        this.delete(id, lease);
+        deleted++;
+      } catch (error) {
+        if (error.name !== "SessionOwnershipConflictError") throw error;
+      }
+    }
+    return deleted;
+  }
+  rebuildCatalog() {
+    return rebuildCatalogIndex(
+      this.db,
+      this.sessionsDir,
+      (rel) => this.containedPath(rel),
+      (run) => this.transaction(run),
+      () => this.bumpGeneration()
+    );
+  }
+  health(base) {
+    this.reapExpired();
+    const count = (table, where = "") => Number(
+      this.db.prepare(`SELECT COUNT(*) AS count FROM ${table} ${where}`).get().count
+    );
+    const reconciliation = this.db.prepare("SELECT value FROM catalog_meta WHERE key='last_reconciliation'").get();
+    return {
+      ...base,
+      catalogRows: count("sessions"),
+      damagedRows: count("sessions", "WHERE damaged<>0"),
+      liveLeases: count("session_leases"),
+      reservations: count("resume_reservations"),
+      maintenanceLeases: count("maintenance_leases"),
+      generation: this.generation(),
+      ...reconciliation ? { lastReconciliation: reconciliation.value } : {}
+    };
+  }
+};
+
+export {
+  deriveSessionAgents,
+  SessionCatalogStore
+};
+//# sourceMappingURL=chunk-27QIURLN.js.map