omp-fabric 0.85.1 → 1.0.3

package/dist/fabric-runtime-state.js

@@ -11,7 +11,7 @@ import {
   MemoryProvider,
   actionArgNormalizer,
   uniqueDeclaredKeyForSpelling
-} from "./chunks/chunk-T6OAX4FO.js";
+} from "./chunks/chunk-3TWC6XOS.js";
 import "./chunks/chunk-2KEWFW56.js";
 import "./chunks/chunk-U5FYOMG5.js";
 import {
@@ -22,6 +22,7 @@ import {
   FabricAutoApprovalClassifier,
   FabricProviderComponentManifest,
   FabricSessionApprovals,
+  FabricSpeculationStreamTap,
   MainAgentController,
   PrewalkController,
   PrewalkDriftTracker,
@@ -32,7 +33,7 @@ import {
   repairFabricGuestCode,
   resolveFabricIdentity,
   runFabricHandoffAtBoundary
-} from "./chunks/chunk-SXMWV447.js";
+} from "./chunks/chunk-DOKANNFC.js";
 import "./chunks/chunk-7VIQNUPS.js";
 import {
   AgentTranscriptReader,
@@ -49,7 +50,7 @@ import {
   repairActionName,
   setActiveCompiledSurface,
   setActiveRepairCompiler
-} from "./chunks/chunk-GKOFZ76R.js";
+} from "./chunks/chunk-2LGLDM34.js";
 import {
   formatFabricEffectConflict
 } from "./chunks/chunk-LMAVZN7J.js";
@@ -62,14 +63,14 @@ import {
   withExclusiveFileLockAsync
 } from "./chunks/chunk-YWEXP724.js";
 import "./chunks/chunk-4A4MVZQW.js";
-import "./chunks/chunk-7BIA5BJN.js";
+import "./chunks/chunk-NX4SNIMR.js";
 import "./chunks/chunk-6QBPSZJ5.js";
 import {
   FABRIC_COMPONENT_DISCOVER_EVENT,
   FABRIC_PROVIDER_DISCOVER_EVENT,
   FABRIC_TOOL_RESULT_PROXY_KIND,
   readFabricToolResultProxyDetailsV1
-} from "./chunks/chunk-YZZIKJX6.js";
+} from "./chunks/chunk-RBA54WC7.js";
 import {
   ActorDirectory,
   ActorRegistryOwnershipError,
@@ -93,27 +94,27 @@ import {
   resolveAgentCwd,
   resolveOmpBinary,
   validateAgentCwdRequest
-} from "./chunks/chunk-UPCARIJP.js";
+} from "./chunks/chunk-FFWALVBN.js";
 import "./chunks/chunk-VPPIJRNZ.js";
 import {
   executeFile,
   processIsAlive,
   spawnDetached
-} from "./chunks/chunk-ZTM45GH5.js";
+} from "./chunks/chunk-JZWLICMS.js";
 import "./chunks/chunk-CT2AJ2UI.js";
 import {
-  checkedHandoffCompaction,
-  resolveAgentDir
-} from "./chunks/chunk-OPTP4PSE.js";
+  checkedHandoffCompaction
+} from "./chunks/chunk-YPYVUGON.js";
 import {
   DEFAULT_FABRIC_CONFIG,
   FUZZY_RESOLUTION_MARKERS,
   MAX_AGENT_TIMEOUT_MS,
   MIN_AGENT_TIMEOUT_MS,
   loadFabricConfig,
+  resolveAgentDir,
   resolveAvailableOmpModel,
   resolveFabricModel
-} from "./chunks/chunk-ROKMBLGN.js";
+} from "./chunks/chunk-IFNDRFW7.js";
 import {
   FABRIC_ACTOR_HOST_EVENTS,
   isFabricActorHostEvent,
@@ -170,7 +171,7 @@ import {
 } from "./chunks/chunk-6N4XGAZY.js";
 
 // src/fabric-runtime-state.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/actors/global-registry.ts
@@ -1039,8 +1040,8 @@ var MAX_CHILDREN_PER_COMPONENT = 256;
 var componentLifecycleStorage;
 var componentLifecycleStorageTask;
 var lifecycleStorage = () => {
-  componentLifecycleStorageTask ??= import("node:async_hooks").then(({ AsyncLocalStorage }) => {
-    componentLifecycleStorage ??= new AsyncLocalStorage();
+  componentLifecycleStorageTask ??= import("node:async_hooks").then(({ AsyncLocalStorage: AsyncLocalStorage2 }) => {
+    componentLifecycleStorage ??= new AsyncLocalStorage2();
     return componentLifecycleStorage;
   });
   return componentLifecycleStorageTask;
@@ -2217,10 +2218,10 @@ var FabricComponentSupervisor = class {
       adjacent.set(edge.from, targets);
     }
     const cycles = /* @__PURE__ */ new Map();
-    const visit = (node, path16, positions) => {
+    const visit = (node, path17, positions) => {
       const position = positions.get(node);
       if (position !== void 0) {
-        const cycle = path16.slice(position);
+        const cycle = path17.slice(position);
         const rotations = cycle.map((_, index) => [
           ...cycle.slice(index),
           ...cycle.slice(0, index)
@@ -2230,10 +2231,10 @@ var FabricComponentSupervisor = class {
         cycles.set(canonical.join("\0"), canonical);
         return;
       }
-      if (path16.length > this.#components.size) return;
-      const nextPositions = new Map(positions).set(node, path16.length);
+      if (path17.length > this.#components.size) return;
+      const nextPositions = new Map(positions).set(node, path17.length);
       for (const target of adjacent.get(node) ?? []) {
-        visit(target, [...path16, node], nextPositions);
+        visit(target, [...path17, node], nextPositions);
       }
     };
     for (const id of this.#components.keys()) visit(id, [], /* @__PURE__ */ new Map());
@@ -2562,13 +2563,53 @@ var checkedPreserve = (value) => {
   }
   return [...value];
 };
+var finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var UNKNOWN_USAGE = {
+  known: false,
+  tokens: null,
+  contextWindow: null,
+  percent: null,
+  remainingTokens: null
+};
+var readCompactContextUsage = (context) => {
+  const modelWindow = finite(context?.model?.contextWindow);
+  let usage;
+  try {
+    usage = context?.getContextUsage?.();
+  } catch {
+    usage = void 0;
+  }
+  if (!usage) return { ...UNKNOWN_USAGE, contextWindow: modelWindow };
+  const tokens = finite(usage.tokens);
+  const contextWindow = finite(usage.contextWindow) ?? modelWindow;
+  const percent = finite(usage.percent) ?? (tokens !== null && contextWindow !== null && contextWindow > 0 ? tokens / contextWindow * 100 : null);
+  return {
+    known: tokens !== null || percent !== null,
+    tokens,
+    contextWindow,
+    percent,
+    remainingTokens: tokens !== null && contextWindow !== null ? Math.max(0, contextWindow - tokens) : null
+  };
+};
+var sessionIdOf = (context) => {
+  try {
+    const id = context?.sessionManager?.getSessionId?.();
+    return typeof id === "string" && id.length > 0 ? id : void 0;
+  } catch {
+    return void 0;
+  }
+};
 var CompactController = class {
   #pending;
   #last;
   #inFlight;
+  #restoredFor;
+  #restored;
   #hooks;
-  constructor(hooks = {}) {
+  #options;
+  constructor(hooks = {}, options = {}) {
     this.#hooks = hooks;
+    this.#options = options;
   }
   // Record a pending compaction intent. A single slot: a new request replaces
   // any pending one, keeping the latest instructions.
@@ -2597,10 +2638,39 @@ var CompactController = class {
   cancel() {
     this.#pending = void 0;
   }
-  status() {
+  #settledOutcome(context) {
+    if (this.#last) return this.#last;
+    const store = this.#options.outcomes;
+    if (!store) return void 0;
+    const sessionId = sessionIdOf(context);
+    if (sessionId === void 0) return void 0;
+    if (this.#restoredFor !== sessionId) {
+      this.#restoredFor = sessionId;
+      this.#restored = store.load(sessionId);
+    }
+    return this.#restored;
+  }
+  #settle(context, outcome) {
+    this.#last = outcome;
+    this.#restoredFor = void 0;
+    this.#restored = void 0;
+    const store = this.#options.outcomes;
+    const sessionId = store ? sessionIdOf(context) : void 0;
+    if (store && sessionId !== void 0) store.save(sessionId, outcome);
+    this.#hooks.onCommit?.(outcome);
+  }
+  status(context) {
+    const settings = this.#options.settings?.();
+    const last = this.#settledOutcome(context);
+    const model = context?.model;
+    const sessionId = sessionIdOf(context);
     return {
       ...this.#pending ? { pending: this.#pending } : {},
-      ...this.#last ? { last: this.#last } : {}
+      ...last ? { last } : {},
+      context: readCompactContextUsage(context),
+      ...settings ? { engine: settings.engine, targetContextRatio: settings.targetContextRatio } : {},
+      ...model ? { model: `${model.provider}/${model.id}` } : {},
+      ...sessionId !== void 0 ? { sessionId } : {}
     };
   }
   async maybeCommit(context) {
@@ -2616,23 +2686,32 @@ var CompactController = class {
     const clearCommittedIntent = () => {
       if (this.#pending === committing) this.#pending = void 0;
     };
+    const before = readCompactContextUsage(context);
     const completion = (async () => {
       try {
         await context.compact(instructions);
         clearCommittedIntent();
-        this.#last = { at: Date.now(), requestedBy, status: "committed" };
-        this.#hooks.onCommit?.(this.#last);
+        const after = readCompactContextUsage(context);
+        const measured = before.tokens !== null && after.tokens !== null;
+        this.#settle(context, {
+          at: Date.now(),
+          requestedBy,
+          status: measured && after.tokens >= before.tokens ? "skipped" : "committed",
+          ...before.tokens !== null ? { tokensBefore: before.tokens } : {},
+          ...after.tokens !== null ? { estimatedTokensAfter: after.tokens } : {},
+          ...measured && after.tokens >= before.tokens ? { error: "Compaction ran but freed no context tokens" } : {}
+        });
       } catch (error) {
         const message2 = error instanceof Error ? error.message : "Compaction failed";
         clearCommittedIntent();
         const cancelled = message2 === "Compaction cancelled" || message2 === "Already compacted";
-        this.#last = {
+        this.#settle(context, {
           at: Date.now(),
           requestedBy,
           status: cancelled ? "cancelled" : "failed",
+          ...before.tokens !== null ? { tokensBefore: before.tokens } : {},
           error: message2
-        };
-        this.#hooks.onCommit?.(this.#last);
+        });
       }
     })();
     this.#inFlight = completion;
@@ -2644,6 +2723,80 @@ var CompactController = class {
   }
 };
 
+// src/core/compact-outcome-store.ts
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import path2 from "node:path";
+var OUTCOME_DIR = ["fabric", "compact"];
+var MAX_OUTCOME_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var sessionFileName = (sessionId) => {
+  const safe = sessionId.replace(/[^A-Za-z0-9._-]/g, "");
+  return safe.length > 0 && safe.length <= 128 ? `${safe}.json` : void 0;
+};
+var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var nonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var decodeOutcome = (raw) => {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const record = raw;
+  const at = finiteNumber(record.at);
+  const requestedBy = nonEmptyString(record.requestedBy);
+  const status = record.status;
+  if (at === void 0 || requestedBy === void 0) return void 0;
+  if (status !== "committed" && status !== "cancelled" && status !== "failed" && status !== "skipped") {
+    return void 0;
+  }
+  const summary = nonEmptyString(record.summary);
+  const error = nonEmptyString(record.error);
+  const tokensBefore = finiteNumber(record.tokensBefore);
+  const estimatedTokensAfter = finiteNumber(record.estimatedTokensAfter);
+  return {
+    at,
+    requestedBy,
+    status,
+    ...summary !== void 0 ? { summary } : {},
+    ...tokensBefore !== void 0 ? { tokensBefore } : {},
+    ...estimatedTokensAfter !== void 0 ? { estimatedTokensAfter } : {},
+    ...error !== void 0 ? { error } : {},
+    persisted: true
+  };
+};
+var pruneStale = (dir, now) => {
+  for (const entry of readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    const target = path2.join(dir, entry);
+    try {
+      if (now - statSync(target).mtimeMs > MAX_OUTCOME_AGE_MS) rmSync(target, { force: true });
+    } catch {
+      continue;
+    }
+  }
+};
+var fileCompactOutcomeStore = (agentDir = resolveAgentDir) => ({
+  load(sessionId) {
+    const name = sessionFileName(sessionId);
+    if (name === void 0) return void 0;
+    try {
+      return decodeOutcome(JSON.parse(readFileSync(path2.join(agentDir(), ...OUTCOME_DIR, name), "utf8")));
+    } catch {
+      return void 0;
+    }
+  },
+  save(sessionId, outcome) {
+    const name = sessionFileName(sessionId);
+    if (name === void 0) return;
+    try {
+      const dir = path2.join(agentDir(), ...OUTCOME_DIR);
+      mkdirSync(dir, { recursive: true });
+      const target = path2.join(dir, name);
+      const staging = `${target}.${process.pid}.tmp`;
+      writeFileSync(staging, JSON.stringify(outcome), "utf8");
+      renameSync(staging, target);
+      pruneStale(dir, Date.now());
+    } catch {
+      return;
+    }
+  }
+});
+
 // src/core/tool-result-proxy.ts
 var nativeLifecycleProviders = /* @__PURE__ */ new Set(["omp", "extensions"]);
 var textFromContent = (content) => content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
@@ -2793,6 +2946,17 @@ var FabricExecutionService = class {
       },
       ...this.#capabilityView ? { capabilityView: this.#capabilityView } : {}
     });
+    const proxyNames = {
+      ...guestTypeSources.extensionTools?.length ? { extensions: guestTypeSources.extensionTools.map((tool) => tool.name) } : {},
+      ...guestTypeSources.mcpServers?.length ? {
+        mcp: Object.fromEntries(
+          guestTypeSources.mcpServers.map((entry) => [
+            entry.server,
+            entry.tools.map((tool) => tool.name)
+          ])
+        )
+      } : {}
+    };
     const coreOverrideDeclarations = effectiveFullCodeMode ? dependencies.buildCoreOverrideGuestDeclarations(
       this.capturedTools?.list().map((entry) => ({
         name: entry.name,
@@ -3263,6 +3427,7 @@ var FabricExecutionService = class {
           ...checked.javascript ? { transpiledCode: checked.javascript } : {},
           ...checked.sourceMap ? { transpiledSourceMap: checked.sourceMap } : {},
           ...options.payloads ? { payloads: options.payloads } : {},
+          ...Object.keys(proxyNames).length > 0 ? { proxyNames } : {},
           ...options.tokenBudget !== void 0 ? { tokenBudget: options.tokenBudget } : {},
           ...options.signal ? { signal: options.signal } : {}
         }
@@ -3370,7 +3535,7 @@ var actionAliasCandidate = (provider, actionName, declared) => {
 
 // src/repairs/store.ts
 import fs2 from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // src/repairs/types.ts
 var REPAIR_TABLE_VERSION = 1;
@@ -3391,8 +3556,8 @@ var emptyRepairTable = (catalogDigest, now = (/* @__PURE__ */ new Date()).toISOS
 
 // src/repairs/store.ts
 var LOCK_TIMEOUT_MESSAGE = "Timed out waiting for the Fabric repair table lock";
-var repairsDirectory = (agentDir) => path2.join(agentDir, "fabric", "repairs");
-var currentPath = (directory) => path2.join(directory, "current.json");
+var repairsDirectory = (agentDir) => path3.join(agentDir, "fabric", "repairs");
+var currentPath = (directory) => path3.join(directory, "current.json");
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var errorCode = (error) => isRecord(error) && typeof error.code === "string" ? error.code : void 0;
 var parseRepair = (value) => {
@@ -3736,7 +3901,7 @@ var isSpeculationEligible = (action, mcpAllowlist) => {
 
 // src/speculation/freshness.ts
 import fs3 from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 var statSignature = (filePath) => {
   try {
     const stats = fs3.statSync(filePath);
@@ -3750,7 +3915,7 @@ var signatureEquals = (left, right) => left === "missing" || right === "missing"
 var readFreshness = (args, cwd) => {
   const target = args.path;
   if (typeof target !== "string" || target.length === 0) return void 0;
-  const resolved = path3.resolve(cwd, target);
+  const resolved = path4.resolve(cwd, target);
   const snapshot = statSignature(resolved);
   if (snapshot === "error") return void 0;
   return () => {
@@ -3770,6 +3935,7 @@ var FabricSpeculationStore = class _FabricSpeculationStore {
   #stats = {
     launched: 0,
     served: 0,
+    absent: 0,
     epochInvalidated: 0,
     freshnessInvalidated: 0,
     failed: 0,
@@ -3779,6 +3945,7 @@ var FabricSpeculationStore = class _FabricSpeculationStore {
   #maxConcurrent;
   #maxEntries;
   #entryTtlMs;
+  #launching = /* @__PURE__ */ new Map();
   constructor(config) {
     this.#maxConcurrent = config.maxConcurrent;
     this.#maxEntries = config.maxEntries;
@@ -3799,12 +3966,39 @@ ${ref}
 ${stableJsonHash(preparedArgs)}
 ${bindingToken}`;
   }
+  beginLaunch(parentToolCallId) {
+    const pending = this.#launching.get(parentToolCallId) ?? { count: 0, waiters: [] };
+    pending.count += 1;
+    this.#launching.set(parentToolCallId, pending);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      pending.count -= 1;
+      if (pending.count > 0) return;
+      this.#launching.delete(parentToolCallId);
+      for (const waiter of pending.waiters.splice(0)) waiter();
+    };
+  }
+  async settleLaunches(parentToolCallId, timeoutMs) {
+    const pending = this.#launching.get(parentToolCallId);
+    if (!pending || pending.count === 0) return;
+    await new Promise((resolvePromise) => {
+      const timer = setTimeout(resolvePromise, timeoutMs);
+      if (typeof timer.unref === "function") timer.unref();
+      pending.waiters.push(() => {
+        clearTimeout(timer);
+        resolvePromise();
+      });
+    });
+  }
   /**
    * Register and start a speculative invocation. Returns false when at
    * capacity; the candidate is dropped silently (a miss costs nothing, the
    * real call executes normally later).
    */
   launch(parentToolCallId, ref, preparedArgs, execute, freshness, replay, bindingToken) {
+    this.#releaseLaunch(parentToolCallId);
     this.#sweepExpired(Date.now());
     if (this.#entries.size >= this.#maxEntries || this.#inFlightCount() >= this.#maxConcurrent) {
       this.#stats.skipped += 1;
@@ -3838,6 +4032,7 @@ ${bindingToken}`;
     const key = _FabricSpeculationStore.key(parentToolCallId, ref, preparedArgs, bindingToken);
     const entry = this.#entries.get(key);
     if (!entry || entry.parentToolCallId !== parentToolCallId) {
+      this.#stats.absent += 1;
       return { hit: false, reason: "absent" };
     }
     this.#entries.delete(key);
@@ -3872,6 +4067,19 @@ ${bindingToken}`;
   reset() {
     for (const entry of this.#entries.values()) entry.controller.abort();
     this.#entries.clear();
+    for (const pending of this.#launching.values()) {
+      pending.count = 0;
+      for (const waiter of pending.waiters.splice(0)) waiter();
+    }
+    this.#launching.clear();
+  }
+  #releaseLaunch(parentToolCallId) {
+    const pending = this.#launching.get(parentToolCallId);
+    if (!pending) return;
+    pending.count -= 1;
+    if (pending.count > 0) return;
+    this.#launching.delete(parentToolCallId);
+    for (const waiter of pending.waiters.splice(0)) waiter();
   }
   #inFlightCount() {
     let count = 0;
@@ -3890,201 +4098,6 @@ ${bindingToken}`;
   }
 };
 
-// src/speculation/partial-json.ts
-var CODE_KEY_PATTERN = /"code"\s*:\s*"/;
-var ESCAPES = {
-  '"': '"',
-  "\\": "\\",
-  "/": "/",
-  b: "\b",
-  f: "\f",
-  n: "\n",
-  r: "\r",
-  t: "	"
-};
-var PartialCodeFieldExtractor = class {
-  #raw = "";
-  #codeStart = -1;
-  #cursor = 0;
-  #decoded = "";
-  #complete = false;
-  #failed = false;
-  #maxBytes;
-  constructor(maxBytes) {
-    this.#maxBytes = maxBytes;
-  }
-  get complete() {
-    return this.#complete;
-  }
-  /** Decoded `code` content so far, or undefined before the key appears. */
-  get code() {
-    return this.#codeStart === -1 ? void 0 : this.#decoded;
-  }
-  push(delta) {
-    if (this.#complete || this.#failed) return;
-    if (this.#raw.length + delta.length > this.#maxBytes) {
-      this.#failed = true;
-      return;
-    }
-    this.#raw += delta;
-    if (this.#codeStart === -1) {
-      const match = CODE_KEY_PATTERN.exec(this.#raw);
-      if (!match) return;
-      this.#codeStart = match.index + match[0].length;
-      this.#cursor = this.#codeStart;
-    }
-    const raw = this.#raw;
-    while (this.#cursor < raw.length) {
-      const ch = raw[this.#cursor];
-      if (ch === '"') {
-        this.#complete = true;
-        this.#cursor = raw.length;
-        return;
-      }
-      if (ch === "\\") {
-        if (this.#cursor + 1 >= raw.length) return;
-        const esc = raw[this.#cursor + 1];
-        if (esc === "u") {
-          if (this.#cursor + 5 >= raw.length) return;
-          const hex = raw.slice(this.#cursor + 2, this.#cursor + 6);
-          if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-            this.#failed = true;
-            return;
-          }
-          this.#decoded += String.fromCharCode(parseInt(hex, 16));
-          this.#cursor += 6;
-          continue;
-        }
-        const mapped = ESCAPES[esc];
-        if (mapped === void 0) {
-          this.#failed = true;
-          return;
-        }
-        this.#decoded += mapped;
-        this.#cursor += 2;
-        continue;
-      }
-      if (ch < " ") {
-        this.#failed = true;
-        return;
-      }
-      this.#decoded += ch;
-      this.#cursor += 1;
-    }
-  }
-};
-
-// src/speculation/stream-tap.ts
-var toolCallBlock = (partial, contentIndex) => {
-  const content = partial?.content;
-  if (!Array.isArray(content)) return {};
-  const block = content[contentIndex];
-  if (!block || typeof block !== "object") return {};
-  const record = block;
-  if (record.type !== "toolCall") return {};
-  return {
-    ...typeof record.name === "string" && record.name ? { name: record.name } : {},
-    ...typeof record.id === "string" && record.id ? { id: record.id } : {}
-  };
-};
-var PARSE_INTERVAL_MS = 50;
-var FabricSpeculationStreamTap = class {
-  #options;
-  #streams = /* @__PURE__ */ new Map();
-  // The scanner depends on the TypeScript compiler; the factory arrives through
-  // a lazy dynamic import so session startup never pays for it. Streams opened
-  // before the factory lands are caught up in full (extractors buffer the
-  // whole decoded prefix, so no candidate is lost, only delayed).
-  #createScanner;
-  #lastParseAt = 0;
-  constructor(options) {
-    this.#options = options;
-  }
-  setScannerFactory(factory) {
-    this.#createScanner = factory;
-    for (const stream of this.#streams.values()) {
-      if (stream.scanner) continue;
-      stream.scanner = factory();
-      const code = stream.extractor.code;
-      if (!stream.isFabricExec || code === void 0) continue;
-      try {
-        for (const candidate of stream.scanner.push(code)) {
-          if (this.#options.isEligible(candidate.ref)) {
-            this.#pendingCatchUp.push({ stream, candidate });
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  #pendingCatchUp = [];
-  /** Drain candidates recovered while the scanner module loaded. */
-  flushCatchUp(context) {
-    const pending = this.#pendingCatchUp.splice(0);
-    for (const { stream, candidate } of pending) {
-      this.#options.launch(stream.toolCallId, candidate, context);
-    }
-  }
-  /** New assistant message: content indices restart. */
-  reset() {
-    this.#streams.clear();
-  }
-  handleMessageUpdate(event, context) {
-    try {
-      if (!this.#options.enabled()) return;
-      if (this.#pendingCatchUp.length > 0) this.flushCatchUp(context);
-      const assistantEvent = event.assistantMessageEvent;
-      if (assistantEvent.type === "toolcall_start") {
-        const block = toolCallBlock(assistantEvent.partial, assistantEvent.contentIndex);
-        this.#streams.set(assistantEvent.contentIndex, {
-          toolCallId: block.id ?? `index-${assistantEvent.contentIndex}`,
-          isFabricExec: block.name !== void 0 ? block.name === "fabric_exec" : true,
-          extractor: new PartialCodeFieldExtractor(this.#options.maxBufferBytes()),
-          ...this.#createScanner ? { scanner: this.#createScanner() } : {}
-        });
-        return;
-      }
-      if (assistantEvent.type === "toolcall_delta") {
-        const stream = this.#streams.get(assistantEvent.contentIndex);
-        if (!stream) return;
-        const block = toolCallBlock(assistantEvent.partial, assistantEvent.contentIndex);
-        if (block.id) stream.toolCallId = block.id;
-        if (block.name !== void 0) stream.isFabricExec = block.name === "fabric_exec";
-        stream.extractor.push(assistantEvent.delta);
-        const code = stream.extractor.code;
-        if (!stream.isFabricExec || code === void 0) return;
-        this.#scan(stream, code, context, false);
-        return;
-      }
-      if (assistantEvent.type === "toolcall_end") {
-        const stream = this.#streams.get(assistantEvent.contentIndex);
-        if (!stream) return;
-        this.#streams.delete(assistantEvent.contentIndex);
-        const block = toolCallBlock(assistantEvent.toolCall, assistantEvent.contentIndex);
-        if (block.id) stream.toolCallId = block.id;
-        if (block.name !== void 0) stream.isFabricExec = block.name === "fabric_exec";
-        const code = stream.extractor.code;
-        if (stream.isFabricExec && code !== void 0) {
-          this.#scan(stream, code, context, true);
-        }
-      }
-    } catch {
-    }
-  }
-  #scan(stream, code, context, force) {
-    const now = Date.now();
-    if (!force && now - this.#lastParseAt < PARSE_INTERVAL_MS) return;
-    this.#lastParseAt = now;
-    if (!stream.scanner) return;
-    const candidates = stream.scanner.push(code);
-    for (const candidate of candidates) {
-      if (this.#options.isEligible(candidate.ref)) {
-        this.#options.launch(stream.toolCallId, candidate, context);
-      }
-    }
-  }
-};
-
 // src/lifecycle/delivery-scheduler.ts
 var DEFAULT_LIFECYCLE_COALESCE_MS = 2e3;
 var LifecycleDeliveryScheduler = class {
@@ -4829,7 +4842,7 @@ var AGENTS_ACTION_DESCRIPTORS = [
 // src/residency/client.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs4 from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 var STARTUP_TIMEOUT_MS = 3e4;
 var COMMAND_TIMEOUT_MS = 3e4;
@@ -4849,7 +4862,7 @@ var readJson = (filePath) => {
 var terminal = (status) => status === "completed" || status === "failed" || status === "stopped" || status === "timed_out";
 var samePath = (left, right) => {
   try {
-    return path4.relative(fs4.realpathSync.native(left), fs4.realpathSync.native(right)) === "";
+    return path5.relative(fs4.realpathSync.native(left), fs4.realpathSync.native(right)) === "";
   } catch {
     return false;
   }
@@ -4878,12 +4891,12 @@ var ResidencyClient = class {
   constructor(options) {
     this.options = options;
     this.hostId = residentHostId(options.config.rootId);
-    this.#configPath = path4.join(options.config.residencyRoot, "config.json");
-    this.#ownerPath = path4.join(options.config.residencyRoot, "owner.json");
-    this.#errorPath = path4.join(options.config.residencyRoot, "error.json");
-    this.#requestsPath = path4.join(options.config.residencyRoot, "requests");
-    this.#responsesPath = path4.join(options.config.residencyRoot, "responses");
-    this.#agentsPath = path4.join(options.config.residencyRoot, "agents");
+    this.#configPath = path5.join(options.config.residencyRoot, "config.json");
+    this.#ownerPath = path5.join(options.config.residencyRoot, "owner.json");
+    this.#errorPath = path5.join(options.config.residencyRoot, "error.json");
+    this.#requestsPath = path5.join(options.config.residencyRoot, "requests");
+    this.#responsesPath = path5.join(options.config.residencyRoot, "responses");
+    this.#agentsPath = path5.join(options.config.residencyRoot, "agents");
     this.#deliveryPrefix = residentDeliveryPrefix(options.config.rootId);
     this.#hostPath = options.hostPath ?? fileURLToPath(new URL("./launcher.js", import.meta.url));
   }
@@ -4957,7 +4970,7 @@ var ResidencyClient = class {
     }
     const readIfPresent = (name) => {
       try {
-        return fs4.readFileSync(path4.join(this.options.config.residencyRoot, name), "utf8").trim();
+        return fs4.readFileSync(path5.join(this.options.config.residencyRoot, name), "utf8").trim();
       } catch {
         return "";
       }
@@ -5019,13 +5032,13 @@ var ResidencyClient = class {
   statusAgent(id) {
     const metadata = this.#metadata(id);
     if (!metadata) throw new Error(`Unknown durable Fabric agent: ${id}`);
-    const record = readJson(path4.join(metadata.runDirectory, "status.json"));
+    const record = readJson(path5.join(metadata.runDirectory, "status.json"));
     if (!record || record.id !== metadata.id) return structuredClone(metadata.handle);
     return {
       ...record,
       cwd: metadata.handle.cwd,
       residency: "durable",
-      logFile: path4.join(metadata.runDirectory, "events.jsonl"),
+      logFile: path5.join(metadata.runDirectory, "events.jsonl"),
       ...metadata.handle.sessionId ? { sessionId: metadata.handle.sessionId } : {},
       ...metadata.handle.attachCommand ? { attachCommand: metadata.handle.attachCommand } : {}
     };
@@ -5066,9 +5079,9 @@ var ResidencyClient = class {
   readAgentLog(id, options = {}) {
     const metadata = this.#metadata(id);
     if (!metadata) throw new Error(`Unknown durable Fabric agent: ${id}`);
-    const logFile = path4.join(metadata.runDirectory, "events.jsonl");
+    const logFile = path5.join(metadata.runDirectory, "events.jsonl");
     const page = readJsonlPage(logFile, Math.max(1, Math.min(options.lines ?? 200, 5e3)), options.before);
-    const status = readJson(path4.join(metadata.runDirectory, "status.json"));
+    const status = readJson(path5.join(metadata.runDirectory, "status.json"));
     return {
       id,
       runDirectory: metadata.runDirectory,
@@ -5143,8 +5156,8 @@ var ResidencyClient = class {
     return { cleaned: true };
   }
   async #command(command, signal) {
-    const responsePath = path4.join(this.#responsesPath, `${command.requestId}.json`);
-    atomicWrite2(path4.join(this.#requestsPath, `${command.requestId}.json`), command);
+    const responsePath = path5.join(this.#responsesPath, `${command.requestId}.json`);
+    atomicWrite2(path5.join(this.#requestsPath, `${command.requestId}.json`), command);
     const deadline = Date.now() + COMMAND_TIMEOUT_MS;
     while (Date.now() < deadline) {
       if (signal?.aborted) throw new Error("Fabric residency request was aborted");
@@ -5172,12 +5185,12 @@ var ResidencyClient = class {
     throw new Error(`Timed out publishing durable Fabric ${kind} ${id} from ${this.hostId}`);
   }
   #metadataPath(id) {
-    return path4.join(this.#agentsPath, `${id}.json`);
+    return path5.join(this.#agentsPath, `${id}.json`);
   }
   #metadata(id) {
     if (!AGENT_ID_PATTERN.test(id)) return void 0;
     const metadata = readJson(this.#metadataPath(id));
-    if (metadata?.format !== RESIDENT_HOST_FORMAT || metadata.rootId !== this.options.config.rootId || metadata.id !== id || metadata.handle.id !== id || metadata.worktreeGitRoot !== void 0 && typeof metadata.worktreeGitRoot !== "string" || path4.resolve(metadata.runDirectory) !== path4.resolve(this.options.config.residencyRoot, "runs", id)) {
+    if (metadata?.format !== RESIDENT_HOST_FORMAT || metadata.rootId !== this.options.config.rootId || metadata.id !== id || metadata.handle.id !== id || metadata.worktreeGitRoot !== void 0 && typeof metadata.worktreeGitRoot !== "string" || path5.resolve(metadata.runDirectory) !== path5.resolve(this.options.config.residencyRoot, "runs", id)) {
       return void 0;
     }
     if (metadata.handle.worktree && !isFabricWorktreePath(metadata.handle.worktree, id)) {
@@ -6518,7 +6531,7 @@ var AgentsProvider = class {
 };
 
 // src/providers/captured-tools-provider.ts
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/core/child-tool-allowlist.ts
 function readChildToolAllowlist(raw = process.env.OMP_FABRIC_TOOL_ALLOWLIST) {
@@ -6544,9 +6557,9 @@ var sourceLabel = (sourceInfo) => {
   while (index >= 0 && Object.hasOwn(SOURCE_DIRECTORIES, segments[index])) index -= 1;
   const owning = index >= 0 ? segments[index] : void 0;
   if (owning !== void 0 && PACKAGE_SEGMENT.test(owning)) return owning;
-  const filename = path5.basename(sourceInfo.path).replace(/\.[^.]+$/, "");
+  const filename = path6.basename(sourceInfo.path).replace(/\.[^.]+$/, "");
   if (filename && filename !== "index") return filename;
-  return path5.basename(path5.dirname(sourceInfo.path)) || sourceInfo.source;
+  return path6.basename(path6.dirname(sourceInfo.path)) || sourceInfo.source;
 };
 var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var schemaDocument = (schema) => {
@@ -6807,7 +6820,7 @@ var descriptors = [
   },
   {
     name: "status",
-    description: "Read the pending compaction intent and the last compaction outcome",
+    description: "Read context occupancy (context.tokens/percent/contextWindow, context.known=false when the host has not measured yet), the configured engine and targetContextRatio, the pending compaction intent, and the last settled outcome (status committed | skipped | cancelled | failed, with tokensBefore/estimatedTokensAfter)",
     inputSchema: emptySchema,
     risk: "read"
   },
@@ -6863,7 +6876,7 @@ var CompactProvider = class {
         return { requested: true, intent };
       }
       case "status":
-        return this.controller.status();
+        return this.controller.status(context.extensionContext);
       case "cancel":
         this.controller.cancel();
         context.activity?.({ type: "progress", message: "Compaction request cancelled" });
@@ -6963,7 +6976,7 @@ var ComponentsProvider = class {
 import fs5 from "node:fs/promises";
 import fsSync from "node:fs";
 import os from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 var MCP_DESCRIPTOR_CACHE_VERSION = 1;
 var homeDir = () => {
   const home = process.env.HOME;
@@ -6974,25 +6987,25 @@ var expandHome = (input) => {
   const home = homeDir();
   if (input === "~") return home;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path6.join(home, input.slice(2));
+    return path7.join(home, input.slice(2));
   }
   return input;
 };
-var legacyMcporterDir = () => path6.join(homeDir(), ".mcporter");
+var legacyMcporterDir = () => path7.join(homeDir(), ".mcporter");
 var mcporterConfigDir = () => {
   const raw = process.env.XDG_CONFIG_HOME;
   if (raw && raw.trim().length > 0) {
     const resolved = expandHome(raw.trim());
-    if (path6.isAbsolute(resolved)) return path6.join(resolved, "mcporter");
+    if (path7.isAbsolute(resolved)) return path7.join(resolved, "mcporter");
   }
   return legacyMcporterDir();
 };
 var mcporterConfigCandidates = () => {
   const base = mcporterConfigDir();
-  const candidates = [path6.join(base, "mcporter.json"), path6.join(base, "mcporter.jsonc")];
+  const candidates = [path7.join(base, "mcporter.json"), path7.join(base, "mcporter.jsonc")];
   const legacy = legacyMcporterDir();
   if (base !== legacy) {
-    candidates.push(path6.join(legacy, "mcporter.json"), path6.join(legacy, "mcporter.jsonc"));
+    candidates.push(path7.join(legacy, "mcporter.json"), path7.join(legacy, "mcporter.jsonc"));
   }
   return candidates;
 };
@@ -7007,12 +7020,12 @@ var pathExists = (filePath) => {
 var mcpConfigLayerPaths = (rootDir, configPath) => {
   const explicitRaw = configPath ?? process.env.MCPORTER_CONFIG;
   if (explicitRaw && explicitRaw.trim().length > 0) {
-    return [path6.resolve(expandHome(explicitRaw.trim()))];
+    return [path7.resolve(expandHome(explicitRaw.trim()))];
   }
   const paths = [];
   const home = mcporterConfigCandidates().find(pathExists);
   if (home) paths.push(home);
-  const projectPath = path6.resolve(rootDir, "config", "mcporter.json");
+  const projectPath = path7.resolve(rootDir, "config", "mcporter.json");
   if (pathExists(projectPath)) paths.push(projectPath);
   return paths;
 };
@@ -7063,6 +7076,8 @@ var parseCacheFile = (value) => {
     servers: value.servers
   };
 };
+var projectMcpCachePath = (projectRoot) => path7.join(projectRoot, ".omp", "fabric", "mcp-cache.json");
+var globalMcpCachePath = (agentDir) => path7.join(agentDir, "fabric", "mcp-descriptors.json");
 var tempCounter = 0;
 var McpDescriptorCacheStore = class {
   constructor(filePath) {
@@ -7079,9 +7094,9 @@ var McpDescriptorCacheStore = class {
   // Atomic-ish write: temp file then rename, so a concurrent reader either
   // sees the previous cache or the next one, never a torn document.
   async save(file) {
-    const directory = path6.dirname(this.filePath);
+    const directory = path7.dirname(this.filePath);
     await fs5.mkdir(directory, { recursive: true });
-    const tempPath = path6.join(
+    const tempPath = path7.join(
       directory,
       `.mcp-cache-${process.pid}-${Date.now()}-${tempCounter++}.tmp`
     );
@@ -7096,13 +7111,14 @@ var McpDescriptorCacheStore = class {
 };
 
 // src/providers/mcp-provider.ts
-import path7 from "node:path";
+import path8 from "node:path";
 var TOOL_METADATA_TTL_MS = 6e4;
 var REVALIDATE_CONCURRENCY = 3;
 var REVALIDATE_SERVER_TIMEOUT_MS = 2e4;
 var MIN_REVALIDATE_SERVER_TIMEOUT_MS = 5e3;
 var NOTIFY_DEBOUNCE_MS = 100;
 var PERSIST_DEBOUNCE_MS = 150;
+var COLD_LIST_WAIT_MS = 2500;
 var emptyObjectSchema = {
   type: "object",
   properties: {},
@@ -7177,6 +7193,18 @@ var normalizeMcpResult = (result) => {
     structuredContent: record.structuredContent ?? null
   };
 };
+var delay2 = (ms, signal) => new Promise((resolve2) => {
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve2();
+  }, ms);
+  timer.unref?.();
+  const onAbort = () => {
+    clearTimeout(timer);
+    resolve2();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
 var withTimeout = (operation, timeoutMs, onTimeout) => new Promise((resolve2, reject) => {
   const timer = setTimeout(() => {
     onTimeout?.();
@@ -7199,6 +7227,7 @@ var McpProvider = class {
     this.cwd = cwd;
     this.config = config;
     this.#store = options.cache;
+    this.#globalStore = options.globalCache;
     this.#hooks = options.hooks ?? {};
   }
   name = "mcp";
@@ -7207,6 +7236,7 @@ var McpProvider = class {
   #runtimeCreation;
   #toolMetadata = /* @__PURE__ */ new Map();
   #store;
+  #globalStore;
   #hooks;
   #generation = 0;
   #closed = false;
@@ -7217,8 +7247,10 @@ var McpProvider = class {
   #revalidateQueue = [];
   #revalidateQueued = /* @__PURE__ */ new Set();
   #recontacted = /* @__PURE__ */ new Set();
+  #seeded = /* @__PURE__ */ new Set();
   #revalidating;
   #autoKicked = false;
+  #coldWaited = false;
   #dirtyPersist = false;
   #dirtyNotify = false;
   #persistTimer;
@@ -7231,6 +7263,7 @@ var McpProvider = class {
     if (!this.#cacheOn) return this.#listLegacy(request, context);
     await this.#hydrate();
     this.#kickRevalidation();
+    if (!request.namespace) await this.#awaitColdEnumeration(context.signal);
     const query = request.query?.toLowerCase();
     const filterQuery = (descriptors6) => query ? descriptors6.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
@@ -7298,6 +7331,8 @@ var McpProvider = class {
         this.#servers.clear();
         this.#pending.clear();
         this.#recontacted.clear();
+        this.#seeded.clear();
+        this.#coldWaited = false;
         this.#hydration = void 0;
         await this.#hydrate();
         this.#kickRevalidation(true);
@@ -7347,11 +7382,36 @@ var McpProvider = class {
     if (this.#dirtyPersist) await this.#persistNow().catch(() => void 0);
     await this.#resetRuntime();
   }
-  // Fire-and-forget session warm-up: hydrate from the descriptor cache, then
-  // start the background revalidation policy. Never awaited by session start.
   warmup() {
-    if (!this.config.enabled || !this.#cacheOn) return;
-    void this.#hydrate().then(() => this.#kickRevalidation()).catch(() => void 0);
+    if (!this.config.enabled || !this.#cacheOn) return Promise.resolve();
+    return this.#hydrate().then(() => this.#kickRevalidation()).catch(() => void 0);
+  }
+  listCoverage() {
+    if (!this.config.enabled || !this.#cacheOn) return { complete: true, reasons: [] };
+    const pending = [...this.#pending.keys()].sort();
+    if (pending.length === 0) return { complete: true, reasons: [] };
+    return {
+      complete: false,
+      reasons: [
+        "enumeration_pending",
+        ...pending.map((server) => `server_pending:${server}`)
+      ]
+    };
+  }
+  async #awaitColdEnumeration(signal) {
+    if (this.#coldWaited || this.#closed) return;
+    this.#coldWaited = true;
+    if (this.#pending.size === 0 || this.#servers.size > 0) return;
+    const budget = Math.min(COLD_LIST_WAIT_MS, Math.max(0, this.config.cache.revalidateBudgetMs));
+    if (budget <= 0) return;
+    const deadline = Date.now() + budget;
+    while (!this.#closed && this.#pending.size > 0 && signal?.aborted !== true) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return;
+      const inflight = this.#revalidating;
+      if (!inflight) return;
+      await Promise.race([inflight, delay2(remaining, signal)]);
+    }
   }
   // Provider-fidelity descriptors for everything currently known, cached or
   // ephemeral.
@@ -7446,10 +7506,13 @@ var McpProvider = class {
   }
   async #hydrateInternal() {
     const generation = this.#generation;
-    const snapshot = this.#store ? await this.#store.load().catch(() => void 0) : void 0;
+    const [snapshot, globalSnapshot] = await Promise.all([
+      this.#store ? this.#store.load().catch(() => void 0) : Promise.resolve(void 0),
+      this.#globalStore ? this.#globalStore.load().catch(() => void 0) : Promise.resolve(void 0)
+    ]);
     this.#layerStats = await statConfigLayers(this.cwd, this.config.configPath);
     if (generation !== this.#generation) return;
-    if (snapshot && sameConfigLayers(snapshot.layers, this.#layerStats)) {
+    if (snapshot && Object.keys(snapshot.servers).length > 0 && sameConfigLayers(snapshot.layers, this.#layerStats)) {
       for (const [name, raw] of Object.entries(snapshot.servers)) {
         const parsed = parseCachedServer(raw);
         if (parsed) this.#servers.set(name, this.#toWorking(parsed, false));
@@ -7465,15 +7528,21 @@ var McpProvider = class {
         const parsed = recorded ? parseCachedServer(recorded) : void 0;
         if (parsed && parsed.definitionHash === hash) {
           this.#servers.set(definition.name, this.#toWorking(parsed, false));
-        } else {
-          const existing = this.#pending.get(definition.name);
-          this.#pending.set(definition.name, {
-            definitionHash: hash,
-            transport: definition.command.kind,
-            description: definition.description ?? null,
-            ephemeral: existing?.ephemeral ?? false
-          });
+          continue;
+        }
+        const seed = globalSnapshot ? parseCachedServer(globalSnapshot.servers[definition.name]) : void 0;
+        if (seed && seed.definitionHash === hash && seed.tools.length > 0) {
+          this.#servers.set(definition.name, { ...this.#toWorking(seed, false), stale: true });
+          this.#seeded.add(definition.name);
+          continue;
         }
+        const existing = this.#pending.get(definition.name);
+        this.#pending.set(definition.name, {
+          definitionHash: hash,
+          transport: definition.command.kind,
+          description: definition.description ?? null,
+          ephemeral: existing?.ephemeral ?? false
+        });
       }
       this.#dirtyPersist = true;
       this.#schedulePersist();
@@ -7509,7 +7578,7 @@ var McpProvider = class {
     this.#autoKicked = true;
     const policy = this.config.cache.revalidate;
     if (policy === "off" && !forceAll) return;
-    const targets = forceAll || policy === "all" ? [...this.#servers.keys(), ...this.#pending.keys()] : [...this.#pending.keys()];
+    const targets = forceAll || policy === "all" ? [...this.#servers.keys(), ...this.#pending.keys()] : [...this.#pending.keys(), ...this.#seeded];
     this.#scheduleRevalidate(targets);
   }
   #scheduleRevalidate(servers) {
@@ -7616,7 +7685,7 @@ var McpProvider = class {
     return sanitized.length === 1 ? sanitized[0] : void 0;
   }
   #schedulePersist() {
-    if (!this.#store || this.#closed) return;
+    if (!this.#store && !this.#globalStore || this.#closed) return;
     this.#dirtyPersist = true;
     if (this.#persistTimer) return;
     this.#persistTimer = setTimeout(() => {
@@ -7627,7 +7696,7 @@ var McpProvider = class {
   }
   #persistNow() {
     this.#dirtyPersist = false;
-    if (!this.#store) return Promise.resolve();
+    if (!this.#store && !this.#globalStore) return Promise.resolve();
     const servers = {};
     for (const [name, entry] of this.#servers) {
       if (entry.ephemeral) continue;
@@ -7649,11 +7718,36 @@ var McpProvider = class {
         })
       };
     }
-    return this.#store.save({
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return Promise.all([
+      this.#store?.save({
+        version: MCP_DESCRIPTOR_CACHE_VERSION,
+        layers: this.#layerStats,
+        updatedAt,
+        servers
+      }),
+      this.#persistGlobal(servers, updatedAt)
+    ]).then(() => void 0);
+  }
+  async #persistGlobal(servers, updatedAt) {
+    const store = this.#globalStore;
+    if (!store) return;
+    const enumerated = Object.entries(servers).filter(
+      ([, entry]) => entry.tools.length > 0 && !entry.stale
+    );
+    if (enumerated.length === 0) return;
+    const existing = await store.load().catch(() => void 0);
+    const merged = {};
+    for (const [name, raw] of Object.entries(existing?.servers ?? {})) {
+      const parsed = parseCachedServer(raw);
+      if (parsed) merged[name] = parsed;
+    }
+    for (const [name, entry] of enumerated) merged[name] = { ...entry };
+    await store.save({
       version: MCP_DESCRIPTOR_CACHE_VERSION,
-      layers: this.#layerStats,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      servers
+      layers: [],
+      updatedAt,
+      servers: merged
     });
   }
   #scheduleNotify() {
@@ -7728,7 +7822,7 @@ var McpProvider = class {
           kind: "stdio",
           command: args.command,
           args: commandArgs,
-          cwd: path7.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
+          cwd: path8.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
         },
         ...env ? { env } : {}
       };
@@ -8094,13 +8188,16 @@ var MeshProvider = class {
 };
 
 // src/providers/omp-tools-provider.ts
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync as mkdirSync2, mkdtempSync, readFileSync as readFileSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
 import os2 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { BashTool } from "@oh-my-pi/pi-coding-agent/tools/bash";
 import { EditTool } from "@oh-my-pi/pi-coding-agent/edit";
+import { GrepTool, MULTI_FILE_PER_FILE_MATCHES, SINGLE_FILE_MATCHES } from "@oh-my-pi/pi-coding-agent/tools/grep";
 import { ReadTool } from "@oh-my-pi/pi-coding-agent/tools/read";
+import { piEscapeRegexLiteral, piJoinPath } from "@oh-my-pi/pi-ai/providers/cursor-pi-args";
 import { Settings } from "@oh-my-pi/pi-coding-agent";
 import {
   createFindToolDefinition,
@@ -8110,7 +8207,7 @@ import {
 
 // src/agents/bash-worktree-add.ts
 import fs6 from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 var BARE_SAFE = /^[A-Za-z0-9_./:@%+=,-]+$/;
 var parseGitWorktreeAdd = (command) => {
   const trimmed = command.trim();
@@ -8173,8 +8270,8 @@ var tryExecuteGitWorktreeAdd = async (args, sessionCwd) => {
   if (typeof command !== "string") return void 0;
   const parsed = parseGitWorktreeAdd(command);
   if (!parsed) return void 0;
-  const gitCwd = parsed.gitCwd ? path8.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
-  const dest = path8.resolve(gitCwd, parsed.dest);
+  const gitCwd = parsed.gitCwd ? path9.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
+  const dest = path9.resolve(gitCwd, parsed.dest);
   let gitRoot;
   try {
     const root = await executeFile("git", ["rev-parse", "--show-toplevel"], {
@@ -8202,8 +8299,8 @@ var tryExecuteGitWorktreeAdd = async (args, sessionCwd) => {
 };
 
 // src/providers/omp-bash-cwd.ts
-import { accessSync, constants, statSync } from "node:fs";
-import path9 from "node:path";
+import { accessSync, constants, statSync as statSync2 } from "node:fs";
+import path10 from "node:path";
 import { createBashToolDefinition } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-pi-coding-agent-shim";
 import { Type as Type2 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 var OMP_BASH_CWD_KEY = "cwd";
@@ -8213,9 +8310,9 @@ var resolveOmpShellCwd = (toolName, sessionCwd, requested) => {
       `Invalid omp.${toolName} cwd ${JSON.stringify(requested)}: path must be a non-empty string`
     );
   }
-  const resolved = path9.isAbsolute(requested) ? path9.resolve(requested) : path9.resolve(sessionCwd, requested);
+  const resolved = path10.isAbsolute(requested) ? path10.resolve(requested) : path10.resolve(sessionCwd, requested);
   try {
-    if (!statSync(resolved).isDirectory()) throw new Error("path is not a directory");
+    if (!statSync2(resolved).isDirectory()) throw new Error("path is not a directory");
     accessSync(resolved, constants.R_OK | constants.X_OK);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
@@ -8292,19 +8389,19 @@ import { dirname, isAbsolute, resolve } from "node:path";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { Type as Type3 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 var mutationQueues = /* @__PURE__ */ new Map();
-var withFileMutationQueue = async (path16, operation) => {
-  const previous = mutationQueues.get(path16) ?? Promise.resolve();
+var withFileMutationQueue = async (path17, operation) => {
+  const previous = mutationQueues.get(path17) ?? Promise.resolve();
   let release;
   const current = new Promise((resolve2) => {
     release = resolve2;
   });
-  mutationQueues.set(path16, current);
+  mutationQueues.set(path17, current);
   await previous;
   try {
     return await operation();
   } finally {
     release();
-    if (mutationQueues.get(path16) === current) mutationQueues.delete(path16);
+    if (mutationQueues.get(path17) === current) mutationQueues.delete(path17);
   }
 };
 var resolvePreviewPath = (filePath, cwd) => {
@@ -8357,14 +8454,14 @@ var createPreviewWriteToolDefinition = (cwd) => {
   return {
     ...original,
     async execute(_toolCallId, params, signal) {
-      const { path: path16, content } = params;
-      const absolutePath = resolvePreviewPath(path16, cwd);
+      const { path: path17, content } = params;
+      const absolutePath = resolvePreviewPath(path17, cwd);
       return withFileMutationQueue(absolutePath, async () => {
         const throwIfAborted2 = () => {
           if (signal?.aborted) throw new Error("Operation aborted");
         };
         throwIfAborted2();
-        const before = await readExistingFileForPreview(path16, cwd, content);
+        const before = await readExistingFileForPreview(path17, cwd, content);
         throwIfAborted2();
         await mkdir(dirname(absolutePath), { recursive: true });
         throwIfAborted2();
@@ -8374,7 +8471,7 @@ var createPreviewWriteToolDefinition = (cwd) => {
           content: [
             {
               type: "text",
-              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path16}`
+              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path17}`
             }
           ],
           details: { codePreviewBeforeWrite: before }
@@ -8386,27 +8483,39 @@ var createPreviewWriteToolDefinition = (cwd) => {
 
 // src/providers/omp-tools-provider.ts
 var MAX_RENDERER_ARGUMENT_CHARS = 2e5;
+var GUEST_READ_LINE_LIMIT = 1e5;
 var MAX_REPLACE_ALL_FILE_CHARS = 2e6;
 var createNativeSession = (cwd, artifactPaths) => {
-  const artifactRoot = artifactPaths ? mkdtempSync(path10.join(os2.tmpdir(), "omp-fabric-bash-")) : void 0;
+  const artifactRoot = artifactPaths ? mkdtempSync(path11.join(os2.tmpdir(), "omp-fabric-bash-")) : void 0;
   return {
     cwd,
     hasUI: false,
     hasEditTool: false,
     getSessionFile: () => null,
     getSessionSpawns: () => null,
-    settings: Settings.isolated({ readLineNumbers: false }),
+    settings: Settings.isolated({
+      readLineNumbers: false,
+      "read.defaultLimit": GUEST_READ_LINE_LIMIT,
+      "tools.outputMaxColumns": 0
+    }),
     ...artifactRoot && artifactPaths ? {
       allocateOutputArtifact: async (toolType) => {
-        const id = randomUUID3();
-        const artifactPath = path10.join(artifactRoot, `${toolType}-${id}.log`);
-        writeFileSync(artifactPath, "", { mode: 384 });
-        artifactPaths.set(id, artifactPath);
-        return { id, path: artifactPath };
+        try {
+          mkdirSync2(artifactRoot, { recursive: true, mode: 448 });
+          const id = randomUUID3();
+          const artifactPath = path11.join(artifactRoot, `${toolType}-${id}.log`);
+          writeFileSync2(artifactPath, "", { mode: 384 });
+          artifactPaths.set(id, artifactPath);
+          artifactAllocations.getStore()?.push(artifactPath);
+          return { id, path: artifactPath };
+        } catch {
+          return {};
+        }
       }
     } : {}
   };
 };
+var artifactAllocations = new AsyncLocalStorage();
 var nativeDefinition = (tool) => {
   const execute = (toolCallId, params, signal, onUpdate, context) => tool.execute(toolCallId, params, signal, onUpdate, context);
   return {
@@ -8420,6 +8529,65 @@ var nativeDefinition = (tool) => {
 var createNativeBashToolDefinition = (cwd, artifactPaths) => nativeDefinition(new BashTool(createNativeSession(cwd, artifactPaths)));
 var createNativeReadToolDefinition = (cwd) => nativeDefinition(new ReadTool(createNativeSession(cwd)));
 var createNativeReplaceEditToolDefinition = (cwd) => nativeDefinition(new EditTool(createNativeSession(cwd), "replace"));
+var normalizeReadArguments = (args) => {
+  const offset = finiteNumber2(args.offset);
+  const limit = finiteNumber2(args.limit);
+  if (offset === void 0 && limit === void 0) return args;
+  const { offset: _offset, limit: _limit, ...rest } = args;
+  const target = parseReadTarget(args.path);
+  if (!target || target.selected) return rest;
+  const start = offset === void 0 ? 1 : Math.max(1, Math.floor(offset));
+  const end = limit === void 0 ? Number.POSITIVE_INFINITY : start + Math.max(1, Math.floor(limit)) - 1;
+  return { ...rest, path: readPageSelector({ ...target, endLimit: end }, start) };
+};
+var GREP_SKIP_PROPERTY = {
+  type: "number",
+  description: "Files to skip before collecting results \u2014 paginate when a search hit the file limit"
+};
+var withGrepSkipSchema = (document) => {
+  const schema = asRecord(document);
+  const properties = asRecord(schema?.properties);
+  if (!schema || !properties || Object.hasOwn(properties, "skip")) return document;
+  return { ...schema, properties: { ...properties, skip: GREP_SKIP_PROPERTY } };
+};
+var grepSession = (cwd, context) => ({
+  cwd,
+  hasUI: false,
+  getSessionFile: () => null,
+  getSessionSpawns: () => null,
+  settings: Settings.isolated(
+    context === void 0 ? void 0 : { "grep.contextBefore": Math.max(0, Math.floor(context)), "grep.contextAfter": Math.max(0, Math.floor(context)) }
+  )
+});
+var createGrepDefinitionWithSkip = (cwd) => {
+  const legacy = createGrepToolDefinition(cwd);
+  const defaultTool = new GrepTool(grepSession(cwd));
+  return {
+    ...legacy,
+    parameters: withGrepSkipSchema(legacy.parameters),
+    execute: (toolCallId, params, signal, onUpdate, context) => {
+      const record = asRecord(params) ?? {};
+      const rawPattern = typeof record.pattern === "string" ? record.pattern : "";
+      const searchPath = typeof record.path === "string" ? record.path : ".";
+      const glob = typeof record.glob === "string" ? record.glob : void 0;
+      const contextLines = typeof record.context === "number" ? record.context : void 0;
+      const skip = typeof record.skip === "number" ? record.skip : void 0;
+      const tool = contextLines === void 0 ? defaultTool : new GrepTool(grepSession(cwd, contextLines));
+      return tool.execute(
+        toolCallId,
+        {
+          pattern: record.literal === true ? piEscapeRegexLiteral(rawPattern) : rawPattern,
+          path: glob ? piJoinPath(searchPath, glob) : searchPath,
+          case: record.ignoreCase === true ? false : void 0,
+          ...skip === void 0 ? {} : { skip }
+        },
+        signal,
+        onUpdate,
+        context
+      );
+    }
+  };
+};
 var normalizeEditArguments = (args, replaceAll, cwd) => {
   const filePath = args.path;
   if (typeof filePath !== "string") throw new Error("omp.edit requires a path");
@@ -8442,8 +8610,8 @@ var normalizeEditArguments = (args, replaceAll, cwd) => {
       ...replaceAll || record.all === true || record.replace_all === true ? { replace_all: true } : {}
     };
   });
-  const resolvedPath = path10.resolve(cwd, filePath.startsWith("@") ? filePath.slice(1) : filePath);
-  const current = readFileSync(resolvedPath, "utf8");
+  const resolvedPath = path11.resolve(cwd, filePath.startsWith("@") ? filePath.slice(1) : filePath);
+  const current = readFileSync2(resolvedPath, "utf8");
   if (current.length > MAX_REPLACE_ALL_FILE_CHARS) {
     throw new Error(`omp.edit refuses files over ${MAX_REPLACE_ALL_FILE_CHARS} characters`);
   }
@@ -8503,6 +8671,206 @@ var imageBlocks = (content) => {
   }
   return blocks;
 };
+var TRUNCATION_MARKER = "[[omp-fabric:truncated]]";
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+var finiteNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var appendTruncationMarker = (text, signal) => `${text.endsWith("\n") || text.length === 0 ? text : `${text}
+`}${TRUNCATION_MARKER} ${JSON.stringify(signal)}
+`;
+var readTruncationMeta = (details) => {
+  const truncation = asRecord(asRecord(asRecord(details)?.meta)?.truncation);
+  if (!truncation) return void 0;
+  const shown = asRecord(truncation.shownRange);
+  const truncatedBy = typeof truncation.truncatedBy === "string" ? truncation.truncatedBy : void 0;
+  const totalLines = finiteNumber2(truncation.totalLines);
+  const totalBytes = finiteNumber2(truncation.totalBytes);
+  const outputBytes = finiteNumber2(truncation.outputBytes);
+  const nextOffset = finiteNumber2(truncation.nextOffset);
+  const shownStart = finiteNumber2(shown?.start);
+  const shownEnd = finiteNumber2(shown?.end);
+  return {
+    partialLine: truncation.partialLine === true,
+    ...truncatedBy === void 0 ? {} : { truncatedBy },
+    ...totalLines === void 0 ? {} : { totalLines },
+    ...totalBytes === void 0 ? {} : { totalBytes },
+    ...outputBytes === void 0 ? {} : { outputBytes },
+    ...nextOffset === void 0 ? {} : { nextOffset },
+    ...shownStart === void 0 ? {} : { shownStart },
+    ...shownEnd === void 0 ? {} : { shownEnd }
+  };
+};
+var UNREADABLE_READ_NOTE = /^\[Cannot read (?:binary file '|\.[^\s:]+ file: )/;
+var REPEAT_READ_HINT_PATTERN = /\n\n\[You have received this identical output \d+ times\. Re-reading '[\s\S]*?' will not change it — use a narrower selector \(path:A-B\), or proceed with the edit\.\]$/;
+var stripRepeatReadHint = (text) => text.endsWith("]") ? text.replace(REPEAT_READ_HINT_PATTERN, "") : text;
+var dropLeadingLines = (text, count) => {
+  if (count <= 0) return text;
+  let index = 0;
+  for (let dropped = 0; dropped < count; dropped++) {
+    const newline = text.indexOf("\n", index);
+    if (newline === -1) return "";
+    index = newline + 1;
+  }
+  return text.slice(index);
+};
+var keepLeadingLines = (text, count) => {
+  if (count <= 0) return "";
+  let index = 0;
+  for (let kept = 0; kept < count; kept++) {
+    const newline = text.indexOf("\n", index);
+    if (newline === -1) return text;
+    index = newline + 1;
+  }
+  return text.slice(0, index - 1);
+};
+var countLines = (text) => {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) lines++;
+  return text.endsWith("\n") ? lines - 1 : lines;
+};
+var READ_SELECTOR_PATTERN = /:(raw:)?(\d+)(-(\d+)?)?$/i;
+var READ_RAW_SELECTOR_PATTERN = /:raw$/i;
+var WINDOWS_PATH_ROOT_PATTERN = /^(?:\\\\[?.]\\)?[A-Za-z]:(?=[\\/])/;
+var withoutWindowsRoot = (rawPath) => rawPath.slice(WINDOWS_PATH_ROOT_PATTERN.exec(rawPath)?.[0].length ?? 0);
+var readPageSelector = (target, offset) => target.endLimit === Number.POSITIVE_INFINITY ? `${target.base}:raw:${offset}-` : `${target.base}:raw:${offset}-${target.endLimit}`;
+var parseReadTarget = (rawPath) => {
+  if (typeof rawPath !== "string" || rawPath.length === 0 || rawPath.includes("://")) return void 0;
+  const match = READ_SELECTOR_PATTERN.exec(rawPath);
+  if (match) {
+    const end = match[3] === void 0 ? Number.POSITIVE_INFINITY : match[4] === void 0 ? Number.POSITIVE_INFINITY : Number(match[4]);
+    return { base: rawPath.slice(0, match.index), start: Number(match[2]), endLimit: end, pageable: true, selected: true };
+  }
+  if (READ_RAW_SELECTOR_PATTERN.test(rawPath)) {
+    return {
+      base: rawPath.replace(READ_RAW_SELECTOR_PATTERN, ""),
+      start: 1,
+      endLimit: Number.POSITIVE_INFINITY,
+      pageable: true,
+      selected: true
+    };
+  }
+  const body = withoutWindowsRoot(rawPath);
+  const lastColon = body.lastIndexOf(":");
+  const suffix = lastColon === -1 ? "" : body.slice(lastColon + 1);
+  const pageable = suffix.length === 0;
+  return { base: rawPath, start: 1, endLimit: Number.POSITIVE_INFINITY, pageable, selected: false };
+};
+var unreadableReadMessage = (note, readPath) => {
+  const target = typeof readPath === "string" ? readPath.replace(READ_SELECTOR_PATTERN, "") : void 0;
+  const remedy = target ? ` Read the bytes with omp.read("${target}:raw").` : "";
+  return `omp.read returned no text content: ${note.trim()}${remedy}`;
+};
+var restoreBashOutput = (artifactPath, maxChars, delivered) => {
+  if (!artifactPath || maxChars <= 0) return void 0;
+  let size;
+  try {
+    size = statSync3(artifactPath).size;
+  } catch {
+    return void 0;
+  }
+  if (size === 0 || size > maxChars) return void 0;
+  let full;
+  try {
+    full = readFileSync2(artifactPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  if (full.length < delivered.length) return void 0;
+  const ellipsis = delivered.indexOf("\u2026");
+  const prefix = ellipsis === -1 ? delivered : delivered.slice(0, ellipsis);
+  return full.startsWith(prefix) ? full : void 0;
+};
+var withoutColumnLimit = (detailRecord, metaRecord) => {
+  const limits = asRecord(metaRecord?.limits);
+  if (!metaRecord || !limits || !Object.hasOwn(limits, "columnTruncated")) return detailRecord;
+  const { columnTruncated: _dropped, ...remainingLimits } = limits;
+  const { limits: _limits, ...remainingMeta } = metaRecord;
+  const nextMeta = Object.keys(remainingLimits).length > 0 ? { ...remainingMeta, limits: remainingLimits } : remainingMeta;
+  if (Object.keys(nextMeta).length > 0) return { ...detailRecord, meta: nextMeta };
+  const { meta: _meta, ...remainingDetails } = detailRecord;
+  return remainingDetails;
+};
+var grepTruncationSignal = (details) => {
+  const record = asRecord(details);
+  if (!record || record.truncated !== true) return void 0;
+  const perFile = finiteNumber2(record.perFileLimitReached);
+  const maxColumn = finiteNumber2(asRecord(asRecord(asRecord(record.meta)?.limits)?.columnTruncated)?.maxColumn);
+  const fileCount = finiteNumber2(record.fileCount);
+  const reasons = [];
+  const notes = [];
+  let continuation = null;
+  if (perFile !== void 0) {
+    reasons.push("matchLimit");
+    notes.push(
+      perFile <= MULTI_FILE_PER_FILE_MATCHES ? `Only ${perFile} matches per file are returned for a multi-file scope; point path at a single file to raise it to ${SINGLE_FILE_MATCHES}.` : `Only ${perFile} matches per file are returned; grep has no match cursor, so narrow the pattern or split the search by path.`
+    );
+  }
+  if (maxColumn !== void 0) {
+    reasons.push("columnLimit");
+    notes.push(
+      `Match lines are cut at ${maxColumn} bytes by the host, so a reported line need not contain the match; read the full line with omp.read("<file>:<line>").`
+    );
+  }
+  if (reasons.length === 0) {
+    reasons.push("fileLimit");
+    if (fileCount !== void 0) continuation = { skip: fileCount };
+    notes.push(
+      fileCount === void 0 ? "More files matched than were returned; narrow the pattern or path." : `More files matched than were returned; pass skip=${fileCount} for the next page.`
+    );
+  }
+  return {
+    tool: "grep",
+    partial: true,
+    reasons,
+    ...finiteNumber2(record.matchCount) === void 0 ? {} : { matchCount: record.matchCount },
+    ...fileCount === void 0 ? {} : { fileCount },
+    ...perFile === void 0 ? {} : { perFileMatchLimit: perFile },
+    ...maxColumn === void 0 ? {} : { maxColumn },
+    continue: continuation,
+    note: notes.join(" ")
+  };
+};
+var GUEST_RESULT_CHAR_FALLBACK = 1e6;
+var READ_MARKER_RESERVE_CHARS = 512;
+var resultCharBound = (context) => {
+  const value = Reflect.get(context, "maxResultChars");
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : GUEST_RESULT_CHAR_FALLBACK;
+};
+var byteBudgetSignal = (meta) => ({
+  tool: "read",
+  partial: true,
+  reasons: ["byteBudget"],
+  totalBytes: meta.totalBytes ?? null,
+  deliveredBytes: meta.outputBytes ?? null,
+  continue: null,
+  note: "A single line exceeded the host per-read byte budget and no read selector continues a partial line; split the file (omp.bash with fold or split) and read the pieces."
+});
+var lineBudgetSignal = (meta, target, progress) => {
+  const nextOffset = progress ? progress.nextOffset : meta.nextOffset;
+  const continuation = target && nextOffset !== void 0 ? readPageSelector(target, nextOffset) : null;
+  return {
+    tool: "read",
+    partial: true,
+    reasons: [progress?.reason ?? "lineBudget"],
+    totalLines: meta.totalLines ?? null,
+    deliveredLines: progress?.delivered ?? null,
+    continue: continuation,
+    note: continuation ? `More lines remain; continue with omp.read("${continuation}").` : "More lines remain and the host offered no continuation offset."
+  };
+};
+var findTruncationSignal = (details) => {
+  const record = asRecord(details);
+  if (!record || record.truncated !== true) return void 0;
+  const reached = finiteNumber2(record.resultLimitReached) ?? finiteNumber2(record.fileCount);
+  return {
+    tool: "find",
+    partial: true,
+    reasons: ["resultLimit"],
+    ...reached === void 0 ? {} : { resultLimit: reached },
+    continue: null,
+    note: `The host caps find at ${reached ?? "its result limit"} results and clamps any larger limit, so narrow pattern or path, or enumerate with omp.bash.`
+  };
+};
 var resultHasTruncation = (details) => {
   if (details === null || typeof details !== "object" || Array.isArray(details)) return false;
   const meta = Reflect.get(details, "meta");
@@ -8516,15 +8884,26 @@ var resultExitCode = (details) => {
   const exitCode = Reflect.get(details, "exitCode");
   return Number.isSafeInteger(exitCode) && exitCode > 0 ? exitCode : void 0;
 };
-var normalizeResult = (name, result, artifactPaths, appendReadNewline = true) => {
-  const text = isOmpShellToolName(name) ? stripOmpBashTiming(textContent(result.content)) : textContent(result.content);
+var normalizeResult = (name, result, artifactPaths, appendReadNewline = true, extras) => {
+  const readSignal = extras?.read;
+  const text = isOmpShellToolName(name) ? stripOmpBashTiming(textContent(result.content)) : name === "read" ? stripRepeatReadHint(textContent(result.content)) : textContent(result.content);
   if (result.isError && !resultHasTruncation(result.details)) throw new Error(text || `${name} failed`);
   if (name === "read") {
-    return appendReadNewline && text.length > 0 && !text.endsWith("\n") ? `${text}
+    const body = appendReadNewline && text.length > 0 && !text.endsWith("\n") ? `${text}
 ` : text;
+    return readSignal?.signal ? appendTruncationMarker(body, readSignal.signal) : body;
+  }
+  if (name === "grep") {
+    const signal = grepTruncationSignal(result.details);
+    return signal ? appendTruncationMarker(text, signal) : text;
   }
-  if (name === "grep" || name === "find" || name === "ls") return text;
+  if (name === "find") {
+    const signal = findTruncationSignal(result.details);
+    return signal ? appendTruncationMarker(text, signal) : text;
+  }
+  if (name === "ls") return text;
   let details = result.details;
+  let output = text;
   if (isOmpShellToolName(name) && details && typeof details === "object" && !Array.isArray(details)) {
     const detailRecord = details;
     const meta = detailRecord.meta;
@@ -8533,19 +8912,62 @@ var normalizeResult = (name, result, artifactPaths, appendReadNewline = true) =>
     if (truncation && typeof truncation === "object" && !Array.isArray(truncation)) {
       const truncationRecord = truncation;
       const artifactId = truncationRecord.artifactId;
-      const fullOutputPath = typeof artifactId === "string" ? artifactPaths?.get(artifactId) : void 0;
+      const fullOutputPath = typeof artifactId === "string" ? artifactPaths?.get(artifactId) ?? extras?.bashArtifactPath : extras?.bashArtifactPath;
       details = {
         ...detailRecord,
         truncation: { ...truncationRecord, truncated: true },
         ...fullOutputPath ? { fullOutputPath } : {}
       };
+      if (truncationRecord.truncated !== false) {
+        const columnCap = finiteNumber2(asRecord(asRecord(metaRecord?.limits)?.columnTruncated)?.maxColumn);
+        output = appendTruncationMarker(text, {
+          tool: name,
+          partial: true,
+          reasons: columnCap === void 0 ? ["outputLimit"] : ["outputLimit", "columnLimit"],
+          truncatedBy: truncationRecord.truncatedBy ?? null,
+          totalLines: finiteNumber2(truncationRecord.totalLines) ?? null,
+          totalBytes: finiteNumber2(truncationRecord.totalBytes) ?? null,
+          deliveredBytes: finiteNumber2(truncationRecord.outputBytes) ?? null,
+          ...columnCap === void 0 ? {} : { maxColumn: columnCap },
+          fullOutputPath: fullOutputPath ?? null,
+          continue: null,
+          note: fullOutputPath ? `Output exceeded the host bash result budget; the complete stream is on disk at ${fullOutputPath}.` : "Output exceeded the host bash result budget and no full-output artifact was retained."
+        });
+      }
+    } else {
+      const columnCap = finiteNumber2(asRecord(asRecord(metaRecord?.limits)?.columnTruncated)?.maxColumn);
+      if (columnCap !== void 0) {
+        const restored = restoreBashOutput(extras?.bashArtifactPath, extras?.maxResultChars ?? 0, text);
+        if (restored === void 0) {
+          details = {
+            ...detailRecord,
+            columnTruncated: { maxColumn: columnCap, restored: false },
+            ...extras?.bashArtifactPath ? { fullOutputPath: extras.bashArtifactPath } : {}
+          };
+          output = appendTruncationMarker(text, {
+            tool: name,
+            partial: true,
+            reasons: ["columnLimit"],
+            maxColumn: columnCap,
+            fullOutputPath: extras?.bashArtifactPath ?? null,
+            continue: null,
+            note: `Output lines were cut at ${columnCap} bytes by the host bash executor, which reads global settings and ignores this session's tools.outputMaxColumns.`
+          });
+        } else {
+          output = restored;
+          details = {
+            ...withoutColumnLimit(detailRecord, metaRecord),
+            columnTruncated: { maxColumn: columnCap, restored: true }
+          };
+        }
+      }
     }
   }
   if (name === "write" && details && typeof details === "object" && !Array.isArray(details)) {
     const { codePreviewBeforeWrite: _before, ...publicDetails } = details;
     details = Object.keys(publicDetails).length > 0 ? publicDetails : void 0;
   }
-  return { ok: true, output: text, details: details ?? null };
+  return { ok: true, output, details: details ?? null };
 };
 var OmpToolsProvider = class _OmpToolsProvider {
   static async create(cwd, catalog, capturedTools) {
@@ -8567,7 +8989,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
       bash: createNativeBashToolDefinition(cwd, this.#artifactPaths),
       edit: createNativeReplaceEditToolDefinition(cwd),
       write: createPreviewWriteToolDefinition(cwd),
-      grep: createGrepToolDefinition(cwd),
+      grep: createGrepDefinitionWithSkip(cwd),
       find: createFindToolDefinition(cwd),
       ls: createLsToolDefinition(cwd)
     };
@@ -8608,6 +9030,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
       const shellArgs = Object.hasOwn(args, OMP_BASH_CWD_KEY) ? { ...record, [OMP_BASH_CWD_KEY]: args[OMP_BASH_CWD_KEY] } : record;
       return resolveShellCwdArgument(actionName, this.#cwd, shellArgs);
     }
+    if (actionName === "read") return normalizeReadArguments(record);
     return actionName === "edit" ? normalizeEditArguments(record, args.all === true, this.#cwd) : record;
   }
   #assertAllowed(name) {
@@ -8638,27 +9061,28 @@ var OmpToolsProvider = class _OmpToolsProvider {
       const intercepted = await tryExecuteGitWorktreeAdd(args, this.#cwd);
       if (intercepted) {
         this.#attachPreview(name, intercepted, args, context);
-        return this.#normalizeResult(name, intercepted, args);
+        return this.#normalizeResult(name, intercepted, args, context);
       }
     }
     if (this.#catalog?.get(name)) {
       const result = await this.#capturedTools.invoke(name, args, context);
       this.#attachReadMedia(name, result, context);
       this.#attachReadNote(name, result, context);
-      return this.#normalizeResult(name, result, args, false);
+      return this.#normalizeResult(name, result, args, context, false);
     }
     const tool = this.#definitionFor(name, args);
     const runner = this.#catalog?.runner;
     if (!runner) {
+      const artifacts = [];
       const result = await runAbortable(
         context.signal,
-        () => tool.execute(
+        () => artifactAllocations.run(artifacts, () => tool.execute(
           context.nestedToolCallId,
           args,
           context.signal,
           (partialResult) => this.#attachPartialPreview(name, partialResult, args, context),
           this.#executionContextFor(name, args, context.extensionContext)
-        )
+        ))
       ).catch((error) => {
         throwIfAborted(context.signal);
         throw isOmpShellToolName(name) ? classifyOmpBashError(error) : error;
@@ -8670,7 +9094,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
       this.#attachReadMedia(name, result, context);
       this.#attachReadNote(name, result, context);
       this.#attachPreview(name, result, args, context);
-      return this.#normalizeResult(name, result, args);
+      return this.#normalizeResult(name, result, args, context, true, artifacts);
     }
     return this.#invokeWithEvents(name, tool, args, context, runner);
   }
@@ -8694,6 +9118,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
     let isError = false;
     let thrown;
     let executionStarted = false;
+    const artifacts = [];
     let updateTail = Promise.resolve();
     try {
       const preflight = await runAbortable(context.signal, () => runner.emitToolCall({
@@ -8707,7 +9132,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
         throw new Error(preflight.reason || `OMP tool ${name} was blocked`);
       }
       executionStarted = true;
-      result = await runAbortable(context.signal, () => tool.execute(
+      result = await runAbortable(context.signal, () => artifactAllocations.run(artifacts, () => tool.execute(
         toolCallId,
         args,
         context.signal,
@@ -8724,7 +9149,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
           ).catch(() => void 0);
         },
         this.#executionContextFor(name, args, context.extensionContext)
-      ));
+      )));
       isError = result.isError === true;
     } catch (error) {
       thrown = isOmpShellToolName(name) && executionStarted ? classifyOmpBashError(error) : error;
@@ -8777,16 +9202,110 @@ var OmpToolsProvider = class _OmpToolsProvider {
       throw new Error(text || (thrown instanceof Error ? thrown.message : `OMP tool ${name} failed`));
     }
     this.#attachPreview(name, result, args, context);
-    return this.#normalizeResult(name, result, args, patch?.content === void 0);
+    return this.#normalizeResult(name, result, args, context, patch?.content === void 0, artifacts);
   }
   // Schema-enforce and early-startup calls may have no ExtensionRunner, so the
   // top-level tool_result marker middleware cannot run. Expand again at the
   // provider boundary; replacement is idempotent when middleware already ran.
-  #normalizeResult(name, result, args, appendReadNewline = true) {
-    const normalized = normalizeResult(name, result, this.#artifactPaths, appendReadNewline);
+  async #normalizeResult(name, result, args, context, appendReadNewline = true, artifacts) {
+    const extras = {};
+    if (isOmpShellToolName(name)) {
+      const artifactPath = artifacts?.at(-1);
+      if (artifactPath !== void 0) extras.bashArtifactPath = artifactPath;
+      extras.maxResultChars = resultCharBound(context);
+    }
+    let effective = result;
+    if (name === "read" && !this.#catalog?.get(name)) {
+      const paged = await this.#completeRead(result, args, context);
+      effective = paged.result;
+      extras.read = paged.read;
+    }
+    const normalized = normalizeResult(name, effective, this.#artifactPaths, appendReadNewline, extras);
     if (name !== "read" || typeof normalized !== "string") return normalized;
+    if (UNREADABLE_READ_NOTE.test(normalized)) throw new Error(unreadableReadMessage(normalized, extras.read?.path));
     return expandSkillDirMarkersForRead(normalized, args, this.#cwd);
   }
+  async #completeRead(result, args, context) {
+    const rawPath = args.path;
+    const readPath = typeof rawPath === "string" ? rawPath : void 0;
+    const base = readPath === void 0 ? {} : { path: readPath };
+    const meta = readTruncationMeta(result.details);
+    const target = parseReadTarget(rawPath);
+    if (!meta || !target || result.isError === true) return { result, read: base };
+    if (meta.truncatedBy === "bytes" || meta.partialLine) {
+      return { result, read: { ...base, signal: byteBudgetSignal(meta) } };
+    }
+    const tool = this.#tools.read;
+    if (!tool || !target.pageable || meta.nextOffset === void 0) {
+      return { result, read: { ...base, signal: lineBudgetSignal(meta, target, void 0) } };
+    }
+    const budget = resultCharBound(context) - READ_MARKER_RESERVE_CHARS;
+    let text = stripRepeatReadHint(textContent(result.content));
+    let covered = meta.shownEnd ?? countLines(text);
+    let nextOffset = meta.nextOffset;
+    let stopped;
+    while (nextOffset !== void 0 && covered < target.endLimit) {
+      if (text.length + covered >= budget) {
+        stopped = "budget";
+        break;
+      }
+      const selector = readPageSelector(target, nextOffset);
+      const page = await runAbortable(
+        context.signal,
+        () => tool.execute(
+          context.nestedToolCallId,
+          { ...args, path: selector },
+          context.signal,
+          () => {
+          },
+          this.#executionContextFor("read", args, context.extensionContext)
+        )
+      );
+      const pageMeta = readTruncationMeta(page.details);
+      const pageText = stripRepeatReadHint(textContent(page.content));
+      const start = pageMeta?.shownStart ?? nextOffset;
+      const body = dropLeadingLines(pageText, Math.max(0, covered - start + 1));
+      const pageEnd = pageMeta?.shownEnd ?? start + countLines(pageText) - 1;
+      if (body.length === 0 || pageEnd <= covered) {
+        nextOffset = void 0;
+        break;
+      }
+      const candidate = `${text.endsWith("\n") ? text : `${text}
+`}${body}`;
+      if (candidate.length + pageEnd >= budget) {
+        stopped = "budget";
+        break;
+      }
+      text = candidate;
+      covered = pageEnd;
+      nextOffset = pageMeta?.nextOffset;
+      if (pageMeta?.truncatedBy === "bytes" || pageMeta?.partialLine === true) {
+        stopped = "bytes";
+        break;
+      }
+    }
+    if (target.endLimit !== Number.POSITIVE_INFINITY && covered > target.endLimit) {
+      text = keepLeadingLines(text, target.endLimit - target.start + 1);
+      covered = target.endLimit;
+    }
+    const remaining = stopped !== void 0 || nextOffset !== void 0 && covered < target.endLimit;
+    const paged = {
+      content: [{ type: "text", text }],
+      details: result.details
+    };
+    if (!remaining) return { result: paged, read: base };
+    return {
+      result: paged,
+      read: {
+        ...base,
+        signal: lineBudgetSignal(meta, target, {
+          nextOffset,
+          delivered: covered,
+          reason: stopped === "bytes" ? "byteBudget" : "resultBudget"
+        })
+      }
+    };
+  }
   #attachPartialPreview(name, partialResult, args, context) {
     const progress = textContent(partialResult.content).trim();
     const boundedProgress = Array.from(progress).slice(-4e3).join("");
@@ -8876,7 +9395,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
 import { spawn } from "node:child_process";
 import { createHash as createHash3, randomBytes, randomUUID as randomUUID4 } from "node:crypto";
 import fs8 from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 
 // src/schema/types.ts
 var stateBinding = (head) => head ? { transitionId: head.transitionId, version: head.version, to: head.to } : null;
@@ -8885,7 +9404,7 @@ var stateBinding = (head) => head ? { transitionId: head.transitionId, version:
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import fs7 from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 var SNAPSHOT_MAX_FILES = 2e4;
 var SNAPSHOT_MAX_BYTES = 512 * 1024 * 1024;
 var FALLBACK_SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -8903,10 +9422,10 @@ var git = (cwd, args) => execFileSync("git", ["-C", cwd, ...args], {
   stdio: ["ignore", "pipe", "ignore"]
 });
 var nulPaths = (buffer) => buffer.toString("utf8").split("\0").filter((item) => item.length > 0);
-var normalizeRelative = (value) => value.split(path11.sep).join("/");
+var normalizeRelative = (value) => value.split(path12.sep).join("/");
 var isInside = (root, candidate) => {
-  const relative = path11.relative(root, candidate);
-  return relative === "" || !path11.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path11.sep}`);
+  const relative = path12.relative(root, candidate);
+  return relative === "" || !path12.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
 };
 var excluded = (absolute, exclusions) => exclusions.some((root) => isInside(root, absolute));
 var entryDigest = (absolute) => {
@@ -8932,12 +9451,12 @@ var buildSnapshot = (cwd, paths, metadata, exclusions) => {
   let bytes = 0;
   const unique = [...new Set(paths)].sort((left, right) => left.localeCompare(right));
   for (const relativeInput of unique) {
-    const absolute = path11.resolve(cwd, relativeInput);
+    const absolute = path12.resolve(cwd, relativeInput);
     if (!isInside(cwd, absolute) || excluded(absolute, exclusions)) continue;
     if (Object.keys(entries).length >= SNAPSHOT_MAX_FILES) {
       throw new Error(`Schema workspace snapshot exceeds ${SNAPSHOT_MAX_FILES} files`);
     }
-    const relative = normalizeRelative(path11.relative(cwd, absolute));
+    const relative = normalizeRelative(path12.relative(cwd, absolute));
     const entry = entryDigest(absolute);
     bytes += entry.bytes;
     if (bytes > SNAPSHOT_MAX_BYTES) {
@@ -8966,9 +9485,9 @@ var fallbackPaths = (cwd, exclusions) => {
     const entries = fs7.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
       if (FALLBACK_SKIPPED_DIRECTORIES.has(entry.name)) continue;
-      const absolute = path11.join(directory, entry.name);
+      const absolute = path12.join(directory, entry.name);
       if (excluded(absolute, exclusions)) continue;
-      const relative = normalizeRelative(path11.relative(cwd, absolute));
+      const relative = normalizeRelative(path12.relative(cwd, absolute));
       if (entry.isDirectory()) visit(absolute);
       else paths.push(relative);
       if (paths.length > SNAPSHOT_MAX_FILES) {
@@ -8982,7 +9501,7 @@ var fallbackPaths = (cwd, exclusions) => {
 var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   const cwd = fs7.realpathSync(cwdInput);
   const exclusions = excludedRoots.map((root) => {
-    const absolute = path11.resolve(root);
+    const absolute = path12.resolve(root);
     try {
       return fs7.realpathSync(absolute);
     } catch {
@@ -9020,18 +9539,18 @@ var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   );
 };
 var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
-  if (!requestedPath.trim() || path11.isAbsolute(requestedPath)) {
+  if (!requestedPath.trim() || path12.isAbsolute(requestedPath)) {
     throw new Error(`Schema paths must be non-empty project-relative paths: ${requestedPath}`);
   }
   const cwd = fs7.realpathSync(cwdInput);
-  const absolute = path11.resolve(cwd, requestedPath);
+  const absolute = path12.resolve(cwd, requestedPath);
   if (!isInside(cwd, absolute) || absolute === cwd) {
     throw new Error(`Schema path escapes the project workspace: ${requestedPath}`);
   }
-  const relativeParts = path11.relative(cwd, absolute).split(path11.sep);
+  const relativeParts = path12.relative(cwd, absolute).split(path12.sep);
   let cursor = cwd;
   for (let index = 0; index < relativeParts.length; index++) {
-    cursor = path11.join(cursor, relativeParts[index]);
+    cursor = path12.join(cursor, relativeParts[index]);
     let stat2;
     try {
       stat2 = fs7.lstatSync(cursor);
@@ -9040,9 +9559,9 @@ var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
         if (index !== relativeParts.length - 1 || !options.allowAbsent) {
           throw new Error(`Schema path does not exist: ${requestedPath}`);
         }
-        const parentReal = fs7.realpathSync(path11.dirname(cursor));
+        const parentReal = fs7.realpathSync(path12.dirname(cursor));
         if (!isInside(cwd, parentReal)) throw new Error(`Schema path parent escapes the workspace: ${requestedPath}`);
-        return { absolute, relative: normalizeRelative(path11.relative(cwd, absolute)), exists: false };
+        return { absolute, relative: normalizeRelative(path12.relative(cwd, absolute)), exists: false };
       }
       throw error;
     }
@@ -9054,7 +9573,7 @@ var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
       throw new Error(`Schema transaction paths must name regular files: ${requestedPath}`);
     }
   }
-  return { absolute, relative: normalizeRelative(path11.relative(cwd, absolute)), exists: true };
+  return { absolute, relative: normalizeRelative(path12.relative(cwd, absolute)), exists: true };
 };
 var sha256File = (absolute) => `sha256:${digest(fs7.readFileSync(absolute))}`;
 
@@ -9105,8 +9624,8 @@ var SchemaController = class {
     this.identity = identity;
     this.state = state;
     this.cwd = fs8.realpathSync(cwd);
-    this.#journalRoot = path12.join(mesh.root, "schema-transactions");
-    this.#lockPath = path12.join(this.#journalRoot, ".commit.lock");
+    this.#journalRoot = path13.join(mesh.root, "schema-transactions");
+    this.#lockPath = path13.join(this.#journalRoot, ".commit.lock");
     this.#recoverJournals();
   }
   #activeHypotheses = /* @__PURE__ */ new Map();
@@ -9305,7 +9824,7 @@ var SchemaController = class {
     this.#assertPayloadBound(input);
     const release = this.#acquireCommitLock();
     const transactionId = randomUUID4();
-    const journalPath = path12.join(this.#journalRoot, `${transactionId}.json`);
+    const journalPath = path13.join(this.#journalRoot, `${transactionId}.json`);
     let journal;
     let consumed = false;
     let committed = false;
@@ -9786,7 +10305,7 @@ ${Date.now()}
     }
     for (const name of fs8.readdirSync(this.#journalRoot)) {
       if (!name.endsWith(".json")) continue;
-      const filePath = path12.join(this.#journalRoot, name);
+      const filePath = path13.join(this.#journalRoot, name);
       try {
         const journal = JSON.parse(fs8.readFileSync(filePath, "utf8"));
         if (journal.format !== 1 || journal.status !== "applying" || !Array.isArray(journal.before)) continue;
@@ -10040,11 +10559,11 @@ var SchemaProvider = class {
 
 // src/state/store.ts
 import { createHash as createHash5 } from "node:crypto";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // src/state/complexity.ts
 import fs9 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 var isWordStart = (character) => character !== void 0 && (character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_" || character === "$");
 var isWordPart = (character) => isWordStart(character) || character !== void 0 && character >= "0" && character <= "9";
 var regularExpressionPrefixWords = /* @__PURE__ */ new Set([
@@ -10276,7 +10795,7 @@ var languageComplexities = [
   typeScriptJavaScriptComplexity
 ];
 var complexityForFile = (file, languages = languageComplexities) => {
-  const extension = path13.extname(file).toLowerCase();
+  const extension = path14.extname(file).toLowerCase();
   return languages.find((language) => language.extensions.includes(extension));
 };
 var countFileComplexity = (file) => {
@@ -11167,7 +11686,7 @@ var StateStore = class {
     const files = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(requestedFiles, input.cwd)) {
-      const measured = countFileComplexity(path14.resolve(input.cwd, file));
+      const measured = countFileComplexity(path15.resolve(input.cwd, file));
       if (!measured) {
         files.push({ file, supported: false });
         continue;
@@ -11194,7 +11713,7 @@ var StateStore = class {
     const updates = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(files, cwd)) {
-      const measured = countFileComplexity(path14.resolve(cwd, file));
+      const measured = countFileComplexity(path15.resolve(cwd, file));
       if (!measured) {
         deltas.push({ file, supported: false });
         continue;
@@ -11244,11 +11763,11 @@ var StateStore = class {
     const normalized = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (!file.trim()) continue;
-      const relative = path14.relative(cwd, path14.resolve(cwd, file));
-      if (relative === ".." || relative.startsWith(`..${path14.sep}`) || path14.isAbsolute(relative)) {
+      const relative = path15.relative(cwd, path15.resolve(cwd, file));
+      if (relative === ".." || relative.startsWith(`..${path15.sep}`) || path15.isAbsolute(relative)) {
         throw new Error(`State complexity file must be inside the project cwd: ${file}`);
       }
-      normalized.add(relative.split(path14.sep).join("/"));
+      normalized.add(relative.split(path15.sep).join("/"));
     }
     return [...normalized];
   }
@@ -12203,13 +12722,9 @@ var FabricRuntimeState = class {
       create: () => new McpProvider(context.cwd, this.#config.mcp, {
         ...this.#config.mcp.cache.enabled ? {
           cache: new McpDescriptorCacheStore(
-            path15.join(
-              process.env.OMP_FABRIC_PROJECT_ROOT ?? context.cwd,
-              ".omp",
-              "fabric",
-              "mcp-cache.json"
-            )
-          )
+            projectMcpCachePath(process.env.OMP_FABRIC_PROJECT_ROOT ?? context.cwd)
+          ),
+          globalCache: new McpDescriptorCacheStore(globalMcpCachePath(resolveAgentDir()))
         } : {},
         hooks: {
           onSliceChanged: () => {
@@ -12223,9 +12738,7 @@ var FabricRuntimeState = class {
       unmounted: (provider) => {
         if (this.#mcpProvider === provider) this.#mcpProvider = void 0;
       },
-      start: (provider) => {
-        provider.warmup();
-      }
+      start: (provider) => provider.warmup()
     }));
     if (capturedToolsProvider && !enforceSchema) {
       await installBuiltin(createProviderComponent({
@@ -12248,7 +12761,7 @@ var FabricRuntimeState = class {
     this.#mainAgent = mainAgent;
     const projectRoot = process.env.OMP_FABRIC_PROJECT_ROOT ?? context.cwd;
     const configuredMeshRoot = this.#config.mesh.root;
-    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path15.resolve(projectRoot, configuredMeshRoot) : path15.join(projectRoot, ".omp", "fabric", "mesh"));
+    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path16.resolve(projectRoot, configuredMeshRoot) : path16.join(projectRoot, ".omp", "fabric", "mesh"));
     this.#mesh = new MeshStore(
       meshRoot,
       this.#config.mesh.maxEventBytes,
@@ -12301,6 +12814,12 @@ var FabricRuntimeState = class {
     this.#compact = new CompactController({
       onRequest: (intent) => void this.#publishCompactEvent("requested", intent),
       onCommit: (info) => void this.#publishCompactEvent(info.status, info)
+    }, {
+      settings: () => ({
+        engine: this.#config?.compaction.engine ?? DEFAULT_FABRIC_CONFIG.compaction.engine,
+        targetContextRatio: this.#config?.compaction.targetContextRatio ?? DEFAULT_FABRIC_CONFIG.compaction.targetContextRatio
+      }),
+      outcomes: fileCompactOutcomeStore()
     });
     await installBuiltin(createProviderComponent({
       provider: "compact",
@@ -12403,8 +12922,8 @@ var FabricRuntimeState = class {
     };
     const lineageAlive = (rootId) => this.#participants?.get(rootId) !== void 0;
     const actorRoots = {
-      project: path15.join(meshRoot, "actors"),
-      session: path15.join(meshRoot, "actors", fabricSessionId)
+      project: path16.join(meshRoot, "actors"),
+      session: path16.join(meshRoot, "actors", fabricSessionId)
     };
     const acquireActorCapabilityView = (requirements, signal) => this.#registry.acquireCapabilityView(requirements, {
       cwd: context.cwd,