pi-fabric 0.76.2 → 0.78.0

package/dist/chunks/{chunk-F2GKEXGI.js → chunk-PFF3X7OO.js}

@@ -27,7 +27,7 @@ import {
   DEFAULT_FABRIC_CONFIG,
   MAX_AGENT_TIMEOUT_MS,
   MIN_AGENT_TIMEOUT_MS
-} from "./chunk-QXB75FLD.js";
+} from "./chunk-2E3CAABA.js";
 import {
   isFabricThinking
 } from "./chunk-7B55UIZL.js";
@@ -905,9 +905,9 @@ function appendBudgetLedger(file, entry) {
 
 // src/agents/manager.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import fs6 from "node:fs";
-import os4 from "node:os";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import os3 from "node:os";
+import path10 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/agents/semaphore.ts
@@ -1267,13 +1267,137 @@ var TmuxTransport = class {
 };
 
 // src/agents/worktree-manager.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+
+// src/agents/clone-first-worktree.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+
+// src/agents/cow-clone.ts
 import fs4 from "node:fs";
-import os2 from "node:os";
 import path4 from "node:path";
+var CLONE_SKIP_PREFIXES = [".git", ".pi/fabric/worktrees"];
+var CowUnavailableError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CowUnavailableError";
+  }
+};
+var posixRel = (value) => value.replaceAll("\\", "/");
+var isCowUnavailable = (error) => {
+  if (typeof error !== "object" || error === null || !("code" in error)) return false;
+  const code = error.code;
+  return code === "ENOTSUP" || code === "EOPNOTSUPP" || code === "EXDEV" || code === "ENOTSUPP";
+};
+var cloneEntry = async (from, to) => {
+  try {
+    await fs4.promises.cp(from, to, {
+      recursive: true,
+      verbatimSymlinks: true,
+      force: false,
+      mode: fs4.constants.COPYFILE_FICLONE_FORCE
+    });
+  } catch (error) {
+    if (isCowUnavailable(error)) {
+      throw new CowUnavailableError(`copy-on-write clone unavailable: ${from} -> ${to}`, {
+        cause: error
+      });
+    }
+    throw error;
+  }
+};
+var skipped = (rel, prefixes) => {
+  const value = posixRel(rel);
+  return prefixes.some((prefix) => value === prefix || value.startsWith(`${prefix}/`));
+};
+var hasNestedSkip = (rel, prefixes) => {
+  const value = posixRel(rel);
+  return prefixes.some((prefix) => prefix.startsWith(`${value}/`));
+};
+var cloneLevel = async (source, dest, relBase, prefixes) => {
+  await fs4.promises.mkdir(dest, { recursive: true });
+  const entries = await fs4.promises.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const rel = relBase ? `${relBase}/${entry.name}` : entry.name;
+    if (skipped(rel, prefixes)) continue;
+    const from = path4.join(source, entry.name);
+    const to = path4.join(dest, entry.name);
+    if (entry.isDirectory() && !entry.isSymbolicLink() && hasNestedSkip(rel, prefixes)) {
+      await cloneLevel(from, to, rel, prefixes);
+      continue;
+    }
+    if (!(entry.isFile() || entry.isDirectory() || entry.isSymbolicLink())) continue;
+    await cloneEntry(from, to);
+  }
+};
+var cloneTree = async (source, dest, prefixes = CLONE_SKIP_PREFIXES) => {
+  await cloneLevel(source, dest, "", prefixes);
+};
+
+// src/agents/worktree-paths.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+var FABRIC_WORKTREE_SEGMENTS = [".pi", "fabric", "worktrees"];
+var FABRIC_WORKTREE_EXCLUDE = ".pi/fabric/worktrees/";
+var fabricWorktreePath = (gitRoot, id) => path5.join(gitRoot, ...FABRIC_WORKTREE_SEGMENTS, id);
+var isFabricWorktreePath = (worktree, id) => {
+  const parts = worktree.split(/[\\/]/).filter(Boolean);
+  return parts.length >= 4 && parts.at(-1) === id && parts.at(-2) === "worktrees" && parts.at(-3) === "fabric" && parts.at(-4) === ".pi";
+};
+var ensureWorktreeExclude = async (gitRoot) => {
+  const located = await executeFile("git", ["rev-parse", "--git-path", "info/exclude"], {
+    cwd: gitRoot,
+    timeoutMs: 1e4
+  });
+  const excludePath = path5.resolve(gitRoot, located.stdout.trim());
+  fs5.mkdirSync(path5.dirname(excludePath), { recursive: true });
+  let current = "";
+  try {
+    current = fs5.readFileSync(excludePath, "utf8");
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? error.code : void 0;
+    if (code !== "ENOENT") throw error;
+  }
+  const lines = current.split(/\r?\n/);
+  if (lines.some((line) => line.trim() === FABRIC_WORKTREE_EXCLUDE)) return;
+  const prefix = current.length === 0 || current.endsWith("\n") ? "" : "\n";
+  fs5.appendFileSync(excludePath, `${prefix}${FABRIC_WORKTREE_EXCLUDE}
+`);
+};
+
+// src/agents/clone-first-worktree.ts
+var addCloneFirstWorktree = async (options) => {
+  const dest = options.dest;
+  if (isFabricWorktreePath(dest, path6.basename(dest))) {
+    await ensureWorktreeExclude(options.gitRoot);
+  }
+  fs6.mkdirSync(path6.dirname(dest), { recursive: true });
+  const args = ["worktree", "add", "--no-checkout"];
+  if (options.quiet) args.push("-q");
+  if (options.detach) args.push("--detach");
+  if (options.branch) args.push(options.branch.flag, options.branch.name);
+  args.push(dest);
+  if (options.startPoint) args.push(options.startPoint);
+  const added = await executeFile("git", args, { cwd: options.gitRoot, timeoutMs: 6e4 });
+  let cloned = false;
+  try {
+    await cloneTree(options.gitRoot, dest, CLONE_SKIP_PREFIXES);
+    cloned = true;
+  } catch (error) {
+    cloned = false;
+    if (!(error instanceof CowUnavailableError) && !(error instanceof Error)) throw error;
+  }
+  await executeFile("git", ["reset", "--hard", "HEAD"], { cwd: dest, timeoutMs: 6e4 });
+  await executeFile("git", ["clean", "-fd"], { cwd: dest, timeoutMs: 6e4 });
+  return { cloned, message: added.stdout.trim() };
+};
+
+// src/agents/worktree-manager.ts
 var safeLabel = (value) => value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30) || "agent";
 var isInside = (root, target) => {
-  const relative = path4.relative(root, target);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
+  const relative = path7.relative(root, target);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 };
 var worktreePrefixParts = (prefix) => {
   const parts = prefix.split(/[\\/]+/).filter(Boolean);
@@ -1291,27 +1415,27 @@ var WorktreeManager = class {
       ]);
       const output = root.stdout.trim();
       if (!output) throw new Error("Git did not return a worktree root");
-      gitRoot = fs4.realpathSync(output);
+      gitRoot = fs7.realpathSync(output);
       sourcePrefix = prefix2.stdout.trim();
     } catch {
       throw new Error("Worktree isolation requires a Git repository");
     }
     const branch = `pi-fabric/${safeLabel(name)}-${id.slice(0, 8)}`;
-    const parent = path4.join(os2.tmpdir(), "pi-fabric-worktrees");
-    fs4.mkdirSync(parent, { recursive: true });
-    const worktreePath = path4.join(parent, id);
-    await executeFile("git", ["worktree", "add", "-b", branch, worktreePath, "HEAD"], {
-      cwd: gitRoot,
-      timeoutMs: 6e4
+    const worktreePath = fabricWorktreePath(gitRoot, id);
+    await addCloneFirstWorktree({
+      gitRoot,
+      dest: worktreePath,
+      branch: { flag: "-b", name: branch },
+      startPoint: "HEAD"
     });
-    const canonicalWorktreePath = fs4.realpathSync(worktreePath);
+    const canonicalWorktreePath = fs7.realpathSync(worktreePath);
     const prefix = preserveSourceSubdirectory ? worktreePrefixParts(sourcePrefix) : void 0;
     let effectiveCwd = canonicalWorktreePath;
     if (prefix && prefix.length > 0) {
-      const candidate = path4.resolve(canonicalWorktreePath, ...prefix);
+      const candidate = path7.resolve(canonicalWorktreePath, ...prefix);
       try {
-        const canonicalCandidate = fs4.realpathSync(candidate);
-        if (fs4.statSync(canonicalCandidate).isDirectory() && isInside(canonicalWorktreePath, canonicalCandidate)) {
+        const canonicalCandidate = fs7.realpathSync(candidate);
+        if (fs7.statSync(canonicalCandidate).isDirectory() && isInside(canonicalWorktreePath, canonicalCandidate)) {
           effectiveCwd = canonicalCandidate;
         }
       } catch {
@@ -1343,15 +1467,15 @@ var WorktreeManager = class {
 };
 
 // src/storage/retention.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 var FABRIC_RUN_ROOT_PREFIX = "pi-fabric-runs-";
 var RUN_ROOT_OWNER_FILE = ".fabric-owner.json";
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "stopped", "timed_out"]);
-var ownerPath = (root) => path5.join(root, RUN_ROOT_OWNER_FILE);
+var ownerPath = (root) => path8.join(root, RUN_ROOT_OWNER_FILE);
 var readJson = (filePath) => {
   try {
-    return JSON.parse(fs5.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs8.readFileSync(filePath, "utf8"));
   } catch {
     return void 0;
   }
@@ -1393,32 +1517,32 @@ var pruneClosedRunRoot = (root, orphanedTempRunRetentionMs, oneShotRunRetentionM
   const removed = [];
   let entries;
   try {
-    entries = fs5.readdirSync(root, { withFileTypes: true });
+    entries = fs8.readdirSync(root, { withFileTypes: true });
   } catch {
     return removed;
   }
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const runDirectory = path5.join(root, entry.name);
-    const record = readJson(path5.join(runDirectory, "status.json"));
+    const runDirectory = path8.join(root, entry.name);
+    const record = readJson(path8.join(runDirectory, "status.json"));
     if (!record?.status || !TERMINAL_STATUSES.has(record.status)) continue;
     let fallback = now;
     try {
-      fallback = fs5.statSync(runDirectory).mtimeMs;
+      fallback = fs8.statSync(runDirectory).mtimeMs;
     } catch {
     }
     const retentionMs = record.actorId ? orphanedTempRunRetentionMs : oneShotRunRetentionMs;
     if (now - recordAgeReference(record, fallback) < retentionMs) continue;
-    fs5.rmSync(runDirectory, { recursive: true, force: true });
+    fs8.rmSync(runDirectory, { recursive: true, force: true });
     removed.push(runDirectory);
   }
   return removed;
 };
 var removeIfEmpty = (root) => {
   try {
-    const remaining = fs5.readdirSync(root).filter((name) => name !== RUN_ROOT_OWNER_FILE);
+    const remaining = fs8.readdirSync(root).filter((name) => name !== RUN_ROOT_OWNER_FILE);
     if (remaining.length > 0) return false;
-    fs5.rmSync(root, { recursive: true, force: true });
+    fs8.rmSync(root, { recursive: true, force: true });
     return true;
   } catch {
     return false;
@@ -1429,19 +1553,19 @@ var sweepTempRunRoots = (options) => {
   const result = { removedRoots: [], removedRuns: [] };
   let entries;
   try {
-    entries = fs5.readdirSync(options.tempRoot, { withFileTypes: true });
+    entries = fs8.readdirSync(options.tempRoot, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || !entry.name.startsWith(FABRIC_RUN_ROOT_PREFIX)) continue;
-    const root = path5.join(options.tempRoot, entry.name);
-    if (options.currentRoot && path5.resolve(root) === path5.resolve(options.currentRoot)) continue;
+    const root = path8.join(options.tempRoot, entry.name);
+    if (options.currentRoot && path8.resolve(root) === path8.resolve(options.currentRoot)) continue;
     const owner = readJson(ownerPath(root));
     if (!owner) {
       try {
-        if (fs5.readdirSync(root).length === 0 && now - fs5.statSync(root).mtimeMs >= options.orphanedTempRunRetentionMs) {
-          fs5.rmSync(root, { recursive: true, force: true });
+        if (fs8.readdirSync(root).length === 0 && now - fs8.statSync(root).mtimeMs >= options.orphanedTempRunRetentionMs) {
+          fs8.rmSync(root, { recursive: true, force: true });
           result.removedRoots.push(root);
         }
       } catch {
@@ -1466,7 +1590,7 @@ var sweepTempRunRoots = (options) => {
       continue;
     }
     if (now - owner.orphanedAt < options.orphanedTempRunRetentionMs) continue;
-    fs5.rmSync(root, { recursive: true, force: true });
+    fs8.rmSync(root, { recursive: true, force: true });
     result.removedRoots.push(root);
   }
   return result;
@@ -1476,44 +1600,44 @@ var pruneActorRunArchives = (options) => {
   const removed = [];
   let entries;
   try {
-    entries = fs5.readdirSync(options.runsDirectory, { withFileTypes: true });
+    entries = fs8.readdirSync(options.runsDirectory, { withFileTypes: true });
   } catch {
     return removed;
   }
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name === options.latestRunId) continue;
-    const runDirectory = path5.join(options.runsDirectory, entry.name);
-    const record = readJson(path5.join(runDirectory, "status.json"));
+    const runDirectory = path8.join(options.runsDirectory, entry.name);
+    const record = readJson(path8.join(runDirectory, "status.json"));
     if (!record?.status || !TERMINAL_STATUSES.has(record.status)) continue;
     let fallback = now;
     try {
-      fallback = fs5.statSync(runDirectory).mtimeMs;
+      fallback = fs8.statSync(runDirectory).mtimeMs;
     } catch {
     }
     if (now - recordAgeReference(record, fallback) < options.retentionMs) continue;
-    fs5.rmSync(runDirectory, { recursive: true, force: true });
+    fs8.rmSync(runDirectory, { recursive: true, force: true });
     removed.push(runDirectory);
   }
   return removed;
 };
 
 // src/agents/session-export.ts
-import os3 from "node:os";
-import path6 from "node:path";
+import os2 from "node:os";
+import path9 from "node:path";
 var SESSION_EXPORT_ENV = "PI_FABRIC_AGENT_DIR";
-var expandHome = (value) => value === "~" ? os3.homedir() : value.startsWith("~/") || value.startsWith(`~${path6.win32.sep}`) ? path6.join(os3.homedir(), value.slice(2)) : value;
+var expandHome = (value) => value === "~" ? os2.homedir() : value.startsWith("~/") || value.startsWith(`~${path9.win32.sep}`) ? path9.join(os2.homedir(), value.slice(2)) : value;
 var encodeSessionExportCwd = (cwd) => {
-  const absolute = path6.isAbsolute(cwd) || path6.win32.isAbsolute(cwd) ? cwd : path6.resolve(cwd);
+  const absolute = path9.isAbsolute(cwd) || path9.win32.isAbsolute(cwd) ? cwd : path9.resolve(cwd);
   return `--${absolute.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
 };
 var resolveSessionExportDir = (config) => {
   if (!config.sessionExport) return void 0;
-  const raw = process.env[SESSION_EXPORT_ENV]?.trim() || config.sessionExportDir.trim() || path6.join(os3.homedir(), ".pi", "agent");
+  const raw = process.env[SESSION_EXPORT_ENV]?.trim() || config.sessionExportDir.trim() || path9.join(os2.homedir(), ".pi", "agent");
   return expandHome(raw);
 };
 var sessionExportFileFor = (root, cwd, runId, at) => {
   const fileTimestamp = at.toISOString().replace(/[:.]/g, "-");
-  return path6.join(
+  return path9.join(
     root,
     "sessions",
     ".fabric",
@@ -1558,11 +1682,11 @@ var resolveAgentCwd = (parentCwd, requestedCwd) => {
   if (typeof requested !== "string" || requested.trim().length === 0) {
     throw new Error(`Invalid Fabric agent cwd ${JSON.stringify(requested)}: path must not be empty`);
   }
-  const candidate = path7.isAbsolute(requested) ? requested : path7.resolve(parentCwd, requested);
+  const candidate = path10.isAbsolute(requested) ? requested : path10.resolve(parentCwd, requested);
   try {
-    const canonical = fs6.realpathSync(candidate);
-    fs6.accessSync(canonical, fs6.constants.R_OK | fs6.constants.X_OK);
-    if (!fs6.statSync(canonical).isDirectory()) {
+    const canonical = fs9.realpathSync(candidate);
+    fs9.accessSync(canonical, fs9.constants.R_OK | fs9.constants.X_OK);
+    if (!fs9.statSync(canonical).isDirectory()) {
       throw new Error("path is not a directory");
     }
     return canonical;
@@ -1581,7 +1705,7 @@ var retryablePiStartupError = (error) => typeof error === "string" && /\b(?:no|m
 var safeName = (value) => value.replace(/[\r\n\t]+/g, " ").trim().slice(0, MAX_NAME_LENGTH) || "Fabric agent";
 var readRecord = (filePath) => {
   try {
-    const parsed = JSON.parse(fs6.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs9.readFileSync(filePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
     const record = parsed;
     return {
@@ -1621,24 +1745,24 @@ var compactUiRecord = (record) => {
 };
 var readNestedAgents = (runDirectory, depth = 0) => {
   if (depth >= 8) return [];
-  const nestedRoot = path7.join(runDirectory, "nested");
+  const nestedRoot = path10.join(runDirectory, "nested");
   let entries;
   try {
-    entries = fs6.readdirSync(nestedRoot);
+    entries = fs9.readdirSync(nestedRoot);
   } catch {
     return [];
   }
   const agents = [];
   for (const entry of entries.slice(0, 200)) {
-    const runDirectory2 = path7.join(nestedRoot, entry);
-    const record = readRecord(path7.join(runDirectory2, "status.json"));
+    const runDirectory2 = path10.join(nestedRoot, entry);
+    const record = readRecord(path10.join(runDirectory2, "status.json"));
     if (!record) continue;
     const nestedAgents = readNestedAgents(runDirectory2, depth + 1);
     const { logFile: _logFile, nestedAgents: _nestedAgents, ...safeRecord } = record;
     agents.push(
       compactUiRecord({
         ...safeRecord,
-        logFile: path7.join(runDirectory2, "events.jsonl"),
+        logFile: path10.join(runDirectory2, "events.jsonl"),
         ...nestedAgents.length > 0 ? { nestedAgents } : {}
       })
     );
@@ -1646,7 +1770,7 @@ var readNestedAgents = (runDirectory, depth = 0) => {
   return agents;
 };
 var summarizeRunLog = (runDirectory, lines) => {
-  const page = readJsonlPage(path7.join(runDirectory, "events.jsonl"), lines);
+  const page = readJsonlPage(path10.join(runDirectory, "events.jsonl"), lines);
   const summary = [];
   for (const entry of page.lines) {
     const parsed = entry.parsed;
@@ -1697,7 +1821,7 @@ var AgentManager = class {
     this.config = config;
     this.#semaphore = new Semaphore(config.maxConcurrent);
     this.#managedTempRoot = options.runRoot === void 0 && process.env.PI_FABRIC_RUN_ROOT === void 0;
-    this.#runRoot = options.runRoot ?? process.env.PI_FABRIC_RUN_ROOT ?? fs6.mkdtempSync(path7.join(os4.tmpdir(), "pi-fabric-runs-"));
+    this.#runRoot = options.runRoot ?? process.env.PI_FABRIC_RUN_ROOT ?? fs9.mkdtempSync(path10.join(os3.tmpdir(), "pi-fabric-runs-"));
     this.#retention = options.retention ?? DEFAULT_FABRIC_CONFIG.retention;
     this.#workerPath = options.workerPath ?? fileURLToPath(new URL("../worker.js", import.meta.url));
     this.#fabricExtensionPath = options.fabricExtensionPath ?? fileURLToPath(new URL("../index.js", import.meta.url));
@@ -1729,7 +1853,7 @@ var AgentManager = class {
     if (this.#managedTempRoot) {
       markRunRootActive(this.#runRoot);
       sweepTempRunRoots({
-        tempRoot: os4.tmpdir(),
+        tempRoot: os3.tmpdir(),
         currentRoot: this.#runRoot,
         orphanedTempRunRetentionMs: this.#retention.orphanedTempRunMs,
         oneShotRunRetentionMs: this.#retention.oneShotRunMs
@@ -1851,24 +1975,24 @@ var AgentManager = class {
     const release = await this.#semaphore.acquire(signal);
     const id = randomUUID4().replaceAll("-", "");
     const name = safeName(request.name ?? request.task.split("\n", 1)[0] ?? "Fabric agent");
-    const runDirectory = path7.join(this.#runRoot, id);
-    fs6.mkdirSync(runDirectory, { recursive: true });
-    const taskFile = path7.join(runDirectory, "task.txt");
-    const statusFile = path7.join(runDirectory, "status.json");
-    const lifecycleFile = path7.join(runDirectory, "lifecycle.jsonl");
-    const logFile = path7.join(runDirectory, "events.jsonl");
-    const steerFile = path7.join(runDirectory, "steer.jsonl");
-    const schemaFile = request.schema ? path7.join(runDirectory, "schema.json") : void 0;
-    const imagesFile = request.images && request.images.length > 0 ? path7.join(runDirectory, "images.json") : void 0;
-    fs6.writeFileSync(taskFile, request.task, { encoding: "utf8", mode: 384 });
+    const runDirectory = path10.join(this.#runRoot, id);
+    fs9.mkdirSync(runDirectory, { recursive: true });
+    const taskFile = path10.join(runDirectory, "task.txt");
+    const statusFile = path10.join(runDirectory, "status.json");
+    const lifecycleFile = path10.join(runDirectory, "lifecycle.jsonl");
+    const logFile = path10.join(runDirectory, "events.jsonl");
+    const steerFile = path10.join(runDirectory, "steer.jsonl");
+    const schemaFile = request.schema ? path10.join(runDirectory, "schema.json") : void 0;
+    const imagesFile = request.images && request.images.length > 0 ? path10.join(runDirectory, "images.json") : void 0;
+    fs9.writeFileSync(taskFile, request.task, { encoding: "utf8", mode: 384 });
     if (imagesFile) {
-      fs6.writeFileSync(imagesFile, JSON.stringify(request.images), {
+      fs9.writeFileSync(imagesFile, JSON.stringify(request.images), {
         encoding: "utf8",
         mode: 384
       });
     }
     if (schemaFile) {
-      fs6.writeFileSync(schemaFile, JSON.stringify(request.schema, null, 2), {
+      fs9.writeFileSync(schemaFile, JSON.stringify(request.schema, null, 2), {
         encoding: "utf8",
         mode: 384
       });
@@ -1891,7 +2015,7 @@ var AgentManager = class {
       const sessionFile = request.sessionSeed ? writeHandoffSession(
         request.sessionSeed,
         agentCwd,
-        path7.join(runDirectory, "handoff-session"),
+        path10.join(runDirectory, "handoff-session"),
         request.thinkingTransfer,
         request.handoffCompact
       ) : request.sessionFile;
@@ -1968,7 +2092,7 @@ var AgentManager = class {
         ...this.#identityId ? ["--owner-identity-id", this.#identityId] : [],
         ...request.runnerSessionId ? ["--runner-session-id", request.runnerSessionId] : [],
         "--run-root",
-        path7.join(runDirectory, "nested"),
+        path10.join(runDirectory, "nested"),
         "--steer-file",
         steerFile,
         ...schemaFile ? ["--schema-file", schemaFile] : [],
@@ -2156,15 +2280,15 @@ var AgentManager = class {
     this.#runs.delete(id);
     this.#pruneRetainedUiRecords();
     this.#invalidateUiList();
-    return { cleaned: cleaned || !fs6.existsSync(managed.runDirectory) };
+    return { cleaned: cleaned || !fs9.existsSync(managed.runDirectory) };
   }
   readLog(id, opts = {}) {
     const managed = this.#requireRun(id);
     const runDirectory = managed.runDirectory;
-    const logFile = path7.join(runDirectory, "events.jsonl");
+    const logFile = path10.join(runDirectory, "events.jsonl");
     const lines = Math.max(1, Math.min(opts.lines ?? 200, 5e3));
     const page = readJsonlPage(logFile, lines, opts.before);
-    const statusRecord = readRecord(path7.join(runDirectory, "status.json"));
+    const statusRecord = readRecord(path10.join(runDirectory, "status.json"));
     return {
       id,
       runDirectory,
@@ -2225,10 +2349,10 @@ var AgentManager = class {
         `Fabric agent ${id} already finished (${record.status}); steering has no target`
       );
     }
-    const steerFile = path7.join(managed.runDirectory, "steer.jsonl");
+    const steerFile = path10.join(managed.runDirectory, "steer.jsonl");
     const messageId = randomUUID4();
     const line = JSON.stringify({ ...entry, id: messageId, ts: Date.now() }) + "\n";
-    fs6.appendFileSync(steerFile, line, { encoding: "utf8", mode: 384 });
+    fs9.appendFileSync(steerFile, line, { encoding: "utf8", mode: 384 });
     return { queued: true, messageId };
   }
   async close() {
@@ -2246,7 +2370,7 @@ var AgentManager = class {
       await removeTree(this.#runRoot);
     }
     if (this.#budgetOwned && this.#budget) {
-      await removeTree(path7.dirname(this.#budget.file));
+      await removeTree(path10.dirname(this.#budget.file));
       clearOwnedBudgetEnv();
     }
   }
@@ -2260,7 +2384,7 @@ var AgentManager = class {
     if (this.#managedTempRoot) {
       heartbeatRunRoot(this.#runRoot, now);
       sweepTempRunRoots({
-        tempRoot: os4.tmpdir(),
+        tempRoot: os3.tmpdir(),
         currentRoot: this.#runRoot,
         orphanedTempRunRetentionMs: this.#retention.orphanedTempRunMs,
         oneShotRunRetentionMs: this.#retention.oneShotRunMs,
@@ -2275,7 +2399,7 @@ var AgentManager = class {
     });
     for (const managed of expired) {
       await removeTree(managed.runDirectory).catch(() => void 0);
-      if (!fs6.existsSync(managed.runDirectory)) this.#runs.delete(managed.id);
+      if (!fs9.existsSync(managed.runDirectory)) this.#runs.delete(managed.id);
     }
     if (expired.length > 0) {
       this.#pruneRetainedUiRecords();
@@ -2300,14 +2424,14 @@ var AgentManager = class {
     if (managed.settled || this.#closing || managed.abortSignal?.aborted) return false;
     managed.startupAttempts++;
     try {
-      fs6.rmSync(managed.statusFile, { force: true });
+      fs9.rmSync(managed.statusFile, { force: true });
       managed.transport = await managed.adapter.launch(managed.launch);
       delete managed.latestRecord;
       delete managed.latestUiRecord;
       managed.lastLivenessCheckAt = 0;
       managed.lifecycleOffset = 0;
       managed.lifecycleRemainder = Buffer.alloc(0);
-      fs6.rmSync(managed.lifecycleFile, { force: true });
+      fs9.rmSync(managed.lifecycleFile, { force: true });
       this.#invalidateUiList();
       return true;
     } catch (error) {
@@ -2407,7 +2531,7 @@ var AgentManager = class {
     if (managed.settled) return;
     this.#drainLifecycle(managed);
     managed.settled = true;
-    fs6.rmSync(path7.join(managed.runDirectory, "images.json"), { force: true });
+    fs9.rmSync(path10.join(managed.runDirectory, "images.json"), { force: true });
     this.#emitLifecycle(managed, `run.${result.status}`, result.finishedAt ?? Date.now(), {
       status: result.status
     });
@@ -2448,7 +2572,7 @@ var AgentManager = class {
   #drainLifecycle(managed) {
     let content;
     try {
-      content = fs6.readFileSync(managed.lifecycleFile);
+      content = fs9.readFileSync(managed.lifecycleFile);
     } catch {
       return;
     }
@@ -2639,7 +2763,7 @@ var AgentManager = class {
   // in the parent run until that parent is explicitly cleaned up.
   #nestedAgents(managed, force = false) {
     const now = Date.now();
-    const needsInitialDiscovery = managed.nestedSnapshot === void 0 && fs6.existsSync(path7.join(managed.runDirectory, "nested"));
+    const needsInitialDiscovery = managed.nestedSnapshot === void 0 && fs9.existsSync(path10.join(managed.runDirectory, "nested"));
     if (!force && !needsInitialDiscovery && managed.nestedSnapshotAt !== void 0 && now - managed.nestedSnapshotAt < NESTED_SNAPSHOT_POLL_MS) {
       return managed.nestedSnapshot ? structuredClone(managed.nestedSnapshot) : [];
     }
@@ -2663,7 +2787,7 @@ var AgentManager = class {
       cwd: managed.cwd,
       runner: managed.runner,
       ...managed.residency === "durable" ? { residency: "durable" } : {},
-      logFile: path7.join(managed.runDirectory, "events.jsonl"),
+      logFile: path10.join(managed.runDirectory, "events.jsonl"),
       ...nestedAgents.length > 0 ? { nestedAgents } : {},
       ...budget ? { budget } : {},
       ...managed.model ? { model: managed.model } : {},
@@ -2717,9 +2841,9 @@ var actorDeliveryNotice = (delivery, triggerTurn) => {
 
 // src/actors/manager.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import fs8 from "node:fs";
-import os5 from "node:os";
-import path9 from "node:path";
+import fs11 from "node:fs";
+import os4 from "node:os";
+import path12 from "node:path";
 
 // src/actors/predicate.ts
 var PREDICATE_VERSION = 1;
@@ -2790,8 +2914,8 @@ var evaluateActorValidWhile = async (source, facts) => {
 
 // src/actors/binding-store.ts
 import { createHash, randomUUID as randomUUID5 } from "node:crypto";
-import fs7 from "node:fs";
-import path8 from "node:path";
+import fs10 from "node:fs";
+import path11 from "node:path";
 var BINDING_LOCK_TIMEOUT_MS = 5e3;
 var BINDING_STALE_LOCK_MS = 3e4;
 var bindingFileName = (sessionId) => `${createHash("sha256").update(sessionId).digest("hex")}.json`;
@@ -2801,7 +2925,7 @@ var delay3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var ActorBindingStore = class {
   constructor(sessionId, root) {
     this.sessionId = sessionId;
-    this.filePath = root ? path8.join(root, "bindings", bindingFileName(sessionId)) : void 0;
+    this.filePath = root ? path11.join(root, "bindings", bindingFileName(sessionId)) : void 0;
     this.#sync(true);
   }
   #bindings = /* @__PURE__ */ new Map();
@@ -2867,7 +2991,7 @@ var ActorBindingStore = class {
     if (!this.filePath) return bindings;
     let parsed;
     try {
-      parsed = JSON.parse(fs7.readFileSync(this.filePath, "utf8"));
+      parsed = JSON.parse(fs10.readFileSync(this.filePath, "utf8"));
     } catch {
       return bindings;
     }
@@ -2908,7 +3032,7 @@ var ActorBindingStore = class {
   #currentFingerprint() {
     if (!this.filePath) return void 0;
     try {
-      const stat = fs7.statSync(this.filePath);
+      const stat = fs10.statSync(this.filePath);
       return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
     } catch {
       return void 0;
@@ -2917,7 +3041,7 @@ var ActorBindingStore = class {
   async #withLock(operation) {
     if (!this.filePath) return operation();
     const lockPath = `${this.filePath}.lock`;
-    const ownerPath2 = path8.join(lockPath, "owner");
+    const ownerPath2 = path11.join(lockPath, "owner");
     const deadline = Date.now() + BINDING_LOCK_TIMEOUT_MS;
     const token = randomUUID5();
     const processAlive3 = (pid) => {
@@ -2929,11 +3053,11 @@ var ActorBindingStore = class {
         return false;
       }
     };
-    fs7.mkdirSync(path8.dirname(this.filePath), { recursive: true, mode: 448 });
+    fs10.mkdirSync(path11.dirname(this.filePath), { recursive: true, mode: 448 });
     while (true) {
       try {
-        fs7.mkdirSync(lockPath, { mode: 448 });
-        fs7.writeFileSync(ownerPath2, `${token}
+        fs10.mkdirSync(lockPath, { mode: 448 });
+        fs10.writeFileSync(ownerPath2, `${token}
 ${process.pid}
 ${Date.now()}
 `, {
@@ -2944,13 +3068,13 @@ ${Date.now()}
       } catch (error) {
         if (errorCode2(error) !== "EEXIST") throw error;
         try {
-          const firstOwner = fs7.readFileSync(ownerPath2, "utf8");
+          const firstOwner = fs10.readFileSync(ownerPath2, "utf8");
           const [, pidText, createdText] = firstOwner.trim().split("\n");
           const stale = Date.now() - Number(createdText) > BINDING_STALE_LOCK_MS;
           if (stale && !processAlive3(Number(pidText))) {
-            const secondOwner = fs7.readFileSync(ownerPath2, "utf8");
+            const secondOwner = fs10.readFileSync(ownerPath2, "utf8");
             if (secondOwner === firstOwner) {
-              fs7.rmSync(lockPath, { recursive: true, force: true });
+              fs10.rmSync(lockPath, { recursive: true, force: true });
               continue;
             }
           }
@@ -2966,10 +3090,10 @@ ${Date.now()}
       return operation();
     } finally {
       try {
-        const owner = fs7.readFileSync(ownerPath2, "utf8");
+        const owner = fs10.readFileSync(ownerPath2, "utf8");
         if (owner.startsWith(`${token}
 `)) {
-          fs7.rmSync(lockPath, { recursive: true, force: true });
+          fs10.rmSync(lockPath, { recursive: true, force: true });
         }
       } catch {
       }
@@ -3065,7 +3189,7 @@ var atomicWrite2 = (filePath, value) => {
 };
 var readRunRecord = (filePath) => {
   try {
-    const parsed = JSON.parse(fs8.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs11.readFileSync(filePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
     return parsed;
   } catch {
@@ -3109,7 +3233,7 @@ var ActorManager = class {
     this.meshConfig = meshConfig;
     this.agents = agents;
     this.onDeliver = onDeliver;
-    this.#actorRoot = options.actorRoot ?? fs8.mkdtempSync(path9.join(os5.tmpdir(), "pi-fabric-actors-"));
+    this.#actorRoot = options.actorRoot ?? fs11.mkdtempSync(path12.join(os4.tmpdir(), "pi-fabric-actors-"));
     this.#persistent = options.persistent ?? false;
     this.#mainAgent = options.mainAgent;
     this.#canManageActor = options.canManageActor;
@@ -3118,7 +3242,7 @@ var ActorManager = class {
     this.#claimResidency = options.claimResidency;
     this.#rootId = options.rootId ?? identity.id;
     this.#meshCursorPath = options.meshCursorPath;
-    this.#registryPath = path9.join(this.#actorRoot, "actors.json");
+    this.#registryPath = path12.join(this.#actorRoot, "actors.json");
     this.#bindings = new ActorBindingStore(
       sessionId,
       this.#persistent && meshConfig.enabled ? this.#actorRoot : void 0
@@ -3230,8 +3354,8 @@ var ActorManager = class {
       throw new Error("This Fabric host cannot commit actor capability requirements");
     }
     const id = randomUUID6().replaceAll("-", "");
-    const actorDirectory = path9.join(this.#actorRoot, id);
-    fs8.mkdirSync(actorDirectory, { recursive: true, mode: 448 });
+    const actorDirectory = path12.join(this.#actorRoot, id);
+    fs11.mkdirSync(actorDirectory, { recursive: true, mode: 448 });
     const actor = {
       id,
       name,
@@ -3255,7 +3379,7 @@ var ActorManager = class {
       requirements,
       ...request.validWhile ? { validWhile: structuredClone(request.validWhile) } : {},
       latestActivationSequence: 0,
-      sessionFile: path9.join(actorDirectory, "session.jsonl"),
+      sessionFile: path12.join(actorDirectory, "session.jsonl"),
       queue: [],
       draining: false,
       messages: [],
@@ -3588,17 +3712,17 @@ var ActorManager = class {
     const type = opts.type ?? "session";
     const lines = Math.max(1, Math.min(opts.lines ?? 200, 5e3));
     const sessionFile = actor.sessionFile;
-    const logDir = path9.join(path9.dirname(sessionFile), "runs");
+    const logDir = path12.join(path12.dirname(sessionFile), "runs");
     const sessionPage = type === "run" ? { lines: [], hasMore: false } : readJsonlPage(sessionFile, lines, opts.before);
     const session = sessionPage.lines;
     let run;
     if (type !== "session") {
       const targetRunId = opts.runId ?? actor.lastRunId;
       if (targetRunId) {
-        const runPath = path9.join(logDir, targetRunId);
-        if (fs8.existsSync(runPath)) {
-          const statusRecord = readRunRecord(path9.join(runPath, "status.json"));
-          const eventsFile = path9.join(runPath, "events.jsonl");
+        const runPath = path12.join(logDir, targetRunId);
+        if (fs11.existsSync(runPath)) {
+          const statusRecord = readRunRecord(path12.join(runPath, "status.json"));
+          const eventsFile = path12.join(runPath, "events.jsonl");
           const page = readJsonlPage(eventsFile, lines, opts.before);
           run = {
             runId: targetRunId,
@@ -3714,7 +3838,7 @@ var ActorManager = class {
   #readMeshCursor() {
     if (!this.#meshCursorPath) return void 0;
     try {
-      const value = JSON.parse(fs8.readFileSync(this.#meshCursorPath, "utf8"));
+      const value = JSON.parse(fs11.readFileSync(this.#meshCursorPath, "utf8"));
       return value.format === 1 && typeof value.cursor === "number" && value.cursor >= 0 ? value.cursor : void 0;
     } catch {
       return void 0;
@@ -3815,7 +3939,7 @@ var ActorManager = class {
     await this.#bindings.delete(actor.id);
     this.#actors.delete(actor.id);
     this.#emitChange();
-    fs8.rmSync(path9.dirname(actor.sessionFile), { recursive: true, force: true });
+    fs11.rmSync(path12.dirname(actor.sessionFile), { recursive: true, force: true });
     await this.#saveActors(/* @__PURE__ */ new Set([actor.id]));
     await this.mesh.delete({ key: this.#presenceKey(actor.id) }).catch(() => ({ deleted: false }));
     if (retainedRunId) await this.agents.cleanup(retainedRunId).catch(() => ({ cleaned: false }));
@@ -3858,7 +3982,7 @@ var ActorManager = class {
     await Promise.allSettled(
       [...this.#actors.values()].map((actor) => actor.drain ?? Promise.resolve())
     );
-    fs8.rmSync(this.#actorRoot, { recursive: true, force: true });
+    fs11.rmSync(this.#actorRoot, { recursive: true, force: true });
   }
   #enqueue(actor, source, payload, options = {}) {
     const canManage = options.ownershipChecked ? this.#canManageCached(actor.id) : this.#canManage(actor.id);
@@ -4247,8 +4371,8 @@ var ActorManager = class {
       return;
     }
     try {
-      const watcher = fs8.watch(this.mesh.root, { persistent: false }, (_event, filename) => {
-        if (filename !== null && path9.basename(filename.toString()) !== "events.jsonl") return;
+      const watcher = fs11.watch(this.mesh.root, { persistent: false }, (_event, filename) => {
+        if (filename !== null && path12.basename(filename.toString()) !== "events.jsonl") return;
         this.#scheduleMeshPoll();
       });
       this.#meshWatcher = watcher;
@@ -4357,17 +4481,17 @@ var ActorManager = class {
   }
   async #retainRunLog(actor, runId) {
     const runDirectory = this.agents.runDirectory(runId);
-    if (!runDirectory || !fs8.existsSync(runDirectory)) return;
-    const dest = path9.join(path9.dirname(actor.sessionFile), "runs", runId);
-    fs8.mkdirSync(dest, { recursive: true, mode: 448 });
+    if (!runDirectory || !fs11.existsSync(runDirectory)) return;
+    const dest = path12.join(path12.dirname(actor.sessionFile), "runs", runId);
+    fs11.mkdirSync(dest, { recursive: true, mode: 448 });
     for (const file of ["events.jsonl", "status.json", "task.txt"]) {
-      const src = path9.join(runDirectory, file);
-      if (fs8.existsSync(src)) fs8.copyFileSync(src, path9.join(dest, file));
+      const src = path12.join(runDirectory, file);
+      if (fs11.existsSync(src)) fs11.copyFileSync(src, path12.join(dest, file));
     }
-    const nested = path9.join(runDirectory, "nested");
-    if (fs8.existsSync(nested)) {
+    const nested = path12.join(runDirectory, "nested");
+    if (fs11.existsSync(nested)) {
       try {
-        fs8.cpSync(nested, path9.join(dest, "nested"), { recursive: true });
+        fs11.cpSync(nested, path12.join(dest, "nested"), { recursive: true });
       } catch {
       }
     }
@@ -4375,7 +4499,7 @@ var ActorManager = class {
   }
   #pruneRetainedRuns(actor, now = Date.now()) {
     pruneActorRunArchives({
-      runsDirectory: path9.join(path9.dirname(actor.sessionFile), "runs"),
+      runsDirectory: path12.join(path12.dirname(actor.sessionFile), "runs"),
       ...actor.lastRunId ? { latestRunId: actor.lastRunId } : {},
       retentionMs: this.#retention.actorRunArchiveMs,
       now
@@ -4389,9 +4513,9 @@ var ActorManager = class {
     }
   }
   #retainedRunIds(actor) {
-    const runsDir = path9.join(path9.dirname(actor.sessionFile), "runs");
+    const runsDir = path12.join(path12.dirname(actor.sessionFile), "runs");
     try {
-      return fs8.readdirSync(runsDir).sort();
+      return fs11.readdirSync(runsDir).sort();
     } catch {
       return [];
     }
@@ -4507,7 +4631,7 @@ var ActorManager = class {
   }
   #registryRecords() {
     try {
-      const parsed = JSON.parse(fs8.readFileSync(this.#registryPath, "utf8"));
+      const parsed = JSON.parse(fs11.readFileSync(this.#registryPath, "utf8"));
       if (!Array.isArray(parsed.actors)) return [];
       return parsed.actors.flatMap(
         (record) => typeof record === "object" && record !== null && !Array.isArray(record) && typeof record.id === "string" ? [record] : []
@@ -4518,7 +4642,7 @@ var ActorManager = class {
   }
   async #withRegistryLock(operation) {
     const lockPath = `${this.#registryPath}.lock`;
-    const ownerPath2 = path9.join(lockPath, "owner");
+    const ownerPath2 = path12.join(lockPath, "owner");
     const deadline = Date.now() + ACTOR_REGISTRY_LOCK_TIMEOUT_MS;
     const token = randomUUID6();
     const processAlive3 = (pid) => {
@@ -4530,11 +4654,11 @@ var ActorManager = class {
         return false;
       }
     };
-    fs8.mkdirSync(this.#actorRoot, { recursive: true, mode: 448 });
+    fs11.mkdirSync(this.#actorRoot, { recursive: true, mode: 448 });
     while (true) {
       try {
-        fs8.mkdirSync(lockPath, { mode: 448 });
-        fs8.writeFileSync(ownerPath2, `${token}
+        fs11.mkdirSync(lockPath, { mode: 448 });
+        fs11.writeFileSync(ownerPath2, `${token}
 ${process.pid}
 ${Date.now()}
 `, {
@@ -4545,13 +4669,13 @@ ${Date.now()}
       } catch (error) {
         if (errorCode3(error) !== "EEXIST") throw error;
         try {
-          const firstOwner = fs8.readFileSync(ownerPath2, "utf8");
+          const firstOwner = fs11.readFileSync(ownerPath2, "utf8");
           const [, pidText, createdText] = firstOwner.trim().split("\n");
           const stale = Date.now() - Number(createdText) > ACTOR_REGISTRY_STALE_LOCK_MS;
           if (stale && !processAlive3(Number(pidText))) {
-            const secondOwner = fs8.readFileSync(ownerPath2, "utf8");
+            const secondOwner = fs11.readFileSync(ownerPath2, "utf8");
             if (secondOwner === firstOwner) {
-              fs8.rmSync(lockPath, { recursive: true, force: true });
+              fs11.rmSync(lockPath, { recursive: true, force: true });
               continue;
             }
           }
@@ -4567,10 +4691,10 @@ ${Date.now()}
       return operation();
     } finally {
       try {
-        const owner = fs8.readFileSync(ownerPath2, "utf8");
+        const owner = fs11.readFileSync(ownerPath2, "utf8");
         if (owner.startsWith(`${token}
 `)) {
-          fs8.rmSync(lockPath, { recursive: true, force: true });
+          fs11.rmSync(lockPath, { recursive: true, force: true });
         }
       } catch {
       }
@@ -4598,7 +4722,7 @@ ${Date.now()}
   }
   #currentRegistryFingerprint() {
     try {
-      const stat = fs8.statSync(this.#registryPath);
+      const stat = fs11.statSync(this.#registryPath);
       return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
     } catch {
       return void 0;
@@ -4643,7 +4767,7 @@ ${Date.now()}
     let added = 0;
     let parsed;
     try {
-      parsed = JSON.parse(fs8.readFileSync(this.#registryPath, "utf8"));
+      parsed = JSON.parse(fs11.readFileSync(this.#registryPath, "utf8"));
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
       return;
@@ -4704,7 +4828,7 @@ ${Date.now()}
         ...typeof record.capabilityDigest === "string" ? { capabilityDigest: record.capabilityDigest } : {},
         ...record.validWhile?.version === 1 && typeof record.validWhile.source === "string" ? { validWhile: record.validWhile } : {},
         latestActivationSequence: 0,
-        sessionFile: path9.join(this.#actorRoot, record.id, "session.jsonl"),
+        sessionFile: path12.join(this.#actorRoot, record.id, "session.jsonl"),
         queue: [],
         draining: false,
         messages: [],
@@ -4789,7 +4913,7 @@ ${Date.now()}
       ...actor.lastRunId ? { lastRunId: actor.lastRunId } : {},
       ...actor.lastError ? { lastError: actor.lastError } : {},
       sessionFile: actor.sessionFile,
-      logDir: path9.join(path9.dirname(actor.sessionFile), "runs")
+      logDir: path12.join(path12.dirname(actor.sessionFile), "runs")
     };
   }
   validateDirectMessage(message, data) {
@@ -6231,6 +6355,8 @@ export {
   FABRIC_LIFECYCLE_EVENTS,
   isFabricLifecycleEventType,
   lifecycleSourceIdentity,
+  isFabricWorktreePath,
+  addCloneFirstWorktree,
   useBudgetLedger,
   effectiveAgentTimeoutMs,
   validateAgentCwdRequest,
@@ -6245,4 +6371,4 @@ export {
   agentParticipantRecords,
   actorParticipantRecord
 };
-//# sourceMappingURL=chunk-F2GKEXGI.js.map
+//# sourceMappingURL=chunk-PFF3X7OO.js.map