pi-fabric 0.76.2 → 0.78.0

package/dist/chunks/{fabric-runtime-state-VCLWTB55.js → fabric-runtime-state-H2NCRJWK.js}

@@ -7,8 +7,9 @@ import {
 } from "./chunk-IGVDD2HT.js";
 import {
   MemoryProvider,
-  actionArgNormalizer
-} from "./chunk-6BBFFEPO.js";
+  actionArgNormalizer,
+  uniqueDeclaredKeyForSpelling
+} from "./chunk-DYEOFQ64.js";
 import "./chunk-BOIV6E3C.js";
 import "./chunk-NNFA2OIC.js";
 import "./chunk-E3V22XGU.js";
@@ -31,7 +32,7 @@ import {
   repairFabricGuestCode,
   resolveFabricIdentity,
   runFabricHandoffAtBoundary
-} from "./chunk-PAAXKXWT.js";
+} from "./chunk-2AF5ANEB.js";
 import {
   AgentTranscriptReader,
   MAX_WRITE_DIFF_BYTES,
@@ -40,8 +41,11 @@ import {
   writeContentForPreview
 } from "./chunk-5XQA7QX2.js";
 import {
-  ActionRegistry
-} from "./chunk-6ZKYQW33.js";
+  ActionRegistry,
+  clearActiveRepairCompiler,
+  repairActionName,
+  setActiveRepairCompiler
+} from "./chunk-3QPTSKDG.js";
 import {
   formatFabricEffectConflict
 } from "./chunk-LMAVZN7J.js";
@@ -69,15 +73,17 @@ import {
   ParticipantDirectory,
   actorDeliveryNotice,
   actorParticipantRecord,
+  addCloneFirstWorktree,
   agentParticipantRecords,
   effectiveAgentTimeoutMs,
   isFabricLifecycleEventType,
+  isFabricWorktreePath,
   lifecycleSourceIdentity,
   resolveActorDeliveryPolicy,
   resolveAgentCwd,
   resolvePiBinary,
   validateAgentCwdRequest
-} from "./chunk-F2GKEXGI.js";
+} from "./chunk-PFF3X7OO.js";
 import "./chunk-PM5I335G.js";
 import "./chunk-VPPIJRNZ.js";
 import {
@@ -100,7 +106,7 @@ import {
   MIN_AGENT_TIMEOUT_MS,
   loadFabricConfig,
   resolveFabricModel
-} from "./chunk-QXB75FLD.js";
+} from "./chunk-2E3CAABA.js";
 import {
   isFabricThinking
 } from "./chunk-7B55UIZL.js";
@@ -149,7 +155,7 @@ import {
 } from "./chunk-IDTQ2B5W.js";
 
 // src/fabric-runtime-state.ts
-import path14 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/actors/global-registry.ts
@@ -2196,10 +2202,10 @@ var FabricComponentSupervisor = class {
       adjacent.set(edge.from, targets);
     }
     const cycles = /* @__PURE__ */ new Map();
-    const visit = (node, path15, positions) => {
+    const visit = (node, path17, positions) => {
       const position = positions.get(node);
       if (position !== void 0) {
-        const cycle = path15.slice(position);
+        const cycle = path17.slice(position);
         const rotations = cycle.map((_, index) => [
           ...cycle.slice(index),
           ...cycle.slice(0, index)
@@ -2209,10 +2215,10 @@ var FabricComponentSupervisor = class {
         cycles.set(canonical.join("\0"), canonical);
         return;
       }
-      if (path15.length > this.#components.size) return;
-      const nextPositions = new Map(positions).set(node, path15.length);
+      if (path17.length > this.#components.size) return;
+      const nextPositions = new Map(positions).set(node, path17.length);
       for (const target of adjacent.get(node) ?? []) {
-        visit(target, [...path15, node], nextPositions);
+        visit(target, [...path17, node], nextPositions);
       }
     };
     for (const id of this.#components.keys()) visit(id, [], /* @__PURE__ */ new Map());
@@ -3324,6 +3330,473 @@ var FabricExecutionService = class {
   }
 };
 
+// src/repairs/apply.ts
+var strictDeclaredPropertyNames = (schema) => {
+  if (schema.type !== "object" || schema.additionalProperties !== false || schema.patternProperties !== void 0) {
+    return void 0;
+  }
+  const properties = schema.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) return void 0;
+  return Object.keys(properties);
+};
+var applyKeyAliasRepairs = (ref, args, repairs, schema) => {
+  const declared = strictDeclaredPropertyNames(schema);
+  if (!declared) return { args, changed: false };
+  const declaredSet = new Set(declared);
+  const applicable = repairs.filter(
+    (repair) => repair.kind === "keyAlias" && repair.ref === ref && repair.from in args && repair.from !== repair.to && !declaredSet.has(repair.from) && declaredSet.has(repair.to) && uniqueDeclaredKeyForSpelling(repair.from, declared) === repair.to
+  );
+  const sourceCountByTarget = /* @__PURE__ */ new Map();
+  for (const repair of applicable) {
+    sourceCountByTarget.set(repair.to, (sourceCountByTarget.get(repair.to) ?? 0) + 1);
+  }
+  let out = args;
+  let changed = false;
+  for (const repair of applicable) {
+    const canonicalPresent = repair.to in args;
+    if (!canonicalPresent && sourceCountByTarget.get(repair.to) !== 1) continue;
+    if (out === args) out = { ...args };
+    if (!(repair.to in out)) out[repair.to] = out[repair.from];
+    delete out[repair.from];
+    changed = true;
+  }
+  return { args: out, changed };
+};
+var applyActionAliasRepairs = (provider, actionName, repairs, declared) => {
+  if (declared.includes(actionName)) return void 0;
+  const liveTarget = repairActionName(declared, actionName).repaired;
+  if (!liveTarget) return void 0;
+  for (const repair of repairs) {
+    if (repair.kind !== "actionAlias") continue;
+    if (repair.provider !== provider) continue;
+    if (repair.from !== actionName) continue;
+    if (repair.to !== liveTarget) continue;
+    return repair.to;
+  }
+  return void 0;
+};
+var applyCatalogArgRepairs = (ref, args, repairs, schema) => applyKeyAliasRepairs(ref, args, repairs, schema);
+
+// src/repairs/catalog-digest.ts
+var catalogDigestFromSurface = (surface) => stableJsonHash({
+  v: 1,
+  providers: [...surface.providers].sort(),
+  captured: [...surface.capturedTools].sort()
+});
+
+// src/repairs/promote.ts
+var keyAliasCandidate = (ref, extraKeys, declared) => {
+  if (extraKeys.length !== 1) return void 0;
+  const from = extraKeys[0];
+  const to = uniqueDeclaredKeyForSpelling(from, declared);
+  if (!to) return void 0;
+  return { kind: "keyAlias", ref, from, to };
+};
+var actionAliasCandidate = (provider, actionName, declared) => {
+  const repair = repairActionName(declared, actionName);
+  if (!repair.repaired || repair.repaired === actionName) return void 0;
+  return {
+    kind: "actionAlias",
+    provider,
+    from: actionName,
+    to: repair.repaired
+  };
+};
+
+// src/repairs/store.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// src/repairs/types.ts
+var REPAIR_TABLE_VERSION = 1;
+var MAX_CATALOG_REPAIRS = 256;
+var repairIdentity = (repair) => {
+  if (repair.kind === "keyAlias") {
+    return `keyAlias:${repair.ref}:${repair.from}:${repair.to}`;
+  }
+  return `actionAlias:${repair.provider}:${repair.from}:${repair.to}`;
+};
+var emptyRepairTable = (catalogDigest, now = (/* @__PURE__ */ new Date()).toISOString()) => ({
+  version: REPAIR_TABLE_VERSION,
+  catalogDigest,
+  repairs: [],
+  createdAt: now,
+  updatedAt: now
+});
+
+// src/repairs/store.ts
+var REPAIR_LOCK_ATTEMPTS = 50;
+var REPAIR_LOCK_DELAY_MS = 5;
+var REPAIR_STALE_LOCK_MS = 3e4;
+var repairsDirectory = (agentDir) => path2.join(agentDir, "fabric", "repairs");
+var currentPath = (directory) => path2.join(directory, "current.json");
+var lockPath = (directory) => path2.join(directory, "current.lock");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var errorCode = (error) => isRecord(error) && typeof error.code === "string" ? error.code : void 0;
+var sleepSync = (() => {
+  try {
+    const buffer = new Int32Array(new SharedArrayBuffer(4));
+    return (ms) => {
+      Atomics.wait(buffer, 0, 0, ms);
+    };
+  } catch {
+    return () => void 0;
+  }
+})();
+var parseRepair = (value) => {
+  if (!isRecord(value) || typeof value.kind !== "string") return void 0;
+  if (value.kind === "keyAlias") {
+    if (typeof value.ref !== "string" || typeof value.from !== "string" || typeof value.to !== "string" || !value.ref.trim() || !value.from.trim() || !value.to.trim()) {
+      return void 0;
+    }
+    return { kind: "keyAlias", ref: value.ref.trim(), from: value.from.trim(), to: value.to.trim() };
+  }
+  if (value.kind === "actionAlias") {
+    if (typeof value.provider !== "string" || typeof value.from !== "string" || typeof value.to !== "string" || !value.provider.trim() || !value.from.trim() || !value.to.trim()) {
+      return void 0;
+    }
+    return {
+      kind: "actionAlias",
+      provider: value.provider.trim(),
+      from: value.from.trim(),
+      to: value.to.trim()
+    };
+  }
+  return "skip";
+};
+var parseRepairTable = (value) => {
+  if (!isRecord(value) || value.version !== REPAIR_TABLE_VERSION) return void 0;
+  if (typeof value.catalogDigest !== "string" || !value.catalogDigest.trim()) return void 0;
+  if (!Array.isArray(value.repairs) || value.repairs.length > MAX_CATALOG_REPAIRS) return void 0;
+  const repairs = [];
+  const identities = /* @__PURE__ */ new Set();
+  for (const entry of value.repairs) {
+    const parsed = parseRepair(entry);
+    if (parsed === "skip") continue;
+    if (!parsed) return void 0;
+    const identity = repairIdentity(parsed);
+    if (identities.has(identity)) continue;
+    identities.add(identity);
+    repairs.push(parsed);
+  }
+  if (typeof value.createdAt !== "string" || typeof value.updatedAt !== "string") return void 0;
+  return {
+    version: REPAIR_TABLE_VERSION,
+    catalogDigest: value.catalogDigest.trim(),
+    repairs,
+    createdAt: value.createdAt,
+    updatedAt: value.updatedAt
+  };
+};
+var errorText = (error) => (error instanceof Error ? error.message : String(error)).slice(0, 200);
+var writeTable = (file, table) => {
+  writeJsonAtomic(file, table, { space: 2, newline: true, mode: 384, dirMode: 448 });
+};
+var processAlive = (pid) => {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var reapStaleLock = (lock, verify) => {
+  const claim = `${lock}.reap-${process.pid}-${randomUUID2()}`;
+  try {
+    fs2.renameSync(lock, claim);
+  } catch {
+    return false;
+  }
+  if (!verify(claim)) {
+    try {
+      fs2.renameSync(claim, lock);
+    } catch {
+      if (verify(claim)) fs2.rmSync(claim, { recursive: true, force: true });
+    }
+    return false;
+  }
+  fs2.rmSync(claim, { recursive: true, force: true });
+  return true;
+};
+var withRepairLock = (directory, operation) => {
+  fs2.mkdirSync(directory, { recursive: true, mode: 448 });
+  const lock = lockPath(directory);
+  const ownerPath = path2.join(lock, "owner");
+  const token = randomUUID2();
+  let acquired = false;
+  for (let attempt = 0; attempt < REPAIR_LOCK_ATTEMPTS; attempt++) {
+    try {
+      fs2.mkdirSync(lock, { mode: 448 });
+      try {
+        fs2.writeFileSync(ownerPath, `${token}
+${process.pid}
+${Date.now()}
+`, {
+          encoding: "utf8",
+          mode: 384
+        });
+      } catch (error) {
+        fs2.rmSync(lock, { recursive: true, force: true });
+        throw error;
+      }
+      acquired = true;
+      break;
+    } catch (error) {
+      if (errorCode(error) !== "EEXIST") throw error;
+      try {
+        const firstOwner = fs2.readFileSync(ownerPath, "utf8");
+        const [, pidText, createdText] = firstOwner.trim().split("\n");
+        const stale = Date.now() - Number(createdText) > REPAIR_STALE_LOCK_MS;
+        if (stale && !processAlive(Number(pidText))) {
+          const secondOwner = fs2.readFileSync(ownerPath, "utf8");
+          if (secondOwner === firstOwner && reapStaleLock(lock, (claimed) => {
+            try {
+              const owner = fs2.readFileSync(path2.join(claimed, "owner"), "utf8");
+              const [, pid, created] = owner.trim().split("\n");
+              return Date.now() - Number(created) > REPAIR_STALE_LOCK_MS && !processAlive(Number(pid));
+            } catch {
+              return false;
+            }
+          })) {
+            continue;
+          }
+        }
+      } catch {
+        try {
+          const first = fs2.statSync(lock);
+          if (Date.now() - first.mtimeMs > REPAIR_STALE_LOCK_MS && reapStaleLock(lock, (claimed) => {
+            try {
+              return Date.now() - fs2.statSync(claimed).mtimeMs > REPAIR_STALE_LOCK_MS;
+            } catch {
+              return false;
+            }
+          })) {
+            continue;
+          }
+        } catch {
+        }
+      }
+      if (attempt === REPAIR_LOCK_ATTEMPTS - 1) break;
+      sleepSync(REPAIR_LOCK_DELAY_MS);
+    }
+  }
+  if (!acquired) throw new Error("Timed out waiting for the Fabric repair table lock");
+  try {
+    return operation();
+  } finally {
+    try {
+      const owner = fs2.readFileSync(ownerPath, "utf8");
+      if (owner.startsWith(`${token}
+`)) {
+        fs2.rmSync(lock, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+};
+var loadRepairTable = (directory, catalogDigest) => {
+  const file = currentPath(directory);
+  let raw;
+  try {
+    raw = fs2.readFileSync(file, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return { table: emptyRepairTable(catalogDigest) };
+    return {
+      table: emptyRepairTable(catalogDigest),
+      error: `repair table is unreadable: ${errorText(error)}`
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { table: emptyRepairTable(catalogDigest), error: "repair table is malformed JSON" };
+  }
+  const table = parseRepairTable(parsed);
+  if (!table) {
+    return { table: emptyRepairTable(catalogDigest), error: "repair table is invalid" };
+  }
+  if (table.catalogDigest !== catalogDigest) return { table: emptyRepairTable(catalogDigest) };
+  return { table };
+};
+var saveRepairTable = (directory, table) => withRepairLock(directory, () => {
+  const loaded = loadRepairTable(directory, table.catalogDigest);
+  if (loaded.error) throw new Error(loaded.error);
+  const persisted = loaded.table;
+  const repairs = [];
+  const identities = /* @__PURE__ */ new Set();
+  for (const repair of [...persisted.repairs, ...table.repairs]) {
+    const identity = repairIdentity(repair);
+    if (identities.has(identity)) continue;
+    if (repairs.length >= MAX_CATALOG_REPAIRS) break;
+    identities.add(identity);
+    repairs.push(repair);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const merged = {
+    version: REPAIR_TABLE_VERSION,
+    catalogDigest: table.catalogDigest,
+    repairs,
+    createdAt: persisted.repairs.length > 0 ? persisted.createdAt : table.createdAt,
+    updatedAt: now
+  };
+  writeTable(currentPath(directory), merged);
+  return merged;
+});
+
+// src/repairs/compiler.ts
+var errorMessage3 = (error) => (error instanceof Error ? error.message : String(error)).slice(0, 240);
+var RepairCompiler = class {
+  directory;
+  enabled;
+  #digest = "";
+  #table;
+  #counts = /* @__PURE__ */ new Map();
+  #applyHits = 0;
+  #invocationErrors = 0;
+  #effectDropped = 0;
+  #storeError;
+  constructor(options) {
+    this.directory = repairsDirectory(options.agentDir);
+    this.enabled = options.enabled !== false;
+    this.#table = emptyRepairTable("");
+  }
+  get catalogDigest() {
+    return this.#digest;
+  }
+  get repairs() {
+    return this.#table.repairs;
+  }
+  setCatalogSurface(surface) {
+    const digest3 = catalogDigestFromSurface(surface);
+    if (digest3 === this.#digest && this.#table.catalogDigest === digest3) return;
+    this.#digest = digest3;
+    if (!this.enabled) {
+      this.#table = emptyRepairTable(digest3);
+      this.#storeError = void 0;
+    } else {
+      const loaded = loadRepairTable(this.directory, digest3);
+      this.#table = loaded.table;
+      this.#storeError = loaded.error;
+    }
+    this.#counts.clear();
+  }
+  observe(classification, options) {
+    if (classification.stage === "effect") {
+      this.#effectDropped += 1;
+      return void 0;
+    }
+    if (options?.countError !== false) this.#invocationErrors += 1;
+    const existing = this.#counts.get(classification.fingerprint);
+    const candidate = classification.candidate ?? existing?.candidate;
+    const next = {
+      stage: classification.stage,
+      count: (existing?.count ?? 0) + 1,
+      ...candidate ? { candidate } : {}
+    };
+    this.#counts.set(classification.fingerprint, next);
+    if (!this.enabled || !next.candidate) return void 0;
+    return this.#promote(next.candidate);
+  }
+  recordInvocationError() {
+    this.#invocationErrors += 1;
+  }
+  observeInvalidArgs(ref, args, declared, message2, options) {
+    const extra = options?.extraKeys ?? Object.keys(args).filter((key) => !declared.includes(key));
+    const candidate = keyAliasCandidate(ref, extra, declared);
+    return this.observe(
+      {
+        stage: "invocation_args",
+        fingerprint: extra[0] ? `args:${ref}:${extra[0]}` : `args:${ref}:${message2.slice(0, 80)}`,
+        ...candidate ? { candidate } : {}
+      },
+      options
+    );
+  }
+  observeUnknownAction(provider, actionName, declared, options) {
+    const candidate = actionAliasCandidate(provider, actionName, declared);
+    return this.observe(
+      {
+        stage: "invocation_unknown_action",
+        fingerprint: `unknown:${provider}.${actionName}`,
+        ...candidate ? { candidate } : {}
+      },
+      options
+    );
+  }
+  applyArgs(ref, args, schema) {
+    if (!this.enabled || this.#table.repairs.length === 0) return args;
+    const result = applyCatalogArgRepairs(ref, args, this.#table.repairs, schema);
+    if (result.changed) this.#applyHits += 1;
+    return result.args;
+  }
+  applyActionName(provider, actionName, declared) {
+    if (!this.enabled || this.#table.repairs.length === 0) return actionName;
+    const repaired = applyActionAliasRepairs(
+      provider,
+      actionName,
+      this.#table.repairs,
+      declared
+    );
+    if (repaired && repaired !== actionName) {
+      this.#applyHits += 1;
+      return repaired;
+    }
+    return actionName;
+  }
+  status() {
+    const fingerprints = [...this.#counts.entries()].map(([fingerprint, state]) => ({
+      fingerprint,
+      stage: state.stage,
+      count: state.count
+    })).sort((left, right) => right.count - left.count || left.fingerprint.localeCompare(right.fingerprint)).slice(0, 20);
+    return {
+      enabled: this.enabled,
+      catalogDigest: this.#digest,
+      repairCount: this.#table.repairs.length,
+      applyHits: this.#applyHits,
+      invocationErrors: this.#invocationErrors,
+      effectDropped: this.#effectDropped,
+      ...this.#storeError ? { storeError: this.#storeError } : {},
+      fingerprints,
+      repairs: [...this.#table.repairs]
+    };
+  }
+  #promote(candidate) {
+    if (!this.#digest) return void 0;
+    const identity = repairIdentity(candidate);
+    if (this.#table.repairs.some((repair) => repairIdentity(repair) === identity)) {
+      if (this.#storeError) this.#persist(this.#table);
+      return void 0;
+    }
+    if (this.#table.repairs.length >= MAX_CATALOG_REPAIRS) return void 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const next = {
+      ...this.#table,
+      catalogDigest: this.#digest || this.#table.catalogDigest,
+      repairs: [...this.#table.repairs, candidate],
+      updatedAt: now,
+      createdAt: this.#table.createdAt || now
+    };
+    const saved = this.#persist(next);
+    if (!saved) return candidate;
+    return saved.repairs.some((repair) => repairIdentity(repair) === identity) ? candidate : void 0;
+  }
+  #persist(table) {
+    try {
+      this.#table = saveRepairTable(this.directory, table);
+      this.#storeError = void 0;
+      return this.#table;
+    } catch (error) {
+      this.#table = table;
+      this.#storeError = errorMessage3(error);
+      return void 0;
+    }
+  }
+};
+
 // src/speculation/eligibility.ts
 var TIER_A_SPECULATION_REFS = /* @__PURE__ */ new Set([
   "pi.read",
@@ -3365,11 +3838,11 @@ var isSpeculationEligible = (action, mcpAllowlist) => {
 };
 
 // src/speculation/freshness.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 var statSignature = (filePath) => {
   try {
-    const stats = fs2.statSync(filePath);
+    const stats = fs3.statSync(filePath);
     return { mtimeMs: stats.mtimeMs, size: stats.size };
   } catch (error) {
     const code = error instanceof Error && "code" in error ? error.code : void 0;
@@ -3380,7 +3853,7 @@ var signatureEquals = (left, right) => left === "missing" || right === "missing"
 var readFreshness = (args, cwd) => {
   const target = args.path;
   if (typeof target !== "string" || target.length === 0) return void 0;
-  const resolved = path2.resolve(cwd, target);
+  const resolved = path3.resolve(cwd, target);
   const snapshot = statSignature(resolved);
   if (snapshot === "error") return void 0;
   return () => {
@@ -3423,23 +3896,24 @@ var FabricSpeculationStore = class _FabricSpeculationStore {
   bumpEpoch() {
     this.#epoch += 1;
   }
-  static key(parentToolCallId, ref, preparedArgs) {
+  static key(parentToolCallId, ref, preparedArgs, bindingToken) {
     return `${parentToolCallId}
 ${ref}
-${stableJsonHash(preparedArgs)}`;
+${stableJsonHash(preparedArgs)}
+${bindingToken}`;
   }
   /**
    * Register and start a speculative invocation. Returns false when at
    * capacity; the candidate is dropped silently (a miss costs nothing, the
    * real call executes normally later).
    */
-  launch(parentToolCallId, ref, preparedArgs, execute, freshness, replay) {
+  launch(parentToolCallId, ref, preparedArgs, execute, freshness, replay, bindingToken) {
     this.#sweepExpired(Date.now());
     if (this.#entries.size >= this.#maxEntries || this.#inFlightCount() >= this.#maxConcurrent) {
       this.#stats.skipped += 1;
       return false;
     }
-    const key = _FabricSpeculationStore.key(parentToolCallId, ref, preparedArgs);
+    const key = _FabricSpeculationStore.key(parentToolCallId, ref, preparedArgs, bindingToken);
     if (this.#entries.has(key)) {
       this.#stats.skipped += 1;
       return false;
@@ -3463,8 +3937,8 @@ ${stableJsonHash(preparedArgs)}`;
     this.#stats.launched += 1;
     return true;
   }
-  async tryServe(parentToolCallId, ref, preparedArgs) {
-    const key = _FabricSpeculationStore.key(parentToolCallId, ref, preparedArgs);
+  async tryServe(parentToolCallId, ref, preparedArgs, bindingToken) {
+    const key = _FabricSpeculationStore.key(parentToolCallId, ref, preparedArgs, bindingToken);
     const entry = this.#entries.get(key);
     if (!entry || entry.parentToolCallId !== parentToolCallId) {
       return { hit: false, reason: "absent" };
@@ -3789,12 +4263,12 @@ var LifecycleDeliveryScheduler = class {
 
 // src/core/model-usage.ts
 import { readFileSync } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 var MODEL_USAGE_FILENAME = "pi-model-sort.json";
 var loadModelUsage = (agentDir = resolveAgentDir()) => {
   try {
     const raw = JSON.parse(
-      readFileSync(path3.join(agentDir, "extensions", MODEL_USAGE_FILENAME), "utf8")
+      readFileSync(path4.join(agentDir, "extensions", MODEL_USAGE_FILENAME), "utf8")
     );
     const lastUsed = raw?.lastUsed;
     if (typeof lastUsed !== "object" || lastUsed === null) return {};
@@ -4467,10 +4941,9 @@ var AGENTS_ACTION_DESCRIPTORS = [
 ];
 
 // src/residency/client.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import fs3 from "node:fs";
-import os from "node:os";
-import path4 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import fs4 from "node:fs";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 var STARTUP_TIMEOUT_MS = 3e4;
 var COMMAND_TIMEOUT_MS = 3e4;
@@ -4482,7 +4955,7 @@ var atomicWrite2 = (filePath, value) => {
 };
 var readJson = (filePath) => {
   try {
-    return JSON.parse(fs3.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs4.readFileSync(filePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -4490,7 +4963,7 @@ var readJson = (filePath) => {
 var terminal = (status) => status === "completed" || status === "failed" || status === "stopped" || status === "timed_out";
 var samePath = (left, right) => {
   try {
-    return path4.relative(fs3.realpathSync.native(left), fs3.realpathSync.native(right)) === "";
+    return path5.relative(fs4.realpathSync.native(left), fs4.realpathSync.native(right)) === "";
   } catch {
     return false;
   }
@@ -4519,12 +4992,12 @@ var ResidencyClient = class {
   constructor(options) {
     this.options = options;
     this.hostId = residentHostId(options.config.rootId);
-    this.#configPath = path4.join(options.config.residencyRoot, "config.json");
-    this.#ownerPath = path4.join(options.config.residencyRoot, "owner.json");
-    this.#errorPath = path4.join(options.config.residencyRoot, "error.json");
-    this.#requestsPath = path4.join(options.config.residencyRoot, "requests");
-    this.#responsesPath = path4.join(options.config.residencyRoot, "responses");
-    this.#agentsPath = path4.join(options.config.residencyRoot, "agents");
+    this.#configPath = path5.join(options.config.residencyRoot, "config.json");
+    this.#ownerPath = path5.join(options.config.residencyRoot, "owner.json");
+    this.#errorPath = path5.join(options.config.residencyRoot, "error.json");
+    this.#requestsPath = path5.join(options.config.residencyRoot, "requests");
+    this.#responsesPath = path5.join(options.config.residencyRoot, "responses");
+    this.#agentsPath = path5.join(options.config.residencyRoot, "agents");
     this.#deliveryPrefix = residentDeliveryPrefix(options.config.rootId);
     this.#hostPath = options.hostPath ?? fileURLToPath(new URL("./launcher.js", import.meta.url));
   }
@@ -4562,7 +5035,7 @@ var ResidencyClient = class {
     if (serialized === this.#modelGuidanceJson) return;
     this.#modelGuidanceJson = serialized;
     this.options.config.modelGuidance = snapshot;
-    if (fs3.existsSync(this.options.config.residencyRoot)) {
+    if (fs4.existsSync(this.options.config.residencyRoot)) {
       atomicWrite2(this.#configPath, this.options.config);
     }
   }
@@ -4571,7 +5044,7 @@ var ResidencyClient = class {
     atomicWrite2(this.#configPath, this.options.config);
     const existing = this.#liveOwner();
     if (existing) return existing;
-    fs3.rmSync(this.#errorPath, { force: true });
+    fs4.rmSync(this.#errorPath, { force: true });
     await spawnDetached(
       this.#hostPath,
       ["--config", this.#configPath],
@@ -4589,7 +5062,7 @@ var ResidencyClient = class {
     }
     const readIfPresent = (name) => {
       try {
-        return fs3.readFileSync(path4.join(this.options.config.residencyRoot, name), "utf8").trim();
+        return fs4.readFileSync(path5.join(this.options.config.residencyRoot, name), "utf8").trim();
       } catch {
         return "";
       }
@@ -4616,7 +5089,7 @@ var ResidencyClient = class {
       {
         format: RESIDENT_HOST_FORMAT,
         operation: "spawn",
-        requestId: randomUUID2(),
+        requestId: randomUUID3(),
         rootId: this.options.config.rootId,
         request: { ...resolvedRequest, residency: "durable" },
         createdAt: Date.now()
@@ -4628,18 +5101,18 @@ var ResidencyClient = class {
     return response.handle;
   }
   hasAgent(id) {
-    return AGENT_ID_PATTERN.test(id) && fs3.existsSync(this.#metadataPath(id));
+    return AGENT_ID_PATTERN.test(id) && fs4.existsSync(this.#metadataPath(id));
   }
   statusAgent(id) {
     const metadata = this.#metadata(id);
     if (!metadata) throw new Error(`Unknown durable Fabric agent: ${id}`);
-    const record = readJson(path4.join(metadata.runDirectory, "status.json"));
+    const record = readJson(path5.join(metadata.runDirectory, "status.json"));
     if (!record || record.id !== metadata.id) return structuredClone(metadata.handle);
     return {
       ...record,
       cwd: metadata.handle.cwd,
       residency: "durable",
-      logFile: path4.join(metadata.runDirectory, "events.jsonl"),
+      logFile: path5.join(metadata.runDirectory, "events.jsonl"),
       ...metadata.handle.sessionId ? { sessionId: metadata.handle.sessionId } : {},
       ...metadata.handle.attachCommand ? { attachCommand: metadata.handle.attachCommand } : {}
     };
@@ -4647,7 +5120,7 @@ var ResidencyClient = class {
   listAgents() {
     let entries;
     try {
-      entries = fs3.readdirSync(this.#agentsPath);
+      entries = fs4.readdirSync(this.#agentsPath);
     } catch {
       return [];
     }
@@ -4664,7 +5137,7 @@ var ResidencyClient = class {
       await this.#command({
         format: RESIDENT_HOST_FORMAT,
         operation: "foreground",
-        requestId: randomUUID2(),
+        requestId: randomUUID3(),
         rootId: this.options.config.rootId,
         id,
         createdAt: Date.now()
@@ -4680,9 +5153,9 @@ var ResidencyClient = class {
   readAgentLog(id, options = {}) {
     const metadata = this.#metadata(id);
     if (!metadata) throw new Error(`Unknown durable Fabric agent: ${id}`);
-    const logFile = path4.join(metadata.runDirectory, "events.jsonl");
+    const logFile = path5.join(metadata.runDirectory, "events.jsonl");
     const page = readJsonlPage(logFile, Math.max(1, Math.min(options.lines ?? 200, 5e3)), options.before);
-    const status = readJson(path4.join(metadata.runDirectory, "status.json"));
+    const status = readJson(path5.join(metadata.runDirectory, "status.json"));
     return {
       id,
       runDirectory: metadata.runDirectory,
@@ -4698,7 +5171,7 @@ var ResidencyClient = class {
     await this.#command({
       format: RESIDENT_HOST_FORMAT,
       operation: "removeActor",
-      requestId: randomUUID2(),
+      requestId: randomUUID3(),
       rootId: this.options.config.rootId,
       id,
       createdAt: Date.now()
@@ -4714,7 +5187,7 @@ var ResidencyClient = class {
       response = await this.#command({
         format: RESIDENT_HOST_FORMAT,
         operation: "cleanup",
-        requestId: randomUUID2(),
+        requestId: randomUUID3(),
         rootId: this.options.config.rootId,
         id,
         deleteBranch,
@@ -4752,19 +5225,19 @@ var ResidencyClient = class {
     } else if (deleteBranch) {
       throw new Error(`Durable Fabric agent ${metadata.id} has no worktree branch to delete`);
     }
-    fs3.rmSync(metadata.runDirectory, { recursive: true, force: true });
-    fs3.rmSync(this.#metadataPath(metadata.id), { force: true });
+    fs4.rmSync(metadata.runDirectory, { recursive: true, force: true });
+    fs4.rmSync(this.#metadataPath(metadata.id), { force: true });
     return { cleaned: true };
   }
   async #command(command, signal) {
-    const responsePath = path4.join(this.#responsesPath, `${command.requestId}.json`);
-    atomicWrite2(path4.join(this.#requestsPath, `${command.requestId}.json`), command);
+    const responsePath = path5.join(this.#responsesPath, `${command.requestId}.json`);
+    atomicWrite2(path5.join(this.#requestsPath, `${command.requestId}.json`), command);
     const deadline = Date.now() + COMMAND_TIMEOUT_MS;
     while (Date.now() < deadline) {
       if (signal?.aborted) throw new Error("Fabric residency request was aborted");
       const response = readJson(responsePath);
       if (response?.format === RESIDENT_HOST_FORMAT && response.requestId === command.requestId) {
-        fs3.rmSync(responsePath, { force: true });
+        fs4.rmSync(responsePath, { force: true });
         if (!response.ok) throw new Error(response.error ?? "Fabric resident host rejected request");
         return response;
       }
@@ -4786,15 +5259,15 @@ var ResidencyClient = class {
     throw new Error(`Timed out publishing durable Fabric ${kind} ${id} from ${this.hostId}`);
   }
   #metadataPath(id) {
-    return path4.join(this.#agentsPath, `${id}.json`);
+    return path5.join(this.#agentsPath, `${id}.json`);
   }
   #metadata(id) {
     if (!AGENT_ID_PATTERN.test(id)) return void 0;
     const metadata = readJson(this.#metadataPath(id));
-    if (metadata?.format !== RESIDENT_HOST_FORMAT || metadata.rootId !== this.options.config.rootId || metadata.id !== id || metadata.handle.id !== id || metadata.worktreeGitRoot !== void 0 && typeof metadata.worktreeGitRoot !== "string" || path4.resolve(metadata.runDirectory) !== path4.resolve(this.options.config.residencyRoot, "runs", id)) {
+    if (metadata?.format !== RESIDENT_HOST_FORMAT || metadata.rootId !== this.options.config.rootId || metadata.id !== id || metadata.handle.id !== id || metadata.worktreeGitRoot !== void 0 && typeof metadata.worktreeGitRoot !== "string" || path5.resolve(metadata.runDirectory) !== path5.resolve(this.options.config.residencyRoot, "runs", id)) {
       return void 0;
     }
-    if (metadata.handle.worktree && path4.resolve(metadata.handle.worktree) !== path4.resolve(os.tmpdir(), "pi-fabric-worktrees", id)) {
+    if (metadata.handle.worktree && !isFabricWorktreePath(metadata.handle.worktree, id)) {
       return void 0;
     }
     if (metadata.handle.branch && (!metadata.handle.branch.startsWith("pi-fabric/") || !metadata.handle.branch.endsWith(`-${id.slice(0, 8)}`))) {
@@ -6098,16 +6571,16 @@ var AgentsProvider = class {
 };
 
 // src/providers/captured-tools-provider.ts
-import path5 from "node:path";
+import path6 from "node:path";
 var textFromContent2 = (content) => content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
 var sourceLabel = (sourceInfo) => {
   if (sourceInfo.path.startsWith("<")) return sourceInfo.source;
   const segments = sourceInfo.path.split(/[\\/]/);
   const packageSegment = [...segments].reverse().find((segment) => segment.startsWith("pi-"));
   if (packageSegment) return packageSegment;
-  const filename = path5.basename(sourceInfo.path).replace(/\.[^.]+$/, "");
+  const filename = path6.basename(sourceInfo.path).replace(/\.[^.]+$/, "");
   if (filename && filename !== "index") return filename;
-  return path5.basename(path5.dirname(sourceInfo.path)) || sourceInfo.source;
+  return path6.basename(path6.dirname(sourceInfo.path)) || sourceInfo.source;
 };
 var capturedToolNamespace = (entry) => `extension:${sourceLabel(entry.sourceInfo)}`;
 var descriptorFrom = (entry) => ({
@@ -6484,35 +6957,35 @@ var ComponentsProvider = class {
 };
 
 // src/providers/mcp-descriptor-cache.ts
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import fsSync from "node:fs";
-import os2 from "node:os";
-import path6 from "node:path";
+import os from "node:os";
+import path7 from "node:path";
 var MCP_DESCRIPTOR_CACHE_VERSION = 1;
 var expandHome = (input) => {
   if (!input.startsWith("~")) return input;
-  const home = os2.homedir();
+  const home = os.homedir();
   if (input === "~") return home;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path6.join(home, input.slice(2));
+    return path7.join(home, input.slice(2));
   }
   return input;
 };
-var legacyMcporterDir = () => path6.join(os2.homedir(), ".mcporter");
+var legacyMcporterDir = () => path7.join(os.homedir(), ".mcporter");
 var mcporterConfigDir = () => {
   const raw = process.env.XDG_CONFIG_HOME;
   if (raw && raw.trim().length > 0) {
     const resolved = expandHome(raw.trim());
-    if (path6.isAbsolute(resolved)) return path6.join(resolved, "mcporter");
+    if (path7.isAbsolute(resolved)) return path7.join(resolved, "mcporter");
   }
   return legacyMcporterDir();
 };
 var mcporterConfigCandidates = () => {
   const base = mcporterConfigDir();
-  const candidates = [path6.join(base, "mcporter.json"), path6.join(base, "mcporter.jsonc")];
+  const candidates = [path7.join(base, "mcporter.json"), path7.join(base, "mcporter.jsonc")];
   const legacy = legacyMcporterDir();
   if (base !== legacy) {
-    candidates.push(path6.join(legacy, "mcporter.json"), path6.join(legacy, "mcporter.jsonc"));
+    candidates.push(path7.join(legacy, "mcporter.json"), path7.join(legacy, "mcporter.jsonc"));
   }
   return candidates;
 };
@@ -6527,12 +7000,12 @@ var pathExists = (filePath) => {
 var mcpConfigLayerPaths = (rootDir, configPath) => {
   const explicitRaw = configPath ?? process.env.MCPORTER_CONFIG;
   if (explicitRaw && explicitRaw.trim().length > 0) {
-    return [path6.resolve(expandHome(explicitRaw.trim()))];
+    return [path7.resolve(expandHome(explicitRaw.trim()))];
   }
   const paths = [];
   const home = mcporterConfigCandidates().find(pathExists);
   if (home) paths.push(home);
-  const projectPath = path6.resolve(rootDir, "config", "mcporter.json");
+  const projectPath = path7.resolve(rootDir, "config", "mcporter.json");
   if (pathExists(projectPath)) paths.push(projectPath);
   return paths;
 };
@@ -6540,7 +7013,7 @@ var statConfigLayers = async (rootDir, configPath) => {
   const stats = await Promise.all(
     mcpConfigLayerPaths(rootDir, configPath).map(async (layerPath) => {
       try {
-        const stat2 = await fs4.stat(layerPath);
+        const stat2 = await fs5.stat(layerPath);
         return { path: layerPath, mtimeMs: stat2.mtimeMs, size: stat2.size };
       } catch {
         return void 0;
@@ -6554,11 +7027,11 @@ var sameConfigLayers = (left, right) => left.length === right.length && left.eve
   return other !== void 0 && layer.path === other.path && layer.size === other.size && Math.abs(layer.mtimeMs - other.mtimeMs) <= 1;
 });
 var hashServerDefinition = (definition) => stableJsonHash(definition);
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var parseCachedServer = (value) => {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const tools = Array.isArray(value.tools) ? value.tools.filter(
-    (tool) => isRecord(tool) && typeof tool.name === "string"
+    (tool) => isRecord2(tool) && typeof tool.name === "string"
   ) : void 0;
   if (typeof value.definitionHash !== "string" || tools === void 0) return void 0;
   return {
@@ -6571,10 +7044,10 @@ var parseCachedServer = (value) => {
   };
 };
 var parseCacheFile = (value) => {
-  if (!isRecord(value) || value.version !== MCP_DESCRIPTOR_CACHE_VERSION) return void 0;
-  if (!Array.isArray(value.layers) || !isRecord(value.servers)) return void 0;
+  if (!isRecord2(value) || value.version !== MCP_DESCRIPTOR_CACHE_VERSION) return void 0;
+  if (!Array.isArray(value.layers) || !isRecord2(value.servers)) return void 0;
   const layers = value.layers.filter(
-    (layer) => isRecord(layer) && typeof layer.path === "string" && typeof layer.mtimeMs === "number" && typeof layer.size === "number"
+    (layer) => isRecord2(layer) && typeof layer.path === "string" && typeof layer.mtimeMs === "number" && typeof layer.size === "number"
   );
   return {
     version: MCP_DESCRIPTOR_CACHE_VERSION,
@@ -6590,7 +7063,7 @@ var McpDescriptorCacheStore = class {
   }
   async load() {
     try {
-      const raw = await fs4.readFile(this.filePath, "utf8");
+      const raw = await fs5.readFile(this.filePath, "utf8");
       return parseCacheFile(JSON.parse(raw));
     } catch {
       return void 0;
@@ -6599,24 +7072,24 @@ var McpDescriptorCacheStore = class {
   // Atomic-ish write: temp file then rename, so a concurrent reader either
   // sees the previous cache or the next one, never a torn document.
   async save(file) {
-    const directory = path6.dirname(this.filePath);
-    await fs4.mkdir(directory, { recursive: true });
-    const tempPath = path6.join(
+    const directory = path7.dirname(this.filePath);
+    await fs5.mkdir(directory, { recursive: true });
+    const tempPath = path7.join(
       directory,
       `.mcp-cache-${process.pid}-${Date.now()}-${tempCounter++}.tmp`
     );
-    await fs4.writeFile(tempPath, JSON.stringify(file, null, 2));
+    await fs5.writeFile(tempPath, JSON.stringify(file, null, 2));
     try {
-      await fs4.rename(tempPath, this.filePath);
+      await fs5.rename(tempPath, this.filePath);
     } catch (error) {
-      await fs4.rm(tempPath, { force: true }).catch(() => void 0);
+      await fs5.rm(tempPath, { force: true }).catch(() => void 0);
       throw error;
     }
   }
 };
 
 // src/providers/mcp-provider.ts
-import path7 from "node:path";
+import path8 from "node:path";
 var TOOL_METADATA_TTL_MS = 6e4;
 var REVALIDATE_CONCURRENCY = 3;
 var REVALIDATE_SERVER_TIMEOUT_MS = 2e4;
@@ -7248,7 +7721,7 @@ var McpProvider = class {
           kind: "stdio",
           command: args.command,
           args: commandArgs,
-          cwd: path7.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
+          cwd: path8.resolve(this.cwd, typeof args.cwd === "string" ? args.cwd : ".")
         },
         ...env ? { env } : {}
       };
@@ -7615,7 +8088,7 @@ var MeshProvider = class {
 
 // src/providers/pi-tools-provider.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path9 from "node:path";
+import path11 from "node:path";
 import {
   createBashToolDefinition as createBashToolDefinition2,
   createEditToolDefinition,
@@ -7625,9 +8098,102 @@ import {
   createReadToolDefinition
 } from "@earendil-works/pi-coding-agent";
 
+// src/agents/bash-worktree-add.ts
+import fs6 from "node:fs";
+import path9 from "node:path";
+var BARE_SAFE = /^[A-Za-z0-9_./:@%+=,-]+$/;
+var parseGitWorktreeAdd = (command) => {
+  const trimmed = command.trim();
+  if (!trimmed || /[|&;()\n]/.test(trimmed)) return void 0;
+  const tokens = trimmed.split(/\s+/);
+  if (tokens[0] !== "git") return void 0;
+  if (tokens.some((token) => !BARE_SAFE.test(token))) return void 0;
+  let index = 1;
+  let gitCwd;
+  if (tokens[index] === "-C") {
+    gitCwd = tokens[index + 1];
+    if (!gitCwd) return void 0;
+    index += 2;
+  }
+  if (tokens[index] !== "worktree" || tokens[index + 1] !== "add") return void 0;
+  index += 2;
+  let branch;
+  let detach = false;
+  let quiet = false;
+  let flagsEnded = false;
+  const positionals = [];
+  while (index < tokens.length) {
+    const token = tokens[index++];
+    if (token === void 0) break;
+    if (!flagsEnded && token === "--") {
+      flagsEnded = true;
+      continue;
+    }
+    if (!flagsEnded && (token === "-b" || token === "-B")) {
+      if (branch) return void 0;
+      const name = tokens[index++];
+      if (!name) return void 0;
+      branch = { flag: token, name };
+      continue;
+    }
+    if (!flagsEnded && (token === "--detach" || token === "-d")) {
+      detach = true;
+      continue;
+    }
+    if (!flagsEnded && (token === "-q" || token === "--quiet")) {
+      quiet = true;
+      continue;
+    }
+    if (!flagsEnded && token.startsWith("-")) return void 0;
+    positionals.push(token);
+  }
+  if (detach && branch) return void 0;
+  if (positionals.length < 1 || positionals.length > 2) return void 0;
+  return {
+    ...gitCwd ? { gitCwd } : {},
+    ...branch ? { branch } : {},
+    detach,
+    quiet,
+    dest: positionals[0],
+    ...positionals[1] ? { startPoint: positionals[1] } : {}
+  };
+};
+var tryExecuteGitWorktreeAdd = async (args, sessionCwd) => {
+  const command = args.command;
+  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);
+  let gitRoot;
+  try {
+    const root = await executeFile("git", ["rev-parse", "--show-toplevel"], {
+      cwd: gitCwd,
+      timeoutMs: 1e4
+    });
+    const output = root.stdout.trim();
+    if (!output) return void 0;
+    gitRoot = fs6.realpathSync(output);
+  } catch {
+    return void 0;
+  }
+  const result = await addCloneFirstWorktree({
+    gitRoot,
+    dest,
+    ...parsed.branch ? { branch: parsed.branch } : {},
+    detach: parsed.detach,
+    quiet: parsed.quiet,
+    ...parsed.startPoint ? { startPoint: parsed.startPoint } : {}
+  });
+  return {
+    content: [{ type: "text", text: result.message || `Preparing worktree (${dest})` }],
+    details: { exitCode: 0, cloned: result.cloned }
+  };
+};
+
 // src/providers/pi-bash-cwd.ts
 import { accessSync, constants, statSync } from "node:fs";
-import path8 from "node:path";
+import path10 from "node:path";
 import { createBashToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type as Type2 } from "typebox";
 var PI_BASH_CWD_KEY = "cwd";
@@ -7637,7 +8203,7 @@ var resolvePiBashCwd = (sessionCwd, requested) => {
       `Invalid pi.bash cwd ${JSON.stringify(requested)}: path must be a non-empty string`
     );
   }
-  const resolved = path8.isAbsolute(requested) ? path8.resolve(requested) : path8.resolve(sessionCwd, requested);
+  const resolved = path10.isAbsolute(requested) ? path10.resolve(requested) : path10.resolve(sessionCwd, requested);
   try {
     if (!statSync(resolved).isDirectory()) throw new Error("path is not a directory");
     accessSync(resolved, constants.R_OK | constants.X_OK);
@@ -7653,9 +8219,9 @@ var CWD_PROPERTY = Type2.Optional(
     description: "Execution directory for this command; relative paths resolve from the session cwd."
   })
 );
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var withBashCwdSchema = (schema) => {
-  if (!isRecord2(schema) || !isRecord2(schema.properties)) return schema;
+  if (!isRecord3(schema) || !isRecord3(schema.properties)) return schema;
   if (Object.hasOwn(schema.properties, PI_BASH_CWD_KEY)) return schema;
   const { type: _type, properties, required, ...rest } = schema;
   return Type2.Object(
@@ -7736,14 +8302,14 @@ var createPreviewWriteToolDefinition = (cwd) => {
   return {
     ...original,
     async execute(_toolCallId, params, signal) {
-      const { path: path15, content } = params;
-      const absolutePath = resolvePreviewPath(path15, cwd);
+      const { path: path17, content } = params;
+      const absolutePath = resolvePreviewPath(path17, cwd);
       return withFileMutationQueue(absolutePath, async () => {
         const throwIfAborted2 = () => {
           if (signal?.aborted) throw new Error("Operation aborted");
         };
         throwIfAborted2();
-        const before = await readExistingFileForPreview(path15, cwd, content);
+        const before = await readExistingFileForPreview(path17, cwd, content);
         throwIfAborted2();
         await mkdir(dirname(absolutePath), { recursive: true });
         throwIfAborted2();
@@ -7753,7 +8319,7 @@ var createPreviewWriteToolDefinition = (cwd) => {
           content: [
             {
               type: "text",
-              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path15}`
+              text: `Successfully wrote ${Buffer.byteLength(content, "utf8")} bytes to ${path17}`
             }
           ],
           details: { codePreviewBeforeWrite: before }
@@ -7787,7 +8353,7 @@ var expandReplaceAllEdit = (cwd, args, allForEveryEdit) => {
     }
     return { oldText, newText, all: allForEveryEdit || record.all === true };
   });
-  const resolvedPath = path9.resolve(
+  const resolvedPath = path11.resolve(
     cwd,
     filePath.startsWith("@") ? filePath.slice(1) : filePath
   );
@@ -7929,6 +8495,13 @@ var PiToolsProvider = class {
   async invoke(actionName, args, context) {
     if (!(actionName in this.#tools)) throw new Error(`Unknown Pi tool: ${actionName}`);
     const name = actionName;
+    if (name === "bash") {
+      const intercepted = await tryExecuteGitWorktreeAdd(args, this.#cwd);
+      if (intercepted) {
+        this.#attachPreview(name, intercepted, args, context);
+        return this.#normalizeResult(name, intercepted, args);
+      }
+    }
     if (this.#catalog?.get(name)) {
       const result = await this.#capturedTools.invoke(name, args, context);
       this.#attachReadMedia(name, result, context);
@@ -8148,9 +8721,9 @@ var PiToolsProvider = class {
 
 // src/schema/controller.ts
 import { spawn } from "node:child_process";
-import { createHash as createHash3, randomBytes, randomUUID as randomUUID3 } from "node:crypto";
-import fs6 from "node:fs";
-import path11 from "node:path";
+import { createHash as createHash3, randomBytes, randomUUID as randomUUID4 } from "node:crypto";
+import fs8 from "node:fs";
+import path13 from "node:path";
 
 // src/schema/types.ts
 var stateBinding = (head) => head ? { transitionId: head.transitionId, version: head.version, to: head.to } : null;
@@ -8158,8 +8731,8 @@ var stateBinding = (head) => head ? { transitionId: head.transitionId, version:
 // src/schema/workspace.ts
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import fs5 from "node:fs";
-import path10 from "node:path";
+import fs7 from "node:fs";
+import path12 from "node:path";
 var SNAPSHOT_MAX_FILES = 2e4;
 var SNAPSHOT_MAX_BYTES = 512 * 1024 * 1024;
 var FALLBACK_SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -8177,16 +8750,16 @@ 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(path10.sep).join("/");
+var normalizeRelative = (value) => value.split(path12.sep).join("/");
 var isInside = (root, candidate) => {
-  const relative = path10.relative(root, candidate);
-  return relative === "" || !path10.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path10.sep}`);
+  const relative = path12.relative(root, candidate);
+  return relative === "" || !path12.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
 };
 var excluded = (absolute, exclusions) => exclusions.some((root) => isInside(root, absolute));
 var entryDigest = (absolute) => {
   let stat2;
   try {
-    stat2 = fs5.lstatSync(absolute);
+    stat2 = fs7.lstatSync(absolute);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return { marker: "absent", bytes: 0 };
@@ -8194,24 +8767,24 @@ var entryDigest = (absolute) => {
     throw error;
   }
   if (stat2.isSymbolicLink()) {
-    return { marker: `symlink:${digest(fs5.readlinkSync(absolute))}`, bytes: 0 };
+    return { marker: `symlink:${digest(fs7.readlinkSync(absolute))}`, bytes: 0 };
   }
   if (!stat2.isFile()) {
     throw new Error(`Schema workspace snapshot does not support non-file entry: ${absolute}`);
   }
-  return { marker: `file:${stat2.mode & 511}:${digest(fs5.readFileSync(absolute))}`, bytes: stat2.size };
+  return { marker: `file:${stat2.mode & 511}:${digest(fs7.readFileSync(absolute))}`, bytes: stat2.size };
 };
 var buildSnapshot = (cwd, paths, metadata, exclusions) => {
   const entries = {};
   let bytes = 0;
   const unique = [...new Set(paths)].sort((left, right) => left.localeCompare(right));
   for (const relativeInput of unique) {
-    const absolute = path10.resolve(cwd, relativeInput);
+    const absolute = path12.resolve(cwd, relativeInput);
     if (!isInside(cwd, absolute) || excluded(absolute, exclusions)) continue;
     if (Object.keys(entries).length >= SNAPSHOT_MAX_FILES) {
       throw new Error(`Schema workspace snapshot exceeds ${SNAPSHOT_MAX_FILES} files`);
     }
-    const relative = normalizeRelative(path10.relative(cwd, absolute));
+    const relative = normalizeRelative(path12.relative(cwd, absolute));
     const entry = entryDigest(absolute);
     bytes += entry.bytes;
     if (bytes > SNAPSHOT_MAX_BYTES) {
@@ -8237,12 +8810,12 @@ var buildSnapshot = (cwd, paths, metadata, exclusions) => {
 var fallbackPaths = (cwd, exclusions) => {
   const paths = [];
   const visit = (directory) => {
-    const entries = fs5.readdirSync(directory, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    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 = path10.join(directory, entry.name);
+      const absolute = path12.join(directory, entry.name);
       if (excluded(absolute, exclusions)) continue;
-      const relative = normalizeRelative(path10.relative(cwd, absolute));
+      const relative = normalizeRelative(path12.relative(cwd, absolute));
       if (entry.isDirectory()) visit(absolute);
       else paths.push(relative);
       if (paths.length > SNAPSHOT_MAX_FILES) {
@@ -8254,11 +8827,11 @@ var fallbackPaths = (cwd, exclusions) => {
   return paths;
 };
 var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
-  const cwd = fs5.realpathSync(cwdInput);
+  const cwd = fs7.realpathSync(cwdInput);
   const exclusions = excludedRoots.map((root) => {
-    const absolute = path10.resolve(root);
+    const absolute = path12.resolve(root);
     try {
-      return fs5.realpathSync(absolute);
+      return fs7.realpathSync(absolute);
     } catch {
       return absolute;
     }
@@ -8294,29 +8867,29 @@ var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   );
 };
 var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
-  if (!requestedPath.trim() || path10.isAbsolute(requestedPath)) {
+  if (!requestedPath.trim() || path12.isAbsolute(requestedPath)) {
     throw new Error(`Schema paths must be non-empty project-relative paths: ${requestedPath}`);
   }
-  const cwd = fs5.realpathSync(cwdInput);
-  const absolute = path10.resolve(cwd, requestedPath);
+  const cwd = fs7.realpathSync(cwdInput);
+  const absolute = path12.resolve(cwd, requestedPath);
   if (!isInside(cwd, absolute) || absolute === cwd) {
     throw new Error(`Schema path escapes the project workspace: ${requestedPath}`);
   }
-  const relativeParts = path10.relative(cwd, absolute).split(path10.sep);
+  const relativeParts = path12.relative(cwd, absolute).split(path12.sep);
   let cursor = cwd;
   for (let index = 0; index < relativeParts.length; index++) {
-    cursor = path10.join(cursor, relativeParts[index]);
+    cursor = path12.join(cursor, relativeParts[index]);
     let stat2;
     try {
-      stat2 = fs5.lstatSync(cursor);
+      stat2 = fs7.lstatSync(cursor);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
         if (index !== relativeParts.length - 1 || !options.allowAbsent) {
           throw new Error(`Schema path does not exist: ${requestedPath}`);
         }
-        const parentReal = fs5.realpathSync(path10.dirname(cursor));
+        const parentReal = fs7.realpathSync(path12.dirname(cursor));
         if (!isInside(cwd, parentReal)) throw new Error(`Schema path parent escapes the workspace: ${requestedPath}`);
-        return { absolute, relative: normalizeRelative(path10.relative(cwd, absolute)), exists: false };
+        return { absolute, relative: normalizeRelative(path12.relative(cwd, absolute)), exists: false };
       }
       throw error;
     }
@@ -8328,9 +8901,9 @@ var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
       throw new Error(`Schema transaction paths must name regular files: ${requestedPath}`);
     }
   }
-  return { absolute, relative: normalizeRelative(path10.relative(cwd, absolute)), exists: true };
+  return { absolute, relative: normalizeRelative(path12.relative(cwd, absolute)), exists: true };
 };
-var sha256File = (absolute) => `sha256:${digest(fs5.readFileSync(absolute))}`;
+var sha256File = (absolute) => `sha256:${digest(fs7.readFileSync(absolute))}`;
 
 // src/schema/controller.ts
 var SCHEMA_TOPIC = "fabric.schema";
@@ -8340,7 +8913,7 @@ var CERTIFICATE_PREFIX = "schema/certificate/";
 var OUTPUT_LIMIT = 64 * 1024;
 var hashToken = (token) => createHash3("sha256").update(token).digest("hex");
 var sameBinding = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-var errorMessage3 = (error) => error instanceof Error ? error.message : String(error);
+var errorMessage4 = (error) => error instanceof Error ? error.message : String(error);
 var atomicJsonWrite = (filePath, value) => {
   writeJsonAtomic(filePath, value, { newline: true });
 };
@@ -8378,9 +8951,9 @@ var SchemaController = class {
     this.mesh = mesh;
     this.identity = identity;
     this.state = state;
-    this.cwd = fs6.realpathSync(cwd);
-    this.#journalRoot = path11.join(mesh.root, "schema-transactions");
-    this.#lockPath = path11.join(this.#journalRoot, ".commit.lock");
+    this.cwd = fs8.realpathSync(cwd);
+    this.#journalRoot = path13.join(mesh.root, "schema-transactions");
+    this.#lockPath = path13.join(this.#journalRoot, ".commit.lock");
     this.#recoverJournals();
   }
   #activeHypotheses = /* @__PURE__ */ new Map();
@@ -8436,7 +9009,7 @@ var SchemaController = class {
     const generation = this.#generation();
     const now = Date.now();
     const record = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       label: input.label,
       summary: input.summary,
       evidence: input.evidence,
@@ -8476,7 +9049,7 @@ var SchemaController = class {
     try {
       before = snapshotWorkspace(this.cwd, [this.mesh.root]);
     } catch (error) {
-      return this.#failedVerification(record, [], `workspace snapshot failed: ${errorMessage3(error)}`);
+      return this.#failedVerification(record, [], `workspace snapshot failed: ${errorMessage4(error)}`);
     }
     const currentState = stateBinding(this.state?.getHead() ?? null);
     if (!sameBinding(record.state, currentState)) {
@@ -8493,7 +9066,7 @@ var SchemaController = class {
     try {
       after = snapshotWorkspace(this.cwd, [this.mesh.root]);
     } catch (error) {
-      return this.#failedVerification(record, results, `post-evidence snapshot failed: ${errorMessage3(error)}`);
+      return this.#failedVerification(record, results, `post-evidence snapshot failed: ${errorMessage4(error)}`);
     }
     const allConfirmed = results.length > 0 && results.every((result) => result.status === "confirmed");
     if (!allConfirmed || before.fingerprint !== after.fingerprint) {
@@ -8578,8 +9151,8 @@ var SchemaController = class {
     }
     this.#assertPayloadBound(input);
     const release = this.#acquireCommitLock();
-    const transactionId = randomUUID3();
-    const journalPath = path11.join(this.#journalRoot, `${transactionId}.json`);
+    const transactionId = randomUUID4();
+    const journalPath = path13.join(this.#journalRoot, `${transactionId}.json`);
     let journal;
     let consumed = false;
     let committed = false;
@@ -8619,14 +9192,14 @@ var SchemaController = class {
           before.push({ path: resolved.relative, absolute: resolved.absolute, existed: false });
           continue;
         }
-        const content = fs6.readFileSync(resolved.absolute);
+        const content = fs8.readFileSync(resolved.absolute);
         beforeBytes += content.byteLength;
         before.push({
           path: resolved.relative,
           absolute: resolved.absolute,
           existed: true,
           content: content.toString("base64"),
-          mode: fs6.statSync(resolved.absolute).mode & 511
+          mode: fs8.statSync(resolved.absolute).mode & 511
         });
       }
       if (payloadBytes + beforeBytes > this.config.maxBytes) {
@@ -8690,7 +9263,7 @@ var SchemaController = class {
           this.cwd
         ) : null;
       } catch (error) {
-        stateTransition = { error: errorMessage3(error) };
+        stateTransition = { error: errorMessage4(error) };
       }
       try {
         await this.mesh.put({
@@ -8736,18 +9309,18 @@ var SchemaController = class {
       const outcome = rollbackError ? "quarantined" : "rolled_back";
       if (journal) {
         journal.status = outcome;
-        journal.error = rollbackError ? `${errorMessage3(error)}; rollback failed: ${rollbackError}` : errorMessage3(error);
+        journal.error = rollbackError ? `${errorMessage4(error)}; rollback failed: ${rollbackError}` : errorMessage4(error);
         try {
           atomicJsonWrite(journalPath, journal);
         } catch {
         }
       }
-      await this.#recordFailedOutcome(outcome, transactionId, errorMessage3(error), rollbackError);
+      await this.#recordFailedOutcome(outcome, transactionId, errorMessage4(error), rollbackError);
       context.update(`Schema transaction ${outcome}`);
       return {
         outcome,
         transactionId,
-        error: errorMessage3(error),
+        error: errorMessage4(error),
         ...rollbackError ? { rollbackError } : {}
       };
     } finally {
@@ -8870,7 +9443,7 @@ var SchemaController = class {
             observedSha256: sha256File(resolved.absolute)
           });
         } else if (item.kind === "file_contains") {
-          const confirmed = fs6.readFileSync(resolved.absolute, "utf8").includes(item.literal);
+          const confirmed = fs8.readFileSync(resolved.absolute, "utf8").includes(item.literal);
           results.push({
             evidence: item,
             status: confirmed ? "confirmed" : "nonconfirmed",
@@ -8887,7 +9460,7 @@ var SchemaController = class {
           });
         }
       } catch (error) {
-        results.push({ evidence: item, status: "error", detail: errorMessage3(error) });
+        results.push({ evidence: item, status: "error", detail: errorMessage4(error) });
       }
     }
     return results;
@@ -8911,7 +9484,7 @@ var SchemaController = class {
           ...signal ? { signal } : {}
         });
       } catch (error) {
-        resolve2({ evidence, status: "error", detail: errorMessage3(error), exitCode: null });
+        resolve2({ evidence, status: "error", detail: errorMessage4(error), exitCode: null });
         return;
       }
       const append = (chunk) => {
@@ -8941,22 +9514,22 @@ var SchemaController = class {
           throw new Error(`Schema precondition SHA-256 mismatch: ${operation.path}`);
         }
       }
-      fs6.writeFileSync(resolved.absolute, operation.content, "utf8");
+      fs8.writeFileSync(resolved.absolute, operation.content, "utf8");
       return;
     }
     if (sha256File(resolved.absolute) !== operation.expectedSha256) {
       throw new Error(`Schema precondition SHA-256 mismatch: ${operation.path}`);
     }
     if (operation.kind === "delete") {
-      fs6.unlinkSync(resolved.absolute);
+      fs8.unlinkSync(resolved.absolute);
       return;
     }
-    const content = fs6.readFileSync(resolved.absolute, "utf8");
+    const content = fs8.readFileSync(resolved.absolute, "utf8");
     const first = content.indexOf(operation.oldText);
     if (first < 0 || content.indexOf(operation.oldText, first + operation.oldText.length) >= 0) {
       throw new Error(`Schema edit requires oldText to occur exactly once: ${operation.path}`);
     }
-    fs6.writeFileSync(resolved.absolute, `${content.slice(0, first)}${operation.newText}${content.slice(first + operation.oldText.length)}`, "utf8");
+    fs8.writeFileSync(resolved.absolute, `${content.slice(0, first)}${operation.newText}${content.slice(first + operation.oldText.length)}`, "utf8");
   }
   #assertNoOutsideDrift(before, after, declared) {
     if (before.git !== after.git || before.head !== after.head || before.indexDigest !== after.indexDigest) {
@@ -8976,13 +9549,13 @@ var SchemaController = class {
       try {
         const resolved = resolveWorkspaceFile(this.cwd, image.path, { allowAbsent: true });
         if (!image.existed) {
-          if (resolved.exists) fs6.unlinkSync(resolved.absolute);
+          if (resolved.exists) fs8.unlinkSync(resolved.absolute);
         } else {
-          fs6.writeFileSync(resolved.absolute, Buffer.from(image.content ?? "", "base64"));
-          if (image.mode !== void 0) fs6.chmodSync(resolved.absolute, image.mode);
+          fs8.writeFileSync(resolved.absolute, Buffer.from(image.content ?? "", "base64"));
+          if (image.mode !== void 0) fs8.chmodSync(resolved.absolute, image.mode);
         }
       } catch (error) {
-        errors.push(`${image.path}: ${errorMessage3(error)}`);
+        errors.push(`${image.path}: ${errorMessage4(error)}`);
       }
     }
     return errors.length > 0 ? errors.join("; ") : void 0;
@@ -9027,25 +9600,25 @@ var SchemaController = class {
     return this.mesh.publish({ topic: SCHEMA_TOPIC, kind, from: this.identity, data });
   }
   #acquireCommitLock() {
-    fs6.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
+    fs8.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
     try {
-      const descriptor = fs6.openSync(this.#lockPath, "wx", 384);
-      fs6.writeFileSync(descriptor, `${process.pid}
+      const descriptor = fs8.openSync(this.#lockPath, "wx", 384);
+      fs8.writeFileSync(descriptor, `${process.pid}
 ${Date.now()}
 `);
-      fs6.closeSync(descriptor);
+      fs8.closeSync(descriptor);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "EEXIST") {
         throw new Error("Another Schema transaction is in progress");
       }
       throw error;
     }
-    return () => fs6.rmSync(this.#lockPath, { force: true });
+    return () => fs8.rmSync(this.#lockPath, { force: true });
   }
   #recoverJournals() {
-    fs6.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
+    fs8.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
     try {
-      const [pidText] = fs6.readFileSync(this.#lockPath, "utf8").split("\n");
+      const [pidText] = fs8.readFileSync(this.#lockPath, "utf8").split("\n");
       const pid = Number(pidText);
       if (Number.isSafeInteger(pid) && pid > 0) {
         try {
@@ -9054,15 +9627,15 @@ ${Date.now()}
         } catch {
         }
       }
-      fs6.rmSync(this.#lockPath, { force: true });
+      fs8.rmSync(this.#lockPath, { force: true });
     } catch (error) {
       if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
     }
-    for (const name of fs6.readdirSync(this.#journalRoot)) {
+    for (const name of fs8.readdirSync(this.#journalRoot)) {
       if (!name.endsWith(".json")) continue;
-      const filePath = path11.join(this.#journalRoot, name);
+      const filePath = path13.join(this.#journalRoot, name);
       try {
-        const journal = JSON.parse(fs6.readFileSync(filePath, "utf8"));
+        const journal = JSON.parse(fs8.readFileSync(filePath, "utf8"));
         if (journal.format !== 1 || journal.status !== "applying" || !Array.isArray(journal.before)) continue;
         const workspace = this.#workspaceEntry()?.value;
         if (workspace?.lastOutcome === "committed" && workspace.lastTransactionId === journal.id) {
@@ -9314,11 +9887,11 @@ var SchemaProvider = class {
 
 // src/state/store.ts
 import { createHash as createHash5 } from "node:crypto";
-import path13 from "node:path";
+import path15 from "node:path";
 
 // src/state/complexity.ts
-import fs7 from "node:fs";
-import path12 from "node:path";
+import fs9 from "node:fs";
+import path14 from "node:path";
 var isWordStart = (character) => character !== void 0 && (character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_" || character === "$");
 var isWordPart = (character) => isWordStart(character) || character !== void 0 && character >= "0" && character <= "9";
 var regularExpressionPrefixWords = /* @__PURE__ */ new Set([
@@ -9550,7 +10123,7 @@ var languageComplexities = [
   typeScriptJavaScriptComplexity
 ];
 var complexityForFile = (file, languages = languageComplexities) => {
-  const extension = path12.extname(file).toLowerCase();
+  const extension = path14.extname(file).toLowerCase();
   return languages.find((language) => language.extensions.includes(extension));
 };
 var countFileComplexity = (file) => {
@@ -9559,7 +10132,7 @@ var countFileComplexity = (file) => {
   return {
     file,
     language: language.language,
-    count: language.count(fs7.readFileSync(file, "utf8"))
+    count: language.count(fs9.readFileSync(file, "utf8"))
   };
 };
 
@@ -9567,7 +10140,7 @@ var countFileComplexity = (file) => {
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 var COMMAND_OUTPUT_MAX_BYTES = 32 * 1024;
-var errorMessage4 = (error) => error instanceof Error ? error.message : String(error);
+var errorMessage5 = (error) => error instanceof Error ? error.message : String(error);
 var truncateUtf8 = (value, maxBytes) => {
   const bytes = Buffer.from(value, "utf8");
   if (bytes.length <= maxBytes) return { value, omittedBytes: 0 };
@@ -9693,12 +10266,12 @@ var runCommand = (command, options) => new Promise((resolve2) => {
       windowsHide: true
     });
   } catch (error) {
-    finish("error", null, errorMessage4(error));
+    finish("error", null, errorMessage5(error));
     return;
   }
   child.stdout?.on("data", collect);
   child.stderr?.on("data", collect);
-  child.once("error", (error) => finish("error", null, errorMessage4(error)));
+  child.once("error", (error) => finish("error", null, errorMessage5(error)));
   child.once("close", (code) => {
     void (async () => {
       if (termination) await termination;
@@ -9742,7 +10315,7 @@ var EVENT_ROLLBACK_LIMIT = 8;
 var TRANSITION_PROTOCOL_VERSION = 1;
 var DURABLE_HEAD_PROTOCOL_VERSION = 2;
 var HEAD_COMMIT_PROOF_VERSION = 1;
-var errorMessage5 = (error) => error instanceof Error ? error.message : String(error);
+var errorMessage6 = (error) => error instanceof Error ? error.message : String(error);
 var isCasError = (error) => error instanceof Error && /compare-and-swap failed/.test(error.message);
 var toStringArray = (value) => {
   if (!Array.isArray(value)) return void 0;
@@ -9761,9 +10334,9 @@ var truncateUtf82 = (value, maxBytes) => {
   const bounded = bytes.subarray(0, end).toString("utf8");
   return { value: bounded, omittedBytes: bytes.length - end };
 };
-var boundedError = (error) => truncateUtf82(errorMessage5(error), REPORT_TEXT_MAX_BYTES).value;
+var boundedError = (error) => truncateUtf82(errorMessage6(error), REPORT_TEXT_MAX_BYTES).value;
 var casActualVersion = (error) => {
-  const match = errorMessage5(error).match(/found (\d+)$/);
+  const match = errorMessage6(error).match(/found (\d+)$/);
   return match ? Number(match[1]) : void 0;
 };
 var toComplexityRecord = (value) => {
@@ -10219,7 +10792,7 @@ var StateStore = class {
               protocolVersion: TRANSITION_PROTOCOL_VERSION,
               phase: "rejected",
               transitionId: event.id,
-              error: truncateUtf82(errorMessage5(error), EVENT_TEXT_MAX_BYTES).value,
+              error: truncateUtf82(errorMessage6(error), EVENT_TEXT_MAX_BYTES).value,
               rollback: {
                 restored: rollback.errors.length === 0,
                 deleted: deletedChunks[index],
@@ -10441,7 +11014,7 @@ var StateStore = class {
     const files = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(requestedFiles, input.cwd)) {
-      const measured = countFileComplexity(path13.resolve(input.cwd, file));
+      const measured = countFileComplexity(path15.resolve(input.cwd, file));
       if (!measured) {
         files.push({ file, supported: false });
         continue;
@@ -10468,7 +11041,7 @@ var StateStore = class {
     const updates = [];
     let netDelta = 0;
     for (const file of this.normalizeComplexityFiles(files, cwd)) {
-      const measured = countFileComplexity(path13.resolve(cwd, file));
+      const measured = countFileComplexity(path15.resolve(cwd, file));
       if (!measured) {
         deltas.push({ file, supported: false });
         continue;
@@ -10518,11 +11091,11 @@ var StateStore = class {
     const normalized = /* @__PURE__ */ new Set();
     for (const file of files) {
       if (!file.trim()) continue;
-      const relative = path13.relative(cwd, path13.resolve(cwd, file));
-      if (relative === ".." || relative.startsWith(`..${path13.sep}`) || path13.isAbsolute(relative)) {
+      const relative = path15.relative(cwd, path15.resolve(cwd, file));
+      if (relative === ".." || relative.startsWith(`..${path15.sep}`) || path15.isAbsolute(relative)) {
         throw new Error(`State complexity file must be inside the project cwd: ${file}`);
       }
-      normalized.add(relative.split(path13.sep).join("/"));
+      normalized.add(relative.split(path15.sep).join("/"));
     }
     return [...normalized];
   }
@@ -11187,6 +11760,7 @@ var FabricRuntimeState = class {
   #mcpProvider;
   #config;
   #execution;
+  #repairs;
   #speculationStore;
   #speculationTap;
   #agents;
@@ -11296,7 +11870,8 @@ var FabricRuntimeState = class {
       nestedToolCallId: "fabric-speculation",
       extensionContext: context,
       update() {
-      }
+      },
+      ...this.#sessionCapabilityLease?.view ? { capabilityView: this.#sessionCapabilityLease.view } : {}
     };
     const speculation = await registry.speculate(
       candidate.ref,
@@ -11311,7 +11886,8 @@ var FabricRuntimeState = class {
       speculation.preparedArgs,
       speculation.execute,
       createFreshnessChecker(candidate.ref, speculation.preparedArgs, context.cwd),
-      replay
+      replay,
+      speculation.bindingToken
     );
   }
   get registry() {
@@ -11375,6 +11951,10 @@ var FabricRuntimeState = class {
     if (!this.#compact) throw new Error("Pi Fabric has not initialized");
     return this.#compact;
   }
+  get repairs() {
+    if (!this.#repairs) throw new Error("Pi Fabric has not initialized");
+    return this.#repairs;
+  }
   async initialize(context, bootstrapConfig) {
     this.#suppressResidentGuidanceSync = true;
     try {
@@ -11404,9 +11984,11 @@ var FabricRuntimeState = class {
       new FabricToolResultProxy(() => this.capturedTools.runner)
     );
     this.#wireSpeculation();
-    this.#unsubscribeCapturedCatalog = this.capturedTools.subscribe(
-      () => this.#registry?.notifyCatalogChanged("extensions")
-    );
+    this.#unsubscribeCapturedCatalog?.();
+    this.#unsubscribeCapturedCatalog = this.capturedTools.subscribe(() => {
+      this.#registry?.notifyCatalogChanged("extensions");
+      this.#refreshRepairCatalog();
+    });
     this.#componentSupervisor = new FabricComponentSupervisor(this.#registry, {
       invocationContext: () => ({
         cwd: context.cwd,
@@ -11468,7 +12050,7 @@ var FabricRuntimeState = class {
       create: () => new McpProvider(context.cwd, this.#config.mcp, {
         ...this.#config.mcp.cache.enabled ? {
           cache: new McpDescriptorCacheStore(
-            path14.join(
+            path16.join(
               process.env.PI_FABRIC_PROJECT_ROOT ?? context.cwd,
               ".pi",
               "fabric",
@@ -11512,7 +12094,7 @@ var FabricRuntimeState = class {
     this.#mainAgent = mainAgent;
     const projectRoot = process.env.PI_FABRIC_PROJECT_ROOT ?? context.cwd;
     const configuredMeshRoot = this.#config.mesh.root;
-    const meshRoot = process.env.PI_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path14.resolve(projectRoot, configuredMeshRoot) : path14.join(projectRoot, ".pi", "fabric", "mesh"));
+    const meshRoot = process.env.PI_FABRIC_MESH_ROOT ?? (configuredMeshRoot ? path16.resolve(projectRoot, configuredMeshRoot) : path16.join(projectRoot, ".pi", "fabric", "mesh"));
     this.#mesh = new MeshStore(
       meshRoot,
       this.#config.mesh.maxEventBytes,
@@ -11630,7 +12212,7 @@ var FabricRuntimeState = class {
       return participant ? participant.ownerHostId === hostId : void 0;
     };
     const lineageAlive = (rootId) => this.#participants?.get(rootId) !== void 0;
-    const persistentActorRoot = this.#config.mesh.actorScope === "session" ? path14.join(meshRoot, "actors", sessionId) : path14.join(meshRoot, "actors");
+    const persistentActorRoot = this.#config.mesh.actorScope === "session" ? path16.join(meshRoot, "actors", sessionId) : path16.join(meshRoot, "actors");
     const acquireActorCapabilityView = (requirements, signal) => this.#registry.acquireCapabilityView(requirements, {
       cwd: context.cwd,
       signal,
@@ -11690,7 +12272,10 @@ ${escapeXmlText(text)}
         acquireCapabilityView: acquireActorCapabilityView
       }
     );
-    this.#registry.subscribeProviderChanges(() => this.#actors?.retryCapabilityWaiters());
+    this.#registry.subscribeProviderChanges(() => {
+      this.#actors?.retryCapabilityWaiters();
+      this.#refreshRepairCatalog();
+    });
     this.#lifecycle = new LifecycleBroker(
       this.#mesh,
       identity,
@@ -11878,6 +12463,12 @@ ${escapeXmlText(text)}
       this.#sessionCapabilityLease = lease;
       this.#execution.setCapabilityView(lease.view);
     }
+    this.#repairs = new RepairCompiler({
+      agentDir: resolveAgentDir(),
+      enabled: this.#config.repairs.enabled
+    });
+    this.#refreshRepairCatalog();
+    setActiveRepairCompiler(this.#repairs);
   }
   async ensure(context) {
     if (!this.initialized || this.#cwd !== context.cwd) await this.initialize(context);
@@ -12086,6 +12677,7 @@ ${escapeXmlText(text)}
   }
   async shutdown() {
     this.#suppressResidentGuidanceSync = true;
+    this.#deactivateRepairs();
     await this.#participants?.quiesce().catch(() => void 0);
     await this.#componentLoader?.close();
     await Promise.allSettled([...this.#componentTransitionPublications]);
@@ -12149,7 +12741,21 @@ ${escapeXmlText(text)}
     } catch {
     }
   }
+  #refreshRepairCatalog() {
+    if (!this.#repairs || !this.#registry) return;
+    if (this.capturedTools.suspended) return;
+    this.#repairs.setCatalogSurface({
+      providers: this.#registry.providers().map((provider) => provider.name),
+      capturedTools: this.capturedTools.list().map((entry) => entry.name)
+    });
+  }
+  #deactivateRepairs() {
+    const repairs = this.#repairs;
+    this.#repairs = void 0;
+    clearActiveRepairCompiler(repairs);
+  }
   async #closeInternal() {
+    this.#deactivateRepairs();
     if (!this.#registry) return;
     await this.#participants?.quiesce().catch(() => void 0);
     await this.#componentLoader?.close();
@@ -12249,4 +12855,4 @@ var deepAssign = (target, source) => {
 export {
   FabricRuntimeState
 };
-//# sourceMappingURL=fabric-runtime-state-VCLWTB55.js.map
+//# sourceMappingURL=fabric-runtime-state-H2NCRJWK.js.map