omp-fabric 1.25.28 → 1.25.34

package/dist/compaction/lcm-runtime.js

@@ -57,13 +57,119 @@ import fs2 from "node:fs";
 import path2 from "node:path";
 import crypto from "node:crypto";
 
+// src/storage/lcm-offthread.ts
+import { Worker } from "node:worker_threads";
+var WORKER_SOURCE = String.raw`
+const { parentPort, workerData } = require("node:worker_threads");
+const openReadOnly = (file) => {
+  try {
+    const { DatabaseSync } = require("node:sqlite");
+    return new DatabaseSync(file, { readOnly: true });
+  } catch {}
+  const { Database } = require("bun:sqlite");
+  return new Database(file, { readonly: true });
+};
+let db;
+try {
+  db = openReadOnly(workerData.file);
+} catch (error) {
+  parentPort.postMessage({ unavailable: error instanceof Error ? error.message : String(error) });
+}
+if (db) {
+  try {
+    if (workerData.snapshot) db.exec("BEGIN");
+    const rows = workerData.statements.map((sql) => ({ ...(db.prepare(sql).get() ?? {}) }));
+    if (workerData.snapshot) db.exec("COMMIT");
+    parentPort.postMessage({ rows });
+  } catch (error) {
+    parentPort.postMessage({ error: error instanceof Error ? error.message : String(error) });
+  } finally {
+    try { db.close(); } catch {}
+  }
+}
+`;
+var queryLedgerOffThread = (query) => new Promise((resolve, reject) => {
+  if (query.signal?.aborted) {
+    reject(new Error("ledger closed"));
+    return;
+  }
+  let worker;
+  try {
+    worker = new Worker(WORKER_SOURCE, {
+      eval: true,
+      workerData: { file: query.file, statements: [...query.statements], snapshot: query.snapshot === true }
+    });
+  } catch {
+    resolve(void 0);
+    return;
+  }
+  let settled = false;
+  const finish = (settle) => {
+    if (settled) return;
+    settled = true;
+    query.signal?.removeEventListener("abort", onAbort);
+    void worker.terminate();
+    settle();
+  };
+  const onAbort = () => finish(() => reject(new Error("ledger closed")));
+  query.signal?.addEventListener("abort", onAbort, { once: true });
+  worker.once("message", (message) => {
+    if (message.unavailable !== void 0) finish(() => resolve(void 0));
+    else if (message.error !== void 0) finish(() => reject(new Error(message.error)));
+    else if (Array.isArray(message.rows) && message.rows.length === query.statements.length) finish(() => resolve(message.rows));
+    else finish(() => resolve(void 0));
+  });
+  worker.once("error", () => finish(() => resolve(void 0)));
+  worker.once("exit", () => finish(() => resolve(void 0)));
+});
+
 // src/storage/lcm-directory.ts
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 var DIRECTORY_FILE = "projects.json";
 var DIRECTORY_VERSION = 1;
 var SWEEP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var TEMP_RETENTION_MS = 2 * 24 * 60 * 60 * 1e3;
+var tempRootCandidates = () => {
+  const roots = /* @__PURE__ */ new Set();
+  for (const root of [os.tmpdir(), "/tmp", "/var/tmp"]) {
+    const resolved = path.resolve(root);
+    roots.add(resolved);
+    try {
+      roots.add(fs.realpathSync.native(resolved));
+    } catch {
+    }
+  }
+  return [...roots];
+};
+var isUnderTempRoot = (target) => {
+  const resolved = path.resolve(target);
+  const candidates = /* @__PURE__ */ new Set([resolved]);
+  try {
+    candidates.add(fs.realpathSync.native(resolved));
+  } catch {
+    let probe = resolved;
+    while (true) {
+      const parent = path.dirname(probe);
+      if (parent === probe) break;
+      probe = parent;
+      try {
+        const real = fs.realpathSync.native(probe);
+        candidates.add(path.join(real, path.relative(probe, resolved)));
+        break;
+      } catch {
+      }
+    }
+  }
+  const normalize = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+  const normalized = [...candidates].map(normalize);
+  return tempRootCandidates().some((root) => {
+    const base = normalize(root.endsWith(path.sep) ? root.slice(0, -1) : root);
+    return normalized.some((candidate) => candidate === base || candidate.startsWith(base + path.sep));
+  });
+};
 var empty = () => ({ version: DIRECTORY_VERSION, sweptAt: 0, projects: [] });
 var directoryFile = (rootDir) => path.join(rootDir, DIRECTORY_FILE);
 var read = (rootDir) => {
@@ -112,6 +218,7 @@ var stableProjectKey = (rootDir, identity, now = Date.now()) => {
 var sweepLedgers = (rootDir, options) => {
   const now = options.now ?? Date.now();
   const retentionMs = options.retentionMs ?? RETENTION_MS;
+  const tempRetentionMs = options.tempRetentionMs ?? TEMP_RETENTION_MS;
   const file = read(rootDir);
   if (!options.force && now - file.sweptAt < SWEEP_INTERVAL_MS) return { removed: [], bytes: 0, skipped: true };
   const removed = [];
@@ -123,9 +230,12 @@ var sweepLedgers = (rootDir, options) => {
     try {
       stats = fs.statSync(ledger);
     } catch {
+      if (record2.key !== options.keepKey) continue;
+      kept.push(record2);
       continue;
     }
-    const abandoned = record2.key !== options.keepKey && !fs.existsSync(record2.path) && now - Math.max(stats.mtimeMs, record2.updatedAt) >= retentionMs;
+    const retention = isUnderTempRoot(record2.path) ? tempRetentionMs : retentionMs;
+    const abandoned = record2.key !== options.keepKey && !fs.existsSync(record2.path) && now - Math.max(stats.mtimeMs, record2.updatedAt) >= retention;
     if (!abandoned) {
       kept.push(record2);
       continue;
@@ -260,6 +370,8 @@ var LcmLedger = class {
   closed = false;
   fts = false;
   startupChecksRun = false;
+  startupChecksPending;
+  closing = new AbortController();
   migrations = [];
   constructor(options = {}) {
     this.now = options.now ?? Date.now;
@@ -295,18 +407,36 @@ var LcmLedger = class {
   get startupChecksComplete() {
     return this.startupChecksRun;
   }
+  /** Whole-file scans run on a worker thread so a multi-gigabyte ledger never stalls the host event loop. */
   runStartupChecks() {
-    if (this.startupChecksRun) return;
+    if (this.startupChecksRun) return Promise.resolve();
+    this.startupChecksPending ??= this.checkStartup().finally(() => {
+      this.startupChecksPending = void 0;
+    });
+    return this.startupChecksPending;
+  }
+  async checkStartup() {
     try {
-      this.migrateSchema();
-      const result = this.db.prepare("PRAGMA integrity_check").get();
-      if (result.integrity_check !== "ok") throw new Error(String(result.integrity_check));
+      await this.migrateSchema();
+      const [result] = await this.scan(["PRAGMA integrity_check"]);
+      if (result?.integrity_check !== "ok") throw new Error(String(result?.integrity_check));
     } catch (error) {
       this.degraded = true;
       throw new LedgerDegradedError("ledger startup checks failed", error);
     }
     this.startupChecksRun = true;
   }
+  async scan(statements, snapshot = false) {
+    const offThread = await queryLedgerOffThread({ file: this.dbPath, statements, snapshot, signal: this.closing.signal });
+    if (offThread) return offThread;
+    this.guard();
+    if (snapshot && this.transactionDepth === 0) this.db.exec("BEGIN");
+    try {
+      return statements.map((sql) => ({ ...this.db.prepare(sql).get() ?? {} }));
+    } finally {
+      if (snapshot && this.transactionDepth === 0) this.db.exec("COMMIT");
+    }
+  }
   readRepairLadder(projectKey = this.project.key) {
     return this.readOnly((db) => new Map(db.prepare("SELECT fault,attempts,next_at,detail,updated_at FROM repair_ladder WHERE project_key=?").all(projectKey).map((row) => [row.fault, { attempts: Number(row.attempts), nextAt: Number(row.next_at), detail: row.detail, updatedAt: Number(row.updated_at) }])));
   }
@@ -363,15 +493,16 @@ var LcmLedger = class {
   hasObject(type, name) {
     return this.db.prepare("SELECT 1 FROM sqlite_master WHERE type=? AND name=?").get(type, name) !== void 0;
   }
-  indexOutOfStep() {
+  async indexOutOfStep() {
     if (this.fts !== this.hasObject("table", "raw_entries_fts")) return true;
     if (!this.fts) return false;
     if (!this.hasObject("trigger", "raw_entries_fts_insert")) return true;
-    return Number(this.db.prepare("SELECT count(*) n FROM raw_entries_fts").get().n) !== Number(this.db.prepare("SELECT count(*) n FROM raw_entries").get().n);
+    const [indexed, stored] = await this.scan(["SELECT count(*) n FROM raw_entries_fts", "SELECT count(*) n FROM raw_entries"], true);
+    return Number(indexed?.n) !== Number(stored?.n);
   }
-  migrateSchema() {
+  async migrateSchema() {
     const version = this.schemaVersion();
-    if (version < 2 || this.indexOutOfStep()) this.migrations.push(this.migrateFullTextIndex());
+    if (version < 2 || await this.indexOutOfStep()) this.migrations.push(this.migrateFullTextIndex());
     if (version < 3 || this.db.prepare("PRAGMA foreign_key_list(summary_edges)").all().length === 0) this.migrations.push(this.migrateDerivedForeignKeys());
     if (version !== LEDGER_SCHEMA_VERSION) this.db.prepare("INSERT INTO schema_metadata(key,value) VALUES('version',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(String(LEDGER_SCHEMA_VERSION));
   }
@@ -507,6 +638,20 @@ ALTER TABLE summary_node_revisions_next RENAME TO summary_node_revisions;`);
     const rows = sessionId ? this.db.prepare("SELECT * FROM raw_entries WHERE project_key=? AND session_id=? ORDER BY created_at,revision,rowid").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 toRawEntries(rows);
   }
+  /** The same rows in the same order as readRaw for one session, read in keyset pages that yield between batches. */
+  async readSessionRaw(sessionId, slice) {
+    const entries = [];
+    let cursor;
+    for (; ; ) {
+      this.guard();
+      const rows = cursor ? this.db.prepare("SELECT rowid AS lcm_rowid,* FROM raw_entries WHERE project_key=? AND session_id=? AND (created_at,revision,rowid)>(?,?,?) ORDER BY created_at,revision,rowid LIMIT ?").all(this.project.key, sessionId, cursor.createdAt, cursor.revision, cursor.rowid, LCM_SCAN_BATCH) : this.db.prepare("SELECT rowid AS lcm_rowid,* FROM raw_entries WHERE project_key=? AND session_id=? ORDER BY created_at,revision,rowid LIMIT ?").all(this.project.key, sessionId, LCM_SCAN_BATCH);
+      for (const row of rows) entries.push(toRawEntry(row));
+      const last = rows.at(-1);
+      if (!last || rows.length < LCM_SCAN_BATCH) return entries;
+      cursor = { createdAt: Number(last.created_at), revision: Number(last.revision), rowid: Number(last.lcm_rowid) };
+      await slice.pause();
+    }
+  }
   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();
@@ -729,6 +874,7 @@ ALTER TABLE summary_node_revisions_next RENAME TO summary_node_revisions;`);
   }
   close() {
     if (this.closed) return;
+    this.closing.abort();
     this.db.close();
     this.closed = true;
   }
@@ -738,6 +884,33 @@ ALTER TABLE summary_node_revisions_next RENAME TO summary_node_revisions;`);
 import crypto2 from "node:crypto";
 import fs3 from "node:fs";
 import path3 from "node:path";
+
+// src/core/event-loop-slice.ts
+var EVENT_LOOP_SLICE_MS = 20;
+var yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+var EventLoopSlice = class {
+  constructor(budgetMs = EVENT_LOOP_SLICE_MS) {
+    this.budgetMs = budgetMs;
+  }
+  #started = performance.now();
+  #yields = 0;
+  get due() {
+    return performance.now() - this.#started >= this.budgetMs;
+  }
+  get yields() {
+    return this.#yields;
+  }
+  async yield() {
+    this.#yields += 1;
+    await yieldToEventLoop();
+    this.#started = performance.now();
+  }
+  async pause() {
+    if (this.due) await this.yield();
+  }
+};
+
+// src/storage/lcm-migration.ts
 var plural = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
 var megabytes = (bytes) => `${(bytes / 1024 ** 2).toFixed(1)} MB`;
 var migrationDropReasons = (drops) => {
@@ -879,7 +1052,8 @@ var CHECKPOINT_SCHEMA = "CREATE TABLE IF NOT EXISTS migration_checkpoints (proje
 function reconcileSession(options) {
   return migrateSessions({ ...options, onDemand: true });
 }
-function migrateSessions(options) {
+async function migrateSessions(options) {
+  const slice = options.slice ?? new EventLoopSlice();
   const window = migrationWindow(options);
   const maxFileBytes = positive(options.maxFileBytes, 64 * 1024 ** 2);
   const maxLineBytes = positive(options.maxLineBytes, 8 * 1024 ** 2);
@@ -901,6 +1075,8 @@ function migrateSessions(options) {
   const drops = result.drops;
   const drySeen = /* @__PURE__ */ new Set();
   files: for (const [position, file] of discovery.files.entries()) {
+    await slice.pause();
+    if (options.signal?.aborted) break;
     const read2 = readSource(file, maxFileBytes, maxTotalBytes - result.bytesScanned);
     counts.raced += read2.raced;
     if (read2.kind !== "data") {
@@ -944,6 +1120,8 @@ function migrateSessions(options) {
     let ordinal = 0;
     try {
       for (let start = 0; start < data.length; ) {
+        if (slice.due) await slice.yield();
+        if (options.signal?.aborted) break;
         ordinal++;
         const newline = data.indexOf(10, start);
         const end = newline < 0 ? data.length : newline;
@@ -996,7 +1174,7 @@ function migrateSessions(options) {
             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 } });
-            ledger.runStartupChecks();
+            await ledger.runStartupChecks();
             database = ledger.db;
             database.exec(CHECKPOINT_SCHEMA);
           } else if (options.ledger) database = options.ledger.db;
@@ -1074,6 +1252,8 @@ function migrateSessions(options) {
 import crypto3 from "node:crypto";
 var DEFAULT_LCM_BUDGET = { calls: Number.POSITIVE_INFINITY, inputTokens: Number.POSITIVE_INFINITY, outputTokens: Number.POSITIVE_INFINITY, cost: Number.POSITIVE_INFINITY, wallMs: Number.POSITIVE_INFINITY, sessionCalls: Number.POSITIVE_INFINITY };
 var DEFAULT_LEAF_ENTRIES = 32;
+var NODE_SCAN_LIMIT = 1e5;
+var NODE_PAGE_SIZE = 500;
 var EMPTY_TAINT = /* @__PURE__ */ new Set();
 var DEFAULT_MAINTENANCE_CONCURRENCY = 3;
 var LEASE_MS = 3e4;
@@ -1161,8 +1341,7 @@ var LcmMaintenance = class {
   revisionsOf(nodeId) {
     return this.ledger.readOnly((db) => db.prepare("SELECT revision, text, model_hash, created_at FROM summary_node_revisions WHERE node_id=? AND project_key=? ORDER BY revision").all(nodeId, this.projectKey).map((row) => ({ revision: Number(row.revision), text: row.text, modelHash: row.model_hash, createdAt: Number(row.created_at) })));
   }
-  selectUpgrades(sessionId, activeSources, limit = 1) {
-    const all = this.listNodes(1e5);
+  selectUpgrades(sessionId, activeSources, limit = 1, all = this.listNodes(NODE_SCAN_LIMIT)) {
     const taint = this.tainted(all);
     return all.filter((node) => !taint.has(node.nodeId) && node.state === "ready" && node.modelHash === "emergency" && node.policyHash === this.policyHash && (!sessionId || node.sessionId === sessionId) && (!activeSources || node.sources.every((source) => activeSources.has(this.sourceKey(source))))).sort((left, right) => left.depth - right.depth || left.nodeId.localeCompare(right.nodeId)).slice(0, limit);
   }
@@ -1173,7 +1352,7 @@ var LcmMaintenance = class {
       const order = [];
       while (stack.length > 0) {
         const current = stack.pop();
-        const parents = db.prepare("SELECT e.parent_id FROM summary_edges e JOIN summary_nodes parent ON parent.node_id=e.parent_id WHERE e.child_id=? AND parent.project_key=?").all(current, this.projectKey);
+        const parents = db.prepare("SELECT e.parent_id FROM summary_edges e CROSS JOIN summary_nodes parent ON parent.node_id=e.parent_id WHERE e.child_id=? AND parent.project_key=?").all(current, this.projectKey);
         for (const { parent_id: parent } of parents) {
           if (seen.has(parent)) continue;
           seen.add(parent);
@@ -1204,6 +1383,25 @@ var LcmMaintenance = class {
       return node;
     }));
   }
+  /** The same nodes in the same order as listNodes(NODE_SCAN_LIMIT), read in keyset pages that yield between batches. */
+  async loadNodes(slice) {
+    const nodes = [];
+    let cursor;
+    while (nodes.length < NODE_SCAN_LIMIT) {
+      const limit = Math.min(NODE_PAGE_SIZE, NODE_SCAN_LIMIT - nodes.length);
+      const rows = this.ledger.readOnly((db) => cursor ? db.prepare("SELECT payload,created_at,node_id FROM summary_nodes WHERE project_key=? AND (created_at,node_id)>(?,?) ORDER BY created_at,node_id LIMIT ?").all(this.projectKey, cursor.createdAt, cursor.nodeId, limit) : db.prepare("SELECT payload,created_at,node_id FROM summary_nodes WHERE project_key=? ORDER BY created_at,node_id LIMIT ?").all(this.projectKey, limit));
+      for (const row of rows) {
+        const node = parse(row.payload);
+        if (node.projectKey !== this.projectKey) throw new Error("node project does not match ledger project");
+        nodes.push(node);
+      }
+      const last = rows.at(-1);
+      if (!last || rows.length < limit) break;
+      cursor = { createdAt: last.created_at, nodeId: last.node_id };
+      await slice.pause();
+    }
+    return nodes;
+  }
   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);
@@ -1231,7 +1429,7 @@ var LcmMaintenance = class {
   }
   /** Scoped by the live source set when given; drops a condensed child and a contained node. */
   getFrontier(sessionId, activeSources) {
-    const all = this.listNodes(1e5);
+    const all = this.listNodes(NODE_SCAN_LIMIT);
     const taint = this.tainted(all);
     const nodes = all.filter((n) => !taint.has(n.nodeId) && n.state === "ready" && n.policyHash === this.policyHash && (!sessionId || activeSources !== void 0 || n.sessionId === sessionId) && (!activeSources || n.sources.every((s) => activeSources.has(this.sourceKey(s)))));
     const condensed = new Set(nodes.flatMap((n) => n.children));
@@ -1363,10 +1561,9 @@ var LcmMaintenance = class {
       return next;
     });
   }
-  selectLeaf(entries = this.ledger.readRaw(this.projectKey), activeSources) {
+  selectLeaf(entries = this.ledger.readRaw(this.projectKey), activeSources, all = this.listNodes(NODE_SCAN_LIMIT)) {
     const first = entries[0];
     if (!first) return [];
-    const all = this.listNodes(1e5);
     const taint = this.tainted(all);
     const nodes = all.filter((n) => !taint.has(n.nodeId) && n.state !== "failed" && n.policyHash === this.policyHash && (n.sessionId === first.sessionId || activeSources !== void 0 && n.state === "ready") && (!activeSources || n.sources.every((s) => activeSources.has(this.sourceKey(s)))));
     const covered = new Set(nodes.flatMap((n) => n.sources.map((s) => this.sourceKey(s))));
@@ -1382,12 +1579,11 @@ var LcmMaintenance = class {
     }
     return picked;
   }
-  selectCondensation(sessionId, activeSources) {
-    const all = this.listNodes(1e5);
+  selectCondensation(sessionId, activeSources, all = this.listNodes(NODE_SCAN_LIMIT)) {
     const taint = this.tainted(all);
     const nodes = all.filter((n) => !taint.has(n.nodeId) && n.state === "ready" && n.policyHash === this.policyHash && (!sessionId || n.sessionId === sessionId) && (!activeSources || n.sources.every((s) => activeSources.has(this.sourceKey(s)))));
     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 edges = this.ledger.readOnly((db) => db.prepare("SELECT e.parent_id,e.child_id FROM summary_edges e CROSS JOIN summary_nodes parent ON parent.node_id=e.parent_id AND parent.project_key=? CROSS 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];
@@ -1801,8 +1997,13 @@ var LcmRuntime = class {
   persisted = /* @__PURE__ */ new WeakMap();
   persistedSessionId;
   lastReconciliation;
+  reconciled = false;
+  /** Subagent sessions share the parent's ledger; only the top-level session migrates and maintains it. */
+  owner;
   constructor(context, options = {}) {
     this.context = context;
+    const agent = context.agent;
+    this.owner = agent?.kind !== "sub" && (agent?.depth ?? 0) === 0;
     this.resolveOptions = typeof options === "function" ? options : () => options;
     const initial = this.resolveOptions();
     const recorded = context.sessionManager.getRecordedCwd?.();
@@ -1824,10 +2025,13 @@ var LcmRuntime = class {
     });
   }
   get ready() {
-    return this.ledger.startupChecksComplete;
+    return this.owner && this.reconciled && this.ledger.startupChecksComplete;
   }
   open() {
-    this.ledger.runStartupChecks();
+    return this.owner ? this.ledger.runStartupChecks() : Promise.resolve();
+  }
+  slice() {
+    return new EventLoopSlice(this.options.sliceMs);
   }
   get options() {
     return this.resolveOptions();
@@ -1893,39 +2097,50 @@ var LcmRuntime = class {
     this.frontierCache = void 0;
   }
   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.lastReconciliation = {
-        degraded: result.degraded,
-        errors: result.counts.errors,
-        raced: result.counts.raced,
-        absent: result.counts.absent,
-        drops: result.drops,
-        reasons: migrationDropReasons(result.drops)
-      };
-      const sessionId = this.context.sessionManager.getSessionId();
-      this.refreshActiveSources(sessionId, this.context.sessionManager.getBranch());
+    if (this.closed || !this.owner) return Promise.resolve();
+    return this.enqueueWrite(async () => {
+      try {
+        await this.reconcileSessionFile();
+      } finally {
+        this.reconciled = true;
+      }
+    });
+  }
+  async reconcileSessionFile() {
+    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 = await 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,
+      slice: this.slice(),
+      signal: this.signal
     });
+    if (this.closed) return;
+    this.lastReconciliation = {
+      degraded: result.degraded,
+      errors: result.counts.errors,
+      raced: result.counts.raced,
+      absent: result.counts.absent,
+      drops: result.drops,
+      reasons: migrationDropReasons(result.drops)
+    };
+    const sessionId = this.context.sessionManager.getSessionId();
+    this.refreshActiveSources(sessionId, this.context.sessionManager.getBranch());
   }
   /** Appends only the entries this session has not stored yet; the rest are already addressed. */
   readback() {
-    if (this.closed) return Promise.resolve();
-    return this.enqueueWrite(() => {
+    if (this.closed || !this.owner) return Promise.resolve();
+    return this.enqueueWrite(async () => {
       if (this.closed) return;
+      const slice = this.slice();
       const entries = this.context.sessionManager.getBranch();
       const sessionId = this.context.sessionManager.getSessionId();
       const recorded = this.context.sessionManager.getRecordedCwd?.();
@@ -1936,15 +2151,20 @@ var LcmRuntime = class {
       const active = /* @__PURE__ */ new Set();
       const pending = [];
       for (const entry of entries) {
+        if (slice.due) await slice.yield();
         const payloadJson = canonicalLcmPayload(entry);
         const contentHash = hash(canonicalLcmEntry(entry));
         const known = this.persisted.get(entry);
         if (known?.contentHash === contentHash) active.add(known.key);
         else pending.push({ entry, payloadJson, contentHash });
       }
-      if (pending.length > 0) {
+      for (let next = 0; next < pending.length; ) {
+        if (slice.due) await slice.yield();
+        if (this.closed) return;
+        const first = next;
         this.ledger.transaction(() => {
-          for (const { entry, payloadJson, contentHash } of pending) {
+          for (; next < pending.length && (next === first || !slice.due); next += 1) {
+            const { entry, payloadJson, contentHash } = pending[next];
             const message = entry.type === "message" ? entry.message : void 0;
             const stored = this.ledger.appendRaw({
               projectKey: this.projectKey,
@@ -1976,7 +2196,7 @@ var LcmRuntime = class {
     });
   }
   async syncAndSchedule() {
-    if (this.closed) return;
+    if (this.closed || !this.owner) return;
     const sessionId = this.context.sessionManager.getSessionId();
     if (this.dirty || !this.activeSessionId || this.activeSessionId !== sessionId || this.activeSources.size === 0) {
       await this.readback();
@@ -2022,7 +2242,7 @@ var LcmRuntime = class {
   }
   /** Reclaims ledgers whose project directory is gone; bounded to one sweep a day. */
   sweepLedgers() {
-    if (this.closed) return { removed: [], bytes: 0, skipped: true };
+    if (this.closed || !this.owner) return { removed: [], bytes: 0, skipped: true };
     try {
       return sweepLedgers(this.options.rootDir ?? defaultLedgerRoot(), { keepKey: this.projectKey });
     } catch {
@@ -2070,7 +2290,7 @@ var LcmRuntime = class {
     return this.syncAndSchedule();
   }
   scheduleMaintenance() {
-    if (this.closed) return;
+    if (this.closed || !this.owner) return;
     if (this.maintenanceRunning) {
       this.maintenanceQueued = true;
       return;
@@ -2135,9 +2355,13 @@ var LcmRuntime = class {
     const fanIn = Math.max(2, this.options.maxCondenseChildren ?? 4);
     const passes = Math.max(1, this.options.maxMaintenancePasses ?? 4);
     const runDeadline = Date.now() + Math.max(1, this.options.maintenanceRunSeconds ?? 60) * 1e3;
-    const raw = this.ledger.readRaw(this.projectKey, sessionId).filter(
+    const slice = this.slice();
+    await slice.pause();
+    if (this.closed) return;
+    const raw = (await this.ledger.readSessionRaw(sessionId, slice)).filter(
       (entry) => this.activeSources.has(this.sourceKey(entry))
     );
+    if (this.closed) return;
     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) => {
@@ -2166,6 +2390,8 @@ var LcmRuntime = class {
       let next = 0;
       const worker = async (slot) => {
         while (!this.closed && Date.now() < runDeadline && slot < this.maintenance.concurrencyLimit) {
+          await slice.pause();
+          if (this.closed) return;
           const item = items[next];
           if (!item) return;
           next += 1;
@@ -2188,7 +2414,10 @@ var LcmRuntime = class {
       const leaves = [];
       const seen = /* @__PURE__ */ new Set();
       while (leaves.length < this.maintenance.concurrencyLimit) {
-        const rows = this.maintenance.selectLeaf(raw, this.activeSources);
+        const nodes2 = await this.maintenance.loadNodes(slice);
+        await slice.pause();
+        if (this.closed) return;
+        const rows = this.maintenance.selectLeaf(raw, this.activeSources, nodes2);
         if (rows.length === 0) break;
         const created = this.maintenance.createLeaf(rows);
         const node = created ? this.maintenance.getNode(created.nodeId) : void 0;
@@ -2206,13 +2435,18 @@ var LcmRuntime = class {
           queued.add(job.jobId);
         }
       }
+      await slice.pause();
+      if (this.closed) return;
       const pending = this.actionableJobs(sessionId, passes);
       for (const item of pending) if (!queued.has(item.job.jobId)) {
         queued.add(item.job.jobId);
         batch.push(item);
       }
       await dispatch(batch);
-      const children = this.maintenance.selectCondensation(sessionId, this.activeSources);
+      const nodes = await this.maintenance.loadNodes(slice);
+      await slice.pause();
+      if (this.closed) return;
+      const children = this.maintenance.selectCondensation(sessionId, this.activeSources, nodes);
       if (children.length >= fanIn) {
         const node = this.maintenance.createCondensed(children);
         if (node) {
@@ -2221,7 +2455,10 @@ var LcmRuntime = class {
         }
       }
       if (leaves.length === 0 && pending.length === 0 && children.length < fanIn) {
-        const upgrade = this.maintenance.selectUpgrades(sessionId, this.activeSources, UPGRADE_CANDIDATES).find(fitsBound);
+        const nodes2 = await this.maintenance.loadNodes(slice);
+        await slice.pause();
+        if (this.closed) return;
+        const upgrade = this.maintenance.selectUpgrades(sessionId, this.activeSources, UPGRADE_CANDIDATES, nodes2).find(fitsBound);
         if (!upgrade) break;
         const job = this.maintenance.reopen(upgrade.nodeId);
         await runJob(job, upgrade);