pi-fabric 0.76.2 → 0.77.0

package/dist/chunks/{chunk-BT6UELLP.js → chunk-SBHF6CVR.js}

@@ -9,7 +9,7 @@ import {
   agentParticipantRecords,
   lifecycleSourceIdentity,
   useBudgetLedger
-} from "./chunk-F2GKEXGI.js";
+} from "./chunk-4DRVOAFY.js";
 import {
   parseFabricOwnedModelGuidance,
   resolveFabricModelGuidance
@@ -662,4 +662,4 @@ if (isMain) {
 export {
   runResidentHostFromConfigPath
 };
-//# sourceMappingURL=chunk-BT6UELLP.js.map
+//# sourceMappingURL=chunk-SBHF6CVR.js.map

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

@@ -69,15 +69,17 @@ import {
   ParticipantDirectory,
   actorDeliveryNotice,
   actorParticipantRecord,
+  addCloneFirstWorktree,
   agentParticipantRecords,
   effectiveAgentTimeoutMs,
   isFabricLifecycleEventType,
+  isFabricWorktreePath,
   lifecycleSourceIdentity,
   resolveActorDeliveryPolicy,
   resolveAgentCwd,
   resolvePiBinary,
   validateAgentCwdRequest
-} from "./chunk-F2GKEXGI.js";
+} from "./chunk-4DRVOAFY.js";
 import "./chunk-PM5I335G.js";
 import "./chunk-VPPIJRNZ.js";
 import {
@@ -149,7 +151,7 @@ import {
 } from "./chunk-IDTQ2B5W.js";
 
 // src/fabric-runtime-state.ts
-import path14 from "node:path";
+import path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/actors/global-registry.ts
@@ -2196,10 +2198,10 @@ var FabricComponentSupervisor = class {
       adjacent.set(edge.from, targets);
     }
     const cycles = /* @__PURE__ */ new Map();
-    const visit = (node, path15, positions) => {
+    const visit = (node, path16, positions) => {
       const position = positions.get(node);
       if (position !== void 0) {
-        const cycle = path15.slice(position);
+        const cycle = path16.slice(position);
         const rotations = cycle.map((_, index) => [
           ...cycle.slice(index),
           ...cycle.slice(0, index)
@@ -2209,10 +2211,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 (path16.length > this.#components.size) return;
+      const nextPositions = new Map(positions).set(node, path16.length);
       for (const target of adjacent.get(node) ?? []) {
-        visit(target, [...path15, node], nextPositions);
+        visit(target, [...path16, node], nextPositions);
       }
     };
     for (const id of this.#components.keys()) visit(id, [], /* @__PURE__ */ new Map());
@@ -4469,7 +4471,6 @@ 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 { fileURLToPath } from "node:url";
 var STARTUP_TIMEOUT_MS = 3e4;
@@ -4794,7 +4795,7 @@ var ResidencyClient = class {
     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)) {
       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)}`))) {
@@ -6486,19 +6487,19 @@ var ComponentsProvider = class {
 // src/providers/mcp-descriptor-cache.ts
 import fs4 from "node:fs/promises";
 import fsSync from "node:fs";
-import os2 from "node:os";
+import os from "node:os";
 import path6 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 input;
 };
-var legacyMcporterDir = () => path6.join(os2.homedir(), ".mcporter");
+var legacyMcporterDir = () => path6.join(os.homedir(), ".mcporter");
 var mcporterConfigDir = () => {
   const raw = process.env.XDG_CONFIG_HOME;
   if (raw && raw.trim().length > 0) {
@@ -7615,7 +7616,7 @@ var MeshProvider = class {
 
 // src/providers/pi-tools-provider.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import {
   createBashToolDefinition as createBashToolDefinition2,
   createEditToolDefinition,
@@ -7625,9 +7626,102 @@ import {
   createReadToolDefinition
 } from "@earendil-works/pi-coding-agent";
 
+// src/agents/bash-worktree-add.ts
+import fs5 from "node:fs";
+import path8 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 ? path8.resolve(sessionCwd, parsed.gitCwd) : typeof args.cwd === "string" ? args.cwd : sessionCwd;
+  const dest = path8.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 = fs5.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 path9 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 +7731,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 = path9.isAbsolute(requested) ? path9.resolve(requested) : path9.resolve(sessionCwd, requested);
   try {
     if (!statSync(resolved).isDirectory()) throw new Error("path is not a directory");
     accessSync(resolved, constants.R_OK | constants.X_OK);
@@ -7736,14 +7830,14 @@ var createPreviewWriteToolDefinition = (cwd) => {
   return {
     ...original,
     async execute(_toolCallId, params, signal) {
-      const { path: path15, content } = params;
-      const absolutePath = resolvePreviewPath(path15, cwd);
+      const { path: path16, content } = params;
+      const absolutePath = resolvePreviewPath(path16, 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(path16, cwd, content);
         throwIfAborted2();
         await mkdir(dirname(absolutePath), { recursive: true });
         throwIfAborted2();
@@ -7753,7 +7847,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 ${path16}`
             }
           ],
           details: { codePreviewBeforeWrite: before }
@@ -7787,7 +7881,7 @@ var expandReplaceAllEdit = (cwd, args, allForEveryEdit) => {
     }
     return { oldText, newText, all: allForEveryEdit || record.all === true };
   });
-  const resolvedPath = path9.resolve(
+  const resolvedPath = path10.resolve(
     cwd,
     filePath.startsWith("@") ? filePath.slice(1) : filePath
   );
@@ -7929,6 +8023,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);
@@ -8149,8 +8250,8 @@ 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 fs7 from "node:fs";
+import path12 from "node:path";
 
 // src/schema/types.ts
 var stateBinding = (head) => head ? { transitionId: head.transitionId, version: head.version, to: head.to } : null;
@@ -8158,8 +8259,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 fs6 from "node:fs";
+import path11 from "node:path";
 var SNAPSHOT_MAX_FILES = 2e4;
 var SNAPSHOT_MAX_BYTES = 512 * 1024 * 1024;
 var FALLBACK_SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -8177,16 +8278,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(path11.sep).join("/");
 var isInside = (root, candidate) => {
-  const relative = path10.relative(root, candidate);
-  return relative === "" || !path10.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path10.sep}`);
+  const relative = path11.relative(root, candidate);
+  return relative === "" || !path11.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path11.sep}`);
 };
 var excluded = (absolute, exclusions) => exclusions.some((root) => isInside(root, absolute));
 var entryDigest = (absolute) => {
   let stat2;
   try {
-    stat2 = fs5.lstatSync(absolute);
+    stat2 = fs6.lstatSync(absolute);
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return { marker: "absent", bytes: 0 };
@@ -8194,24 +8295,24 @@ var entryDigest = (absolute) => {
     throw error;
   }
   if (stat2.isSymbolicLink()) {
-    return { marker: `symlink:${digest(fs5.readlinkSync(absolute))}`, bytes: 0 };
+    return { marker: `symlink:${digest(fs6.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(fs6.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 = path11.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(path11.relative(cwd, absolute));
     const entry = entryDigest(absolute);
     bytes += entry.bytes;
     if (bytes > SNAPSHOT_MAX_BYTES) {
@@ -8237,12 +8338,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 = fs6.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 = path11.join(directory, entry.name);
       if (excluded(absolute, exclusions)) continue;
-      const relative = normalizeRelative(path10.relative(cwd, absolute));
+      const relative = normalizeRelative(path11.relative(cwd, absolute));
       if (entry.isDirectory()) visit(absolute);
       else paths.push(relative);
       if (paths.length > SNAPSHOT_MAX_FILES) {
@@ -8254,11 +8355,11 @@ var fallbackPaths = (cwd, exclusions) => {
   return paths;
 };
 var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
-  const cwd = fs5.realpathSync(cwdInput);
+  const cwd = fs6.realpathSync(cwdInput);
   const exclusions = excludedRoots.map((root) => {
-    const absolute = path10.resolve(root);
+    const absolute = path11.resolve(root);
     try {
-      return fs5.realpathSync(absolute);
+      return fs6.realpathSync(absolute);
     } catch {
       return absolute;
     }
@@ -8294,29 +8395,29 @@ var snapshotWorkspace = (cwdInput, excludedRoots = []) => {
   );
 };
 var resolveWorkspaceFile = (cwdInput, requestedPath, options) => {
-  if (!requestedPath.trim() || path10.isAbsolute(requestedPath)) {
+  if (!requestedPath.trim() || path11.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 = fs6.realpathSync(cwdInput);
+  const absolute = path11.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 = path11.relative(cwd, absolute).split(path11.sep);
   let cursor = cwd;
   for (let index = 0; index < relativeParts.length; index++) {
-    cursor = path10.join(cursor, relativeParts[index]);
+    cursor = path11.join(cursor, relativeParts[index]);
     let stat2;
     try {
-      stat2 = fs5.lstatSync(cursor);
+      stat2 = fs6.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 = fs6.realpathSync(path11.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(path11.relative(cwd, absolute)), exists: false };
       }
       throw error;
     }
@@ -8328,9 +8429,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(path11.relative(cwd, absolute)), exists: true };
 };
-var sha256File = (absolute) => `sha256:${digest(fs5.readFileSync(absolute))}`;
+var sha256File = (absolute) => `sha256:${digest(fs6.readFileSync(absolute))}`;
 
 // src/schema/controller.ts
 var SCHEMA_TOPIC = "fabric.schema";
@@ -8378,9 +8479,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 = fs7.realpathSync(cwd);
+    this.#journalRoot = path12.join(mesh.root, "schema-transactions");
+    this.#lockPath = path12.join(this.#journalRoot, ".commit.lock");
     this.#recoverJournals();
   }
   #activeHypotheses = /* @__PURE__ */ new Map();
@@ -8579,7 +8680,7 @@ var SchemaController = class {
     this.#assertPayloadBound(input);
     const release = this.#acquireCommitLock();
     const transactionId = randomUUID3();
-    const journalPath = path11.join(this.#journalRoot, `${transactionId}.json`);
+    const journalPath = path12.join(this.#journalRoot, `${transactionId}.json`);
     let journal;
     let consumed = false;
     let committed = false;
@@ -8619,14 +8720,14 @@ var SchemaController = class {
           before.push({ path: resolved.relative, absolute: resolved.absolute, existed: false });
           continue;
         }
-        const content = fs6.readFileSync(resolved.absolute);
+        const content = fs7.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: fs7.statSync(resolved.absolute).mode & 511
         });
       }
       if (payloadBytes + beforeBytes > this.config.maxBytes) {
@@ -8870,7 +8971,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 = fs7.readFileSync(resolved.absolute, "utf8").includes(item.literal);
           results.push({
             evidence: item,
             status: confirmed ? "confirmed" : "nonconfirmed",
@@ -8941,22 +9042,22 @@ var SchemaController = class {
           throw new Error(`Schema precondition SHA-256 mismatch: ${operation.path}`);
         }
       }
-      fs6.writeFileSync(resolved.absolute, operation.content, "utf8");
+      fs7.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);
+      fs7.unlinkSync(resolved.absolute);
       return;
     }
-    const content = fs6.readFileSync(resolved.absolute, "utf8");
+    const content = fs7.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");
+    fs7.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,10 +9077,10 @@ 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) fs7.unlinkSync(resolved.absolute);
         } else {
-          fs6.writeFileSync(resolved.absolute, Buffer.from(image.content ?? "", "base64"));
-          if (image.mode !== void 0) fs6.chmodSync(resolved.absolute, image.mode);
+          fs7.writeFileSync(resolved.absolute, Buffer.from(image.content ?? "", "base64"));
+          if (image.mode !== void 0) fs7.chmodSync(resolved.absolute, image.mode);
         }
       } catch (error) {
         errors.push(`${image.path}: ${errorMessage3(error)}`);
@@ -9027,25 +9128,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 });
+    fs7.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
     try {
-      const descriptor = fs6.openSync(this.#lockPath, "wx", 384);
-      fs6.writeFileSync(descriptor, `${process.pid}
+      const descriptor = fs7.openSync(this.#lockPath, "wx", 384);
+      fs7.writeFileSync(descriptor, `${process.pid}
 ${Date.now()}
 `);
-      fs6.closeSync(descriptor);
+      fs7.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 () => fs7.rmSync(this.#lockPath, { force: true });
   }
   #recoverJournals() {
-    fs6.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
+    fs7.mkdirSync(this.#journalRoot, { recursive: true, mode: 448 });
     try {
-      const [pidText] = fs6.readFileSync(this.#lockPath, "utf8").split("\n");
+      const [pidText] = fs7.readFileSync(this.#lockPath, "utf8").split("\n");
       const pid = Number(pidText);
       if (Number.isSafeInteger(pid) && pid > 0) {
         try {
@@ -9054,15 +9155,15 @@ ${Date.now()}
         } catch {
         }
       }
-      fs6.rmSync(this.#lockPath, { force: true });
+      fs7.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 fs7.readdirSync(this.#journalRoot)) {
       if (!name.endsWith(".json")) continue;
-      const filePath = path11.join(this.#journalRoot, name);
+      const filePath = path12.join(this.#journalRoot, name);
       try {
-        const journal = JSON.parse(fs6.readFileSync(filePath, "utf8"));
+        const journal = JSON.parse(fs7.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 +9415,11 @@ var SchemaProvider = class {
 
 // src/state/store.ts
 import { createHash as createHash5 } from "node:crypto";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/state/complexity.ts
-import fs7 from "node:fs";
-import path12 from "node:path";
+import fs8 from "node:fs";
+import path13 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 +9651,7 @@ var languageComplexities = [
   typeScriptJavaScriptComplexity
 ];
 var complexityForFile = (file, languages = languageComplexities) => {
-  const extension = path12.extname(file).toLowerCase();
+  const extension = path13.extname(file).toLowerCase();
   return languages.find((language) => language.extensions.includes(extension));
 };
 var countFileComplexity = (file) => {
@@ -9559,7 +9660,7 @@ var countFileComplexity = (file) => {
   return {
     file,
     language: language.language,
-    count: language.count(fs7.readFileSync(file, "utf8"))
+    count: language.count(fs8.readFileSync(file, "utf8"))
   };
 };
 
@@ -10441,7 +10542,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(path14.resolve(input.cwd, file));
       if (!measured) {
         files.push({ file, supported: false });
         continue;
@@ -10468,7 +10569,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(path14.resolve(cwd, file));
       if (!measured) {
         deltas.push({ file, supported: false });
         continue;
@@ -10518,11 +10619,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 = path14.relative(cwd, path14.resolve(cwd, file));
+      if (relative === ".." || relative.startsWith(`..${path14.sep}`) || path14.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(path14.sep).join("/"));
     }
     return [...normalized];
   }
@@ -11468,7 +11569,7 @@ var FabricRuntimeState = class {
       create: () => new McpProvider(context.cwd, this.#config.mcp, {
         ...this.#config.mcp.cache.enabled ? {
           cache: new McpDescriptorCacheStore(
-            path14.join(
+            path15.join(
               process.env.PI_FABRIC_PROJECT_ROOT ?? context.cwd,
               ".pi",
               "fabric",
@@ -11512,7 +11613,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 ? path15.resolve(projectRoot, configuredMeshRoot) : path15.join(projectRoot, ".pi", "fabric", "mesh"));
     this.#mesh = new MeshStore(
       meshRoot,
       this.#config.mesh.maxEventBytes,
@@ -11630,7 +11731,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" ? path15.join(meshRoot, "actors", sessionId) : path15.join(meshRoot, "actors");
     const acquireActorCapabilityView = (requirements, signal) => this.#registry.acquireCapabilityView(requirements, {
       cwd: context.cwd,
       signal,
@@ -12249,4 +12350,4 @@ var deepAssign = (target, source) => {
 export {
   FabricRuntimeState
 };
-//# sourceMappingURL=fabric-runtime-state-VCLWTB55.js.map
+//# sourceMappingURL=fabric-runtime-state-H7UA3DJC.js.map