omp-fabric 1.3.3 → 1.4.0

package/dist/index.js

@@ -67,7 +67,7 @@ import {
   resolveFabricIdentity,
   settleInPlacePrewalk,
   streamedToolCallName
-} from "./chunks/chunk-VSSC4IDU.js";
+} from "./chunks/chunk-RTDJFHGH.js";
 import "./chunks/chunk-7VIQNUPS.js";
 import {
   AgentTranscriptReader
@@ -76,7 +76,7 @@ import "./chunks/chunk-DLXPTBPL.js";
 import {
   GUEST_TYPE_DECLARATIONS,
   OMP_CORE_COMPATIBILITY_ARGUMENT_TYPE_NAMES
-} from "./chunks/chunk-Z5AP4M6K.js";
+} from "./chunks/chunk-YOAZ5SO7.js";
 import {
   NESTED_TOOL_CALL_ID_PREFIX,
   getActiveRepairCompiler,
@@ -168,7 +168,10 @@ import {
   replaySuccessfulCallsAsync,
   schemaDigest
 } from "./chunks/chunk-4A4MVZQW.js";
-import "./chunks/chunk-FX3XLQYI.js";
+import {
+  sessionDirNamesForCwd,
+  sessionsDirRoot
+} from "./chunks/chunk-FX3XLQYI.js";
 import "./chunks/chunk-6QBPSZJ5.js";
 import {
   FABRIC_COMPONENT_DISCOVER_EVENT,
@@ -186,9 +189,12 @@ import {
   readFabricToolResultProxyDetailsV1
 } from "./chunks/chunk-RBA54WC7.js";
 import {
+  LcmModelAdapter,
   awaitPeerSettle,
-  buildPeerCards
-} from "./chunks/chunk-JOWMM3EX.js";
+  buildLcmPrompt,
+  buildPeerCards,
+  emergencyReduce
+} from "./chunks/chunk-WPU4PKXQ.js";
 import {
   DEFAULT_FABRIC_CONFIG,
   effectiveToolCaptureConfig,
@@ -196,13 +202,20 @@ import {
   loadFabricConfigForScope,
   resolveAgentDir,
   saveFabricConfig
-} from "./chunks/chunk-WZAH7BO2.js";
+} from "./chunks/chunk-2J2GOB4A.js";
 import {
   FABRIC_ACTOR_OMP_HOST_EVENTS
 } from "./chunks/chunk-3LI7YO4M.js";
 import {
   defaultCodePreviewSettings
 } from "./chunks/chunk-JSBTB3P6.js";
+import {
+  LcmLedger,
+  canonicalLcmPayload,
+  canonicalProjectIdentity,
+  defaultLedgerPath,
+  hashLcmPayload
+} from "./chunks/chunk-IY3IQPRQ.js";
 import {
   FABRIC_EXECUTION_GUIDANCE_SLOT,
   MAX_FABRIC_MODEL_GUIDANCE_CONTENT_CHARS,
@@ -221,7 +234,7 @@ import {
   fabricExecTitleHintCached,
   normalizeRunDisplay,
   registerCompactionHook
-} from "./chunks/chunk-ZP3S74LW.js";
+} from "./chunks/chunk-SG4GVSWX.js";
 import {
   fabricWriteBindings
 } from "./chunks/chunk-3J7BKUNG.js";
@@ -263,13 +276,13 @@ var clearTimingInterval = (state) => {
 };
 var ensureTimingInterval = (state, invalidate) => {
   state.codePreviewTimingInterval ??= setInterval(() => {
-    const token = (state.codePreviewTimingOnlyRenderToken ?? 0) + 1;
-    state.codePreviewTimingOnlyRenderToken = token;
+    const token2 = (state.codePreviewTimingOnlyRenderToken ?? 0) + 1;
+    state.codePreviewTimingOnlyRenderToken = token2;
     try {
       invalidate();
     } finally {
       queueMicrotask(() => {
-        if (state.codePreviewTimingOnlyRenderToken === token) {
+        if (state.codePreviewTimingOnlyRenderToken === token2) {
           delete state.codePreviewTimingOnlyRenderToken;
         }
       });
@@ -805,10 +818,10 @@ var extractContentText = (content) => {
 };
 var summarizeLogLine = (entry) => {
   if (typeof entry !== "object" || entry === null) return truncateMiddle(String(entry), 200);
-  const record = entry;
-  const type = typeof record.type === "string" ? record.type : void 0;
-  const tool = typeof record.toolName === "string" ? record.toolName : void 0;
-  const msg = record.message;
+  const record2 = entry;
+  const type = typeof record2.type === "string" ? record2.type : void 0;
+  const tool = typeof record2.toolName === "string" ? record2.toolName : void 0;
+  const msg = record2.message;
   if (typeof msg === "object" && msg !== null && !Array.isArray(msg)) {
     const m = msg;
     const role = typeof m.role === "string" ? m.role : "message";
@@ -820,13 +833,13 @@ var summarizeLogLine = (entry) => {
   if (type) {
     const bits = [type];
     if (tool) bits.push(tool);
-    const model = typeof record.modelId === "string" ? record.modelId : void 0;
-    const provider = typeof record.provider === "string" && !model ? record.provider : void 0;
+    const model = typeof record2.modelId === "string" ? record2.modelId : void 0;
+    const provider = typeof record2.provider === "string" && !model ? record2.provider : void 0;
     if (provider) bits.push(provider);
     if (model) bits.push(model);
     return bits.join(" ");
   }
-  return truncateMiddle(JSON.stringify(record), 160);
+  return truncateMiddle(JSON.stringify(record2), 160);
 };
 var resolvePrewalkModel = async (state, context) => {
   const configured = state.config.prewalk.model?.trim();
@@ -1843,8 +1856,877 @@ var FabricSpeculationWarmup = class {
   }
 };
 
-// src/core/tool-ownership.ts
+// src/storage/lcm-migration.ts
+import crypto from "node:crypto";
+import fs2 from "node:fs";
 import path3 from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var hash = (data) => crypto.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(path3.resolve(file))) {
+      incomplete++;
+      return;
+    }
+    files.add(path3.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(path3.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 = path3.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(path3.join(root, entry.name));
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) add(path3.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 = hash(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 (ordinal !== 1 || row.type !== "session" || !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 DatabaseSync(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 && data.length === 0) 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 crypto2 from "node:crypto";
+var DEFAULT_LCM_BUDGET = { calls: 32, inputTokens: 2e6, outputTokens: 128e3, cost: Number.POSITIVE_INFINITY, wallMs: 6e4, sessionCalls: 16 };
+var hash2 = (v) => hashLcmPayload(v);
+var parse = (v) => JSON.parse(String(v));
+var rawHash = (e) => e.payloadHash;
+var token = () => crypto2.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 ?? crypto2.randomUUID();
+    this.policyHash = options.policyHash ?? hash2("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 (hash2(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:${hash2({ projectKey: this.projectKey, source, branch, policyHash: this.policyHash })}`, projectKey: this.projectKey, sessionId: entries[0].sessionId, branch, kind: "leaf", sources: source, children: [], depth: 0, sourceHash: hash2(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:${hash2({ 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: hash2(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 || hash2(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 || hash2(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;
+  options;
+  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.options = options;
+    const recorded = context.sessionManager.getRecordedCwd?.();
+    const liveCwd = recorded || context.cwd;
+    const project = canonicalProjectIdentity({ liveCwd });
+    const ledgerOptions = options.rootDir === void 0 ? { project: { liveCwd: project.canonicalPath ?? liveCwd } } : { rootDir: options.rootDir, project: { liveCwd: project.canonicalPath ?? liveCwd } };
+    this.ledger = new LcmLedger(ledgerOptions);
+    this.maintenance = new LcmMaintenance(this.ledger, {
+      ...options,
+      ...options.lcmMaxInputChars === void 0 ? {} : { maxInputChars: options.lcmMaxInputChars },
+      ...options.lcmMaxOutputChars === void 0 ? {} : { maxOutputChars: options.lcmMaxOutputChars }
+    });
+  }
+  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
+      });
+      if (result.exitCode !== 0) throw new Error(`LCM session reconciliation failed with exit code ${result.exitCode}`);
+      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 budget = Math.max(1, this.options.maxCondenseChildren ?? 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 < budget && !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, budget);
+      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 >= budget) {
+        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 < budget) 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();
+  }
+};
+
+// src/core/tool-ownership.ts
+import path4 from "node:path";
 
 // src/audit/details.ts
 var FABRIC_EXECUTION_DETAILS_MAX_BYTES = 512 * 1024;
@@ -1946,7 +2828,7 @@ var readFabricExecutionRenderDetails = (value) => {
 var FABRIC_TOOL_NAME = "fabric_exec";
 var TOP_LEVEL_SCHEMA_REF_PREFIX = "schema.top_level_tool.";
 var ownsFabricToolSource = (tools, extensionEntryPath) => tools.some(
-  (tool) => tool.name === FABRIC_TOOL_NAME && path3.resolve(tool.sourceInfo.path) === path3.resolve(extensionEntryPath)
+  (tool) => tool.name === FABRIC_TOOL_NAME && path4.resolve(tool.sourceInfo.path) === path4.resolve(extensionEntryPath)
 );
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var finalFabricDetailsFailed = (details) => {
@@ -2109,7 +2991,7 @@ ${sections.join("\n")}` : "";
 
 // src/core/system-guidance.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 var fabricExecutionKernelGuidance = (fullCodeMode) => [
   fullCodeMode ? "OMP Fabric full code mode: `fabric_exec` is the only way to call OMP core tools \u2014 use them as `omp.*` inside `code`." : "OMP Fabric is in orchestration-only mode. OMP core and registered extension tools stay on their native direct execution path; inside fabric_exec, `omp.*` and `extensions.*` are unavailable.",
   // Files the model has not opened (images in particular) must be read before
@@ -2121,10 +3003,10 @@ var defaultFabricExecutionGuidance = (fullCodeMode) => fullCodeMode ? "Examples
 var manifestNameCache = /* @__PURE__ */ new Map();
 var packageNameFromManifest = (startPath) => {
   if (!startPath) return void 0;
-  let directory = path4.dirname(path4.resolve(startPath));
+  let directory = path5.dirname(path5.resolve(startPath));
   while (true) {
     if (manifestNameCache.has(directory)) return manifestNameCache.get(directory);
-    const manifestPath = path4.join(directory, "package.json");
+    const manifestPath = path5.join(directory, "package.json");
     let name;
     if (existsSync2(manifestPath)) {
       try {
@@ -2135,7 +3017,7 @@ var packageNameFromManifest = (startPath) => {
     }
     manifestNameCache.set(directory, name);
     if (name) return name;
-    const parent = path4.dirname(directory);
+    const parent = path5.dirname(directory);
     if (parent === directory) return void 0;
     directory = parent;
   }
@@ -2403,8 +3285,8 @@ var formatFailureProgress = (trace) => {
   );
   if (completed.length === 0) return void 0;
   const summaries = completed.slice(0, MAX_COMPLETED_CALLS).map((operation) => {
-    const path11 = operation.args.path;
-    return typeof path11 === "string" ? `${operation.ref}(${compactPath(path11)})` : operation.ref;
+    const path12 = operation.args.path;
+    return typeof path12 === "string" ? `${operation.ref}(${compactPath(path12)})` : operation.ref;
   });
   const omitted = completed.length - summaries.length;
   return [
@@ -2713,12 +3595,12 @@ var PartialResultObserver = class {
 // src/output-budget.ts
 import { mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 var MAX_FAILURE_MODEL_OUTPUT_CHARS = 2e4;
 var modelOutputBudget = (configuredMaxChars, success) => success ? configuredMaxChars : Math.min(configuredMaxChars, MAX_FAILURE_MODEL_OUTPUT_CHARS);
 var writeOutputArtifact = async (content) => {
-  const directory = await mkdtemp(path5.join(tmpdir(), "omp-fabric-output-"));
-  const artifactPath = path5.join(directory, "output.txt");
+  const directory = await mkdtemp(path6.join(tmpdir(), "omp-fabric-output-"));
+  const artifactPath = path6.join(directory, "output.txt");
   await writeFile(artifactPath, content, { encoding: "utf8", mode: 384 });
   return artifactPath;
 };
@@ -2754,20 +3636,20 @@ var normalizeFabricExecParams = (input) => {
   if (typeof prepared !== "object" || prepared === null || Array.isArray(prepared)) {
     throw new Error("fabric_exec arguments must be an object");
   }
-  const record = prepared;
-  const code = record.code;
+  const record2 = prepared;
+  const code = record2.code;
   if (typeof code !== "string" && !(Array.isArray(code) && code.every((line) => typeof line === "string"))) {
     throw new Error("fabric_exec code must be a string or string array");
   }
-  const resultFormat = RESULT_FORMATS.includes(record.resultFormat) ? record.resultFormat : void 0;
+  const resultFormat = RESULT_FORMATS.includes(record2.resultFormat) ? record2.resultFormat : void 0;
   return {
     code,
-    ...record.payloads !== void 0 ? { payloads: record.payloads } : {},
-    ...record.display !== void 0 ? { display: record.display } : {},
+    ...record2.payloads !== void 0 ? { payloads: record2.payloads } : {},
+    ...record2.display !== void 0 ? { display: record2.display } : {},
     ...resultFormat !== void 0 ? { resultFormat } : {},
-    ...typeof record.tokenBudget === "number" ? { tokenBudget: record.tokenBudget } : {},
-    ...typeof record.agentBudget === "number" ? { agentBudget: record.agentBudget } : {},
-    ...typeof record.timeoutMs === "number" ? { timeoutMs: record.timeoutMs } : {}
+    ...typeof record2.tokenBudget === "number" ? { tokenBudget: record2.tokenBudget } : {},
+    ...typeof record2.agentBudget === "number" ? { agentBudget: record2.agentBudget } : {},
+    ...typeof record2.timeoutMs === "number" ? { timeoutMs: record2.timeoutMs } : {}
   };
 };
 var toolDisplayMode = (state) => state.bootstrapped ? state.config.ui.toolDisplay : "full";
@@ -3502,8 +4384,8 @@ ${recoveryHint}` : ""}`,
 );
 
 // src/fabric-state.ts
-import fs2 from "node:fs";
-import path6 from "node:path";
+import fs3 from "node:fs";
+import path7 from "node:path";
 var FabricState = class {
   constructor(omp, capturedTools, options = {}) {
     this.omp = omp;
@@ -3642,15 +4524,15 @@ var FabricState = class {
     const sessionId = context.sessionManager.getSessionId();
     if (resolveFabricIdentity(sessionId).identity.kind !== "main") return false;
     const projectRoot = process.env.OMP_FABRIC_PROJECT_ROOT ?? context.cwd;
-    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (this.config.mesh.root ? path6.resolve(projectRoot, this.config.mesh.root) : path6.join(projectRoot, ".omp", "fabric", "mesh"));
+    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (this.config.mesh.root ? path7.resolve(projectRoot, this.config.mesh.root) : path7.join(projectRoot, ".omp", "fabric", "mesh"));
     const fabricSessionId = process.env.OMP_FABRIC_SESSION_ID?.trim() || sessionId;
     const actorRoots = [
-      path6.join(meshRoot, "actors"),
-      path6.join(meshRoot, "actors", fabricSessionId)
+      path7.join(meshRoot, "actors"),
+      path7.join(meshRoot, "actors", fabricSessionId)
     ];
     return actorRoots.some((actorRoot) => {
       try {
-        const registry = JSON.parse(fs2.readFileSync(path6.join(actorRoot, "actors.json"), "utf8"));
+        const registry = JSON.parse(fs3.readFileSync(path7.join(actorRoot, "actors.json"), "utf8"));
         if (typeof registry !== "object" || registry === null || Array.isArray(registry)) return false;
         const actors = registry.actors;
         return Array.isArray(actors) && actors.some((value) => {
@@ -3865,7 +4747,8 @@ var FabricState = class {
         prewalk: this.prewalk,
         prewalkDrift: this.prewalkDrift,
         sessionApprovals: this.sessionApprovals,
-        ...this.#options.paths ? { paths: this.#options.paths } : {}
+        ...this.#options.paths ? { paths: this.#options.paths } : {},
+        ...this.#options.lcmContext ? { lcmContext: this.#options.lcmContext } : {}
       }
     );
   }
@@ -4052,7 +4935,7 @@ var classifyToolResult = (input) => {
 
 // src/host-compatibility.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 var MINIMUM_OMP_HOST_VERSION = "18.1.10";
 var OMP_HOST_PACKAGE_NAMES = {
   "@oh-my-pi/pi-coding-agent": true
@@ -4082,12 +4965,12 @@ var detectOmpHostVersion = (cliPath = process.argv[1]) => {
   if (!cliPath) return void 0;
   let directory;
   try {
-    directory = path7.dirname(realpathSync2(cliPath));
+    directory = path8.dirname(realpathSync2(cliPath));
   } catch {
     return void 0;
   }
   while (true) {
-    const manifestPath = path7.join(directory, "package.json");
+    const manifestPath = path8.join(directory, "package.json");
     if (existsSync3(manifestPath)) {
       try {
         const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
@@ -4097,7 +4980,7 @@ var detectOmpHostVersion = (cliPath = process.argv[1]) => {
       } catch {
       }
     }
-    const parent = path7.dirname(directory);
+    const parent = path8.dirname(directory);
     if (parent === directory) return void 0;
     directory = parent;
   }
@@ -4110,8 +4993,8 @@ var ompHostCompatibilityWarning = (version = detectOmpHostVersion()) => {
 };
 
 // src/update/check.ts
-import fs3 from "node:fs";
-import path8 from "node:path";
+import fs4 from "node:fs";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
 var PACKAGE_NAME = "omp-fabric";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
@@ -4119,27 +5002,27 @@ var UPGRADE_COMMAND = `omp plugin install ${PACKAGE_NAME}`;
 var REQUEST_TIMEOUT_MS = 4e3;
 var UPDATE_STATUS_KEY = "fabric-update";
 var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
-var updateCheckCachePath = (agentDir) => path8.join(agentDir, "fabric", "update-check.json");
+var updateCheckCachePath = (agentDir) => path9.join(agentDir, "fabric", "update-check.json");
 var installedVersionFromManifest = () => {
-  let directory = path8.dirname(fileURLToPath(import.meta.url));
+  let directory = path9.dirname(fileURLToPath(import.meta.url));
   while (true) {
     try {
       const manifest = JSON.parse(
-        fs3.readFileSync(path8.join(directory, "package.json"), "utf8")
+        fs4.readFileSync(path9.join(directory, "package.json"), "utf8")
       );
       if (manifest.name === PACKAGE_NAME && typeof manifest.version === "string") {
         return manifest.version;
       }
     } catch {
     }
-    const parent = path8.dirname(directory);
+    const parent = path9.dirname(directory);
     if (parent === directory) return void 0;
     directory = parent;
   }
 };
 var readCache = (cachePath) => {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(cachePath, "utf8"));
+    const parsed = JSON.parse(fs4.readFileSync(cachePath, "utf8"));
     if (typeof parsed.checkedAt !== "number" || !Number.isFinite(parsed.checkedAt)) return void 0;
     if (typeof parsed.latest !== "string" || parsed.latest.length === 0) return void 0;
     return {
@@ -4186,32 +5069,32 @@ var checkFabricUpdate = async (options) => {
     const cached = readCache(cachePath);
     const age = cached === void 0 ? void 0 : now - cached.checkedAt;
     const fresh = cached !== void 0 && age !== void 0 && age >= 0 && age < UPDATE_CHECK_TTL_MS;
-    let record;
+    let record2;
     if (fresh && cached !== void 0) {
-      record = cached;
+      record2 = cached;
     } else {
       const latest = await fetchLatestVersion(
         options.fetchImpl ?? globalThis.fetch,
         options.timeoutMs ?? REQUEST_TIMEOUT_MS
       );
       if (latest === void 0) return void 0;
-      record = {
+      record2 = {
         format: 1,
         checkedAt: now,
         latest,
         ...cached?.notified === void 0 ? {} : { notified: cached.notified }
       };
     }
-    const behind = compareVersions(record.latest, installed) === 1;
-    const announce = behind && record.notified !== record.latest;
+    const behind = compareVersions(record2.latest, installed) === 1;
+    const announce = behind && record2.notified !== record2.latest;
     if (!fresh || announce) {
-      writeCache(cachePath, announce ? { ...record, notified: record.latest } : record);
+      writeCache(cachePath, announce ? { ...record2, notified: record2.latest } : record2);
     }
     if (!announce) return void 0;
     return {
       installed,
-      latest: record.latest,
-      message: `${PACKAGE_NAME} ${installed} \u2192 ${record.latest} \xB7 ${UPGRADE_COMMAND}`
+      latest: record2.latest,
+      message: `${PACKAGE_NAME} ${installed} \u2192 ${record2.latest} \xB7 ${UPGRADE_COMMAND}`
     };
   } catch {
     return void 0;
@@ -4240,7 +5123,7 @@ var scheduleFabricUpdateCheck = async (context, options) => {
 };
 
 // src/ui/controller.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/ui/snapshot.ts
 var MAX_UI_AGENTS = 240;
@@ -4297,57 +5180,57 @@ var createDashboardSnapshot = (state, events, context, activityRuns) => {
     if (leftLaunch !== rightLaunch) return leftLaunch ? -1 : 1;
     return left.call.startedAt - right.call.startedAt;
   });
-  const agentFromRecord = (record, nestingDepth, parentId, parent) => {
+  const agentFromRecord = (record2, nestingDepth, parentId, parent) => {
     const linked = parentId ? void 0 : agentLinks.find(
-      ({ call }) => call.entityId && (record.id.startsWith(call.entityId) || call.entityId.startsWith(record.id))
+      ({ call }) => call.entityId && (record2.id.startsWith(call.entityId) || call.entityId.startsWith(record2.id))
     );
     const base = {
-      id: record.id,
-      name: record.name,
-      status: record.status,
-      runner: record.runner,
-      transport: record.transport,
-      cwd: record.cwd,
-      ...!isRunRecord(record) && linked ? { startedAt: linked.call.startedAt } : {},
-      ...record.model ? { model: record.model } : {},
-      ...record.thinking ? { thinking: record.thinking } : {},
-      ...record.attachCommand ? { attachCommand: record.attachCommand } : {},
-      ...isRunRecord(record) && record.logFile ? { logFile: record.logFile } : {},
-      ...record.branch ? { branch: record.branch } : {},
-      ...record.worktree ? { worktree: record.worktree } : {},
-      ...record.actorId ? { actorId: record.actorId } : {},
-      ...record.actorName ? { actorName: record.actorName } : {},
+      id: record2.id,
+      name: record2.name,
+      status: record2.status,
+      runner: record2.runner,
+      transport: record2.transport,
+      cwd: record2.cwd,
+      ...!isRunRecord(record2) && linked ? { startedAt: linked.call.startedAt } : {},
+      ...record2.model ? { model: record2.model } : {},
+      ...record2.thinking ? { thinking: record2.thinking } : {},
+      ...record2.attachCommand ? { attachCommand: record2.attachCommand } : {},
+      ...isRunRecord(record2) && record2.logFile ? { logFile: record2.logFile } : {},
+      ...record2.branch ? { branch: record2.branch } : {},
+      ...record2.worktree ? { worktree: record2.worktree } : {},
+      ...record2.actorId ? { actorId: record2.actorId } : {},
+      ...record2.actorName ? { actorName: record2.actorName } : {},
       ...parentId ? { parentId } : {},
       ...nestingDepth > 0 ? { nestingDepth } : {},
       ...linked ? { runId: linked.runId } : parent?.runId ? { runId: parent.runId } : {},
       ...linked?.call.phaseId ? { phaseId: linked.call.phaseId } : parent?.phaseId ? { phaseId: parent.phaseId } : {}
     };
-    if (!isRunRecord(record)) return base;
+    if (!isRunRecord(record2)) return base;
     return {
       ...base,
-      task: record.task,
-      startedAt: record.startedAt,
-      updatedAt: record.updatedAt,
-      ...record.finishedAt !== void 0 ? { finishedAt: record.finishedAt } : {},
-      ...record.currentTool ? { currentTool: record.currentTool } : {},
-      turns: record.turns,
-      toolCalls: record.toolCalls,
-      usage: { ...record.usage },
-      ...record.text ? { text: record.text } : {},
-      ...record.value !== void 0 ? { value: structuredClone(record.value) } : {},
-      ...record.error ? { error: record.error } : {}
+      task: record2.task,
+      startedAt: record2.startedAt,
+      updatedAt: record2.updatedAt,
+      ...record2.finishedAt !== void 0 ? { finishedAt: record2.finishedAt } : {},
+      ...record2.currentTool ? { currentTool: record2.currentTool } : {},
+      turns: record2.turns,
+      toolCalls: record2.toolCalls,
+      usage: { ...record2.usage },
+      ...record2.text ? { text: record2.text } : {},
+      ...record2.value !== void 0 ? { value: structuredClone(record2.value) } : {},
+      ...record2.error ? { error: record2.error } : {}
     };
   };
   const allAgents = [];
-  const appendAgent = (record, nestingDepth, parentId, parent) => {
-    const agent = agentFromRecord(record, nestingDepth, parentId, parent);
+  const appendAgent = (record2, nestingDepth, parentId, parent) => {
+    const agent = agentFromRecord(record2, nestingDepth, parentId, parent);
     allAgents.push(agent);
-    if (!isRunRecord(record)) return;
-    for (const nested of record.nestedAgents ?? []) {
-      appendAgent(nested, nestingDepth + 1, record.id, agent);
+    if (!isRunRecord(record2)) return;
+    for (const nested of record2.nestedAgents ?? []) {
+      appendAgent(nested, nestingDepth + 1, record2.id, agent);
     }
   };
-  for (const record of agentRecords) appendAgent(record, 0);
+  for (const record2 of agentRecords) appendAgent(record2, 0);
   const participants = typeof state.participantInfos === "function" ? state.participantInfos({ scope: "project" }) : [];
   const participantById = new Map(participants.map((participant) => [participant.id, participant]));
   const actors = state.actors.list().map((actor) => {
@@ -5097,7 +5980,7 @@ var FabricUiController = class {
         logFile: actor.worker.logFile
       };
     }
-    const retained = actor.lastRunId && actor.logDir ? path9.join(actor.logDir, actor.lastRunId, "events.jsonl") : void 0;
+    const retained = actor.lastRunId && actor.logDir ? path10.join(actor.logDir, actor.lastRunId, "events.jsonl") : void 0;
     if (retained) return { id: actor.id, status: actor.status, logFile: retained };
     if (actor.sessionFile) {
       return { id: actor.id, status: actor.status, logFile: actor.sessionFile };
@@ -5256,15 +6139,15 @@ var REFRESH_CARDS_PER_TICK = 3;
 
 // src/index.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var FABRIC_EXTENSION_ENTRY_PATH = path10.resolve(fileURLToPath2(import.meta.url));
-var FABRIC_ENTRY_DIR = path10.dirname(FABRIC_EXTENSION_ENTRY_PATH);
+var FABRIC_EXTENSION_ENTRY_PATH = path11.resolve(fileURLToPath2(import.meta.url));
+var FABRIC_ENTRY_DIR = path11.dirname(FABRIC_EXTENSION_ENTRY_PATH);
 var FABRIC_RUNTIME_PATHS = {
   extension: FABRIC_EXTENSION_ENTRY_PATH,
-  worker: path10.join(FABRIC_ENTRY_DIR, "worker.js"),
-  residentHost: path10.join(FABRIC_ENTRY_DIR, "residency", "launcher.js"),
-  skills: path10.resolve(FABRIC_ENTRY_DIR, "..", "skills")
+  worker: path11.join(FABRIC_ENTRY_DIR, "worker.js"),
+  residentHost: path11.join(FABRIC_ENTRY_DIR, "residency", "launcher.js"),
+  skills: path11.resolve(FABRIC_ENTRY_DIR, "..", "skills")
 };
 var FABRIC_SKILLS_DIR = FABRIC_RUNTIME_PATHS.skills;
 var componentRegistrationFrom = (value) => {
@@ -5297,13 +6180,19 @@ async function ompFabric(omp) {
   );
   const capturedTools = new CapturedToolCatalog();
   const proxyContract = new ProxyContractLedger();
-  const state = new FabricState(omp, capturedTools, { paths: FABRIC_RUNTIME_PATHS });
+  const state = new FabricState(omp, capturedTools, {
+    paths: FABRIC_RUNTIME_PATHS,
+    lcmContext: () => lcmRuntime?.memoryContext()
+  });
   const directToolApproval = new FabricDirectToolApproval(
     omp,
     () => state.config,
     state.sessionApprovals
   );
   const pendingHandoffs = /* @__PURE__ */ new Map();
+  let lcmRuntime;
+  let lcmCwd;
+  let lcmProjectKey;
   const toolOwnership = new FabricToolOwnership(omp);
   const fabricUi = new FabricUiController(state, codePreviewSettings, {
     getToolDefinition: (name) => name === "fabric_exec" ? fabricTool : capturedTools.get(name)?.definition,
@@ -5568,6 +6457,27 @@ async function ompFabric(omp) {
       }
     }
     await state.bootstrap(context);
+    const recordedCwd = context.sessionManager.getRecordedCwd?.() || context.cwd;
+    const projectKey = canonicalProjectIdentity({ liveCwd: recordedCwd }).key;
+    if (lcmRuntime && (lcmCwd !== context.cwd || lcmProjectKey !== projectKey || state.config.compaction.engine !== "lcm")) {
+      await lcmRuntime.shutdown();
+      lcmRuntime = void 0;
+      lcmCwd = void 0;
+      lcmProjectKey = void 0;
+    }
+    if (state.config.compaction.engine === "lcm" && !lcmRuntime) {
+      lcmRuntime = new LcmRuntime(context, {
+        ...state.config.compaction.summaryModel ? { summaryModel: state.config.compaction.summaryModel } : {},
+        maxLeafEntries: state.config.compaction.lcmMaxLeafEntries,
+        maxCondenseChildren: state.config.compaction.lcmMaxCondenseChildren,
+        lcmMaxInputChars: state.config.compaction.lcmMaxInputChars,
+        lcmMaxOutputTokens: state.config.compaction.lcmMaxOutputTokens,
+        lcmMaxOutputChars: state.config.compaction.lcmMaxOutputChars
+      });
+      lcmCwd = context.cwd;
+      lcmProjectKey = lcmRuntime.projectKey;
+    }
+    if (state.config.compaction.engine === "lcm" && lcmRuntime) await lcmRuntime.reconcileSelectedSession();
     refreshCodePreviewSettings();
     applyFabricMode();
     if (!updateCheckStarted) {
@@ -5606,6 +6516,7 @@ async function ompFabric(omp) {
   });
   omp.on("agent_end", async (event, context) => {
     if (event.willContinue === true) return;
+    await lcmRuntime?.syncAndSchedule();
     if (!state.initialized) {
       await compactAtConfiguredThreshold(context, state.config);
       return;
@@ -5667,6 +6578,9 @@ async function ompFabric(omp) {
     });
     return changed ? { content } : void 0;
   });
+  omp.on("message_end", () => {
+    lcmRuntime?.markDirty();
+  });
   omp.on("message_end", (event) => {
     if (event.message.role !== "toolResult") return;
     const message = event.message;
@@ -5706,12 +6620,16 @@ async function ompFabric(omp) {
     }
   });
   omp.on("session_compact", async (event, context) => {
+    await lcmRuntime?.syncAndSchedule();
     if (!state.initialized) return;
     await state.publishHostLifecycle("omp.session_compact", event);
   });
   registerCompactionHook(omp, {
-    getEngine: () => state.cwd ? state.config.compaction.engine === "omp" ? "omp" : "fabric" : DEFAULT_FABRIC_CONFIG.compaction.engine === "omp" ? "omp" : "fabric",
-    getTargetContextRatio: () => state.cwd ? state.config.compaction.targetContextRatio : DEFAULT_FABRIC_CONFIG.compaction.targetContextRatio
+    getEngine: () => state.cwd ? state.config.compaction.engine : DEFAULT_FABRIC_CONFIG.compaction.engine,
+    getTargetContextRatio: () => state.cwd ? state.config.compaction.targetContextRatio : DEFAULT_FABRIC_CONFIG.compaction.targetContextRatio,
+    lcm: {
+      compact: (input) => lcmRuntime?.compact(input)
+    }
   });
   omp.on("context", (event, context) => {
     const sessionId = context.sessionManager.getSessionId();
@@ -5832,6 +6750,10 @@ ${guidance}`],
     directToolApproval.clear();
     toolDisplay.clear();
     try {
+      await lcmRuntime?.shutdown();
+      lcmRuntime = void 0;
+      lcmCwd = void 0;
+      lcmProjectKey = void 0;
       await state.shutdown();
     } finally {
       uninstallHaltOnEscape();