omp-fabric 1.1.0 → 1.2.0

package/dist/fabric-runtime-state.js

@@ -33,7 +33,7 @@ import {
   repairFabricGuestCode,
   resolveFabricIdentity,
   runFabricHandoffAtBoundary
-} from "./chunks/chunk-TLSJXU4F.js";
+} from "./chunks/chunk-5YGOVBOZ.js";
 import "./chunks/chunk-7VIQNUPS.js";
 import {
   AgentTranscriptReader,
@@ -94,7 +94,7 @@ import {
   resolveAgentCwd,
   resolveOmpBinary,
   validateAgentCwdRequest
-} from "./chunks/chunk-WXZP5VWP.js";
+} from "./chunks/chunk-TQL7FKMG.js";
 import "./chunks/chunk-VPPIJRNZ.js";
 import {
   executeFile,
@@ -104,7 +104,7 @@ import {
 import "./chunks/chunk-CT2AJ2UI.js";
 import {
   checkedHandoffCompaction
-} from "./chunks/chunk-YPYVUGON.js";
+} from "./chunks/chunk-JOWMM3EX.js";
 import {
   DEFAULT_FABRIC_CONFIG,
   FUZZY_RESOLUTION_MARKERS,
@@ -114,7 +114,7 @@ import {
   resolveAgentDir,
   resolveAvailableOmpModel,
   resolveFabricModel
-} from "./chunks/chunk-EZPERYEG.js";
+} from "./chunks/chunk-XRJYPNTI.js";
 import {
   FABRIC_ACTOR_HOST_EVENTS,
   isFabricActorHostEvent,
@@ -155,8 +155,9 @@ import {
   MAX_PRESERVE_ITEM_CHARS,
   compactionRequestBoundsError,
   encodeCompactionRequest,
+  estimateTokens,
   fabricExecTitleHintCached
-} from "./chunks/chunk-KIREBD2V.js";
+} from "./chunks/chunk-ZP3S74LW.js";
 import "./chunks/chunk-3J7BKUNG.js";
 import "./chunks/chunk-4HQDSTHN.js";
 import {
@@ -171,7 +172,7 @@ import {
 } from "./chunks/chunk-6N4XGAZY.js";
 
 // src/fabric-runtime-state.ts
-import path16 from "node:path";
+import path18 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/actors/global-registry.ts
@@ -425,36 +426,36 @@ var GlobalActorRegistry = class {
     if (!Array.isArray(records)) return;
     for (const value of records) {
       if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
-      const record = value;
-      if (typeof record.id !== "string" || !/^[a-f0-9]{32}$/.test(record.id) || typeof record.name !== "string" || !ACTOR_NAME_PATTERN.test(record.name) || typeof record.instructions !== "string" || Buffer.byteLength(record.instructions, "utf8") > this.#maxBytes || typeof record.createdAt !== "number") {
+      const record2 = value;
+      if (typeof record2.id !== "string" || !/^[a-f0-9]{32}$/.test(record2.id) || typeof record2.name !== "string" || !ACTOR_NAME_PATTERN.test(record2.name) || typeof record2.instructions !== "string" || Buffer.byteLength(record2.instructions, "utf8") > this.#maxBytes || typeof record2.createdAt !== "number") {
         continue;
       }
-      const events = Array.isArray(record.events) ? record.events.filter((event) => HOST_EVENTS.has(event)) : [];
-      const topics = Array.isArray(record.topics) ? record.topics.filter(
+      const events = Array.isArray(record2.events) ? record2.events.filter((event) => HOST_EVENTS.has(event)) : [];
+      const topics = Array.isArray(record2.topics) ? record2.topics.filter(
         (topic) => typeof topic === "string" && TOPIC_PATTERN.test(topic)
       ) : [];
-      const delivery = record.delivery === "steer" || record.delivery === "followUp" || record.delivery === "nextTurn" ? record.delivery : "mailbox";
-      const responseMode = record.responseMode === "directive" ? "directive" : "text";
-      const triggerTurn = (delivery === "steer" || delivery === "followUp") && record.triggerTurn === true;
-      const coalesce = record.coalesce !== false;
-      const residency = record.residency === "durable" ? "durable" : "session";
-      const runner = record.runner === "claude" ? "claude" : "omp";
-      const thinking = isFabricThinking(record.thinking) ? record.thinking : void 0;
-      const tools = Array.isArray(record.tools) ? record.tools.filter((tool) => typeof tool === "string") : void 0;
-      const transport = record.transport !== void 0 && TRANSPORTS.has(record.transport) ? record.transport : void 0;
-      const timeoutMs = typeof record.timeoutMs === "number" ? record.timeoutMs : void 0;
-      const extensions = typeof record.extensions === "boolean" ? record.extensions : void 0;
+      const delivery = record2.delivery === "steer" || record2.delivery === "followUp" || record2.delivery === "nextTurn" ? record2.delivery : "mailbox";
+      const responseMode = record2.responseMode === "directive" ? "directive" : "text";
+      const triggerTurn = (delivery === "steer" || delivery === "followUp") && record2.triggerTurn === true;
+      const coalesce = record2.coalesce !== false;
+      const residency = record2.residency === "durable" ? "durable" : "session";
+      const runner = record2.runner === "claude" ? "claude" : "omp";
+      const thinking = isFabricThinking(record2.thinking) ? record2.thinking : void 0;
+      const tools = Array.isArray(record2.tools) ? record2.tools.filter((tool) => typeof tool === "string") : void 0;
+      const transport = record2.transport !== void 0 && TRANSPORTS.has(record2.transport) ? record2.transport : void 0;
+      const timeoutMs = typeof record2.timeoutMs === "number" ? record2.timeoutMs : void 0;
+      const extensions = typeof record2.extensions === "boolean" ? record2.extensions : void 0;
       let requires;
       try {
-        requires = normalizeRequirements(record.requires);
+        requires = normalizeRequirements(record2.requires);
       } catch {
         continue;
       }
-      const validWhile = record.validWhile?.version === 1 && typeof record.validWhile.source === "string" && record.validWhile.source.length <= 16e3 ? clone(record.validWhile) : void 0;
+      const validWhile = record2.validWhile?.version === 1 && typeof record2.validWhile.source === "string" && record2.validWhile.source.length <= 16e3 ? clone(record2.validWhile) : void 0;
       const def = {
-        id: record.id,
-        name: record.name,
-        instructions: record.instructions,
+        id: record2.id,
+        name: record2.name,
+        instructions: record2.instructions,
         events,
         topics,
         delivery,
@@ -463,9 +464,9 @@ var GlobalActorRegistry = class {
         coalesce,
         residency,
         runner,
-        createdAt: record.createdAt,
-        updatedAt: typeof record.updatedAt === "number" ? record.updatedAt : record.createdAt,
-        ...typeof record.model === "string" && record.model ? { model: record.model } : {},
+        createdAt: record2.createdAt,
+        updatedAt: typeof record2.updatedAt === "number" ? record2.updatedAt : record2.createdAt,
+        ...typeof record2.model === "string" && record2.model ? { model: record2.model } : {},
         ...thinking ? { thinking } : {},
         ...tools ? { tools } : {},
         ...transport ? { transport } : {},
@@ -793,10 +794,10 @@ var normalizeRegistration = (registration, fallbackLabel) => {
     }
   };
 };
-var beginCleanup = (record) => {
-  if (record.cleanupStarted) return;
-  record.cleanupStarted = true;
-  record.beforeCleanup?.();
+var beginCleanup = (record2) => {
+  if (record2.cleanupStarted) return;
+  record2.cleanupStarted = true;
+  record2.beforeCleanup?.();
 };
 var closeIterator = async (iterator, disposers) => {
   if (!iterator.return) return;
@@ -809,20 +810,20 @@ var closeIterator = async (iterator, disposers) => {
 var checkTarget = async (guard) => {
   if (guard && !await guard()) throw new FabricEffectDivertedError();
 };
-var driveIterator = async (iterator, record, guard) => {
+var driveIterator = async (iterator, record2, guard) => {
   try {
     for (; ; ) {
-      if (!record.armed) {
-        beginCleanup(record);
-        await closeIterator(iterator, record.disposers);
+      if (!record2.armed) {
+        beginCleanup(record2);
+        await closeIterator(iterator, record2.disposers);
         return;
       }
       await checkTarget(guard);
       const step = await iterator.next();
-      if (!step.done) collectDisposer(step.value, record.disposers);
-      if (!record.armed) {
-        beginCleanup(record);
-        await closeIterator(iterator, record.disposers);
+      if (!step.done) collectDisposer(step.value, record2.disposers);
+      if (!record2.armed) {
+        beginCleanup(record2);
+        await closeIterator(iterator, record2.disposers);
         return;
       }
       if (step.done) {
@@ -833,8 +834,8 @@ var driveIterator = async (iterator, record, guard) => {
   } catch (error) {
     if (error instanceof FabricEffectDivertedError) {
       try {
-        beginCleanup(record);
-        await closeIterator(iterator, record.disposers);
+        beginCleanup(record2);
+        await closeIterator(iterator, record2.disposers);
       } catch (closeError) {
         throw new FabricEffectDivertedError(
           "Fabric effect target changed and iterator close failed",
@@ -845,19 +846,19 @@ var driveIterator = async (iterator, record, guard) => {
     throw error;
   }
 };
-var collectEffect = async (effect, record, guard) => {
+var collectEffect = async (effect, record2, guard) => {
   const resolved = isPromiseLike(effect) ? await effect : effect;
   if (resolved === void 0 || resolved === null || typeof resolved === "function") {
-    collectDisposer(resolved, record.disposers);
-    if (record.armed) await checkTarget(guard);
+    collectDisposer(resolved, record2.disposers);
+    if (record2.armed) await checkTarget(guard);
     return;
   }
   if (isAsyncIterable(resolved)) {
-    await driveIterator(resolved[Symbol.asyncIterator](), record, guard);
+    await driveIterator(resolved[Symbol.asyncIterator](), record2, guard);
     return;
   }
   if (isIterable(resolved)) {
-    await driveIterator(resolved[Symbol.iterator](), record, guard);
+    await driveIterator(resolved[Symbol.iterator](), record2, guard);
     return;
   }
   throw new TypeError("Fabric effect returned an unsupported value");
@@ -876,10 +877,10 @@ var FabricEffectScope = class {
   }
   footprint(limit = Number.POSITIVE_INFINITY) {
     const effects = [];
-    for (const record of this.#records) {
+    for (const record2 of this.#records) {
       if (effects.length >= limit) break;
-      if (!record.disposed && record.effect) {
-        effects.push({ ...record.effect, resources: [...record.effect.resources] });
+      if (!record2.disposed && record2.effect) {
+        effects.push({ ...record2.effect, resources: [...record2.effect.resources] });
       }
     }
     return effects;
@@ -889,7 +890,7 @@ var FabricEffectScope = class {
       throw new Error("Cannot create an effect on a disposing Fabric scope");
     }
     const normalized = normalizeRegistration(registration, "anonymous");
-    const record = {
+    const record2 = {
       label: normalized.label,
       ...normalized.effect ? { effect: normalized.effect } : {},
       disposers: [],
@@ -902,9 +903,9 @@ var FabricEffectScope = class {
       ...hooks.beforeCleanup ? { beforeCleanup: hooks.beforeCleanup } : {}
     };
     const cleanupDisposers = async () => {
-      beginCleanup(record);
+      beginCleanup(record2);
       const failures = [];
-      for (const disposer of record.disposers.splice(0).reverse()) {
+      for (const disposer of record2.disposers.splice(0).reverse()) {
         try {
           await disposer();
         } catch (error) {
@@ -912,64 +913,64 @@ var FabricEffectScope = class {
         }
       }
       if (failures.length > 0) {
-        throw new AggregateError(failures, `Fabric effect cleanup failed: ${record.label}`);
+        throw new AggregateError(failures, `Fabric effect cleanup failed: ${record2.label}`);
       }
     };
     let disposal;
-    record.dispose = async () => {
-      if (record.disposed) return disposal;
-      record.disposed = true;
-      record.armed = false;
+    record2.dispose = async () => {
+      if (record2.disposed) return disposal;
+      record2.disposed = true;
+      record2.armed = false;
       disposal = (async () => {
-        await record.setup.catch(() => void 0);
+        await record2.setup.catch(() => void 0);
         await cleanupDisposers();
       })();
       return disposal;
     };
-    this.#records.push(record);
-    record.setup = (async () => {
+    this.#records.push(record2);
+    record2.setup = (async () => {
       try {
         if (this.#guard) await checkTarget(this.#guard);
-        if (!record.armed) return;
-        await collectEffect(setup(), record, this.#guard);
+        if (!record2.armed) return;
+        await collectEffect(setup(), record2, this.#guard);
       } catch (error) {
         try {
           await cleanupDisposers();
         } catch (cleanupError) {
           const failures = cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError];
           for (const failure of failures) {
-            this.#setupCleanupFailures.push({ label: record.label, error: errorMessage(failure) });
+            this.#setupCleanupFailures.push({ label: record2.label, error: errorMessage(failure) });
           }
           throw new AggregateError(
             [error, cleanupError],
-            `Fabric effect setup and rollback failed: ${record.label}`
+            `Fabric effect setup and rollback failed: ${record2.label}`
           );
         }
         throw error;
       }
     })();
     try {
-      await record.setup;
+      await record2.setup;
       if (this.#state === "open") {
-        const index = this.#records.indexOf(record);
+        const index = this.#records.indexOf(record2);
         if (index >= 0 && index !== this.#records.length - 1) {
           this.#records.splice(index, 1);
-          this.#records.push(record);
+          this.#records.push(record2);
         }
       }
     } catch (error) {
-      const index = this.#records.indexOf(record);
+      const index = this.#records.indexOf(record2);
       if (index >= 0) this.#records.splice(index, 1);
       throw error;
     }
-    return record.dispose;
+    return record2.dispose;
   }
   defer(disposer, registration = "deferred") {
     if (this.#state !== "open") {
       throw new Error("Cannot defer cleanup on a disposing Fabric scope");
     }
     const normalized = normalizeRegistration(registration, "deferred");
-    const record = {
+    const record2 = {
       label: normalized.label,
       ...normalized.effect ? { effect: normalized.effect } : {},
       disposers: [disposer],
@@ -981,13 +982,13 @@ var FabricEffectScope = class {
       cleanupStarted: false
     };
     let disposal;
-    record.dispose = async () => {
-      if (record.disposed) return disposal;
-      record.disposed = true;
-      record.armed = false;
+    record2.dispose = async () => {
+      if (record2.disposed) return disposal;
+      record2.disposed = true;
+      record2.armed = false;
       disposal = (async () => {
         const failures = [];
-        for (const cleanup of record.disposers.splice(0).reverse()) {
+        for (const cleanup of record2.disposers.splice(0).reverse()) {
           try {
             await cleanup();
           } catch (error) {
@@ -995,29 +996,29 @@ var FabricEffectScope = class {
           }
         }
         if (failures.length > 0) {
-          throw new AggregateError(failures, `Fabric effect cleanup failed: ${record.label}`);
+          throw new AggregateError(failures, `Fabric effect cleanup failed: ${record2.label}`);
         }
       })();
       return disposal;
     };
-    this.#records.push(record);
-    return record.dispose;
+    this.#records.push(record2);
+    return record2.dispose;
   }
   dispose() {
     if (this.#cleanup) return this.#cleanup;
     this.#state = "disposing";
     this.#cleanup = (async () => {
       const failures = this.#setupCleanupFailures.splice(0);
-      for (const record of this.#records.splice(0).reverse()) {
+      for (const record2 of this.#records.splice(0).reverse()) {
         try {
-          await record.dispose();
+          await record2.dispose();
         } catch (error) {
           if (error instanceof AggregateError) {
             for (const nested of error.errors) {
-              failures.push({ label: record.label, error: errorMessage(nested) });
+              failures.push({ label: record2.label, error: errorMessage(nested) });
             }
           } else {
-            failures.push({ label: record.label, error: errorMessage(error) });
+            failures.push({ label: record2.label, error: errorMessage(error) });
           }
         }
       }
@@ -2218,10 +2219,10 @@ var FabricComponentSupervisor = class {
       adjacent.set(edge.from, targets);
     }
     const cycles = /* @__PURE__ */ new Map();
-    const visit = (node, path17, positions) => {
+    const visit = (node, path19, positions) => {
       const position = positions.get(node);
       if (position !== void 0) {
-        const cycle = path17.slice(position);
+        const cycle = path19.slice(position);
         const rotations = cycle.map((_, index) => [
           ...cycle.slice(index),
           ...cycle.slice(0, index)
@@ -2231,10 +2232,10 @@ var FabricComponentSupervisor = class {
         cycles.set(canonical.join("\0"), canonical);
         return;
       }
-      if (path17.length > this.#components.size) return;
-      const nextPositions = new Map(positions).set(node, path17.length);
+      if (path19.length > this.#components.size) return;
+      const nextPositions = new Map(positions).set(node, path19.length);
       for (const target of adjacent.get(node) ?? []) {
-        visit(target, [...path17, node], nextPositions);
+        visit(target, [...path19, node], nextPositions);
       }
     };
     for (const id of this.#components.keys()) visit(id, [], /* @__PURE__ */ new Map());
@@ -2736,18 +2737,18 @@ var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value
 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;
+  const record2 = raw;
+  const at = finiteNumber(record2.at);
+  const requestedBy = nonEmptyString(record2.requestedBy);
+  const status = record2.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);
+  const summary = nonEmptyString(record2.summary);
+  const error = nonEmptyString(record2.error);
+  const tokensBefore = finiteNumber(record2.tokensBefore);
+  const estimatedTokensAfter = finiteNumber(record2.estimatedTokensAfter);
   return {
     at,
     requestedBy,
@@ -2964,7 +2965,7 @@ var FabricExecutionService = class {
       })) ?? []
     ) : void 0;
     const code = repairFabricGuestCode(options.code);
-    const checked = dependencies.typeCheckFabricCode(
+    const checked2 = dependencies.typeCheckFabricCode(
       code,
       dependencies.guestTypeDeclarations(effectiveFullCodeMode, {
         excludeGlobals: [...unavailable.keys()],
@@ -2972,8 +2973,8 @@ var FabricExecutionService = class {
         ...coreOverrideDeclarations ? { coreOverrides: coreOverrideDeclarations } : {}
       })
     );
-    if (checked.errors.length > 0) {
-      for (const error of checked.errors) {
+    if (checked2.errors.length > 0) {
+      for (const error of checked2.errors) {
         const missing = /^Cannot find name '([^']+)'/.exec(error.message);
         const reason = missing?.[1] ? unavailable.get(missing[1]) : void 0;
         if (missing && reason) {
@@ -2990,10 +2991,10 @@ var FabricExecutionService = class {
         trace: traceRecorder.seal(
           "failed",
           [],
-          `Type checking failed (${checked.errors.length} ${checked.errors.length === 1 ? "error" : "errors"})`
+          `Type checking failed (${checked2.errors.length} ${checked2.errors.length === 1 ? "error" : "errors"})`
         ),
         elapsedMs: performance.now() - startedAt,
-        typeErrors: checked.errors
+        typeErrors: checked2.errors
       };
     }
     const classifierUsages = [];
@@ -3424,8 +3425,8 @@ var FabricExecutionService = class {
           memoryLimitBytes: this.config.executor.memoryLimitBytes,
           maxLogChars: this.config.executor.maxOutputChars,
           minimumTimeoutMsForHostCall,
-          ...checked.javascript ? { transpiledCode: checked.javascript } : {},
-          ...checked.sourceMap ? { transpiledSourceMap: checked.sourceMap } : {},
+          ...checked2.javascript ? { transpiledCode: checked2.javascript } : {},
+          ...checked2.sourceMap ? { transpiledSourceMap: checked2.sourceMap } : {},
           ...options.payloads ? { payloads: options.payloads } : {},
           ...Object.keys(proxyNames).length > 0 ? { proxyNames } : {},
           ...options.tokenBudget !== void 0 ? { tokenBudget: options.tokenBudget } : {},
@@ -5032,10 +5033,10 @@ var ResidencyClient = class {
   statusAgent(id) {
     const metadata = this.#metadata(id);
     if (!metadata) throw new Error(`Unknown durable Fabric agent: ${id}`);
-    const record = readJson(path5.join(metadata.runDirectory, "status.json"));
-    if (!record || record.id !== metadata.id) return structuredClone(metadata.handle);
+    const record2 = readJson(path5.join(metadata.runDirectory, "status.json"));
+    if (!record2 || record2.id !== metadata.id) return structuredClone(metadata.handle);
     return {
-      ...record,
+      ...record2,
       cwd: metadata.handle.cwd,
       residency: "durable",
       logFile: path5.join(metadata.runDirectory, "events.jsonl"),
@@ -5398,20 +5399,20 @@ var actorRequest = (args, context, manager, inheritModel = true) => {
 var collectAgentToolPreviewNodes = (records, options, depth = 0, budget = { remaining: options.maxNodes ?? AGENT_PREVIEW_TREE_MAX_NODES }) => {
   const maxDepth = options.maxDepth ?? AGENT_PREVIEW_TREE_MAX_DEPTH;
   const nodes = [];
-  for (const record of records) {
+  for (const record2 of records) {
     if (budget.remaining <= 0) break;
     budget.remaining -= 1;
-    const descendants = Array.isArray(record.nestedAgents) ? record.nestedAgents : [];
+    const descendants = Array.isArray(record2.nestedAgents) ? record2.nestedAgents : [];
     const agents = depth + 1 < maxDepth && descendants.length > 0 && budget.remaining > 0 ? collectAgentToolPreviewNodes(descendants, options, depth + 1, budget) : [];
     nodes.push({
-      id: record.id,
-      name: record.actorName ?? record.name,
-      status: record.status,
-      ...record.runner === "omp" || record.runner === "claude" || record.runner === "veda" ? { runner: record.runner } : {},
-      owner: record.actorId ? "actor" : "agent",
-      ...record.currentTool ? { currentTool: record.currentTool } : {},
-      ...record.text ? { text: tailCodePoints(record.text, AGENT_PREVIEW_TEXT_CODE_POINTS) } : {},
-      tools: options.tools(record),
+      id: record2.id,
+      name: record2.actorName ?? record2.name,
+      status: record2.status,
+      ...record2.runner === "omp" || record2.runner === "claude" || record2.runner === "veda" ? { runner: record2.runner } : {},
+      owner: record2.actorId ? "actor" : "agent",
+      ...record2.currentTool ? { currentTool: record2.currentTool } : {},
+      ...record2.text ? { text: tailCodePoints(record2.text, AGENT_PREVIEW_TEXT_CODE_POINTS) } : {},
+      tools: options.tools(record2),
       ...agents.length > 0 ? { agents } : {},
       ...descendants.length > agents.length ? { agentsTruncated: true } : {}
     });
@@ -6457,18 +6458,18 @@ var AgentsProvider = class {
     const scope = this.#participantScope(scopeValue, "local");
     if (scope === "local") return this.manager.list();
     const local = /* @__PURE__ */ new Map();
-    const append = (record) => {
-      local.set(record.id, record);
-      if ("nestedAgents" in record) {
-        for (const nested of record.nestedAgents ?? []) append(nested);
+    const append = (record2) => {
+      local.set(record2.id, record2);
+      if ("nestedAgents" in record2) {
+        for (const nested of record2.nestedAgents ?? []) append(nested);
       }
     };
-    for (const record of this.manager.list()) append(record);
-    for (const record of this.residency?.listAgents() ?? []) append(record);
+    for (const record2 of this.manager.list()) append(record2);
+    for (const record2 of this.residency?.listAgents() ?? []) append(record2);
     const listed = this.participants.list({ scope, kinds: ["agent"] }).map((participant) => local.get(participant.id) ?? participant);
-    const seen = new Set(listed.map((record) => record.id));
-    for (const record of this.residency?.listAgents() ?? []) {
-      if (!seen.has(record.id)) listed.push(record);
+    const seen = new Set(listed.map((record2) => record2.id));
+    for (const record2 of this.residency?.listAgents() ?? []) {
+      if (!seen.has(record2.id)) listed.push(record2);
     }
     return listed;
   }
@@ -6624,9 +6625,9 @@ var CapturedToolsProvider = class {
   #allowedTools = readChildToolAllowlist();
   async list(request, _context) {
     const query = request.query?.trim().toLowerCase();
-    const descriptors6 = this.catalog.list().filter((entry) => !this.#allowedTools || this.#allowedTools.has(entry.name)).map(descriptorFrom);
-    if (!query) return descriptors6;
-    return descriptors6.filter(
+    const descriptors7 = this.catalog.list().filter((entry) => !this.#allowedTools || this.#allowedTools.has(entry.name)).map(descriptorFrom);
+    if (!query) return descriptors7;
+    return descriptors7.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description} ${descriptor.namespace ?? ""}`.toLowerCase().includes(query)
     );
   }
@@ -6762,32 +6763,1274 @@ var CapturedToolsProvider = class {
   }
 };
 
-// src/providers/compact-provider.ts
+// src/providers/codemap-provider.ts
 import { Type } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 import { validateJsonSchemaValue } from "@oh-my-pi/pi-ai/utils/schema";
-var requestSchema = Type.Object({
-  reason: Type.Optional(Type.String({
+
+// src/codemap/budget.ts
+var KIND_LETTERS = {
+  fn: "f",
+  class: "c",
+  iface: "i",
+  type: "t",
+  const: "v",
+  enum: "e",
+  method: "m"
+};
+var LEGEND = "# f=fn c=class i=iface t=type v=const e=enum m=method";
+var MIN_FILE_ENTRY = 8;
+var FOCUS_WEIGHT = 1;
+var CASCADE_WEIGHT = 0.6;
+var NAME_EXACT_SCORE = 6;
+var NAME_WORD_SCORE = 3;
+var PATH_WORD_SCORE = 4;
+var SUBSTRING_SCORE = 1;
+var MIN_SUBSTRING_LENGTH = 3;
+var EXPORT_PASSES = [true, false];
+var isUpper = (code) => code >= 65 && code <= 90;
+var isLower = (code) => code >= 97 && code <= 122;
+var isDigit = (code) => code >= 48 && code <= 57;
+var isWordChar = (code) => isUpper(code) || isLower(code) || isDigit(code);
+var compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var collectWords = (value, sink) => {
+  let start = -1;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (!isWordChar(code)) {
+      if (start >= 0) sink.add(value.slice(start, index).toLowerCase());
+      start = -1;
+      continue;
+    }
+    if (start < 0) {
+      start = index;
+      continue;
+    }
+    const previous = value.charCodeAt(index - 1);
+    const next = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
+    if (isUpper(code) && (!isUpper(previous) || isLower(next))) {
+      sink.add(value.slice(start, index).toLowerCase());
+      start = index;
+    }
+  }
+  if (start >= 0) sink.add(value.slice(start).toLowerCase());
+};
+var focusTerms = (focus) => {
+  if (focus === void 0 || focus.length === 0) return [];
+  const words = /* @__PURE__ */ new Set();
+  collectWords(focus, words);
+  return [...words];
+};
+var lexiconFor = (group) => {
+  const pathWords = /* @__PURE__ */ new Set();
+  collectWords(group.file, pathWords);
+  const names = /* @__PURE__ */ new Set();
+  const nameWords = /* @__PURE__ */ new Set();
+  const distinct = [];
+  for (const symbol of group.symbols) {
+    const lowered = symbol.name.toLowerCase();
+    if (names.has(lowered)) continue;
+    names.add(lowered);
+    distinct.push(lowered);
+    collectWords(symbol.name, nameWords);
+  }
+  return {
+    pathWords,
+    pathLower: group.file.toLowerCase(),
+    names,
+    nameWords,
+    namesBlob: distinct.join("\n")
+  };
+};
+var termScore = (term, lexicon) => {
+  const wideEnough = term.length >= MIN_SUBSTRING_LENGTH;
+  let score = 0;
+  if (lexicon.names.has(term)) score += NAME_EXACT_SCORE;
+  else if (lexicon.nameWords.has(term)) score += NAME_WORD_SCORE;
+  else if (wideEnough && lexicon.namesBlob.includes(term)) score += SUBSTRING_SCORE;
+  if (lexicon.pathWords.has(term)) score += PATH_WORD_SCORE;
+  else if (wideEnough && lexicon.pathLower.includes(term)) score += SUBSTRING_SCORE;
+  return score;
+};
+var groupByFile = (symbols) => {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    let group = byFile.get(symbol.file);
+    if (group === void 0) {
+      group = { file: symbol.file, symbols: [], score: 0 };
+      byFile.set(symbol.file, group);
+    }
+    group.symbols.push(symbol);
+  }
+  for (const group of byFile.values()) {
+    group.symbols.sort((left, right) => left.line - right.line || compareText(left.name, right.name) || compareText(left.kind, right.kind));
+  }
+  return [...byFile.values()];
+};
+var applyFocus = (groups, focus) => {
+  const terms = focusTerms(focus);
+  if (terms.length === 0) return;
+  let peak = 0;
+  for (const group of groups) {
+    const lexicon = lexiconFor(group);
+    let raw = 0;
+    for (const term of terms) raw += termScore(term, lexicon);
+    group.score = raw;
+    if (raw > peak) peak = raw;
+  }
+  for (const group of groups) group.score = peak > 0 ? group.score / peak * FOCUS_WEIGHT : 0;
+};
+var applyCascade = (groups, request) => {
+  const edges = request.cascade?.edges;
+  if (edges === void 0 || edges.length === 0) return;
+  const best = /* @__PURE__ */ new Map();
+  let peak = 0;
+  for (const edge of edges) {
+    if (edge.score > peak) peak = edge.score;
+    const previous = best.get(edge.file);
+    if (previous === void 0 || edge.score > previous) best.set(edge.file, edge.score);
+  }
+  if (peak <= 0) return;
+  for (const group of groups) {
+    const edgeScore = best.get(group.file);
+    if (edgeScore !== void 0 && edgeScore > 0) {
+      group.score += edgeScore / peak * CASCADE_WEIGHT;
+    }
+  }
+};
+var rankGroups = (groups, request) => {
+  applyFocus(groups, request.focus);
+  applyCascade(groups, request);
+  groups.sort((left, right) => right.score - left.score || right.symbols.length - left.symbols.length || compareText(left.file, right.file));
+};
+var spend = (groups, charBudget, reserved) => {
+  const lines = [];
+  let used = reserved;
+  let filesShown = 0;
+  let symbolsShown = 0;
+  let omittedFiles = 0;
+  let omittedSymbols = 0;
+  for (const group of groups) {
+    const headerCost = group.file.length + 1;
+    if (used + headerCost >= charBudget) {
+      omittedFiles++;
+      omittedSymbols += group.symbols.length;
+      continue;
+    }
+    const rendered = new Array(group.symbols.length);
+    const picked = [];
+    let cost = headerCost;
+    for (const exported of EXPORT_PASSES) {
+      for (let index = 0; index < group.symbols.length; index++) {
+        const symbol = group.symbols[index];
+        if (symbol.exported !== exported) continue;
+        let line = rendered[index];
+        if (line === void 0) {
+          line = `${symbol.line} ${KIND_LETTERS[symbol.kind]} ${symbol.name}`;
+          rendered[index] = line;
+        }
+        const lineCost = line.length + 1;
+        if (used + cost + lineCost > charBudget) continue;
+        cost += lineCost;
+        picked.push(index);
+      }
+    }
+    if (picked.length === 0) {
+      omittedFiles++;
+      omittedSymbols += group.symbols.length;
+      continue;
+    }
+    picked.sort((left, right) => left - right);
+    lines.push(group.file);
+    for (const index of picked) lines.push(rendered[index]);
+    used += cost;
+    filesShown++;
+    symbolsShown += picked.length;
+    omittedSymbols += group.symbols.length - picked.length;
+  }
+  return { lines, filesShown, symbolsShown, omittedFiles, omittedSymbols };
+};
+function assembleMap(request) {
+  const groups = groupByFile(request.index.symbols);
+  rankGroups(groups, request);
+  const charBudget = request.maxTokens > 0 ? Math.floor(request.maxTokens) * 4 : 0;
+  const legendCost = LEGEND.length + 1;
+  const reserved = charBudget >= legendCost + MIN_FILE_ENTRY ? legendCost : 0;
+  let plan = spend(groups, charBudget, reserved);
+  let legendShown = reserved > 0;
+  if (plan.filesShown === 0 && reserved > 0) {
+    plan = spend(groups, charBudget, 0);
+    legendShown = false;
+  }
+  const body = plan.lines.join("\n");
+  const text = plan.lines.length === 0 ? "" : legendShown ? `${LEGEND}
+${body}
+` : `${body}
+`;
+  return {
+    text,
+    tokensEstimated: estimateTokens({ role: "user", content: text }),
+    filesShown: plan.filesShown,
+    symbolsShown: plan.symbolsShown,
+    omittedFiles: plan.omittedFiles,
+    omittedSymbols: plan.omittedSymbols,
+    truncated: plan.omittedFiles > 0 || plan.omittedSymbols > 0
+  };
+}
+
+// src/codemap/cascade.ts
+import { execFile } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import path7 from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var BULK_COMMIT_FILE_CEILING = 100;
+var GIT_TIMEOUT_MS = 2e4;
+var GIT_MAX_BUFFER = 64 << 20;
+var COMMIT_MARKER_CODE = 1;
+var QUOTE_CODE = 34;
+var ESCAPE_BYTES = /* @__PURE__ */ new Map([
+  ["a", 7],
+  ["b", 8],
+  ["t", 9],
+  ["n", 10],
+  ["v", 11],
+  ["f", 12],
+  ["r", 13],
+  ['"', 34],
+  ["\\", 92]
+]);
+var toPosix = (value) => path7.sep === "/" ? value : value.replaceAll(path7.sep, "/");
+var unquoteGitPath = (raw) => {
+  if (raw.length < 2 || raw.charCodeAt(raw.length - 1) !== QUOTE_CODE) return raw;
+  const bytes = [];
+  for (let index = 1; index < raw.length - 1; index += 1) {
+    const char = raw[index];
+    if (char !== "\\") {
+      const code = char.charCodeAt(0);
+      if (code < 128) bytes.push(code);
+      else for (const byte of Buffer.from(char, "utf8")) bytes.push(byte);
+      continue;
+    }
+    const next = raw[index + 1];
+    if (next === void 0) break;
+    const mapped = ESCAPE_BYTES.get(next);
+    if (mapped !== void 0) {
+      bytes.push(mapped);
+      index += 1;
+      continue;
+    }
+    if (next >= "0" && next <= "7") {
+      let value = 0;
+      let digits = 0;
+      while (digits < 3) {
+        const digit = raw[index + 1 + digits];
+        if (digit === void 0 || digit < "0" || digit > "7") break;
+        value = value * 8 + (digit.charCodeAt(0) - 48);
+        digits += 1;
+      }
+      bytes.push(value & 255);
+      index += digits;
+      continue;
+    }
+    bytes.push(next.charCodeAt(0));
+    index += 1;
+  }
+  return Buffer.from(bytes).toString("utf8");
+};
+var realPath = (value) => {
+  try {
+    return realpathSync.native(value);
+  } catch {
+    return value;
+  }
+};
+var relativeSeed = (root, top, seed) => {
+  const absolute = path7.isAbsolute(seed) ? seed : path7.resolve(root, seed);
+  for (const base of /* @__PURE__ */ new Set([top, realPath(top)])) {
+    for (const candidate of /* @__PURE__ */ new Set([absolute, realPath(absolute), path7.resolve(realPath(root), seed)])) {
+      const relative = path7.relative(base, candidate);
+      if (!relative || relative === ".." || relative.startsWith(`..${path7.sep}`) || path7.isAbsolute(relative)) {
+        continue;
+      }
+      return toPosix(relative);
+    }
+  }
+  return void 0;
+};
+var emptyGraph = (seeds, unavailable) => ({
+  seeds,
+  edges: [],
+  commitsScanned: 0,
+  truncated: false,
+  unavailable
+});
+async function coChange(request) {
+  const requestedSeeds = request.seeds.filter((seed) => seed.length > 0);
+  if (requestedSeeds.length === 0) return emptyGraph([], "no seed files were provided");
+  if (!existsSync(request.root)) return emptyGraph(requestedSeeds, "root directory does not exist");
+  const maxCommits = Math.max(1, Math.floor(request.maxCommits) || 1);
+  const limit = Math.max(1, Math.floor(request.limit) || 1);
+  let top;
+  try {
+    const revParse = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: request.root,
+      timeout: GIT_TIMEOUT_MS,
+      encoding: "utf8"
+    });
+    top = revParse.stdout.trim();
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") return emptyGraph(requestedSeeds, "git is not available");
+    return emptyGraph(requestedSeeds, "not a git repository");
+  }
+  if (!top) return emptyGraph(requestedSeeds, "not a git repository");
+  const seedSet = /* @__PURE__ */ new Set();
+  for (const seed of requestedSeeds) {
+    const normalized = relativeSeed(request.root, top, seed);
+    if (normalized) seedSet.add(normalized);
+  }
+  const seeds = [...seedSet];
+  if (seeds.length === 0) return emptyGraph(requestedSeeds, "seed files are outside the repository");
+  let stdout;
+  try {
+    const log = await execFileAsync(
+      "git",
+      [
+        "log",
+        `--max-count=${maxCommits}`,
+        "--no-merges",
+        "--name-only",
+        `--pretty=format:
%H`
+      ],
+      {
+        cwd: top,
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer: GIT_MAX_BUFFER,
+        encoding: "utf8"
+      }
+    );
+    stdout = log.stdout;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+      return emptyGraph(seeds, "commit history exceeded the read budget");
+    }
+    return emptyGraph(seeds, "no commit history");
+  }
+  const fileCommits = /* @__PURE__ */ new Map();
+  const sharedCommits = /* @__PURE__ */ new Map();
+  const current = [];
+  let commitsScanned = 0;
+  let seedCommits = 0;
+  let inCommit = false;
+  let bulk = false;
+  const settle = () => {
+    if (!inCommit) return;
+    inCommit = false;
+    if (bulk) {
+      bulk = false;
+      current.length = 0;
+      return;
+    }
+    commitsScanned += 1;
+    let touchesSeed = false;
+    for (const file of current) {
+      if (seedSet.has(file)) {
+        touchesSeed = true;
+        break;
+      }
+    }
+    if (touchesSeed) seedCommits += 1;
+    for (const file of current) {
+      fileCommits.set(file, (fileCommits.get(file) ?? 0) + 1);
+      if (touchesSeed && !seedSet.has(file)) {
+        sharedCommits.set(file, (sharedCommits.get(file) ?? 0) + 1);
+      }
+    }
+    current.length = 0;
+  };
+  let cursor = 0;
+  while (cursor <= stdout.length) {
+    let end = stdout.indexOf("\n", cursor);
+    if (end < 0) end = stdout.length;
+    const line = stdout.slice(cursor, end);
+    cursor = end + 1;
+    if (line.length === 0) continue;
+    if (line.charCodeAt(0) === COMMIT_MARKER_CODE) {
+      settle();
+      inCommit = true;
+      continue;
+    }
+    if (!inCommit || bulk) continue;
+    if (current.length >= BULK_COMMIT_FILE_CEILING) {
+      bulk = true;
+      current.length = 0;
+      continue;
+    }
+    current.push(line.charCodeAt(0) === QUOTE_CODE ? unquoteGitPath(line) : line);
+  }
+  settle();
+  if (commitsScanned === 0) return emptyGraph(seeds, "no commit history");
+  const edges = [];
+  if (seedCommits > 0) {
+    const seedRoot = Math.sqrt(seedCommits);
+    for (const [file, shared] of sharedCommits) {
+      const total = fileCommits.get(file) ?? shared;
+      edges.push({ file, score: shared / (seedRoot * Math.sqrt(total)), commits: shared });
+    }
+  }
+  edges.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    if (right.commits !== left.commits) return right.commits - left.commits;
+    return left.file < right.file ? -1 : left.file > right.file ? 1 : 0;
+  });
+  const truncated = edges.length > limit;
+  if (truncated) edges.length = limit;
+  if (seedCommits === 0) {
+    return { seeds, edges, commitsScanned, truncated, unavailable: "seed files do not appear in the scanned history" };
+  }
+  return { seeds, edges, commitsScanned, truncated };
+}
+
+// src/codemap/symbols.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile, readdir } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path8 from "node:path";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var commonDirectory = (files) => {
+  let prefix;
+  for (const file of files) {
+    const parts = file.split("/");
+    parts.pop();
+    if (prefix === void 0) {
+      prefix = parts;
+      continue;
+    }
+    let shared = 0;
+    while (shared < prefix.length && shared < parts.length && prefix[shared] === parts[shared]) shared++;
+    prefix.length = shared;
+    if (shared === 0) return "";
+  }
+  return prefix === void 0 ? "" : prefix.join("/");
+};
+var importBundledNatives = async () => {
+  try {
+    const bundled = await import("@oh-my-pi/pi-natives");
+    return typeof bundled.astGrep === "function" ? bundled : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var importPlatformNatives = () => {
+  const load = createRequire(import.meta.url);
+  return load(`@oh-my-pi/pi-natives-${process.platform}-${process.arch}`);
+};
+var nativesOnce;
+var codeNatives = () => {
+  nativesOnce ??= importBundledNatives().then((bundled) => bundled ?? importPlatformNatives());
+  return nativesOnce;
+};
+var SCRIPT_DECLARATION = /^(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?(function|class|interface|type|enum|const|let|var)\b/;
+var ARROW_VALUE = /^(?:async\s*)?[(<]/;
+var classifyScript = (text, meta) => {
+  const exported = text.startsWith("export");
+  const declaration = SCRIPT_DECLARATION.exec(text);
+  switch (declaration?.[1]) {
+    case "function":
+      return { kind: "fn", exported };
+    case "class":
+      return { kind: "class", exported };
+    case "interface":
+      return { kind: "iface", exported };
+    case "type":
+      return { kind: "type", exported };
+    case "enum":
+      return { kind: "enum", exported };
+    default: {
+      const value = meta?.V;
+      if (value === void 0) return { kind: "fn", exported };
+      const arrow = ARROW_VALUE.test(value) && value.includes("=>");
+      return { kind: arrow ? "fn" : "const", exported };
+    }
+  }
+};
+var SCRIPT_VALUE_PATTERNS = [
+  "function $NAME($$$A) { $$$B }",
+  "export function $NAME($$$A) { $$$B }",
+  "export default function $NAME($$$A) { $$$B }",
+  "class $NAME { $$$B }",
+  "export class $NAME { $$$B }",
+  "export default class $NAME { $$$B }",
+  "const $NAME = ($$$A) => $B",
+  "const $NAME = $V",
+  "export const $NAME = $V"
+];
+var TYPED_SCRIPT_PATTERNS = [
+  ...SCRIPT_VALUE_PATTERNS,
+  "interface $NAME { $$$B }",
+  "export interface $NAME { $$$B }",
+  "type $NAME = $V",
+  "export type $NAME = $V",
+  "enum $NAME { $$$B }",
+  "export enum $NAME { $$$B }"
+];
+var PYTHON_DEFINITION = /^(?:async\s+)?def\b/;
+var PYTHON_CLASS = /^class\b/;
+var classifyPython = (text) => {
+  if (PYTHON_DEFINITION.test(text)) return { kind: "fn", exported: true };
+  if (PYTHON_CLASS.test(text)) return { kind: "class", exported: true };
+  return { kind: "const", exported: true };
+};
+var GO_METHOD = /^func\s*\(/;
+var GO_FUNCTION = /^func\b/;
+var GO_STRUCT = /^type\s+\w+\s+struct\b/;
+var GO_INTERFACE = /^type\s+\w+\s+interface\b/;
+var GO_TYPE = /^type\b/;
+var classifyGo = (text) => {
+  if (GO_METHOD.test(text)) return { kind: "method", exported: true };
+  if (GO_FUNCTION.test(text)) return { kind: "fn", exported: true };
+  if (GO_STRUCT.test(text)) return { kind: "class", exported: true };
+  if (GO_INTERFACE.test(text)) return { kind: "iface", exported: true };
+  if (GO_TYPE.test(text)) return { kind: "type", exported: true };
+  return { kind: "const", exported: true };
+};
+var RUST_KEYWORD = /^(?:pub(?:\([^)]*\))?\s+)?(fn|struct|enum|trait|type|const|static)\b/;
+var classifyRust = (text) => {
+  const exported = text.startsWith("pub");
+  switch (RUST_KEYWORD.exec(text)?.[1]) {
+    case "fn":
+      return { kind: "fn", exported };
+    case "struct":
+      return { kind: "class", exported };
+    case "enum":
+      return { kind: "enum", exported };
+    case "trait":
+      return { kind: "iface", exported };
+    case "type":
+      return { kind: "type", exported };
+    default:
+      return { kind: "const", exported };
+  }
+};
+var JAVA_KEYWORD = /^(?:(?:public|private|protected|static|final|abstract|synchronized|native|strictfp)\s+)*(class|interface|enum|record)\b/;
+var classifyJava = (text) => {
+  const exported = text.startsWith("public");
+  switch (JAVA_KEYWORD.exec(text)?.[1]) {
+    case "class":
+    case "record":
+      return { kind: "class", exported };
+    case "interface":
+      return { kind: "iface", exported };
+    case "enum":
+      return { kind: "enum", exported };
+    default:
+      return { kind: "method", exported };
+  }
+};
+var globFor = (extensions) => extensions.length === 1 ? `**/*.${extensions[0]}` : `**/*.{${extensions.join(",")}}`;
+var defineSpec = (id, lang, extensions, patterns, classify) => ({ id, lang, extensions, glob: globFor(extensions), patterns, classify });
+var LANGUAGE_SPECS = [
+  defineSpec("ts", "ts", ["ts", "mts", "cts"], TYPED_SCRIPT_PATTERNS, classifyScript),
+  defineSpec("tsx", "tsx", ["tsx"], TYPED_SCRIPT_PATTERNS, classifyScript),
+  defineSpec("js", "js", ["js", "mjs", "cjs", "jsx"], SCRIPT_VALUE_PATTERNS, classifyScript),
+  defineSpec(
+    "python",
+    "python",
+    ["py", "pyi"],
+    [
+      "def $NAME($$$A): $$$B",
+      "class $NAME($$$A): $$$B",
+      "class $NAME: $$$B",
+      "$NAME = $V"
+    ],
+    classifyPython
+  ),
+  defineSpec(
+    "go",
+    "go",
+    ["go"],
+    [
+      "func $NAME($$$A) $$$R { $$$B }",
+      "func ($$$RECV) $NAME($$$A) $$$R { $$$B }",
+      "type $NAME struct { $$$B }",
+      "type $NAME interface { $$$B }",
+      "type $NAME = $V",
+      "const $NAME = $V",
+      "var $NAME = $V"
+    ],
+    classifyGo
+  ),
+  defineSpec(
+    "rust",
+    "rust",
+    ["rs"],
+    [
+      "fn $NAME($$$A) { $$$B }",
+      "fn $NAME($$$A) -> $R { $$$B }",
+      "pub fn $NAME($$$A) { $$$B }",
+      "pub fn $NAME($$$A) -> $R { $$$B }",
+      "struct $NAME { $$$B }",
+      "pub struct $NAME { $$$B }",
+      "enum $NAME { $$$B }",
+      "pub enum $NAME { $$$B }",
+      "trait $NAME { $$$B }",
+      "pub trait $NAME { $$$B }",
+      "type $NAME = $V;",
+      "pub type $NAME = $V;",
+      "const $NAME: $T = $V;",
+      "pub const $NAME: $T = $V;",
+      "static $NAME: $T = $V;",
+      "pub static $NAME: $T = $V;"
+    ],
+    classifyRust
+  ),
+  defineSpec(
+    "java",
+    "java",
+    ["java"],
+    [
+      "class $NAME { $$$B }",
+      "public class $NAME { $$$B }",
+      "interface $NAME { $$$B }",
+      "public interface $NAME { $$$B }",
+      "enum $NAME { $$$B }",
+      "public enum $NAME { $$$B }",
+      "$RET $NAME($$$A) { $$$B }",
+      "public $RET $NAME($$$A) { $$$B }",
+      "private $RET $NAME($$$A) { $$$B }",
+      "protected $RET $NAME($$$A) { $$$B }",
+      "public static $RET $NAME($$$A) { $$$B }",
+      "static $RET $NAME($$$A) { $$$B }"
+    ],
+    classifyJava
+  )
+];
+var EXTENSION_SPECS = /* @__PURE__ */ new Map();
+for (const spec of LANGUAGE_SPECS) {
+  for (const extension of spec.extensions) EXTENSION_SPECS.set(extension, spec);
+}
+var FALLBACK_EXTENSIONS = /* @__PURE__ */ new Set([
+  "c",
+  "cc",
+  "cpp",
+  "cs",
+  "cxx",
+  "dart",
+  "elm",
+  "erl",
+  "ex",
+  "exs",
+  "groovy",
+  "h",
+  "hh",
+  "hpp",
+  "hs",
+  "jl",
+  "kt",
+  "kts",
+  "lua",
+  "nim",
+  "php",
+  "pl",
+  "pm",
+  "proto",
+  "rb",
+  "scala",
+  "sh",
+  "sql",
+  "svelte",
+  "swift",
+  "vue",
+  "zig"
+]);
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist"]);
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var KIND_RANK = {
+  method: 5,
+  fn: 4,
+  class: 3,
+  iface: 3,
+  enum: 3,
+  type: 2,
+  const: 1
+};
+var MATCH_TIMEOUT_MS = 12e4;
+var MAX_FALLBACK_BYTES = 2e6;
+var extensionOf = (file) => {
+  const slash = file.lastIndexOf("/");
+  const dot = file.lastIndexOf(".");
+  if (dot <= slash + 1) return void 0;
+  return file.slice(dot + 1).toLowerCase();
+};
+var indexableExtension = (file) => {
+  const extension = extensionOf(file);
+  if (extension === void 0) return void 0;
+  if (EXTENSION_SPECS.has(extension) || FALLBACK_EXTENSIONS.has(extension)) return extension;
+  return void 0;
+};
+var GLOB_ESCAPE = /[.+^$()|[\]\\]/g;
+var globToRegExp = (pattern) => {
+  let source = "";
+  let braces = 0;
+  for (let i = 0; i < pattern.length; i += 1) {
+    const character = pattern[i];
+    if (character === "*") {
+      if (pattern[i + 1] === "*") {
+        i += 1;
+        if (pattern[i + 1] === "/") {
+          i += 1;
+          source += "(?:[^/]*/)*";
+        } else {
+          source += ".*";
+        }
+        continue;
+      }
+      source += "[^/]*";
+      continue;
+    }
+    if (character === "?") {
+      source += "[^/]";
+      continue;
+    }
+    if (character === "{") {
+      braces += 1;
+      source += "(?:";
+      continue;
+    }
+    if (character === "}" && braces > 0) {
+      braces -= 1;
+      source += ")";
+      continue;
+    }
+    if (character === "," && braces > 0) {
+      source += "|";
+      continue;
+    }
+    source += character?.replace(GLOB_ESCAPE, "\\$&") ?? "";
+  }
+  return new RegExp(`^${source}$`);
+};
+var GIT_LIST_TIMEOUT_MS = 2e4;
+var GIT_LIST_MAX_BUFFER = 64 * 1024 * 1024;
+var gitTrackedFiles = async (root, matcher, signal) => {
+  let stdout;
+  try {
+    const result = await execFileAsync2(
+      "git",
+      ["-C", root, "ls-files", "--cached", "--others", "--exclude-standard", "-z"],
+      {
+        maxBuffer: GIT_LIST_MAX_BUFFER,
+        timeout: GIT_LIST_TIMEOUT_MS,
+        ...signal ? { signal } : {}
+      }
+    );
+    stdout = result.stdout;
+  } catch {
+    return void 0;
+  }
+  const found = [];
+  let cursor = 0;
+  while (cursor < stdout.length) {
+    let end = stdout.indexOf("\0", cursor);
+    if (end === -1) end = stdout.length;
+    const relative = stdout.slice(cursor, end);
+    cursor = end + 1;
+    if (relative.length === 0) continue;
+    if (relative.charCodeAt(0) === 46) continue;
+    if (indexableExtension(relative) === void 0) continue;
+    if (matcher !== void 0 && !matcher.test(relative)) continue;
+    let skipped2 = false;
+    let segmentStart = 0;
+    while (segmentStart < relative.length) {
+      let segmentEnd = relative.indexOf("/", segmentStart);
+      if (segmentEnd === -1) break;
+      const segment = relative.slice(segmentStart, segmentEnd);
+      if (segment.charCodeAt(0) === 46 || SKIP_DIRECTORIES.has(segment)) {
+        skipped2 = true;
+        break;
+      }
+      segmentStart = segmentEnd + 1;
+    }
+    if (!skipped2) found.push(relative);
+  }
+  return found;
+};
+var walkFiles = async (root, matcher, signal) => {
+  const found = [];
+  const pending = [""];
+  while (pending.length > 0) {
+    const directory = pending.pop() ?? "";
+    throwIfAborted(signal);
+    let entries;
+    try {
+      entries = await readdir(directory === "" ? root : path8.join(root, directory), {
+        withFileTypes: true
+      });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const name = entry.name;
+      if (name.charCodeAt(0) === 46) continue;
+      const relative = directory === "" ? name : `${directory}/${name}`;
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRECTORIES.has(name)) pending.push(relative);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (indexableExtension(relative) === void 0) continue;
+      if (matcher !== void 0 && !matcher.test(relative)) continue;
+      found.push(relative);
+    }
+  }
+  return found;
+};
+var discoverFiles = async (root, matcher, signal) => await gitTrackedFiles(root, matcher, signal) ?? await walkFiles(root, matcher, signal);
+var COMMENT_HEAD = /^(?:\/\/|\/\*|\*|#|--|<!--|;|%)/;
+var IMPORT_HEAD = /^(?:import|from|require|include|use|using|package|open|load|source)\b/;
+var DECLARATION_HEAD = /^(?:export|pub|public|private|protected|internal|static|final|abstract|override|virtual|inline|async|unsafe|extern|shared|readonly|declare|local|def|defp|defmodule|defstruct|defmacro|class|module|namespace|record|object|data|struct|enum|union|interface|trait|protocol|actor|impl|extension|fn|func|function|sub|procedure|method|const|let|var|val|type|typedef|typealias|template|operator|constructor|init|property|event|signal|macro|task)\b/;
+var ASSIGNMENT_HEAD = /^[A-Za-z_$][\w$]*\s*(?::[^=]*)?=[^=]/;
+var EXPORTED_HEAD = /^(?:export|pub|public)\b/;
+var IDENTIFIERS = /[A-Za-z_$][\w$]*/g;
+var FALLBACK_KINDS = /* @__PURE__ */ new Map([
+  ["class", "class"],
+  ["module", "class"],
+  ["namespace", "class"],
+  ["record", "class"],
+  ["object", "class"],
+  ["struct", "class"],
+  ["impl", "class"],
+  ["actor", "class"],
+  ["defmodule", "class"],
+  ["defstruct", "class"],
+  ["interface", "iface"],
+  ["trait", "iface"],
+  ["protocol", "iface"],
+  ["enum", "enum"],
+  ["union", "enum"],
+  ["def", "fn"],
+  ["defp", "fn"],
+  ["defmacro", "fn"],
+  ["fn", "fn"],
+  ["func", "fn"],
+  ["function", "fn"],
+  ["sub", "fn"],
+  ["procedure", "fn"],
+  ["method", "method"],
+  ["constructor", "method"],
+  ["init", "method"],
+  ["type", "type"],
+  ["typedef", "type"],
+  ["typealias", "type"]
+]);
+var FALLBACK_SKIP = /* @__PURE__ */ new Set([
+  ...FALLBACK_KINDS.keys(),
+  "export",
+  "pub",
+  "public",
+  "private",
+  "protected",
+  "internal",
+  "static",
+  "final",
+  "abstract",
+  "override",
+  "virtual",
+  "inline",
+  "async",
+  "unsafe",
+  "extern",
+  "shared",
+  "readonly",
+  "declare",
+  "local",
+  "extension",
+  "template",
+  "operator",
+  "property",
+  "event",
+  "signal",
+  "macro",
+  "task",
+  "const",
+  "let",
+  "var",
+  "val",
+  "auto",
+  "new",
+  "return",
+  "self",
+  "this",
+  "void",
+  "int",
+  "long",
+  "short",
+  "byte",
+  "char",
+  "bool",
+  "boolean",
+  "float",
+  "double",
+  "string",
+  "str",
+  "unsigned",
+  "signed",
+  "size_t",
+  "mut",
+  "end",
+  "do",
+  "then",
+  "begin",
+  "where",
+  "with",
+  "as",
+  "in",
+  "of",
+  "is",
+  "not",
+  "and",
+  "or",
+  "if",
+  "else",
+  "for",
+  "while",
+  "switch",
+  "match",
+  "try",
+  "catch",
+  "throw",
+  "throws",
+  "extends",
+  "implements"
+]);
+var fallbackSymbol = (file, line, lineNumber) => {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return void 0;
+  if (COMMENT_HEAD.test(trimmed) || IMPORT_HEAD.test(trimmed)) return void 0;
+  if (!DECLARATION_HEAD.test(trimmed) && !ASSIGNMENT_HEAD.test(trimmed)) return void 0;
+  IDENTIFIERS.lastIndex = 0;
+  let kind = "const";
+  let name;
+  for (let token = IDENTIFIERS.exec(trimmed); token !== null; token = IDENTIFIERS.exec(trimmed)) {
+    const word = token[0];
+    if (!FALLBACK_SKIP.has(word)) {
+      name = word;
+      break;
+    }
+    const mapped = FALLBACK_KINDS.get(word);
+    if (mapped !== void 0 && kind === "const") kind = mapped;
+  }
+  if (name === void 0 || !IDENTIFIER.test(name)) return void 0;
+  const exported = EXPORTED_HEAD.test(trimmed) || name.charCodeAt(0) !== 95;
+  return { file, line: lineNumber, kind, name, exported };
+};
+var countLines = (code) => {
+  let lines = 1;
+  for (let at = code.indexOf("\n"); at >= 0; at = code.indexOf("\n", at + 1)) lines += 1;
+  return lines;
+};
+var record = (into, symbol) => {
+  const key = `${symbol.file}\0${symbol.line}\0${symbol.name}`;
+  const existing = into.get(key);
+  if (existing === void 0) {
+    into.set(key, symbol);
+    return;
+  }
+  if (symbol.exported) existing.exported = true;
+  if (KIND_RANK[symbol.kind] > KIND_RANK[existing.kind]) existing.kind = symbol.kind;
+};
+var toPosix2 = (value) => path8.sep === "/" ? value : value.split(path8.sep).join("/");
+var compareSymbols = (left, right) => {
+  if (left.file !== right.file) return left.file < right.file ? -1 : 1;
+  if (left.line !== right.line) return left.line - right.line;
+  return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+};
+async function buildSymbolIndex(request) {
+  const startedAt = Date.now();
+  const signal = request.signal;
+  throwIfAborted(signal);
+  const root = path8.resolve(request.root);
+  const matcher = request.glob === void 0 ? void 0 : globToRegExp(request.glob);
+  const discovered = await discoverFiles(root, matcher, signal);
+  discovered.sort();
+  let truncated = false;
+  let files = discovered;
+  if (files.length > request.maxFiles) {
+    files = discovered.slice(0, request.maxFiles);
+    truncated = true;
+  }
+  const languages = {};
+  const assigned = /* @__PURE__ */ new Map();
+  const activeSpecs = /* @__PURE__ */ new Set();
+  const fallbackFiles = [];
+  for (const file of files) {
+    const extension = indexableExtension(file);
+    if (extension === void 0) continue;
+    const spec = EXTENSION_SPECS.get(extension);
+    const label = spec?.id ?? extension;
+    languages[label] = (languages[label] ?? 0) + 1;
+    if (spec === void 0) {
+      fallbackFiles.push(file);
+      continue;
+    }
+    assigned.set(file, spec.id);
+    activeSpecs.add(spec.id);
+  }
+  const natives = await codeNatives();
+  const collected = /* @__PURE__ */ new Map();
+  const matchLimit = Math.max(4096, request.maxSymbols * 2);
+  for (const spec of LANGUAGE_SPECS) {
+    if (!activeSpecs.has(spec.id)) continue;
+    throwIfAborted(signal);
+    const scoped = [];
+    for (const [file, id] of assigned) if (id === spec.id) scoped.push(file);
+    const prefix = commonDirectory(scoped);
+    const result = await natives.astGrep({
+      patterns: spec.patterns,
+      lang: spec.lang,
+      path: prefix === "" ? root : path8.join(root, prefix),
+      glob: spec.glob,
+      includeMeta: true,
+      limit: matchLimit,
+      timeoutMs: MATCH_TIMEOUT_MS,
+      ...signal ? { signal } : {}
+    });
+    if (result.limitReached) truncated = true;
+    for (const match of result.matches) {
+      const relative = toPosix2(match.path);
+      const file = prefix === "" ? relative : `${prefix}/${relative}`;
+      if (assigned.get(file) !== spec.id) continue;
+      const name = match.metaVariables?.NAME;
+      if (name === void 0 || !IDENTIFIER.test(name)) continue;
+      const classification = spec.classify(match.text, match.metaVariables);
+      record(collected, {
+        file,
+        line: match.startLine,
+        kind: classification.kind,
+        name,
+        exported: classification.exported
+      });
+    }
+  }
+  for (const file of fallbackFiles) {
+    throwIfAborted(signal);
+    let code;
+    try {
+      code = await readFile(path8.join(root, file), "utf8");
+    } catch {
+      continue;
+    }
+    if (code.length === 0 || code.length > MAX_FALLBACK_BYTES) continue;
+    let summary;
+    try {
+      summary = natives.summarizeCode({
+        code,
+        path: file,
+        unfoldUntilLines: Math.max(64, countLines(code) >> 2)
+      });
+    } catch {
+      continue;
+    }
+    for (const segment of summary.segments) {
+      if (segment.kind !== "kept" || segment.text === void 0) continue;
+      const lines = segment.text.split("\n");
+      for (let offset = 0; offset < lines.length; offset += 1) {
+        const symbol = fallbackSymbol(file, lines[offset] ?? "", segment.startLine + offset);
+        if (symbol !== void 0) record(collected, symbol);
+      }
+    }
+  }
+  const symbols = [...collected.values()];
+  symbols.sort(compareSymbols);
+  if (symbols.length > request.maxSymbols) {
+    symbols.length = request.maxSymbols;
+    truncated = true;
+  }
+  return {
+    root,
+    symbols,
+    files,
+    languages,
+    fallbackFiles,
+    truncated,
+    elapsedMs: Date.now() - startedAt
+  };
+}
+
+// src/providers/codemap-provider.ts
+var INDEX_TTL_MS = 3e4;
+var mapSchema = Type.Object({
+  maxTokens: Type.Optional(Type.Number({
+    minimum: 200,
+    maximum: 2e5,
+    description: "Token ceiling for the rendered map"
+  })),
+  glob: Type.Optional(Type.String({
+    maxLength: 512,
+    description: "Glob filter relative to the workspace root"
+  })),
+  focus: Type.Optional(Type.String({
+    maxLength: 512,
+    description: "Task description or symbol name the map should centre on"
+  })),
+  seeds: Type.Optional(Type.Array(Type.String({ maxLength: 1024 }), {
+    maxItems: 32,
+    description: "Files whose git co-change history should raise related files in the ranking"
+  })),
+  refresh: Type.Optional(Type.Boolean({
+    description: "Rebuild the symbol index instead of reusing the cached one"
+  }))
+}, { additionalProperties: false });
+var cascadeSchema = Type.Object({
+  seeds: Type.Array(Type.String({ maxLength: 1024 }), {
+    minItems: 1,
+    maxItems: 32,
+    description: "Files to rank co-change against"
+  }),
+  limit: Type.Optional(Type.Number({ minimum: 1, maximum: 200 })),
+  maxCommits: Type.Optional(Type.Number({ minimum: 10, maximum: 2e4 }))
+}, { additionalProperties: false });
+var checked = (action, schema, args) => {
+  const validation = validateJsonSchemaValue(schema.toJsonSchema(), args);
+  if (!validation.success) {
+    const message2 = validation.issues.slice(0, 5).map((issue) => issue.message).join("; ");
+    throw new Error(`Invalid codemap.${action} arguments: ${message2}`);
+  }
+  return args;
+};
+var descriptors = [
+  {
+    name: "map",
+    description: "Repo-wide symbol map under an explicit token budget. Returns one line per symbol (line, kind, name) grouped by file, ranked by focus relevance and optional git co-change, with omission counts when the budget bites. Answers which files and symbols a task touches; use omp.grep for text and omp.read for source.",
+    inputSchema: mapSchema.toJsonSchema(),
+    risk: "read"
+  },
+  {
+    name: "cascade",
+    description: "Rank files by how often they historically changed in the same commits as the seed files, normalised so ubiquitous files (lockfiles, changelogs) do not dominate. Answers which files a change will drag along, which text search cannot.",
+    inputSchema: cascadeSchema.toJsonSchema(),
+    risk: "read"
+  }
+];
+var normalizeCodemapArgs = actionArgNormalizer(() => descriptors);
+var CodemapProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  name = "codemap";
+  description = "Structural repo map: budgeted symbol disclosure and git co-change ranking";
+  #cache = /* @__PURE__ */ new Map();
+  async list(request, _context) {
+    const query = request.query?.toLowerCase();
+    return query ? descriptors.filter(
+      (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
+    ) : descriptors;
+  }
+  async describe(actionName, _context) {
+    return descriptors.find((descriptor) => descriptor.name === actionName);
+  }
+  prepareArguments(actionName, args) {
+    return normalizeCodemapArgs(actionName, args);
+  }
+  async #index(root, glob, refresh, signal) {
+    const key = `${root}\0${glob ?? ""}`;
+    const cached = this.#cache.get(key);
+    if (!refresh && cached && Date.now() - cached.at < INDEX_TTL_MS) return cached.index;
+    const index = await buildSymbolIndex({
+      root,
+      ...glob !== void 0 ? { glob } : {},
+      maxFiles: this.config.maxFiles,
+      maxSymbols: this.config.maxSymbols,
+      ...signal !== void 0 ? { signal } : {}
+    });
+    this.#cache.set(key, { index, at: Date.now() });
+    return index;
+  }
+  async invoke(actionName, args, context) {
+    switch (actionName) {
+      case "map": {
+        const input = checked("map", mapSchema, args);
+        const index = await this.#index(context.cwd, input.glob, input.refresh === true, context.signal);
+        let cascade;
+        if (input.seeds && input.seeds.length > 0) {
+          cascade = await coChange({
+            root: context.cwd,
+            seeds: input.seeds,
+            maxCommits: this.config.cascadeCommits,
+            limit: this.config.cascadeLimit
+          });
+        }
+        const budgeted = assembleMap({
+          index,
+          maxTokens: input.maxTokens ?? this.config.defaultMaxTokens,
+          ...input.focus !== void 0 ? { focus: input.focus } : {},
+          ...cascade !== void 0 ? { cascade } : {}
+        });
+        context.activity?.({
+          type: "progress",
+          message: `Code map: ${budgeted.symbolsShown} symbols across ${budgeted.filesShown} files${budgeted.truncated ? ` (${budgeted.omittedSymbols} omitted)` : ""}`
+        });
+        return {
+          ...budgeted,
+          indexed: {
+            files: index.files.length,
+            symbols: index.symbols.length,
+            languages: index.languages,
+            fallbackFiles: index.fallbackFiles.length,
+            truncated: index.truncated,
+            elapsedMs: index.elapsedMs
+          },
+          ...cascade !== void 0 ? { cascade } : {}
+        };
+      }
+      case "cascade": {
+        const input = checked("cascade", cascadeSchema, args);
+        const graph = await coChange({
+          root: context.cwd,
+          seeds: input.seeds,
+          maxCommits: input.maxCommits ?? this.config.cascadeCommits,
+          limit: input.limit ?? this.config.cascadeLimit
+        });
+        context.activity?.({
+          type: "progress",
+          message: graph.unavailable ? `Co-change unavailable: ${graph.unavailable}` : `Co-change: ${graph.edges.length} related files from ${graph.commitsScanned} commits`
+        });
+        return graph;
+      }
+      default:
+        throw new Error(`Unknown codemap action: ${actionName}`);
+    }
+  }
+};
+
+// src/providers/compact-provider.ts
+import { Type as Type2 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
+import { validateJsonSchemaValue as validateJsonSchemaValue2 } from "@oh-my-pi/pi-ai/utils/schema";
+var requestSchema = Type2.Object({
+  reason: Type2.Optional(Type2.String({
     maxLength: 1024,
     description: "Short human-readable reason for the compaction"
   })),
-  instructions: Type.Optional(Type.String({
+  instructions: Type2.Optional(Type2.String({
     maxLength: MAX_COMPACTION_INSTRUCTIONS_CHARS,
     description: "Custom compaction instructions forwarded to OMP core"
   })),
-  preserve: Type.Optional(Type.Array(
-    Type.String({ maxLength: MAX_PRESERVE_ITEM_CHARS }),
+  preserve: Type2.Optional(Type2.Array(
+    Type2.String({ maxLength: MAX_PRESERVE_ITEM_CHARS }),
     {
       maxItems: MAX_PRESERVE_ITEMS,
       description: "Explicit bounded facts to preserve, encoded as a typed Fabric compaction request"
     }
   )),
-  requestedBy: Type.Optional(Type.String({
+  requestedBy: Type2.Optional(Type2.String({
     maxLength: 256,
     description: "Who requested the compaction (default: model)"
   }))
 }, { additionalProperties: false });
 var checkedRequestArguments = (args) => {
-  const validation = validateJsonSchemaValue(requestSchema.toJsonSchema(), args);
+  const validation = validateJsonSchemaValue2(requestSchema.toJsonSchema(), args);
   if (!validation.success) {
     const message2 = validation.issues.slice(0, 5).map((error) => error.message).join("; ");
     throw new Error(`Invalid compact.request arguments: ${message2}`);
@@ -6811,7 +8054,7 @@ var emptySchema = {
   properties: {},
   additionalProperties: false
 };
-var descriptors = [
+var descriptors2 = [
   {
     name: "request",
     description: "Request an advisory compaction of the host session's context at the next safe boundary (agent_end). The host commits it only between turns, never mid-turn. A new request replaces any pending one.",
@@ -6834,7 +8077,7 @@ var descriptors = [
     risk: "write"
   }
 ];
-var normalizeCompactArgs = actionArgNormalizer(() => descriptors);
+var normalizeCompactArgs = actionArgNormalizer(() => descriptors2);
 var CompactProvider = class {
   constructor(controller) {
     this.controller = controller;
@@ -6843,12 +8086,12 @@ var CompactProvider = class {
   description = "Programmatic, advisory-then-committed context compaction for the host OMP session";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors.filter(
+    return query ? descriptors2.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors;
+    ) : descriptors2;
   }
   async describe(actionName, _context) {
-    return descriptors.find((descriptor) => descriptor.name === actionName);
+    return descriptors2.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeCompactArgs(actionName, args);
@@ -6888,7 +8131,7 @@ var CompactProvider = class {
 };
 
 // src/providers/components-provider.ts
-var descriptors2 = [
+var descriptors3 = [
   {
     name: "list",
     description: "List registered component definitions and configured component instances.",
@@ -6935,13 +8178,13 @@ var ComponentsProvider = class {
   description = "Supervised component lifecycle, exact capability dependencies, effect cleanup, and reload diagnostics.";
   async list(request, _context) {
     const query = request.query?.normalize("NFKC").trim().toLowerCase();
-    const filtered = query ? descriptors2.filter(
+    const filtered = query ? descriptors3.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors2;
+    ) : descriptors3;
     return filtered.slice(0, Math.max(1, Math.min(request.limit ?? 100, 100)));
   }
   async describe(actionName, _context) {
-    return descriptors2.find((descriptor) => descriptor.name === actionName);
+    return descriptors3.find((descriptor) => descriptor.name === actionName);
   }
   async invoke(actionName, args, _context) {
     switch (actionName) {
@@ -6976,7 +8219,7 @@ var ComponentsProvider = class {
 import fs5 from "node:fs/promises";
 import fsSync from "node:fs";
 import os from "node:os";
-import path7 from "node:path";
+import path9 from "node:path";
 var MCP_DESCRIPTOR_CACHE_VERSION = 1;
 var homeDir = () => {
   const home = process.env.HOME;
@@ -6987,25 +8230,25 @@ var expandHome = (input) => {
   const home = homeDir();
   if (input === "~") return home;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path7.join(home, input.slice(2));
+    return path9.join(home, input.slice(2));
   }
   return input;
 };
-var legacyMcporterDir = () => path7.join(homeDir(), ".mcporter");
+var legacyMcporterDir = () => path9.join(homeDir(), ".mcporter");
 var mcporterConfigDir = () => {
   const raw = process.env.XDG_CONFIG_HOME;
   if (raw && raw.trim().length > 0) {
     const resolved = expandHome(raw.trim());
-    if (path7.isAbsolute(resolved)) return path7.join(resolved, "mcporter");
+    if (path9.isAbsolute(resolved)) return path9.join(resolved, "mcporter");
   }
   return legacyMcporterDir();
 };
 var mcporterConfigCandidates = () => {
   const base = mcporterConfigDir();
-  const candidates = [path7.join(base, "mcporter.json"), path7.join(base, "mcporter.jsonc")];
+  const candidates = [path9.join(base, "mcporter.json"), path9.join(base, "mcporter.jsonc")];
   const legacy = legacyMcporterDir();
   if (base !== legacy) {
-    candidates.push(path7.join(legacy, "mcporter.json"), path7.join(legacy, "mcporter.jsonc"));
+    candidates.push(path9.join(legacy, "mcporter.json"), path9.join(legacy, "mcporter.jsonc"));
   }
   return candidates;
 };
@@ -7020,12 +8263,12 @@ var pathExists = (filePath) => {
 var mcpConfigLayerPaths = (rootDir, configPath) => {
   const explicitRaw = configPath ?? process.env.MCPORTER_CONFIG;
   if (explicitRaw && explicitRaw.trim().length > 0) {
-    return [path7.resolve(expandHome(explicitRaw.trim()))];
+    return [path9.resolve(expandHome(explicitRaw.trim()))];
   }
   const paths = [];
   const home = mcporterConfigCandidates().find(pathExists);
   if (home) paths.push(home);
-  const projectPath = path7.resolve(rootDir, "config", "mcporter.json");
+  const projectPath = path9.resolve(rootDir, "config", "mcporter.json");
   if (pathExists(projectPath)) paths.push(projectPath);
   return paths;
 };
@@ -7076,8 +8319,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 projectMcpCachePath = (projectRoot) => path9.join(projectRoot, ".omp", "fabric", "mcp-cache.json");
+var globalMcpCachePath = (agentDir) => path9.join(agentDir, "fabric", "mcp-descriptors.json");
 var tempCounter = 0;
 var McpDescriptorCacheStore = class {
   constructor(filePath) {
@@ -7094,9 +8337,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 = path7.dirname(this.filePath);
+    const directory = path9.dirname(this.filePath);
     await fs5.mkdir(directory, { recursive: true });
-    const tempPath = path7.join(
+    const tempPath = path9.join(
       directory,
       `.mcp-cache-${process.pid}-${Date.now()}-${tempCounter++}.tmp`
     );
@@ -7111,7 +8354,7 @@ var McpDescriptorCacheStore = class {
 };
 
 // src/providers/mcp-provider.ts
-import path8 from "node:path";
+import path10 from "node:path";
 var TOOL_METADATA_TTL_MS = 6e4;
 var REVALIDATE_CONCURRENCY = 3;
 var REVALIDATE_SERVER_TIMEOUT_MS = 2e4;
@@ -7181,16 +8424,16 @@ var managementDescriptors = [
 var normalizeSchema = (schema) => typeof schema === "object" && schema !== null && !Array.isArray(schema) ? schema : emptyObjectSchema;
 var normalizeMcpResult = (result) => {
   if (typeof result !== "object" || result === null || Array.isArray(result)) return result;
-  const record = result;
-  if (!Array.isArray(record.content)) return result;
-  const text = record.content.filter(
+  const record2 = result;
+  if (!Array.isArray(record2.content)) return result;
+  const text = record2.content.filter(
     (part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string"
   ).map((part) => part.text).join("\n");
-  if (record.isError === true) throw new Error(text || "MCP tool returned an error");
+  if (record2.isError === true) throw new Error(text || "MCP tool returned an error");
   return {
     text,
-    content: record.content,
-    structuredContent: record.structuredContent ?? null
+    content: record2.content,
+    structuredContent: record2.structuredContent ?? null
   };
 };
 var delay2 = (ms, signal) => new Promise((resolve2) => {
@@ -7265,9 +8508,9 @@ var McpProvider = class {
     this.#kickRevalidation();
     if (!request.namespace) await this.#awaitColdEnumeration(context.signal);
     const query = request.query?.toLowerCase();
-    const filterQuery = (descriptors6) => query ? descriptors6.filter(
+    const filterQuery = (descriptors7) => query ? descriptors7.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors6;
+    ) : descriptors7;
     if (request.namespace) {
       const server = await this.#resolveKnownServer(request.namespace);
       if (!server) return [];
@@ -7416,11 +8659,11 @@ var McpProvider = class {
   // Provider-fidelity descriptors for everything currently known, cached or
   // ephemeral.
   sliceDescriptors() {
-    const descriptors6 = [];
+    const descriptors7 = [];
     for (const [server, entry] of this.#servers) {
-      for (const tool of entry.tools) descriptors6.push(this.#toolDescriptor(server, tool));
+      for (const tool of entry.tools) descriptors7.push(this.#toolDescriptor(server, tool));
     }
-    return descriptors6;
+    return descriptors7;
   }
   // Test/ops hook: await hydration and any in-flight background revalidation,
   // then flush pending persistence and notifications.
@@ -7822,7 +9065,7 @@ var McpProvider = class {
           kind: "stdio",
           command: args.command,
           args: commandArgs,
-          cwd: path8.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
+          cwd: path10.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
         },
         ...env ? { env } : {}
       };
@@ -7887,13 +9130,13 @@ var McpProvider = class {
         return tools.map((tool) => this.#toolDescriptor(server, tool));
       })
     );
-    const descriptors6 = settled.flatMap(
+    const descriptors7 = settled.flatMap(
       (entry) => entry.status === "fulfilled" ? entry.value : []
     );
     const query = request.query?.toLowerCase();
-    const filtered = query ? descriptors6.filter(
+    const filtered = query ? descriptors7.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors6;
+    ) : descriptors7;
     return request.namespace ? filtered : [...managementDescriptors, ...filtered];
   }
   async #describeLegacy(actionName, _context) {
@@ -7965,7 +9208,7 @@ var assertReadableStateKey = (key) => {
     throw new Error(`Fabric mesh key is private host state: ${key}`);
   }
 };
-var descriptors3 = [
+var descriptors4 = [
   {
     name: "self",
     description: "Return this Fabric participant's mesh identity",
@@ -8084,7 +9327,7 @@ var descriptors3 = [
     namespace: "coordination"
   }
 ];
-var normalizeMeshArgs = actionArgNormalizer(() => descriptors3);
+var normalizeMeshArgs = actionArgNormalizer(() => descriptors4);
 var MeshProvider = class {
   constructor(store, identity, participants) {
     this.store = store;
@@ -8095,12 +9338,12 @@ var MeshProvider = class {
   description = "Durable topics and compare-and-swap shared state for emergent agent coordination";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors3.filter(
+    return query ? descriptors4.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors3;
+    ) : descriptors4;
   }
   async describe(actionName, _context) {
-    return descriptors3.find((descriptor) => descriptor.name === actionName);
+    return descriptors4.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeMeshArgs(actionName, args);
@@ -8191,7 +9434,7 @@ var MeshProvider = class {
 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 path11 from "node:path";
+import path13 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";
@@ -8207,7 +9450,7 @@ import {
 
 // src/agents/bash-worktree-add.ts
 import fs6 from "node:fs";
-import path9 from "node:path";
+import path11 from "node:path";
 var BARE_SAFE = /^[A-Za-z0-9_./:@%+=,-]+$/;
 var parseGitWorktreeAdd = (command) => {
   const trimmed = command.trim();
@@ -8270,8 +9513,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 ? path9.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
-  const dest = path9.resolve(gitCwd, parsed.dest);
+  const gitCwd = parsed.gitCwd ? path11.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
+  const dest = path11.resolve(gitCwd, parsed.dest);
   let gitRoot;
   try {
     const root = await executeFile("git", ["rev-parse", "--show-toplevel"], {
@@ -8300,9 +9543,9 @@ var tryExecuteGitWorktreeAdd = async (args, sessionCwd) => {
 
 // src/providers/omp-bash-cwd.ts
 import { accessSync, constants, statSync as statSync2 } from "node:fs";
-import path10 from "node:path";
+import path12 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";
+import { Type as Type3 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 var OMP_BASH_CWD_KEY = "cwd";
 var resolveOmpShellCwd = (toolName, sessionCwd, requested) => {
   if (typeof requested !== "string" || requested.trim().length === 0) {
@@ -8310,7 +9553,7 @@ var resolveOmpShellCwd = (toolName, sessionCwd, requested) => {
       `Invalid omp.${toolName} cwd ${JSON.stringify(requested)}: path must be a non-empty string`
     );
   }
-  const resolved = path10.isAbsolute(requested) ? path10.resolve(requested) : path10.resolve(sessionCwd, requested);
+  const resolved = path12.isAbsolute(requested) ? path12.resolve(requested) : path12.resolve(sessionCwd, requested);
   try {
     if (!statSync2(resolved).isDirectory()) throw new Error("path is not a directory");
     accessSync(resolved, constants.R_OK | constants.X_OK);
@@ -8330,8 +9573,8 @@ var resolveShellCwdArgument = (toolName, sessionCwd, args) => Object.hasOwn(args
     args[OMP_BASH_CWD_KEY]
   )
 } : args;
-var CWD_PROPERTY = Type2.Optional(
-  Type2.String({
+var CWD_PROPERTY = Type3.Optional(
+  Type3.String({
     description: "Execution directory for this command; relative paths resolve from the session cwd."
   })
 );
@@ -8350,7 +9593,7 @@ var withShellCwdSchema = (schema) => {
   if (Object.hasOwn(document.properties, OMP_BASH_CWD_KEY)) return schema;
   const cwdSchema = schemaDocument2(CWD_PROPERTY);
   if (!cwdSchema) return schema;
-  return Type2.Unsafe({
+  return Type3.Unsafe({
     ...document,
     properties: { ...document.properties, [OMP_BASH_CWD_KEY]: cwdSchema }
   });
@@ -8386,22 +9629,22 @@ var BashCwdDefinitions = class extends ShellCwdDefinitions {
 // src/providers/write-preview.ts
 import { homedir } from "node:os";
 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";
+import { mkdir, readFile as readFile2, stat, writeFile } from "node:fs/promises";
+import { Type as Type4 } from "@oh-my-pi/pi-coding-agent/extensibility/legacy-typebox";
 var mutationQueues = /* @__PURE__ */ new Map();
-var withFileMutationQueue = async (path17, operation) => {
-  const previous = mutationQueues.get(path17) ?? Promise.resolve();
+var withFileMutationQueue = async (path19, operation) => {
+  const previous = mutationQueues.get(path19) ?? Promise.resolve();
   let release;
   const current = new Promise((resolve2) => {
     release = resolve2;
   });
-  mutationQueues.set(path17, current);
+  mutationQueues.set(path19, current);
   await previous;
   try {
     return await operation();
   } finally {
     release();
-    if (mutationQueues.get(path17) === current) mutationQueues.delete(path17);
+    if (mutationQueues.get(path19) === current) mutationQueues.delete(path19);
   }
 };
 var resolvePreviewPath = (filePath, cwd) => {
@@ -8436,7 +9679,7 @@ var readExistingFileForPreview = async (filePath, cwd, nextContent) => {
     return skipped("previous file too large", fileStat.size, true);
   }
   try {
-    const content = await readFile(absolutePath, "utf8");
+    const content = await readFile2(absolutePath, "utf8");
     const bytes = Buffer.byteLength(content, "utf8");
     return bytes > MAX_WRITE_DIFF_BYTES ? skipped("previous file too large", bytes, true) : { kind: "content", content };
   } catch {
@@ -8448,20 +9691,20 @@ var createPreviewWriteToolDefinition = (cwd) => {
     name: "write",
     label: "Write",
     description: "Write a file",
-    parameters: Type3.Object({ path: Type3.String(), content: Type3.String() }),
+    parameters: Type4.Object({ path: Type4.String(), content: Type4.String() }),
     execute: async () => ({ content: [{ type: "text", text: "" }] })
   };
   return {
     ...original,
     async execute(_toolCallId, params, signal) {
-      const { path: path17, content } = params;
-      const absolutePath = resolvePreviewPath(path17, cwd);
+      const { path: path19, content } = params;
+      const absolutePath = resolvePreviewPath(path19, cwd);
       return withFileMutationQueue(absolutePath, async () => {
         const throwIfAborted2 = () => {
           if (signal?.aborted) throw new Error("Operation aborted");
         };
         throwIfAborted2();
-        const before = await readExistingFileForPreview(path17, cwd, content);
+        const before = await readExistingFileForPreview(path19, cwd, content);
         throwIfAborted2();
         await mkdir(dirname(absolutePath), { recursive: true });
         throwIfAborted2();
@@ -8471,7 +9714,7 @@ var createPreviewWriteToolDefinition = (cwd) => {
           content: [
             {
               type: "text",
-              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path17}`
+              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path19}`
             }
           ],
           details: { codePreviewBeforeWrite: before }
@@ -8486,7 +9729,7 @@ 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(path11.join(os2.tmpdir(), "omp-fabric-bash-")) : void 0;
+  const artifactRoot = artifactPaths ? mkdtempSync(path13.join(os2.tmpdir(), "omp-fabric-bash-")) : void 0;
   return {
     cwd,
     hasUI: false,
@@ -8503,7 +9746,7 @@ var createNativeSession = (cwd, artifactPaths) => {
         try {
           mkdirSync2(artifactRoot, { recursive: true, mode: 448 });
           const id = randomUUID3();
-          const artifactPath = path11.join(artifactRoot, `${toolType}-${id}.log`);
+          const artifactPath = path13.join(artifactRoot, `${toolType}-${id}.log`);
           writeFileSync2(artifactPath, "", { mode: 384 });
           artifactPaths.set(id, artifactPath);
           artifactAllocations.getStore()?.push(artifactPath);
@@ -8566,19 +9809,19 @@ var createGrepDefinitionWithSkip = (cwd) => {
     ...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 record2 = asRecord(params) ?? {};
+      const rawPattern = typeof record2.pattern === "string" ? record2.pattern : "";
+      const searchPath = typeof record2.path === "string" ? record2.path : ".";
+      const glob = typeof record2.glob === "string" ? record2.glob : void 0;
+      const contextLines = typeof record2.context === "number" ? record2.context : void 0;
+      const skip = typeof record2.skip === "number" ? record2.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,
+          pattern: record2.literal === true ? piEscapeRegexLiteral(rawPattern) : rawPattern,
           path: glob ? piJoinPath(searchPath, glob) : searchPath,
-          case: record.ignoreCase === true ? false : void 0,
+          case: record2.ignoreCase === true ? false : void 0,
           ...skip === void 0 ? {} : { skip }
         },
         signal,
@@ -8598,19 +9841,19 @@ var normalizeEditArguments = (args, replaceAll, cwd) => {
     if (typeof edit !== "object" || edit === null || Array.isArray(edit)) {
       throw new Error(`omp.edit edits[${index}] must be an object`);
     }
-    const record = edit;
-    const oldString = record.old_string ?? record.oldText ?? record.old;
-    const newString = record.new_string ?? record.newText ?? record.new ?? record.replacement;
+    const record2 = edit;
+    const oldString = record2.old_string ?? record2.oldText ?? record2.old;
+    const newString = record2.new_string ?? record2.newText ?? record2.new ?? record2.replacement;
     if (typeof oldString !== "string" || typeof newString !== "string") {
       throw new Error(`omp.edit edits[${index}] requires old and new text strings`);
     }
     return {
       old_string: oldString,
       new_string: newString,
-      ...replaceAll || record.all === true || record.replace_all === true ? { replace_all: true } : {}
+      ...replaceAll || record2.all === true || record2.replace_all === true ? { replace_all: true } : {}
     };
   });
-  const resolvedPath = path11.resolve(cwd, filePath.startsWith("@") ? filePath.slice(1) : filePath);
+  const resolvedPath = path13.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`);
@@ -8722,7 +9965,7 @@ var keepLeadingLines = (text, count) => {
   }
   return text.slice(0, index - 1);
 };
-var countLines = (text) => {
+var countLines2 = (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++;
@@ -8791,11 +10034,11 @@ var withoutColumnLimit = (detailRecord, metaRecord) => {
   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 record2 = asRecord(details);
+  if (!record2 || record2.truncated !== true) return void 0;
+  const perFile = finiteNumber2(record2.perFileLimitReached);
+  const maxColumn = finiteNumber2(asRecord(asRecord(asRecord(record2.meta)?.limits)?.columnTruncated)?.maxColumn);
+  const fileCount = finiteNumber2(record2.fileCount);
   const reasons = [];
   const notes = [];
   let continuation = null;
@@ -8822,7 +10065,7 @@ var grepTruncationSignal = (details) => {
     tool: "grep",
     partial: true,
     reasons,
-    ...finiteNumber2(record.matchCount) === void 0 ? {} : { matchCount: record.matchCount },
+    ...finiteNumber2(record2.matchCount) === void 0 ? {} : { matchCount: record2.matchCount },
     ...fileCount === void 0 ? {} : { fileCount },
     ...perFile === void 0 ? {} : { perFileMatchLimit: perFile },
     ...maxColumn === void 0 ? {} : { maxColumn },
@@ -8859,9 +10102,9 @@ var lineBudgetSignal = (meta, target, progress) => {
   };
 };
 var findTruncationSignal = (details) => {
-  const record = asRecord(details);
-  if (!record || record.truncated !== true) return void 0;
-  const reached = finiteNumber2(record.resultLimitReached) ?? finiteNumber2(record.fileCount);
+  const record2 = asRecord(details);
+  if (!record2 || record2.truncated !== true) return void 0;
+  const reached = finiteNumber2(record2.resultLimitReached) ?? finiteNumber2(record2.fileCount);
   return {
     tool: "find",
     partial: true,
@@ -9014,10 +10257,10 @@ var OmpToolsProvider = class _OmpToolsProvider {
   }
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    const descriptors6 = await Promise.all(
+    const descriptors7 = await Promise.all(
       OMP_CORE_TOOL_NAMES.map((name) => this.describe(name, _context))
     );
-    return descriptors6.filter((descriptor) => descriptor !== void 0).filter(
+    return descriptors7.filter((descriptor) => descriptor !== void 0).filter(
       (descriptor) => query ? `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query) : true
     );
   }
@@ -9041,13 +10284,13 @@ var OmpToolsProvider = class _OmpToolsProvider {
     if (typeof prepared !== "object" || prepared === null || Array.isArray(prepared)) {
       throw new Error(`OMP tool ${actionName} prepared non-object arguments`);
     }
-    const record = prepared;
+    const record2 = prepared;
     if (isOmpShellToolName(actionName)) {
-      const shellArgs = Object.hasOwn(args, OMP_BASH_CWD_KEY) ? { ...record, [OMP_BASH_CWD_KEY]: args[OMP_BASH_CWD_KEY] } : record;
+      const shellArgs = Object.hasOwn(args, OMP_BASH_CWD_KEY) ? { ...record2, [OMP_BASH_CWD_KEY]: args[OMP_BASH_CWD_KEY] } : record2;
       return resolveShellCwdArgument(actionName, this.#cwd, shellArgs);
     }
-    if (actionName === "read") return normalizeReadArguments(record);
-    return actionName === "edit" ? normalizeEditArguments(record, args.all === true, this.#cwd) : record;
+    if (actionName === "read") return normalizeReadArguments(record2);
+    return actionName === "edit" ? normalizeEditArguments(record2, args.all === true, this.#cwd) : record2;
   }
   #assertAllowed(name) {
     if (this.#allowedTools && !this.#allowedTools.has(name)) {
@@ -9257,7 +10500,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
     }
     const budget = resultCharBound(context) - READ_MARKER_RESERVE_CHARS;
     let text = stripRepeatReadHint(textContent(result.content));
-    let covered = meta.shownEnd ?? countLines(text);
+    let covered = meta.shownEnd ?? countLines2(text);
     let nextOffset = meta.nextOffset;
     let stopped;
     while (nextOffset !== void 0 && covered < target.endLimit) {
@@ -9281,7 +10524,7 @@ var OmpToolsProvider = class _OmpToolsProvider {
       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;
+      const pageEnd = pageMeta?.shownEnd ?? start + countLines2(pageText) - 1;
       if (body.length === 0 || pageEnd <= covered) {
         nextOffset = void 0;
         break;
@@ -9411,7 +10654,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 path13 from "node:path";
+import path15 from "node:path";
 
 // src/schema/types.ts
 var stateBinding = (head) => head ? { transitionId: head.transitionId, version: head.version, to: head.to } : null;
@@ -9420,7 +10663,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 path12 from "node:path";
+import path14 from "node:path";
 var SNAPSHOT_MAX_FILES = 2e4;
 var SNAPSHOT_MAX_BYTES = 512 * 1024 * 1024;
 var FALLBACK_SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -9438,10 +10681,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(path12.sep).join("/");
+var normalizeRelative = (value) => value.split(path14.sep).join("/");
 var isInside = (root, candidate) => {
-  const relative = path12.relative(root, candidate);
-  return relative === "" || !path12.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
+  const relative = path14.relative(root, candidate);
+  return relative === "" || !path14.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path14.sep}`);
 };
 var excluded = (absolute, exclusions) => exclusions.some((root) => isInside(root, absolute));
 var entryDigest = (absolute) => {
@@ -9467,12 +10710,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 = path12.resolve(cwd, relativeInput);
+    const absolute = path14.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(path12.relative(cwd, absolute));
+    const relative = normalizeRelative(path14.relative(cwd, absolute));
     const entry = entryDigest(absolute);
     bytes += entry.bytes;
     if (bytes > SNAPSHOT_MAX_BYTES) {
@@ -9501,9 +10744,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 = path12.join(directory, entry.name);
+      const absolute = path14.join(directory, entry.name);
       if (excluded(absolute, exclusions)) continue;
-      const relative = normalizeRelative(path12.relative(cwd, absolute));
+      const relative = normalizeRelative(path14.relative(cwd, absolute));
       if (entry.isDirectory()) visit(absolute);
       else paths.push(relative);
       if (paths.length > SNAPSHOT_MAX_FILES) {
@@ -9517,7 +10760,7 @@ var fallbackPaths = (cwd, exclusions) => {
 var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   const cwd = fs7.realpathSync(cwdInput);
   const exclusions = excludedRoots.map((root) => {
-    const absolute = path12.resolve(root);
+    const absolute = path14.resolve(root);
     try {
       return fs7.realpathSync(absolute);
     } catch {
@@ -9555,18 +10798,18 @@ var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   );
 };
 var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
-  if (!requestedPath.trim() || path12.isAbsolute(requestedPath)) {
+  if (!requestedPath.trim() || path14.isAbsolute(requestedPath)) {
     throw new Error(`Schema paths must be non-empty project-relative paths: ${requestedPath}`);
   }
   const cwd = fs7.realpathSync(cwdInput);
-  const absolute = path12.resolve(cwd, requestedPath);
+  const absolute = path14.resolve(cwd, requestedPath);
   if (!isInside(cwd, absolute) || absolute === cwd) {
     throw new Error(`Schema path escapes the project workspace: ${requestedPath}`);
   }
-  const relativeParts = path12.relative(cwd, absolute).split(path12.sep);
+  const relativeParts = path14.relative(cwd, absolute).split(path14.sep);
   let cursor = cwd;
   for (let index = 0; index < relativeParts.length; index++) {
-    cursor = path12.join(cursor, relativeParts[index]);
+    cursor = path14.join(cursor, relativeParts[index]);
     let stat2;
     try {
       stat2 = fs7.lstatSync(cursor);
@@ -9575,9 +10818,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(path12.dirname(cursor));
+        const parentReal = fs7.realpathSync(path14.dirname(cursor));
         if (!isInside(cwd, parentReal)) throw new Error(`Schema path parent escapes the workspace: ${requestedPath}`);
-        return { absolute, relative: normalizeRelative(path12.relative(cwd, absolute)), exists: false };
+        return { absolute, relative: normalizeRelative(path14.relative(cwd, absolute)), exists: false };
       }
       throw error;
     }
@@ -9589,7 +10832,7 @@ var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
       throw new Error(`Schema transaction paths must name regular files: ${requestedPath}`);
     }
   }
-  return { absolute, relative: normalizeRelative(path12.relative(cwd, absolute)), exists: true };
+  return { absolute, relative: normalizeRelative(path14.relative(cwd, absolute)), exists: true };
 };
 var sha256File = (absolute) => `sha256:${digest(fs7.readFileSync(absolute))}`;
 
@@ -9640,8 +10883,8 @@ var SchemaController = class {
     this.identity = identity;
     this.state = state;
     this.cwd = fs8.realpathSync(cwd);
-    this.#journalRoot = path13.join(mesh.root, "schema-transactions");
-    this.#lockPath = path13.join(this.#journalRoot, ".commit.lock");
+    this.#journalRoot = path15.join(mesh.root, "schema-transactions");
+    this.#lockPath = path15.join(this.#journalRoot, ".commit.lock");
     this.#recoverJournals();
   }
   #activeHypotheses = /* @__PURE__ */ new Map();
@@ -9666,12 +10909,12 @@ var SchemaController = class {
   }
   status(parentToolCallId) {
     const workspace = this.#workspaceEntry();
-    const hypotheses = this.mesh.list(HYPOTHESIS_PREFIX, this.mesh.maxReadEvents).map((entry) => entry.value).filter((record) => !parentToolCallId || record.parentToolCallId === parentToolCallId).map((record) => ({
-      id: record.id,
-      label: record.label,
-      status: record.status,
-      generation: record.generation,
-      updatedAt: record.updatedAt
+    const hypotheses = this.mesh.list(HYPOTHESIS_PREFIX, this.mesh.maxReadEvents).map((entry) => entry.value).filter((record2) => !parentToolCallId || record2.parentToolCallId === parentToolCallId).map((record2) => ({
+      id: record2.id,
+      label: record2.label,
+      status: record2.status,
+      generation: record2.generation,
+      updatedAt: record2.updatedAt
     }));
     return {
       mode: this.config.mode,
@@ -9696,7 +10939,7 @@ var SchemaController = class {
     const snapshot = snapshotWorkspace(this.cwd, [this.mesh.root]);
     const generation = this.#generation();
     const now = Date.now();
-    const record = {
+    const record2 = {
       id: randomUUID4(),
       label: input.label,
       summary: input.summary,
@@ -9710,66 +10953,66 @@ var SchemaController = class {
       createdAt: now,
       updatedAt: now
     };
-    await this.#publish("hypothesized", record);
+    await this.#publish("hypothesized", record2);
     await this.mesh.put({
-      key: `${HYPOTHESIS_PREFIX}${record.id}`,
-      value: record,
+      key: `${HYPOTHESIS_PREFIX}${record2.id}`,
+      value: record2,
       ifVersion: 0,
       identity: this.identity
     });
-    this.#activeHypotheses.set(record.id, context.parentToolCallId);
-    context.update(`Schema hypothesis recorded: ${record.label}`);
+    this.#activeHypotheses.set(record2.id, context.parentToolCallId);
+    context.update(`Schema hypothesis recorded: ${record2.label}`);
     return {
-      hypothesisId: record.id,
-      status: record.status,
-      state: record.state,
-      fingerprint: record.fingerprint,
+      hypothesisId: record2.id,
+      status: record2.status,
+      state: record2.state,
+      fingerprint: record2.fingerprint,
       generation
     };
   }
   async verify(hypothesisId, context) {
     const entry = this.#requireHypothesis(hypothesisId);
-    const record = entry.value;
-    this.#assertInvocation(record.parentToolCallId, context.parentToolCallId);
-    if (record.status !== "active") throw new Error(`Schema hypothesis is not active: ${record.status}`);
-    if (record.evidence.length === 0) return this.#failedVerification(record, [], "missing evidence");
+    const record2 = entry.value;
+    this.#assertInvocation(record2.parentToolCallId, context.parentToolCallId);
+    if (record2.status !== "active") throw new Error(`Schema hypothesis is not active: ${record2.status}`);
+    if (record2.evidence.length === 0) return this.#failedVerification(record2, [], "missing evidence");
     let before;
     try {
       before = snapshotWorkspace(this.cwd, [this.mesh.root]);
     } catch (error) {
-      return this.#failedVerification(record, [], `workspace snapshot failed: ${errorMessage4(error)}`);
+      return this.#failedVerification(record2, [], `workspace snapshot failed: ${errorMessage4(error)}`);
     }
     const currentState = stateBinding(this.state?.getHead() ?? null);
-    if (!sameBinding(record.state, currentState)) {
-      return this.#failedVerification(record, [], "state head changed since hypothesis");
+    if (!sameBinding(record2.state, currentState)) {
+      return this.#failedVerification(record2, [], "state head changed since hypothesis");
     }
-    if (record.generation !== this.#generation()) {
-      return this.#failedVerification(record, [], "workspace generation changed since hypothesis");
+    if (record2.generation !== this.#generation()) {
+      return this.#failedVerification(record2, [], "workspace generation changed since hypothesis");
     }
-    if (record.fingerprint !== before.fingerprint) {
-      return this.#failedVerification(record, [], "workspace fingerprint changed since hypothesis");
+    if (record2.fingerprint !== before.fingerprint) {
+      return this.#failedVerification(record2, [], "workspace fingerprint changed since hypothesis");
     }
-    const results = await this.#verifyEvidence(record.evidence, context);
+    const results = await this.#verifyEvidence(record2.evidence, context);
     let after;
     try {
       after = snapshotWorkspace(this.cwd, [this.mesh.root]);
     } catch (error) {
-      return this.#failedVerification(record, results, `post-evidence snapshot failed: ${errorMessage4(error)}`);
+      return this.#failedVerification(record2, results, `post-evidence snapshot failed: ${errorMessage4(error)}`);
     }
     const allConfirmed = results.length > 0 && results.every((result) => result.status === "confirmed");
     if (!allConfirmed || before.fingerprint !== after.fingerprint) {
       const reason = before.fingerprint !== after.fingerprint ? "workspace fingerprint changed while evidence ran" : "one or more evidence items were not confirmed";
-      return this.#failedVerification(record, results, reason);
+      return this.#failedVerification(record2, results, reason);
     }
     const certificate = randomBytes(32).toString("hex");
     const issuedAt = Date.now();
     const certificateRecord = {
       tokenHash: hashToken(certificate),
-      hypothesisId: record.id,
+      hypothesisId: record2.id,
       parentToolCallId: context.parentToolCallId,
-      state: record.state,
-      fingerprint: record.fingerprint,
-      generation: record.generation,
+      state: record2.state,
+      fingerprint: record2.fingerprint,
+      generation: record2.generation,
       issuedAt,
       expiresAt: issuedAt + this.config.certificateTtlMs,
       status: "active"
@@ -9784,7 +11027,7 @@ var SchemaController = class {
     try {
       await this.mesh.put({
         key: entry.key,
-        value: { ...record, status: "verified", updatedAt: Date.now() },
+        value: { ...record2, status: "verified", updatedAt: Date.now() },
         ifVersion: entry.version,
         identity: this.identity
       });
@@ -9803,16 +11046,16 @@ var SchemaController = class {
     this.#activeCertificates.set(certificateRecord.tokenHash, context.parentToolCallId);
     try {
       await this.#publish("verified", {
-        hypothesisId: record.id,
+        hypothesisId: record2.id,
         tokenHash: certificateRecord.tokenHash,
         results: results.map((result) => ({
           kind: result.evidence.kind,
           status: result.status,
           detail: result.detail
         })),
-        state: record.state,
-        fingerprint: record.fingerprint,
-        generation: record.generation,
+        state: record2.state,
+        fingerprint: record2.fingerprint,
+        generation: record2.generation,
         issuedAt,
         expiresAt: certificateRecord.expiresAt
       });
@@ -9821,7 +11064,7 @@ var SchemaController = class {
     context.update(`Schema evidence confirmed; certificate expires in ${this.config.certificateTtlMs}ms`);
     return {
       verified: true,
-      hypothesisId: record.id,
+      hypothesisId: record2.id,
       certificate,
       issuedAt,
       expiresAt: certificateRecord.expiresAt,
@@ -9840,7 +11083,7 @@ var SchemaController = class {
     this.#assertPayloadBound(input);
     const release = this.#acquireCommitLock();
     const transactionId = randomUUID4();
-    const journalPath = path13.join(this.#journalRoot, `${transactionId}.json`);
+    const journalPath = path15.join(this.#journalRoot, `${transactionId}.json`);
     let journal;
     let consumed = false;
     let committed = false;
@@ -10050,12 +11293,12 @@ var SchemaController = class {
       if (invocation !== parentToolCallId) continue;
       const entry = this.mesh.get(`${CERTIFICATE_PREFIX}${tokenHash}`);
       if (entry) {
-        const record = entry.value;
-        if (record.status === "active") {
+        const record2 = entry.value;
+        if (record2.status === "active") {
           try {
             await this.mesh.put({
               key: entry.key,
-              value: { ...record, status: "abandoned" },
+              value: { ...record2, status: "abandoned" },
               ifVersion: entry.version,
               identity: this.identity
             });
@@ -10069,12 +11312,12 @@ var SchemaController = class {
       if (invocation !== parentToolCallId) continue;
       const entry = this.mesh.get(`${HYPOTHESIS_PREFIX}${hypothesisId}`);
       if (entry) {
-        const record = entry.value;
-        if (record.status === "active" || record.status === "verified") {
+        const record2 = entry.value;
+        if (record2.status === "active" || record2.status === "verified") {
           try {
             await this.mesh.put({
               key: entry.key,
-              value: { ...record, status: "abandoned", updatedAt: Date.now() },
+              value: { ...record2, status: "abandoned", updatedAt: Date.now() },
               ifVersion: entry.version,
               identity: this.identity
             });
@@ -10085,16 +11328,16 @@ var SchemaController = class {
       this.#activeHypotheses.delete(hypothesisId);
     }
   }
-  async #failedVerification(record, results, reason) {
+  async #failedVerification(record2, results, reason) {
     try {
       await this.#publish("verification_failed", {
-        hypothesisId: record.id,
+        hypothesisId: record2.id,
         reason,
         results: results.map((result) => ({ kind: result.evidence.kind, status: result.status, detail: result.detail }))
       });
     } catch {
     }
-    return { verified: false, hypothesisId: record.id, reason, results };
+    return { verified: false, hypothesisId: record2.id, reason, results };
   }
   async #verifyEvidence(evidence, context) {
     if (evidence.length === 0) return [];
@@ -10321,7 +11564,7 @@ ${Date.now()}
     }
     for (const name of fs8.readdirSync(this.#journalRoot)) {
       if (!name.endsWith(".json")) continue;
-      const filePath = path13.join(this.#journalRoot, name);
+      const filePath = path15.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;
@@ -10441,7 +11684,7 @@ var operationSchema = {
     }
   ]
 };
-var descriptors4 = [
+var descriptors5 = [
   {
     name: "status",
     description: "Read the fixed session Schema mode, transaction bounds, generation, and invocation hypotheses",
@@ -10511,7 +11754,7 @@ var descriptors4 = [
     namespace: "schema"
   }
 ];
-var normalizeSchemaArgs = actionArgNormalizer(() => descriptors4);
+var normalizeSchemaArgs = actionArgNormalizer(() => descriptors5);
 var SchemaProvider = class {
   constructor(controller) {
     this.controller = controller;
@@ -10520,12 +11763,12 @@ var SchemaProvider = class {
   description = "Host-owned, opt-in Schema verification and bounded local-file transaction control plane";
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors4.filter(
+    return query ? descriptors5.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors4;
+    ) : descriptors5;
   }
   async describe(actionName, _context) {
-    return descriptors4.find((descriptor) => descriptor.name === actionName);
+    return descriptors5.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeSchemaArgs(actionName, args);
@@ -10575,11 +11818,11 @@ var SchemaProvider = class {
 
 // src/state/store.ts
 import { createHash as createHash5 } from "node:crypto";
-import path15 from "node:path";
+import path17 from "node:path";
 
 // src/state/complexity.ts
 import fs9 from "node:fs";
-import path14 from "node:path";
+import path16 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([
@@ -10811,7 +12054,7 @@ var languageComplexities = [
   typeScriptJavaScriptComplexity
 ];
 var complexityForFile = (file, languages = languageComplexities) => {
-  const extension = path14.extname(file).toLowerCase();
+  const extension = path16.extname(file).toLowerCase();
   return languages.find((language) => language.extensions.includes(extension));
 };
 var countFileComplexity = (file) => {
@@ -11630,10 +12873,10 @@ var StateStore = class {
     const currentHead = this.getHead();
     const records = [];
     for (const event of events) {
-      const record = toRecord(event, committedIds);
-      if (record) records.push(record);
+      const record2 = toRecord(event, committedIds);
+      if (record2) records.push(record2);
     }
-    if (currentHead && !records.some((record) => record.transitionId === currentHead.transitionId)) {
+    if (currentHead && !records.some((record2) => record2.transitionId === currentHead.transitionId)) {
       const currentRecord = toHeadRecord(currentHead);
       if (currentRecord) records.push(currentRecord);
     }
@@ -11646,7 +12889,7 @@ var StateStore = class {
       }
     }
     const visibleRecords = input.includeArchived || lastRepresentation < 0 ? records : records.slice(lastRepresentation);
-    const visibleIds = new Set(visibleRecords.map((record) => record.transitionId));
+    const visibleIds = new Set(visibleRecords.map((record2) => record2.transitionId));
     const latestOutcomes = latestTransitionOutcomes(events);
     const eventCertifications = events.map((event) => toCertificate(event, currentHead, latestOutcomes)).filter((certificate) => certificate !== void 0).filter(
       (certificate) => certificate.targets.every((target) => visibleIds.has(target.transitionId))
@@ -11662,32 +12905,32 @@ var StateStore = class {
       certifications.map((certificate) => [certificate.sequence, certificate])
     );
     const latestCertificate = /* @__PURE__ */ new Map();
-    for (const record of visibleRecords) {
-      const outcome = latestOutcomes.get(record.transitionId);
+    for (const record2 of visibleRecords) {
+      const outcome = latestOutcomes.get(record2.transitionId);
       if (outcome?.phase !== "certified") continue;
       const certificate = certificatesBySequence.get(outcome.event.sequence);
-      if (certificate) latestCertificate.set(record.transitionId, certificate);
+      if (certificate) latestCertificate.set(record2.transitionId, certificate);
     }
     if (durableCertificate) {
       latestCertificate.set(currentHead.transitionId, durableCertificate);
     }
     const archiveBoundaryId = input.includeArchived !== true && lastRepresentation > 0 ? records[lastRepresentation]?.transitionId : void 0;
     const filtered = (input.label ? visibleRecords.filter(
-      (record) => record.label === input.label || record.to === input.label || record.from === input.label && record.transitionId !== archiveBoundaryId
-    ) : visibleRecords).map((record) => {
-      const certificate = latestCertificate.get(record.transitionId);
-      return certificate ? { ...record, certificationStatus: "certified", certificate } : record;
+      (record2) => record2.label === input.label || record2.to === input.label || record2.from === input.label && record2.transitionId !== archiveBoundaryId
+    ) : visibleRecords).map((record2) => {
+      const certificate = latestCertificate.get(record2.transitionId);
+      return certificate ? { ...record2, certificationStatus: "certified", certificate } : record2;
     });
     const limited = input.limit !== void 0 && input.limit > 0 ? filtered.slice(0, input.limit) : filtered;
     const labelSet = /* @__PURE__ */ new Set();
     const limitedIds = /* @__PURE__ */ new Set();
-    for (const record of limited) {
-      limitedIds.add(record.transitionId);
-      if (record.from && record.transitionId !== archiveBoundaryId) {
-        labelSet.add(record.from);
+    for (const record2 of limited) {
+      limitedIds.add(record2.transitionId);
+      if (record2.from && record2.transitionId !== archiveBoundaryId) {
+        labelSet.add(record2.from);
       }
-      labelSet.add(record.to);
-      labelSet.add(record.label);
+      labelSet.add(record2.to);
+      labelSet.add(record2.label);
     }
     return {
       transitions: limited,
@@ -11702,7 +12945,7 @@ var StateStore = class {
     const files = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(requestedFiles, input.cwd)) {
-      const measured = countFileComplexity(path15.resolve(input.cwd, file));
+      const measured = countFileComplexity(path17.resolve(input.cwd, file));
       if (!measured) {
         files.push({ file, supported: false });
         continue;
@@ -11729,7 +12972,7 @@ var StateStore = class {
     const updates = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(files, cwd)) {
-      const measured = countFileComplexity(path15.resolve(cwd, file));
+      const measured = countFileComplexity(path17.resolve(cwd, file));
       if (!measured) {
         deltas.push({ file, supported: false });
         continue;
@@ -11779,11 +13022,11 @@ var StateStore = class {
     const normalized = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (!file.trim()) continue;
-      const relative = path15.relative(cwd, path15.resolve(cwd, file));
-      if (relative === ".." || relative.startsWith(`..${path15.sep}`) || path15.isAbsolute(relative)) {
+      const relative = path17.relative(cwd, path17.resolve(cwd, file));
+      if (relative === ".." || relative.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative)) {
         throw new Error(`State complexity file must be inside the project cwd: ${file}`);
       }
-      normalized.add(relative.split(path15.sep).join("/"));
+      normalized.add(relative.split(path17.sep).join("/"));
     }
     return [...normalized];
   }
@@ -11917,7 +13160,7 @@ var StateStore = class {
         includeArchived: input.includeArchived === true
       });
       const match = transitions.find(
-        (record) => record.transitionId === verificationHead.transitionId
+        (record2) => record2.transitionId === verificationHead.transitionId
       );
       targets = match ? [match] : [];
     } else {
@@ -12225,7 +13468,7 @@ var checkGoalSchema = {
   additionalProperties: false
 };
 var emptySchema3 = { type: "object", properties: {}, additionalProperties: false };
-var descriptors5 = [
+var descriptors6 = [
   {
     name: "transition",
     description: "Append a labeled, validated state transition and compare-and-swap advance the head",
@@ -12276,7 +13519,7 @@ var descriptors5 = [
     namespace: "state"
   }
 ];
-var normalizeStateArgs = actionArgNormalizer(() => descriptors5);
+var normalizeStateArgs = actionArgNormalizer(() => descriptors6);
 var StateProvider = class {
   name = "state";
   description = "Schema-style labeled transition layer: an append-only timeline of validated transitions with a compare-and-swap head and evidence-based certification over mesh storage";
@@ -12291,12 +13534,12 @@ var StateProvider = class {
   }
   async list(request, _context) {
     const query = request.query?.toLowerCase();
-    return query ? descriptors5.filter(
+    return query ? descriptors6.filter(
       (descriptor) => `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query)
-    ) : descriptors5;
+    ) : descriptors6;
   }
   async describe(actionName, _context) {
-    return descriptors5.find((descriptor) => descriptor.name === actionName);
+    return descriptors6.find((descriptor) => descriptor.name === actionName);
   }
   prepareArguments(actionName, args) {
     return normalizeStateArgs(actionName, args);
@@ -12777,7 +14020,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 ? path16.resolve(projectRoot, configuredMeshRoot) : path16.join(projectRoot, ".omp", "fabric", "mesh"));
+    const meshRoot = process.env.OMP_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path18.resolve(projectRoot, configuredMeshRoot) : path18.join(projectRoot, ".omp", "fabric", "mesh"));
     this.#mesh = new MeshStore(
       meshRoot,
       this.#config.mesh.maxEventBytes,
@@ -12842,6 +14085,19 @@ var FabricRuntimeState = class {
       description: "Host context compaction controller",
       create: () => new CompactProvider(this.#compact)
     }));
+    if (this.#config.codemap.enabled) {
+      const codemapConfig = this.#config.codemap;
+      await installBuiltin(createProviderComponent({
+        provider: "codemap",
+        description: "Structural repo map and git co-change ranking",
+        create: () => new CodemapProvider(codemapConfig)
+      }));
+    } else {
+      this.#registry.markUnavailable(
+        "codemap",
+        'disabled by configuration (codemap.enabled=false); set "codemap": { "enabled": true } in .omp/fabric.json or the agent fabric.json to enable codemap.* actions'
+      );
+    }
     const agentConfig = enforceSchema ? { ...this.#config.agents, enabled: false } : this.#config.agents;
     const modelsConfig = this.#config.models;
     const visibleOmpModels = () => {
@@ -12938,8 +14194,8 @@ var FabricRuntimeState = class {
     };
     const lineageAlive = (rootId) => this.#participants?.get(rootId) !== void 0;
     const actorRoots = {
-      project: path16.join(meshRoot, "actors"),
-      session: path16.join(meshRoot, "actors", fabricSessionId)
+      project: path18.join(meshRoot, "actors"),
+      session: path18.join(meshRoot, "actors", fabricSessionId)
     };
     const acquireActorCapabilityView = (requirements, signal) => this.#registry.acquireCapabilityView(requirements, {
       cwd: context.cwd,
@@ -13139,6 +14395,7 @@ ${escapeXmlText(text)}
       ...this.#config.mesh.enabled ? ["mesh", "state"] : [],
       "schema",
       "compact",
+      ...this.#config.codemap.enabled ? ["codemap"] : [],
       "agents",
       ...this.#config.memory.enabled ? ["memory"] : []
     ]);
@@ -13279,7 +14536,11 @@ ${escapeXmlText(text)}
       pending,
       outerToolResult,
       context,
-      (update) => this.activity.updateCall(runId, callId, update)
+      (update) => this.activity.updateCall(runId, callId, update),
+      {
+        handoffRetirement: this.#config?.prewalk.handoffRetirement ?? DEFAULT_FABRIC_CONFIG.prewalk.handoffRetirement,
+        handoffRetirementKeep: this.#config?.prewalk.handoffRetirementKeep ?? DEFAULT_FABRIC_CONFIG.prewalk.handoffRetirementKeep
+      }
     );
     const succeeded = result.completed === true || result.continued === true;
     const error = typeof result.error === "string" ? result.error : void 0;