omp-fabric 1.4.4 → 1.5.0

package/dist/compaction/lcm-runtime.js

@@ -0,0 +1,1169 @@
+import {
+  sqliteDriver
+} from "../chunks/chunk-TQQPXV3I.js";
+import {
+  sessionDirNamesForCwd,
+  sessionsDirRoot
+} from "../chunks/chunk-FX3XLQYI.js";
+import "../chunks/chunk-6QBPSZJ5.js";
+import {
+  LcmModelAdapter,
+  buildLcmPrompt,
+  emergencyReduce
+} from "../chunks/chunk-ZDWBTQB6.js";
+import {
+  canonicalLcmPayload,
+  canonicalProjectIdentity,
+  defaultLedgerPath,
+  hash,
+  hashLcmPayload
+} from "../chunks/chunk-KTB4R3E3.js";
+import "../chunks/chunk-3XPR2AZL.js";
+import "../chunks/chunk-4HQDSTHN.js";
+import "../chunks/chunk-T5ZA5YRU.js";
+import "../chunks/chunk-6N4XGAZY.js";
+
+// src/storage/lcm-ledger.ts
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+var LCM_LEDGER_WARNING_BYTES = 8 * 1024 ** 3;
+var LCM_LEDGER_MAINTENANCE_BYTES = 10 * 1024 ** 3;
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS schema_metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS projects (project_key TEXT PRIMARY KEY, identity_json TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS project_aliases (alias TEXT PRIMARY KEY, project_key TEXT NOT NULL REFERENCES projects(project_key));
+CREATE TABLE IF NOT EXISTS sessions (project_key TEXT NOT NULL, session_id TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY(project_key, session_id));
+CREATE TABLE IF NOT EXISTS raw_entries (project_key TEXT NOT NULL, session_id TEXT NOT NULL, entry_id TEXT NOT NULL, revision INTEGER NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, content_hash TEXT NOT NULL, payload_json TEXT NOT NULL, parent_entry_id TEXT, branch TEXT, created_at INTEGER NOT NULL, PRIMARY KEY(project_key, session_id, entry_id, revision), UNIQUE(project_key, session_id, entry_id, content_hash));
+CREATE TABLE IF NOT EXISTS summary_nodes (node_id TEXT PRIMARY KEY, project_key TEXT NOT NULL, payload TEXT NOT NULL, created_at INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS summary_edges (parent_id TEXT NOT NULL, child_id TEXT NOT NULL, PRIMARY KEY(parent_id, child_id));
+CREATE TABLE IF NOT EXISTS frontiers (project_key TEXT NOT NULL, frontier_id TEXT NOT NULL, node_id TEXT NOT NULL, created_at INTEGER NOT NULL, PRIMARY KEY(project_key, frontier_id, node_id));
+CREATE TABLE IF NOT EXISTS maintenance_jobs (job_id TEXT PRIMARY KEY, project_key TEXT NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS maintenance_usage (project_key TEXT NOT NULL, day TEXT NOT NULL, session_id TEXT NOT NULL, calls INTEGER NOT NULL, input_tokens INTEGER NOT NULL, output_tokens INTEGER NOT NULL, cost REAL NOT NULL, wall_ms INTEGER NOT NULL, PRIMARY KEY(project_key,day,session_id));
+CREATE INDEX IF NOT EXISTS raw_entries_lookup ON raw_entries(project_key, session_id, entry_id, revision);
+`;
+var fileHash = (file) => crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+var snapshotHash = (db) => {
+  const digest = crypto.createHash("sha256");
+  for (const [table, order] of [["schema_metadata", "key"], ["projects", "project_key"], ["project_aliases", "alias"], ["sessions", "project_key,session_id"], ["raw_entries", "project_key,session_id,entry_id,revision"], ["summary_nodes", "node_id"], ["summary_edges", "parent_id,child_id"], ["frontiers", "project_key,frontier_id,node_id"], ["maintenance_jobs", "job_id"], ["maintenance_usage", "project_key,day,session_id"]]) {
+    digest.update(`${table}\0`);
+    for (const row of db.prepare(`SELECT * FROM ${table} ORDER BY ${order}`).all()) digest.update(`${JSON.stringify(row)}\0`);
+  }
+  return digest.digest("hex");
+};
+var LedgerDegradedError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "LedgerDegradedError";
+  }
+};
+var LcmLedger = class {
+  db;
+  project;
+  degraded = false;
+  dbPath;
+  now;
+  warningBytes;
+  maintenanceBytes;
+  writeChain = Promise.resolve();
+  transactionDepth = 0;
+  closed = false;
+  constructor(options = {}) {
+    this.now = options.now ?? Date.now;
+    this.warningBytes = options.warningBytes ?? LCM_LEDGER_WARNING_BYTES;
+    this.maintenanceBytes = options.maintenanceBytes ?? LCM_LEDGER_MAINTENANCE_BYTES;
+    if (!Number.isSafeInteger(this.warningBytes) || !Number.isSafeInteger(this.maintenanceBytes) || this.warningBytes < 0 || this.maintenanceBytes < this.warningBytes) {
+      throw new Error("invalid ledger size thresholds");
+    }
+    this.project = canonicalProjectIdentity(options.project ?? { liveCwd: process.cwd() });
+    const dbPath = options.dbPath ?? defaultLedgerPath(options.rootDir, this.project.key);
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    this.dbPath = dbPath;
+    this.db = new (sqliteDriver())(dbPath);
+    try {
+      this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=5000; PRAGMA wal_autocheckpoint=1000;");
+      this.db.exec("BEGIN IMMEDIATE;" + SCHEMA + "INSERT INTO schema_metadata(key,value) VALUES ('version','1') ON CONFLICT(key) DO UPDATE SET value='1'; COMMIT;");
+      const columns = this.db.prepare("PRAGMA table_info(raw_entries)").all();
+      if (!columns.some((column) => column.name === "payload_json")) {
+        if (Number(this.db.prepare("SELECT count(*) n FROM raw_entries").get().n)) throw new Error("raw payloads missing; reimport authoritative session entries");
+        this.db.exec("ALTER TABLE raw_entries ADD COLUMN payload_json TEXT NOT NULL DEFAULT ''");
+      }
+      const result = this.db.prepare("PRAGMA integrity_check").get();
+      if (result.integrity_check !== "ok") throw new Error(String(result.integrity_check));
+      this.registerProject(this.project);
+    } catch (error) {
+      this.degraded = true;
+      throw new LedgerDegradedError("ledger startup failed", error);
+    }
+  }
+  get isDegraded() {
+    return this.degraded;
+  }
+  get operationalState() {
+    if (this.degraded) return "degraded";
+    try {
+      const size = fs.statSync(this.dbPath).size;
+      if (size >= this.maintenanceBytes) return "maintenance";
+      if (size >= this.warningBytes) return "warning";
+    } catch {
+    }
+    return "healthy";
+  }
+  markDegraded(error) {
+    this.degraded = true;
+    return new LedgerDegradedError("ledger is degraded", error);
+  }
+  registerProject(identity) {
+    const now = this.now();
+    this.db.prepare("INSERT INTO projects(project_key,identity_json,created_at,updated_at) VALUES(?,?,?,?) ON CONFLICT(project_key) DO UPDATE SET identity_json=excluded.identity_json,updated_at=excluded.updated_at").run(identity.key, JSON.stringify(identity), now, now);
+    for (const alias of identity.aliases) {
+      const existing = this.db.prepare("SELECT project_key FROM project_aliases WHERE alias=?").get(alias);
+      if (existing && existing.project_key !== identity.key) throw new LedgerDegradedError(`ambiguous project alias: ${alias}`);
+      this.db.prepare("INSERT OR IGNORE INTO project_aliases(alias,project_key) VALUES(?,?)").run(alias, identity.key);
+    }
+  }
+  guard() {
+    if (this.degraded) throw new LedgerDegradedError("ledger is degraded");
+  }
+  assertProjectKey(projectKey) {
+    if (projectKey !== this.project.key) throw new Error("project key does not match ledger project");
+  }
+  async serialize(operation) {
+    const previous = this.writeChain;
+    let release;
+    this.writeChain = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      this.guard();
+      return operation();
+    } finally {
+      release();
+    }
+  }
+  appendRaw(entry) {
+    this.guard();
+    if (entry.projectKey !== this.project.key) throw new Error("entry project does not match ledger project");
+    if (entry.entryId.trim().length === 0) throw new Error("entry ID is required");
+    if (typeof entry.payloadJson !== "string" || !entry.payloadJson.trim()) throw new Error("full payload JSON is required");
+    let payload;
+    try {
+      payload = JSON.parse(entry.payloadJson);
+    } catch {
+      throw new Error("invalid payload JSON");
+    }
+    if (!payload || typeof payload !== "object" || typeof payload.type !== "string" || typeof payload.id !== "string" || payload.id !== entry.entryId) throw new Error("payload must be a full SessionEntry");
+    const payloadJson = canonicalLcmPayload(payload);
+    const contentHash = hashLcmPayload(payload);
+    const ownsTransaction = this.transactionDepth === 0;
+    if (ownsTransaction) this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const existing = this.db.prepare("SELECT revision,created_at FROM raw_entries WHERE project_key=? AND session_id=? AND entry_id=? AND content_hash=?").get(entry.projectKey, entry.sessionId, entry.entryId, contentHash);
+      if (existing) {
+        if (ownsTransaction) this.db.exec("COMMIT");
+        return { ...entry, payloadJson, payloadHash: contentHash, revision: existing.revision, contentHash, createdAt: existing.created_at };
+      }
+      const latest = this.db.prepare("SELECT COALESCE(MAX(revision),0) revision FROM raw_entries WHERE project_key=? AND session_id=? AND entry_id=?").get(entry.projectKey, entry.sessionId, entry.entryId);
+      const revision = latest.revision + 1;
+      const createdAt = entry.createdAt ?? this.now();
+      this.db.prepare("INSERT OR IGNORE INTO sessions(project_key,session_id,created_at) VALUES(?,?,?)").run(entry.projectKey, entry.sessionId, createdAt);
+      this.db.prepare("INSERT INTO raw_entries(project_key,session_id,entry_id,revision,role,content,content_hash,payload_json,parent_entry_id,branch,created_at) VALUES(?,?,?,?,?,?,?,?,?,?,?)").run(entry.projectKey, entry.sessionId, entry.entryId, revision, entry.role, entry.content, contentHash, payloadJson, entry.parentEntryId ?? null, entry.branch ?? null, createdAt);
+      if (ownsTransaction) this.db.exec("COMMIT");
+      return { ...entry, payloadJson, payloadHash: contentHash, revision, contentHash, createdAt };
+    } catch (error) {
+      if (ownsTransaction) this.db.exec("ROLLBACK");
+      const code = error.code;
+      if (code === "ENOSPC" || code === "SQLITE_FULL" || String(error).includes("database or disk is full")) this.degraded = true;
+      throw new LedgerDegradedError("ledger write failed", error);
+    }
+  }
+  readRaw(projectKey = this.project.key, sessionId) {
+    this.guard();
+    this.assertProjectKey(projectKey);
+    const rows = sessionId ? this.db.prepare("SELECT * FROM raw_entries WHERE project_key=? AND session_id=? ORDER BY created_at,revision").all(projectKey, sessionId) : this.db.prepare("SELECT * FROM raw_entries WHERE project_key=? ORDER BY created_at,session_id,entry_id,revision").all(projectKey);
+    return rows.map((row) => ({ projectKey: row.project_key, sessionId: row.session_id, entryId: row.entry_id, revision: row.revision, role: row.role, content: row.content, contentHash: row.content_hash, payloadHash: row.content_hash, payloadJson: row.payload_json, parentEntryId: row.parent_entry_id, branch: row.branch, createdAt: row.created_at }));
+  }
+  readRawPage(projectKey = this.project.key, sessionId, offset = 0, limit = 100) {
+    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1) throw new Error("invalid raw page");
+    this.guard();
+    this.assertProjectKey(projectKey);
+    const rows = sessionId ? this.db.prepare("SELECT * FROM raw_entries WHERE project_key=? AND session_id=? ORDER BY created_at,revision LIMIT ? OFFSET ?").all(projectKey, sessionId, limit, offset) : this.db.prepare("SELECT * FROM raw_entries WHERE project_key=? ORDER BY created_at,session_id,entry_id,revision LIMIT ? OFFSET ?").all(projectKey, limit, offset);
+    return rows.map((row) => ({ projectKey: row.project_key, sessionId: row.session_id, entryId: row.entry_id, revision: row.revision, role: row.role, content: row.content, contentHash: row.content_hash, payloadHash: row.content_hash, payloadJson: row.payload_json, parentEntryId: row.parent_entry_id, branch: row.branch, createdAt: row.created_at }));
+  }
+  readRawEntry(projectKey, sessionId, entryId, revision) {
+    this.guard();
+    this.assertProjectKey(projectKey);
+    const row = this.db.prepare("SELECT * FROM raw_entries WHERE project_key=? AND session_id=? AND entry_id=? AND revision=?").get(projectKey, sessionId, entryId, revision);
+    return row ? { projectKey: row.project_key, sessionId: row.session_id, entryId: row.entry_id, revision: row.revision, role: row.role, content: row.content, contentHash: row.content_hash, payloadHash: row.content_hash, payloadJson: row.payload_json, parentEntryId: row.parent_entry_id, branch: row.branch, createdAt: row.created_at } : void 0;
+  }
+  readOnly(fn) {
+    this.guard();
+    return fn(this.db);
+  }
+  transaction(fn) {
+    this.guard();
+    if (this.transactionDepth > 0) return fn(this.db);
+    this.db.exec("BEGIN IMMEDIATE");
+    this.transactionDepth = 1;
+    try {
+      const result = fn(this.db);
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    } finally {
+      this.transactionDepth = 0;
+    }
+  }
+  checkpoint(mode = "passive") {
+    const row = this.db.prepare(`PRAGMA wal_checkpoint(${mode.toUpperCase()})`).get();
+    const busy = row.busy ?? 0;
+    const logPages = row.log ?? 0;
+    return { mode, busy, logPages, checkpointedPages: row.checkpointed ?? 0, truncated: mode === "truncate" && busy === 0 && logPages === 0 };
+  }
+  backup(destination) {
+    this.guard();
+    return this.serializeSync(() => {
+      const target = path.resolve(destination);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      if (fs.existsSync(target)) throw new Error("backup destination exists");
+      this.db.exec(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
+      fs.chmodSync(target, 384);
+      const copy = new (sqliteDriver())(target);
+      let integrity = "unknown";
+      let backupStateSha256 = "";
+      const rowCounts = {};
+      try {
+        integrity = copy.prepare("PRAGMA integrity_check").get().integrity_check ?? "unknown";
+        for (const table of ["projects", "sessions", "raw_entries", "summary_nodes", "summary_edges", "frontiers", "maintenance_jobs", "maintenance_usage"]) {
+          rowCounts[table] = Number(copy.prepare(`SELECT count(*) n FROM ${table}`).get().n);
+        }
+        backupStateSha256 = snapshotHash(copy);
+      } finally {
+        copy.close();
+      }
+      const manifest = { format: "lcm-ledger-backup", version: 1, source: this.dbPath, destination: target, sourceSha256: fileHash(this.dbPath), backupSha256: fileHash(target), sourceStateSha256: backupStateSha256, rowCounts, integrity, createdAt: this.now() };
+      fs.writeFileSync(`${target}.manifest.json`, JSON.stringify(manifest), { mode: 384 });
+      fs.chmodSync(`${target}.manifest.json`, 384);
+      return manifest;
+    });
+  }
+  exportBackup(destination) {
+    return this.backup(destination);
+  }
+  deleteProject(token2, backupManifest) {
+    this.guard();
+    if (token2.__brand !== "DeleteConfirmationToken" || token2.projectKey !== this.project.key || token2.value !== hash(`delete:${this.project.key}`)) throw new Error("invalid delete confirmation token");
+    const backupDb = fs.existsSync(backupManifest.destination) ? new (sqliteDriver())(backupManifest.destination) : void 0;
+    let backupStateSha256;
+    try {
+      if (backupDb) backupStateSha256 = snapshotHash(backupDb);
+    } finally {
+      backupDb?.close();
+    }
+    if (backupManifest.integrity !== "ok" || backupManifest.source !== this.dbPath || !backupManifest.backupSha256 || backupManifest.backupSha256 !== fileHash(backupManifest.destination) || !backupManifest.sourceStateSha256 || backupManifest.sourceStateSha256 !== backupStateSha256 || backupManifest.sourceSha256 !== fileHash(this.dbPath) || backupManifest.sourceStateSha256 !== snapshotHash(this.db)) throw new Error("backup verification failed");
+    this.transaction((db) => {
+      db.prepare("DELETE FROM summary_edges WHERE parent_id IN (SELECT node_id FROM summary_nodes WHERE project_key=?) OR child_id IN (SELECT node_id FROM summary_nodes WHERE project_key=?)").run(this.project.key, this.project.key);
+      for (const table of ["raw_entries", "sessions", "frontiers", "summary_nodes", "maintenance_jobs", "maintenance_usage"]) db.prepare(`DELETE FROM ${table} WHERE project_key=?`).run(this.project.key);
+      db.prepare("DELETE FROM project_aliases WHERE project_key=?").run(this.project.key);
+      db.prepare("DELETE FROM projects WHERE project_key=?").run(this.project.key);
+    });
+    const integrity = this.db.prepare("PRAGMA integrity_check").get().integrity_check;
+    if (integrity !== "ok") throw new Error(`post-delete integrity failed: ${integrity}`);
+    const audit = { format: "lcm-ledger-delete", version: 1, projectKey: this.project.key, deletedAt: this.now(), integrity, remaining: Number(this.db.prepare("SELECT count(*) n FROM projects WHERE project_key=?").get(this.project.key).n) };
+    fs.writeFileSync(`${backupManifest.destination}.delete-manifest.json`, JSON.stringify(audit), { mode: 384 });
+  }
+  serializeSync(operation) {
+    this.guard();
+    return operation();
+  }
+  close() {
+    if (this.closed) return;
+    this.db.close();
+    this.closed = true;
+  }
+};
+
+// src/storage/lcm-migration.ts
+import crypto2 from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+var hash2 = (data) => crypto2.createHash("sha256").update(data).digest("hex");
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var nonblank = (value) => typeof value === "string" && value.trim().length > 0;
+var utc = (value) => {
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|\+00:00)$/.test(value)) throw new Error("timestamps must be explicit UTC ISO-8601 values");
+  const at = Date.parse(value);
+  const normalized = value.replace("+00:00", "Z").replace(/Z$/, "");
+  if (!Number.isFinite(at) || new Date(at).toISOString().slice(0, 19) !== normalized.slice(0, 19)) throw new Error("invalid UTC timestamp");
+  return at;
+};
+function migrationWindow(options) {
+  const now = options.now ?? Date.now();
+  const since = options.since === void 0 ? now - 72 * 60 * 60 * 1e3 : utc(options.since);
+  const until = options.until === void 0 ? now : utc(options.until);
+  if (!Number.isFinite(since) || !Number.isFinite(until) || since > until) throw new Error("invalid migration window");
+  return { since, until };
+}
+var positive = (value, fallback) => {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result < 1) throw new Error("scan limits must be positive safe integers");
+  return result;
+};
+function discoverMigrationSessions(options) {
+  const maxFiles = positive(options.maxFiles, 1e4);
+  const maxEntries = positive(options.maxDiscoveryEntries, 1e5);
+  const files = /* @__PURE__ */ new Set();
+  let incomplete = 0;
+  let entries = 0;
+  const add = (file) => {
+    if (files.size >= maxFiles && !files.has(path2.resolve(file))) {
+      incomplete++;
+      return;
+    }
+    files.add(path2.resolve(file));
+  };
+  if (options.files) {
+    for (const file of options.files.slice(0, maxFiles)) add(file);
+    if (options.files.length > maxFiles) incomplete++;
+    return { files: [...files].sort(), incomplete };
+  }
+  const list = (dir, visit) => {
+    let handle;
+    try {
+      handle = fs2.opendirSync(dir);
+      let entry;
+      while ((entry = handle.readSync()) !== null) {
+        if (++entries > maxEntries) {
+          incomplete++;
+          break;
+        }
+        visit(entry);
+      }
+    } catch {
+      incomplete++;
+    } finally {
+      handle?.closeSync();
+    }
+  };
+  const scan = (dir) => list(dir, (entry) => {
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) add(path2.join(dir, entry.name));
+    else if (entry.isSymbolicLink() && entry.name.endsWith(".jsonl")) incomplete++;
+  });
+  if (options.candidateDirs) {
+    for (const dir of options.candidateDirs) {
+      if (entries >= maxEntries) {
+        incomplete++;
+        break;
+      }
+      scan(dir);
+    }
+  } else if (options.projectCwd) {
+    const names = sessionDirNamesForCwd(options.projectCwd);
+    let found = false;
+    for (const name of [names.canonical, ...names.legacy]) {
+      const dir = path2.join(sessionsDirRoot(options.agentDir), name);
+      try {
+        if (fs2.statSync(dir).isDirectory()) {
+          found = true;
+          scan(dir);
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") incomplete++;
+      }
+    }
+    if (!found) incomplete++;
+  } else {
+    const root = sessionsDirRoot(options.agentDir);
+    list(root, (entry) => {
+      if (entry.isDirectory()) scan(path2.join(root, entry.name));
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) add(path2.join(root, entry.name));
+      else if (entry.isSymbolicLink()) incomplete++;
+    });
+  }
+  return { files: [...files].sort(), incomplete };
+}
+var CHECKPOINT_SCHEMA = "CREATE TABLE IF NOT EXISTS migration_checkpoints (project_key TEXT NOT NULL, session_path TEXT NOT NULL, source_hash TEXT NOT NULL, line_ordinal INTEGER NOT NULL, entry_id TEXT NOT NULL, content_hash TEXT NOT NULL, PRIMARY KEY(project_key,session_path,source_hash,line_ordinal,entry_id,content_hash))";
+function reconcileSession(options) {
+  return migrateSessions({ ...options, onDemand: true });
+}
+function migrateSessions(options) {
+  const window = migrationWindow(options);
+  const maxFileBytes = positive(options.maxFileBytes, 64 * 1024 ** 2);
+  const maxLineBytes = positive(options.maxLineBytes, 8 * 1024 ** 2);
+  const maxTotalBytes = positive(options.maxTotalBytes, 1024 ** 3);
+  const discovery = discoverMigrationSessions(options);
+  const result = {
+    mode: options.apply ? "apply" : "dry-run",
+    since: new Date(window.since).toISOString(),
+    until: new Date(window.until).toISOString(),
+    counts: { eligible: 0, imported: 0, skippedDuplicate: 0, skippedOutOfWindow: 0, malformed: 0, oversized: 0, incompleteDiscovery: discovery.incomplete, errors: 0 },
+    filesScanned: 0,
+    bytesScanned: 0,
+    generations: [],
+    exitCode: 0
+  };
+  const counts = result.counts;
+  const drySeen = /* @__PURE__ */ new Set();
+  for (const file of discovery.files) {
+    let data;
+    let fd;
+    try {
+      fd = fs2.openSync(file, "r");
+      const before = fs2.fstatSync(fd);
+      if (!before.isFile()) {
+        counts.incompleteDiscovery++;
+        continue;
+      }
+      if (before.size > maxFileBytes) {
+        counts.oversized++;
+        continue;
+      }
+      if (result.bytesScanned + before.size > maxTotalBytes) {
+        counts.incompleteDiscovery++;
+        break;
+      }
+      data = Buffer.allocUnsafe(before.size);
+      let offset = 0;
+      while (offset < data.length) {
+        const size = fs2.readSync(fd, data, offset, data.length - offset, offset);
+        if (size === 0) throw new Error("source shortened during read");
+        offset += size;
+      }
+      const after = fs2.fstatSync(fd);
+      if (after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs) throw new Error("source changed during read");
+    } catch {
+      counts.errors++;
+      counts.incompleteDiscovery++;
+      continue;
+    } finally {
+      if (fd !== void 0) fs2.closeSync(fd);
+    }
+    result.filesScanned++;
+    result.bytesScanned += data.length;
+    const sourceHash = hash2(data);
+    result.generations.push({ sessionPath: file, sourceHash });
+    let header;
+    let ledger;
+    let database;
+    let sessionId = "";
+    let projectKey = "";
+    let cwd;
+    let ordinal = 0;
+    try {
+      for (let start = 0; start < data.length; ) {
+        ordinal++;
+        const newline = data.indexOf(10, start);
+        const end = newline < 0 ? data.length : newline;
+        const bytes = data.subarray(start, end);
+        start = newline < 0 ? data.length : end + 1;
+        if (bytes.length > maxLineBytes) {
+          counts.oversized++;
+          continue;
+        }
+        const content = bytes.toString("utf8").replace(/\r$/, "");
+        if (!content.trim()) continue;
+        let row;
+        try {
+          row = record(JSON.parse(content));
+        } catch {
+          counts.malformed++;
+          continue;
+        }
+        if (!row) {
+          counts.malformed++;
+          continue;
+        }
+        if (row.type === "message_end") continue;
+        if (!header) {
+          if (row.type !== "session") {
+            if (record(row.message)) counts.malformed++;
+            continue;
+          }
+          if (!nonblank(row.id)) {
+            counts.malformed++;
+            break;
+          }
+          header = row;
+          sessionId = row.id;
+          cwd = nonblank(row.cwd) ? row.cwd : options.liveCwd;
+          if (!cwd) {
+            counts.malformed++;
+            break;
+          }
+          const projectInput = options.liveCwd ? { recordedCwd: cwd, liveCwd: options.liveCwd } : { recordedCwd: cwd };
+          projectKey = canonicalProjectIdentity(projectInput).key;
+          if (options.ledger && options.ledger.project.key !== projectKey) {
+            counts.errors++;
+            break;
+          }
+          if (options.apply) {
+            if (options.ledger) ledger = options.ledger;
+            else if (options.ledgerRoot) ledger = new LcmLedger({ rootDir: options.ledgerRoot, project: { recordedCwd: cwd } });
+            else ledger = new LcmLedger({ project: { recordedCwd: cwd } });
+            database = ledger.db;
+            database.exec(CHECKPOINT_SCHEMA);
+          } else if (options.ledger) database = options.ledger.db;
+          else {
+            const dbPath = defaultLedgerPath(options.ledgerRoot, projectKey);
+            if (fs2.existsSync(dbPath)) database = new (sqliteDriver())(dbPath, { readOnly: true });
+          }
+          continue;
+        }
+        if (row.type === "session" || !nonblank(row.type) || !nonblank(row.id) || row.parentId !== null && row.parentId !== void 0 && typeof row.parentId !== "string") {
+          counts.malformed++;
+          continue;
+        }
+        const message = record(row.message);
+        if (row.type === "message" && (!message || !nonblank(message.role))) {
+          counts.malformed++;
+          continue;
+        }
+        let at;
+        try {
+          at = typeof row.timestamp === "string" ? utc(row.timestamp) : NaN;
+        } catch {
+          at = NaN;
+        }
+        if (!Number.isFinite(at)) {
+          counts.malformed++;
+          continue;
+        }
+        if (!options.onDemand && (at < window.since || at > window.until)) {
+          counts.skippedOutOfWindow++;
+          continue;
+        }
+        counts.eligible++;
+        const payloadJson = canonicalLcmPayload(row);
+        const contentHash = hashLcmPayload(row);
+        const identity = JSON.stringify([projectKey, sessionId, row.id, contentHash]);
+        const progress = { projectKey, sessionPath: file, sourceHash, lineOrdinal: ordinal, entryId: row.id, contentHash };
+        const duplicate = drySeen.has(identity) || database?.prepare("SELECT 1 FROM raw_entries WHERE project_key=? AND session_id=? AND entry_id=? AND content_hash=?").get(projectKey, sessionId, row.id, contentHash) !== void 0;
+        if (duplicate) counts.skippedDuplicate++;
+        else if (ledger) {
+          ledger.appendRaw({
+            projectKey,
+            sessionId,
+            entryId: row.id,
+            role: message && typeof message.role === "string" ? message.role : row.type,
+            content,
+            payloadJson,
+            parentEntryId: typeof row.parentId === "string" ? row.parentId : null,
+            branch: typeof row.branch === "string" ? row.branch : typeof row.branchId === "string" ? row.branchId : null,
+            ...cwd ? { recordedCwd: cwd } : {},
+            createdAt: at
+          });
+          counts.imported++;
+        } else if (!duplicate) counts.imported++;
+        drySeen.add(identity);
+        if (ledger) database.prepare("INSERT OR IGNORE INTO migration_checkpoints(project_key,session_path,source_hash,line_ordinal,entry_id,content_hash) VALUES(?,?,?,?,?,?)").run(projectKey, file, sourceHash, ordinal, row.id, contentHash);
+        options.onProgress?.(progress);
+      }
+      if (!header) counts.malformed++;
+    } catch (error) {
+      counts.errors++;
+      if (options.onProgress) throw error;
+    } finally {
+      if (ledger && ledger !== options.ledger) ledger.close();
+      else if (!ledger && database && database !== options.ledger?.db) database.close();
+    }
+  }
+  result.exitCode = counts.errors || counts.malformed || counts.oversized || counts.incompleteDiscovery && !options.allowIncompleteDiscovery ? 1 : 0;
+  return result;
+}
+
+// src/compaction/lcm-maintenance.ts
+import crypto3 from "node:crypto";
+var DEFAULT_LCM_BUDGET = { calls: 32, inputTokens: 2e6, outputTokens: 128e3, cost: Number.POSITIVE_INFINITY, wallMs: 6e4, sessionCalls: 16 };
+var hash3 = (v) => hashLcmPayload(v);
+var parse = (v) => JSON.parse(String(v));
+var rawHash = (e) => e.payloadHash;
+var token = () => crypto3.randomUUID();
+var LcmMaintenance = class {
+  constructor(ledger, options = {}) {
+    this.ledger = ledger;
+    this.projectKey = ledger.project.key;
+    this.now = options.now ?? Date.now;
+    this.ownerId = options.ownerId ?? crypto3.randomUUID();
+    this.policyHash = options.policyHash ?? hash3("lcm-policy-v1");
+    this.maxLeaf = options.maxLeafEntries ?? 8;
+    this.maxChildren = options.maxCondenseChildren ?? 4;
+    this.maxInputChars = options.maxInputChars ?? 48e3;
+    this.maxOutputChars = options.maxOutputChars ?? 4096;
+    this.budget = { ...DEFAULT_LCM_BUDGET, ...options.budget };
+  }
+  projectKey;
+  now;
+  ownerId;
+  policyHash;
+  maxLeaf;
+  maxChildren;
+  maxInputChars;
+  maxOutputChars;
+  budget;
+  listNodes(limit = 100) {
+    return this.ledger.readOnly((db) => db.prepare("SELECT payload FROM summary_nodes WHERE project_key=? ORDER BY created_at,node_id LIMIT ?").all(this.projectKey, limit).map((r) => {
+      const node = parse(r.payload);
+      if (node.projectKey !== this.projectKey) throw new Error("node project does not match ledger project");
+      return node;
+    }));
+  }
+  getNode(nodeId) {
+    return this.ledger.readOnly((db) => {
+      const row = db.prepare("SELECT payload FROM summary_nodes WHERE node_id=? AND project_key=?").get(nodeId, this.projectKey);
+      if (!row?.payload) return void 0;
+      const node = parse(row.payload);
+      if (node.projectKey !== this.projectKey) throw new Error("node project does not match ledger project");
+      return node;
+    });
+  }
+  getFrontier(sessionId, branch, activeSources) {
+    const nodes = this.listNodes(1e5).filter((n) => n.state === "ready" && n.policyHash === this.policyHash && (!sessionId || n.sessionId === sessionId) && (branch === void 0 || n.branch === branch || n.branch === null) && (!activeSources || n.sources.every((s) => activeSources.has(this.sourceKey(s)))));
+    const covered = new Set(nodes.flatMap((n) => n.children));
+    return nodes.filter((n) => !covered.has(n.nodeId));
+  }
+  listJobs(limit = 100) {
+    return this.ledger.readOnly((db) => db.prepare("SELECT payload FROM maintenance_jobs WHERE project_key=? ORDER BY created_at,job_id LIMIT ?").all(this.projectKey, limit).map((r) => {
+      const job = parse(r.payload);
+      if (job.projectKey !== this.projectKey) throw new Error("job project does not match ledger project");
+      return job;
+    }));
+  }
+  selectLeaf(entries = this.ledger.readRaw(this.projectKey), branch) {
+    const first = entries[0];
+    if (!first) return [];
+    const nodes = this.listNodes(1e5).filter((n) => n.state !== "failed" && n.policyHash === this.policyHash && n.sessionId === first.sessionId && (branch === void 0 || n.branch === branch || n.branch === null));
+    const covered = new Set(nodes.flatMap((n) => n.sources.map((s) => this.sourceKey(s))));
+    return entries.filter((e) => e.sessionId === first.sessionId && (branch === void 0 || e.branch === branch || e.branch === null) && !covered.has(this.sourceKey(e))).slice(0, this.maxLeaf);
+  }
+  selectCondensation(sessionId, activeSources, branch) {
+    const nodes = this.listNodes(1e5).filter((n) => n.state === "ready" && n.policyHash === this.policyHash && (!sessionId || n.sessionId === sessionId) && (!activeSources || n.sources.every((s) => activeSources.has(this.sourceKey(s)))) && (branch === void 0 || n.branch === branch || n.branch === null));
+    const eligible = new Set(nodes.map((n) => n.nodeId));
+    const edges = this.ledger.readOnly((db) => db.prepare("SELECT e.parent_id,e.child_id FROM summary_edges e JOIN summary_nodes parent ON parent.node_id=e.parent_id AND parent.project_key=? JOIN summary_nodes child ON child.node_id=e.child_id AND child.project_key=parent.project_key WHERE parent.project_key=?").all(this.projectKey, this.projectKey));
+    const consumed = new Set(edges.filter((e) => eligible.has(e.parent_id)).map((e) => e.child_id));
+    const candidates = nodes.filter((n) => !consumed.has(n.nodeId));
+    const first = candidates[0];
+    if (!first) return [];
+    const depth = Math.min(...candidates.map((n) => n.depth));
+    const sameDepth = candidates.filter((n) => n.depth === depth);
+    if (depth > 0 && sameDepth.length < 2) return [];
+    return candidates.filter((n) => n.projectKey === first.projectKey && n.sessionId === first.sessionId && n.depth === depth).sort((a, b) => a.nodeId.localeCompare(b.nodeId)).slice(0, this.maxChildren);
+  }
+  createLeaf(entries = this.selectLeaf()) {
+    if (!entries.length) return void 0;
+    const branches = new Set(entries.map((entry) => entry.branch).filter((value) => typeof value === "string"));
+    if (branches.size > 1) throw new Error("cross-branch ranges");
+    const branch = [...branches][0] ?? null;
+    const source = entries.map((e, index) => {
+      if (e.projectKey !== this.projectKey) throw new Error("entry project does not match ledger project");
+      const payload = parse(e.payloadJson);
+      if (typeof payload.type !== "string" || !payload.type || payload.id !== e.entryId) throw new Error("invalid raw payload");
+      if (hash3(payload) !== rawHash(e)) throw new Error("payload hash mismatch");
+      return { sessionId: e.sessionId, entryId: e.entryId, revision: e.revision, payloadHash: rawHash(e) };
+    });
+    this.validateSources(source);
+    const node = { nodeId: `leaf:${hash3({ projectKey: this.projectKey, source, branch, policyHash: this.policyHash })}`, projectKey: this.projectKey, sessionId: entries[0].sessionId, branch, kind: "leaf", sources: source, children: [], depth: 0, sourceHash: hash3(source.map((s) => s.payloadHash)), policyHash: this.policyHash, modelHash: "", state: "pending", createdAt: this.now() };
+    this.publish(node);
+    return node;
+  }
+  createCondensed(children = this.selectCondensation()) {
+    if (!children.length) return void 0;
+    if (children.some((c) => c.state !== "ready")) throw new Error("condensation requires ready children");
+    if (new Set(children.map((c) => c.sessionId)).size !== 1 || new Set(children.map((c) => c.depth)).size !== 1) throw new Error("cross-branch ranges");
+    const storedChildren = children.map((child) => this.getNode(child.nodeId));
+    if (storedChildren.some((child) => !child || child.projectKey !== this.projectKey)) throw new Error("child project does not match ledger project");
+    if (storedChildren.some((child, index) => JSON.stringify(child) !== JSON.stringify(children[index]))) throw new Error("child payload changed");
+    const concreteBranches = new Set(storedChildren.map((c) => c.branch).filter((value) => typeof value === "string"));
+    if (concreteBranches.size > 1) throw new Error("cross-branch ranges");
+    const branch = [...concreteBranches][0] ?? null;
+    const source = [...new Map(storedChildren.flatMap((c) => c.sources).map((value) => [this.sourceKey(value), value])).values()];
+    this.validateSources(source);
+    const node = { nodeId: `condensed:${hash3({ projectKey: this.projectKey, children: storedChildren.map((c) => c.nodeId), branch, policyHash: this.policyHash })}`, projectKey: this.projectKey, sessionId: children[0].sessionId, branch, kind: "condensed", sources: source, children: children.map((c) => c.nodeId), depth: Math.max(...children.map((c) => c.depth)) + 1, sourceHash: hash3(children.map((c) => c.sourceHash)), policyHash: this.policyHash, modelHash: "", state: "pending", createdAt: this.now() };
+    this.publish(node);
+    return node;
+  }
+  validateSources(source) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const s of source) {
+      if (seen.has(this.sourceKey(s))) throw new Error("duplicate source identity");
+      seen.add(this.sourceKey(s));
+    }
+    if (new Set(source.map((s) => s.sessionId)).size !== 1) throw new Error("cross-session ranges");
+  }
+  sourceKey(source) {
+    return `${source.sessionId}:${source.entryId}:${source.revision}`;
+  }
+  publish(node) {
+    this.ledger.transaction((db) => {
+      if (node.children.includes(node.nodeId)) throw new Error("cycle");
+      for (const child of node.children) if (!db.prepare("SELECT 1 FROM summary_nodes WHERE node_id=? AND project_key=?").get(child, this.projectKey)) throw new Error("missing child");
+      db.prepare("INSERT OR IGNORE INTO summary_nodes(node_id,project_key,payload,created_at) VALUES(?,?,?,?)").run(node.nodeId, this.projectKey, JSON.stringify(node), node.createdAt);
+      for (const child of node.children) db.prepare("INSERT OR IGNORE INTO summary_edges(parent_id,child_id) VALUES(?,?)").run(node.nodeId, child);
+      const job = this.job(node);
+      db.prepare("INSERT OR IGNORE INTO maintenance_jobs(job_id,project_key,status,payload,created_at,updated_at) VALUES(?,?,?,?,?,?)").run(job.jobId, this.projectKey, job.state, JSON.stringify(job), job.createdAt, job.updatedAt);
+    });
+  }
+  job(node) {
+    const t = this.now();
+    return { jobId: `job:${node.nodeId}`, projectKey: this.projectKey, nodeId: node.nodeId, priority: node.kind === "condensed" ? 20 : 10, eligibleAt: t, state: "pending", attempts: 0, nextRetryAt: t, createdAt: t, updatedAt: t };
+  }
+  claim(jobId, ownerId = this.ownerId) {
+    return this.ledger.transaction((db) => {
+      const row = db.prepare("SELECT payload FROM maintenance_jobs WHERE job_id=? AND project_key=?").get(jobId, this.projectKey);
+      if (!row?.payload) throw new Error("job not found");
+      const old = parse(row.payload);
+      if (old.projectKey !== this.projectKey) throw new Error("job project does not match ledger project");
+      const t = this.now();
+      const expired = old.state === "running" && (old.leaseUntil ?? 0) <= t;
+      if (old.state === "running" && !expired) throw new Error("job lease held");
+      if (old.state !== "pending" && !expired || old.eligibleAt > t || old.nextRetryAt > t) throw new Error("job not eligible");
+      const active = db.prepare("SELECT payload FROM maintenance_jobs WHERE project_key=? AND status=?").all(this.projectKey, "running").map((r) => parse(r.payload)).filter((j) => j.jobId !== old.jobId && (j.leaseUntil ?? 0) > t);
+      if (active.length) throw new Error("project lease held");
+      const nodeRow = db.prepare("SELECT payload FROM summary_nodes WHERE node_id=? AND project_key=?").get(old.nodeId, this.projectKey);
+      const sessionId = nodeRow?.payload ? parse(nodeRow.payload).sessionId : "";
+      const day = this.day(t);
+      const projectUsage = this.usage(db, day);
+      const sessionUsage = this.usage(db, day, sessionId);
+      if (projectUsage.calls >= this.budget.calls || projectUsage.inputTokens >= this.budget.inputTokens || projectUsage.outputTokens >= this.budget.outputTokens || projectUsage.cost >= this.budget.cost || projectUsage.wallMs >= this.budget.wallMs || sessionUsage.calls >= this.budget.sessionCalls) throw new Error("budget exhausted");
+      const out = { ...old, state: "running", ownerId, leaseToken: token(), leaseUntil: t + 3e4, updatedAt: t };
+      db.prepare("UPDATE maintenance_jobs SET status=?,payload=?,updated_at=? WHERE job_id=? AND project_key=?").run(out.state, JSON.stringify(out), t, jobId, this.projectKey);
+      return out;
+    });
+  }
+  claimEmergency(jobId, ownerId = this.ownerId) {
+    return this.ledger.transaction((db) => {
+      const row = db.prepare("SELECT payload FROM maintenance_jobs WHERE job_id=? AND project_key=?").get(jobId, this.projectKey);
+      if (!row?.payload) throw new Error("job not found");
+      const old = parse(row.payload);
+      if (old.projectKey !== this.projectKey) throw new Error("job project does not match ledger project");
+      const t = this.now();
+      const expired = old.state === "running" && (old.leaseUntil ?? 0) <= t;
+      if (old.state === "running" && !expired) throw new Error("job lease held");
+      if (old.state === "completed") throw new Error("job already completed");
+      const out = { ...old, state: "running", ownerId, leaseToken: token(), leaseUntil: t + 3e4, updatedAt: t };
+      db.prepare("UPDATE maintenance_jobs SET status=?,payload=?,updated_at=? WHERE job_id=? AND project_key=?").run(out.state, JSON.stringify(out), t, jobId, this.projectKey);
+      return out;
+    });
+  }
+  renew(job) {
+    return this.fenced(job, (old) => ({ ...old, leaseUntil: this.now() + 3e4, updatedAt: this.now() }));
+  }
+  validateText(text) {
+    if (typeof text !== "string" || text.length === 0) throw new Error("invalid summary text");
+    let length = 0;
+    for (const _ of text) {
+      length += 1;
+      if (length > this.maxOutputChars) throw new Error("summary exceeds output bound");
+    }
+  }
+  complete(job, result) {
+    this.validateText(result.text);
+    return this.ledger.transaction((db) => {
+      const current = this.readJob(db, job.jobId);
+      this.assertLease(current, job);
+      if (current.nodeId !== job.nodeId) throw new Error("job node mismatch");
+      const row = db.prepare("SELECT payload FROM summary_nodes WHERE node_id=? AND project_key=?").get(job.nodeId, this.projectKey);
+      if (!row?.payload) throw new Error("node not found");
+      const node = parse(row.payload);
+      if (node.projectKey !== this.projectKey || node.nodeId !== current.nodeId) throw new Error("node project does not match ledger project");
+      for (const source of node.sources) {
+        const raw = db.prepare("SELECT payload_json,session_id FROM raw_entries WHERE project_key=? AND session_id=? AND entry_id=? AND revision=?").get(this.projectKey, source.sessionId, source.entryId, source.revision);
+        if (!raw?.payload_json || hash3(parse(raw.payload_json)) !== source.payloadHash || raw.session_id !== source.sessionId) throw new Error("stale source");
+      }
+      if (![result.inputTokens, result.outputTokens, result.cost, result.wallMs].every((value) => Number.isFinite(value) && value >= 0)) throw new Error("invalid model usage");
+      const projectUsage = this.usage(db, this.day(this.now()));
+      const sessionUsage = this.usage(db, this.day(this.now()), node.sessionId);
+      if (projectUsage.calls + 1 > this.budget.calls || projectUsage.inputTokens + result.inputTokens > this.budget.inputTokens || projectUsage.outputTokens + result.outputTokens > this.budget.outputTokens || projectUsage.cost + result.cost > this.budget.cost || projectUsage.wallMs + result.wallMs > this.budget.wallMs || sessionUsage.calls + 1 > this.budget.sessionCalls) throw new Error("budget exhausted");
+      const out = { ...node, state: "ready", text: result.text, modelHash: result.modelHash };
+      this.account(db, node.sessionId, result);
+      db.prepare("UPDATE summary_nodes SET payload=? WHERE node_id=? AND project_key=?").run(JSON.stringify(out), node.nodeId, this.projectKey);
+      const { ownerId: _ownerId, leaseToken: _leaseToken, leaseUntil: _leaseUntil, ...base } = current;
+      const done = { ...base, state: "completed", updatedAt: this.now() };
+      db.prepare("UPDATE maintenance_jobs SET status=?,payload=?,updated_at=? WHERE job_id=? AND project_key=?").run(done.state, JSON.stringify(done), done.updatedAt, done.jobId, this.projectKey);
+      return out;
+    });
+  }
+  completeEmergency(job, text) {
+    this.validateText(text);
+    return this.ledger.transaction((db) => {
+      const current = this.readJob(db, job.jobId);
+      this.assertLease(current, job);
+      if (current.nodeId !== job.nodeId) throw new Error("job node mismatch");
+      const row = db.prepare("SELECT payload FROM summary_nodes WHERE node_id=? AND project_key=?").get(job.nodeId, this.projectKey);
+      if (!row?.payload) throw new Error("node not found");
+      const node = parse(row.payload);
+      if (node.projectKey !== this.projectKey || node.nodeId !== current.nodeId) throw new Error("node project does not match ledger project");
+      for (const source of node.sources) {
+        const raw = db.prepare("SELECT payload_json,session_id FROM raw_entries WHERE project_key=? AND session_id=? AND entry_id=? AND revision=?").get(this.projectKey, source.sessionId, source.entryId, source.revision);
+        if (!raw?.payload_json || hash3(parse(raw.payload_json)) !== source.payloadHash || raw.session_id !== source.sessionId) throw new Error("stale source");
+      }
+      const out = { ...node, state: "ready", text, modelHash: "emergency" };
+      db.prepare("UPDATE summary_nodes SET payload=? WHERE node_id=? AND project_key=?").run(JSON.stringify(out), node.nodeId, this.projectKey);
+      const { ownerId: _ownerId, leaseToken: _leaseToken, leaseUntil: _leaseUntil, ...base } = current;
+      const done = { ...base, state: "completed", updatedAt: this.now() };
+      db.prepare("UPDATE maintenance_jobs SET status=?,payload=?,updated_at=? WHERE job_id=? AND project_key=?").run(done.state, JSON.stringify(done), done.updatedAt, done.jobId, this.projectKey);
+      return out;
+    });
+  }
+  fail(job, error) {
+    return this.fenced(job, (old) => {
+      const attempts = old.attempts + 1;
+      const delay = Math.min(9e5, 3e4 * 2 ** (attempts - 1));
+      const { ownerId: _ownerId, leaseToken: _leaseToken, leaseUntil: _leaseUntil, ...base } = old;
+      return { ...base, attempts, error, state: attempts >= 3 ? "failed" : "pending", eligibleAt: this.now() + delay, nextRetryAt: this.now() + delay, updatedAt: this.now() };
+    });
+  }
+  async run(job, model, input, signal = new AbortController().signal) {
+    let sources = [];
+    let claimed;
+    const controller = new AbortController();
+    let renew;
+    const timer = setTimeout(() => controller.abort(), 6e4);
+    const abort = () => controller.abort();
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      claimed = this.claim(job.jobId, job.ownerId ?? this.ownerId);
+      const node = this.getNode(claimed.nodeId);
+      sources = node?.sources ?? [];
+      renew = setInterval(() => {
+        try {
+          if (claimed) claimed = this.renew(claimed);
+        } catch {
+        }
+      }, 1e4);
+      const result = await Promise.race([model.generate({ prompt: buildLcmPrompt(node?.kind ?? "leaf", input, this.maxInputChars), sessionId: node?.sessionId ?? "", signal: controller.signal }), new Promise((_, reject) => controller.signal.addEventListener("abort", () => reject(new Error("LCM timeout")), { once: true }))]);
+      return this.complete(claimed, result);
+    } catch (error) {
+      if (!claimed) throw error;
+      const fallback = emergencyReduce(input, this.maxOutputChars, sources);
+      try {
+        return this.completeEmergency(claimed, fallback);
+      } catch {
+        try {
+          this.fail(claimed, String(error));
+        } catch {
+        }
+        throw error;
+      }
+    } finally {
+      clearTimeout(timer);
+      if (renew) clearInterval(renew);
+      signal.removeEventListener("abort", abort);
+    }
+  }
+  day(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+  }
+  usage(db, day, sessionId) {
+    const q = sessionId === void 0 ? "SELECT COALESCE(SUM(calls),0) calls,COALESCE(SUM(input_tokens),0) inputTokens,COALESCE(SUM(output_tokens),0) outputTokens,COALESCE(SUM(cost),0) cost,COALESCE(SUM(wall_ms),0) wallMs FROM maintenance_usage WHERE project_key=? AND day=?" : "SELECT COALESCE(SUM(calls),0) calls,COALESCE(SUM(input_tokens),0) inputTokens,COALESCE(SUM(output_tokens),0) outputTokens,COALESCE(SUM(cost),0) cost,COALESCE(SUM(wall_ms),0) wallMs FROM maintenance_usage WHERE project_key=? AND day=? AND session_id=?";
+    const r = sessionId === void 0 ? db.prepare(q).get(this.projectKey, day) : db.prepare(q).get(this.projectKey, day, sessionId);
+    return r;
+  }
+  account(db, sessionId, result) {
+    const d = this.day(this.now());
+    db.prepare("INSERT INTO maintenance_usage(project_key,day,session_id,calls,input_tokens,output_tokens,cost,wall_ms) VALUES(?,?,?,?,?,?,?,?) ON CONFLICT(project_key,day,session_id) DO UPDATE SET calls=calls+excluded.calls,input_tokens=input_tokens+excluded.input_tokens,output_tokens=output_tokens+excluded.output_tokens,cost=cost+excluded.cost,wall_ms=wall_ms+excluded.wall_ms").run(this.projectKey, d, sessionId, 1, result.inputTokens, result.outputTokens, result.cost, result.wallMs);
+  }
+  readJob(db, id) {
+    const row = db.prepare("SELECT payload FROM maintenance_jobs WHERE job_id=? AND project_key=?").get(id, this.projectKey);
+    if (!row) throw new Error("job not found");
+    const job = parse(row.payload);
+    if (job.projectKey !== this.projectKey) throw new Error("job project does not match ledger project");
+    return job;
+  }
+  assertLease(current, expected) {
+    if (current.ownerId !== expected.ownerId || current.leaseToken !== expected.leaseToken || current.state !== "running" || (current.leaseUntil ?? 0) < this.now()) throw new Error("lease fenced");
+  }
+  fenced(job, update) {
+    return this.ledger.transaction((db) => {
+      const old = this.readJob(db, job.jobId);
+      this.assertLease(old, job);
+      const out = update(old);
+      db.prepare("UPDATE maintenance_jobs SET status=?,payload=?,updated_at=? WHERE job_id=? AND project_key=?").run(out.state, JSON.stringify(out), out.updatedAt, out.jobId, this.projectKey);
+      return out;
+    });
+  }
+};
+
+// src/compaction/lcm-runtime.ts
+var LcmRuntime = class {
+  ledger;
+  maintenance;
+  context;
+  resolveOptions;
+  abort = new AbortController();
+  writePending = Promise.resolve();
+  maintenancePending = Promise.resolve();
+  closed = false;
+  dirty = false;
+  degradedError;
+  activeSources = /* @__PURE__ */ new Set();
+  activeSessionId;
+  constructor(context, options = {}) {
+    this.context = context;
+    this.resolveOptions = typeof options === "function" ? options : () => options;
+    const initial = this.resolveOptions();
+    const recorded = context.sessionManager.getRecordedCwd?.();
+    const liveCwd = recorded || context.cwd;
+    const project = canonicalProjectIdentity({ liveCwd });
+    const ledgerOptions = initial.rootDir === void 0 ? { project: { liveCwd: project.canonicalPath ?? liveCwd } } : { rootDir: initial.rootDir, project: { liveCwd: project.canonicalPath ?? liveCwd } };
+    this.ledger = new LcmLedger(ledgerOptions);
+    this.maintenance = new LcmMaintenance(this.ledger, {
+      ...initial,
+      ...initial.lcmMaxInputChars === void 0 ? {} : { maxInputChars: initial.lcmMaxInputChars },
+      ...initial.lcmMaxOutputChars === void 0 ? {} : { maxOutputChars: initial.lcmMaxOutputChars }
+    });
+  }
+  get options() {
+    return this.resolveOptions();
+  }
+  get projectKey() {
+    return this.ledger.project.key;
+  }
+  get signal() {
+    return this.abort.signal;
+  }
+  get status() {
+    return this.degradedError === void 0 ? "healthy" : "degraded";
+  }
+  get error() {
+    return this.degradedError;
+  }
+  markDirty() {
+    this.dirty = true;
+  }
+  enqueueWrite(operation) {
+    const run = this.writePending.then(operation);
+    this.writePending = run.catch((error) => {
+      this.degradedError = error;
+    });
+    return run;
+  }
+  refreshActiveSources(sessionId, entries) {
+    const ids = new Set(entries.map((entry) => entry.id));
+    const latest = /* @__PURE__ */ new Map();
+    for (const entry of this.ledger.readRaw(this.projectKey, sessionId)) {
+      if (!ids.has(entry.entryId)) continue;
+      const previous = latest.get(entry.entryId);
+      if (!previous || previous.revision < entry.revision) latest.set(entry.entryId, entry);
+    }
+    this.activeSources = new Set(
+      [...latest.values()].map((entry) => `${entry.sessionId}:${entry.entryId}:${entry.revision}`)
+    );
+    this.activeSessionId = sessionId;
+  }
+  reconcileSelectedSession() {
+    if (this.closed) return Promise.resolve();
+    return this.enqueueWrite(() => {
+      const getSessionFile = this.context.sessionManager.getSessionFile;
+      if (typeof getSessionFile !== "function") return;
+      const sessionFile = getSessionFile.call(this.context.sessionManager);
+      if (!sessionFile) return;
+      const recorded = this.context.sessionManager.getRecordedCwd?.();
+      const cwd = recorded || this.context.cwd;
+      const result = reconcileSession({
+        agentDir: this.options.rootDir ?? process.env.PI_CODING_AGENT_DIR ?? `${process.env.HOME ?? "."}/.omp/agent`,
+        ledger: this.ledger,
+        files: [sessionFile],
+        liveCwd: cwd,
+        projectCwd: cwd,
+        apply: true
+      });
+      this.degradedError = result.counts.errors > 0 ? new Error(`LCM session reconciliation reported ${result.counts.errors} error(s)`) : void 0;
+      const sessionId = this.context.sessionManager.getSessionId();
+      this.refreshActiveSources(sessionId, this.context.sessionManager.getBranch());
+    });
+  }
+  readback() {
+    if (this.closed) return Promise.resolve();
+    return this.enqueueWrite(() => {
+      if (this.closed) return;
+      const entries = this.context.sessionManager.getBranch();
+      const sessionId = this.context.sessionManager.getSessionId();
+      const branch = this.context.sessionManager.getLeafId();
+      const recorded = this.context.sessionManager.getRecordedCwd?.();
+      const active = /* @__PURE__ */ new Set();
+      for (const entry of entries) {
+        const payloadJson = canonicalLcmPayload(entry);
+        const message = entry.type === "message" ? entry.message : void 0;
+        const stored = this.ledger.appendRaw({
+          projectKey: this.projectKey,
+          sessionId,
+          entryId: entry.id,
+          role: message?.role ?? entry.type,
+          content: message ? JSON.stringify(message.content ?? "") : payloadJson,
+          payloadJson,
+          parentEntryId: entry.parentId ?? null,
+          branch,
+          ...recorded || this.context.cwd ? { recordedCwd: recorded || this.context.cwd } : {}
+        });
+        active.add(`${sessionId}:${stored.entryId}:${stored.revision}`);
+      }
+      this.activeSources = active;
+      this.activeSessionId = sessionId;
+      this.dirty = false;
+      this.degradedError = void 0;
+    });
+  }
+  async syncAndSchedule() {
+    if (this.closed) return;
+    await this.readback();
+    this.scheduleMaintenance();
+  }
+  maintain() {
+    return this.syncAndSchedule();
+  }
+  scheduleMaintenance() {
+    if (this.closed) return;
+    const run = this.maintenancePending.then(() => this.runMaintenance());
+    this.maintenancePending = run.catch((error) => {
+      this.degradedError = error;
+    });
+  }
+  async runMaintenance() {
+    if (this.closed || !this.activeSessionId || this.activeSources.size === 0) return;
+    let model;
+    try {
+      model = new LcmModelAdapter(this.context, this.options.summaryModel, true, {
+        ...this.options.lcmMaxInputChars === void 0 ? {} : { maxInputChars: this.options.lcmMaxInputChars },
+        ...this.options.lcmMaxOutputTokens === void 0 ? {} : { maxOutputTokens: this.options.lcmMaxOutputTokens },
+        ...this.options.lcmMaxOutputChars === void 0 ? {} : { maxOutputChars: this.options.lcmMaxOutputChars }
+      });
+    } catch (error) {
+      this.degradedError = error;
+      model = { modelHash: "unavailable", generate: async () => {
+        throw error instanceof Error ? error : new Error(String(error));
+      } };
+    }
+    const fanIn = Math.max(2, this.options.maxCondenseChildren ?? 4);
+    const passes = Math.max(1, this.options.maxMaintenancePasses ?? 4);
+    const sessionId = this.activeSessionId;
+    const raw = this.ledger.readRaw(this.projectKey, sessionId).filter(
+      (entry) => this.activeSources.has(`${entry.sessionId}:${entry.entryId}:${entry.revision}`)
+    );
+    const inputFor = (node) => {
+      if (node.kind === "condensed") return node.children.map((id) => this.maintenance.getNode(id)?.text ?? "").filter(Boolean).join("\n\n");
+      return node.sources.map((source) => {
+        const entry = this.ledger.readRawEntry(this.projectKey, source.sessionId, source.entryId, source.revision);
+        if (!entry || entry.payloadHash !== source.payloadHash) throw new Error("stale source");
+        return entry.payloadJson;
+      }).join("\n");
+    };
+    const runJob = async (job, node) => {
+      try {
+        await this.maintenance.run(job, model, inputFor(node), this.signal);
+      } catch {
+      }
+    };
+    for (let pass = 0; pass < passes && !this.closed; pass += 1) {
+      const leafCandidate = this.maintenance.createLeaf(this.maintenance.selectLeaf(raw, this.context.sessionManager.getLeafId()));
+      const leaf = leafCandidate ? this.maintenance.getNode(leafCandidate.nodeId) : void 0;
+      if (leaf?.state === "pending") {
+        const job = this.maintenance.listJobs().find((item) => item.nodeId === leaf.nodeId);
+        if (job) await runJob(job, leaf);
+      }
+      const branch = this.context.sessionManager.getLeafId();
+      const pending = this.maintenance.listJobs().filter((job) => job.state === "pending").flatMap((job) => {
+        const node = this.maintenance.getNode(job.nodeId);
+        if (!node || node.sessionId !== sessionId || branch !== null && node.branch !== branch && node.branch !== null || !node.sources.every((source) => this.activeSources.has(`${source.sessionId}:${source.entryId}:${source.revision}`))) return [];
+        return [{ job, node }];
+      }).slice(0, passes);
+      for (const item of pending) await runJob(item.job, item.node);
+      const children = this.maintenance.selectCondensation(sessionId, this.activeSources, this.context.sessionManager.getLeafId());
+      if (children.length >= fanIn) {
+        const node = this.maintenance.createCondensed(children);
+        if (node) {
+          const job = this.maintenance.listJobs().find((item) => item.nodeId === node.nodeId);
+          if (job) await runJob(job, node);
+        }
+      }
+      if (!leaf && pending.length === 0 && children.length < fanIn) break;
+    }
+  }
+  compact(input) {
+    const persistedEntries = /* @__PURE__ */ new Map();
+    for (const entry of input.branchEntries) {
+      const message = entry.type === "message" ? entry.message : void 0;
+      const payloadJson = canonicalLcmPayload(entry);
+      const stored = this.ledger.appendRaw({
+        projectKey: this.projectKey,
+        sessionId: input.sessionId,
+        entryId: entry.id,
+        role: message?.role ?? entry.type,
+        content: message ? JSON.stringify(message.content ?? "") : payloadJson,
+        payloadJson,
+        parentEntryId: entry.parentId ?? null,
+        branch: input.branch
+      });
+      persistedEntries.set(`${entry.id}:${stored.payloadHash}`, stored);
+    }
+    const firstKeptIndex = input.firstKeptEntryId ? input.branchEntries.findIndex((entry) => entry.id === input.firstKeptEntryId) : input.branchEntries.length;
+    const sourceEntries = input.branchEntries.slice(0, firstKeptIndex < 0 ? input.branchEntries.length : firstKeptIndex);
+    const selectedStored = sourceEntries.map((entry) => {
+      const payloadHash = hashLcmPayload(JSON.parse(canonicalLcmPayload(entry)));
+      const stored = persistedEntries.get(`${entry.id}:${payloadHash}`);
+      if (!stored) throw new Error("compaction source was not persisted");
+      return stored;
+    });
+    const activeSources = new Set(selectedStored.map((entry) => `${entry.sessionId}:${entry.entryId}:${entry.revision}`));
+    const frontier = this.maintenance.getFrontier(input.sessionId, input.branch, activeSources);
+    const coveredSources = new Set(frontier.flatMap((node) => node.sources.map((source) => `${source.sessionId}:${source.entryId}:${source.revision}`)));
+    const summary = frontier.map((node) => node.text ?? "").filter(Boolean).join("\n\n");
+    if (summary && selectedStored.every((entry) => coveredSources.has(`${entry.sessionId}:${entry.entryId}:${entry.revision}`))) return { summary, firstKeptEntryId: input.firstKeptEntryId, tokensBefore: input.tokensBefore, source: "ready-frontier", branch: input.branch };
+    if (selectedStored.length === 0) throw new Error("LCM emergency fallback has no persisted sources");
+    const payloads = sourceEntries.map((entry) => canonicalLcmPayload(entry)).join("\n");
+    const sources = selectedStored.map((stored) => ({ sessionId: stored.sessionId, entryId: stored.entryId, revision: stored.revision, payloadHash: stored.payloadHash }));
+    const fallback = emergencyReduce(payloads, this.options.lcmMaxOutputChars ?? 4096, sources);
+    const leaf = this.maintenance.createLeaf(selectedStored);
+    if (!leaf) throw new Error("LCM emergency fallback node was not created");
+    const persisted = this.maintenance.getNode(leaf.nodeId);
+    if (persisted?.state === "ready") {
+      if (persisted.branch !== input.branch || JSON.stringify(persisted.sources) !== JSON.stringify(sources)) throw new Error("LCM emergency fallback provenance mismatch");
+      if (!persisted.text) throw new Error("LCM emergency fallback text is missing");
+      return { summary: persisted.text, firstKeptEntryId: input.firstKeptEntryId, tokensBefore: input.tokensBefore, source: "emergency", branch: input.branch };
+    }
+    const job = this.maintenance.listJobs().find((item) => item.nodeId === leaf.nodeId);
+    if (!job) throw new Error("LCM emergency fallback job was not created");
+    const completed = this.maintenance.completeEmergency(this.maintenance.claimEmergency(job.jobId), fallback);
+    return { summary: completed.text ?? fallback, firstKeptEntryId: input.firstKeptEntryId, tokensBefore: input.tokensBefore, source: "emergency", branch: input.branch };
+  }
+  memoryContext() {
+    return {
+      ledger: {
+        projectKey: this.projectKey,
+        readRaw: (sessionId) => this.ledger.readRaw(this.projectKey, sessionId),
+        readRawPage: (sessionId, offset, limit) => this.ledger.readRawPage(this.projectKey, sessionId, offset, limit),
+        readRawEntry: (sessionId, entryId, revision) => this.ledger.readRawEntry(this.projectKey, sessionId, entryId, revision)
+      },
+      ...this.activeSessionId === void 0 ? {} : { currentSessionId: this.activeSessionId },
+      summaries: {
+        listNodes: ({ sessionId, branch, limit }) => this.maintenance.getFrontier(sessionId, branch, sessionId === this.activeSessionId ? this.activeSources : void 0).slice(0, limit).map((node) => ({ ...node, text: node.text ?? "", sources: node.sources.map((source) => ({ entryId: source.entryId, revision: source.revision, contentHash: source.payloadHash })) })),
+        getNode: (nodeId) => {
+          const node = this.maintenance.getNode(nodeId);
+          return node ? { ...node, text: node.text ?? "", sources: node.sources.map((source) => ({ entryId: source.entryId, revision: source.revision, contentHash: source.payloadHash })) } : void 0;
+        }
+      },
+      branchForSession: (sessionId) => sessionId === this.activeSessionId ? { branch: this.context.sessionManager.getLeafId(), activeSourceKeys: [...this.activeSources], ready: this.status === "healthy" } : void 0
+    };
+  }
+  frontier(sessionId, branch) {
+    return this.maintenance.getFrontier(sessionId, branch, sessionId === this.activeSessionId ? this.activeSources : void 0);
+  }
+  raw(sessionId) {
+    return this.ledger.readRaw(this.projectKey, sessionId);
+  }
+  async shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    this.abort.abort();
+    await this.writePending.catch(() => void 0);
+    await this.maintenancePending.catch(() => void 0);
+    this.ledger.close();
+  }
+};
+export {
+  LcmRuntime
+};
+//# sourceMappingURL=lcm-runtime.js.map