agentwheel 0.20.8 → 0.20.9

package/dist/{chunk-JXX6EDIP.js → chunk-SHPNLNBR.js}

@@ -7,9 +7,9 @@ import {
 } from "./chunk-7VPI5J5Y.js";
 
 // src/install/transaction.ts
-import { createHash as createHash5 } from "crypto";
-import { cp, mkdir as mkdir3, readFile as readFile7, rm as rm4, stat as stat2 } from "fs/promises";
-import { dirname as dirname5, join as join6, resolve as resolve9 } from "path";
+import { createHash as createHash6 } from "crypto";
+import { cp, mkdir as mkdir3, readFile as readFile8, rm as rm4, stat as stat2 } from "fs/promises";
+import { dirname as dirname5, join as join7, resolve as resolve10 } from "path";
 
 // src/transport/local.ts
 import { execFile } from "child_process";
@@ -151,13 +151,13 @@ async function spawnWithInput(command, args, input) {
   if (result.stderr) throw new Error(result.stderr);
 }
 function waitForProcess(child, label) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const stderr = [];
     child.stderr?.on("data", (chunk) => stderr.push(chunk));
     child.on("error", reject);
     child.on("close", (code) => {
       const message = Buffer.concat(stderr).toString("utf8");
-      if (code === 0) resolve10({ stderr: "" });
+      if (code === 0) resolve11({ stderr: "" });
       else reject(new Error(`${label} exited ${code}${message ? `: ${message}` : ""}`));
     });
   });
@@ -488,8 +488,8 @@ function sanitizeStateKey(value) {
 
 // src/mutation/coordinator.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { homedir as homedir4 } from "os";
-import { resolve as resolve8 } from "path";
+import { homedir as homedir5 } from "os";
+import { isAbsolute as isAbsolute6, relative as relative3, resolve as resolve9, sep as sep3 } from "path";
 
 // src/model/mutation.ts
 import { z as z3 } from "zod";
@@ -548,10 +548,10 @@ var mutationPolicySchema = z3.object({
 });
 
 // src/model/workspace.ts
-import { readFile as readFile4 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname4, join as join4, resolve as resolve5 } from "path";
-import { z as z6 } from "zod";
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join5, resolve as resolve6 } from "path";
+import { z as z7 } from "zod";
 
 // src/resolve/semver.ts
 var semverPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -651,7 +651,7 @@ function compareSemver(a, b) {
 
 // src/mutation/declarations.ts
 import { chmodSync, closeSync, fsyncSync, mkdirSync, openSync, readFileSync, writeSync } from "fs";
-import { isAbsolute as isAbsolute3, join as join3, relative, resolve as resolve4, sep } from "path";
+import { isAbsolute as isAbsolute4, join as join4, relative, resolve as resolve5, sep } from "path";
 
 // src/mutation/protocol.ts
 import { createHash } from "crypto";
@@ -808,16 +808,280 @@ function canonicalJson(value) {
 }
 
 // src/mutation/receipts.ts
-import { createHash as createHash2, randomUUID } from "crypto";
-import { chmod, link, mkdir as mkdir2, open, readFile as readFile3, readdir as readdir2, rename as rename2, rm as rm2 } from "fs/promises";
+import { createHash as createHash3, randomUUID } from "crypto";
+import { chmod, link, mkdir as mkdir2, open, readFile as readFile4, readdir as readdir2, rename as rename2, rm as rm2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join3, resolve as resolve4 } from "path";
+import { z as z6 } from "zod";
+
+// src/mutation/session-ownership.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join2, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute3, join as join2, posix as posix2, resolve as resolve3 } from "path";
 import { z as z5 } from "zod";
-var preexistingPathSchema = z5.object({
-  path: z5.string().min(1).max(4096),
-  sha256: z5.string().regex(/^[a-f0-9]{64}$/).nullable()
+
+// src/mutation/process.ts
+import { spawn as spawn2 } from "child_process";
+async function runProcess(command, args, options = {}) {
+  return new Promise((resolve11, reject) => {
+    const useProcessGroup = options.killProcessGroup === true && process.platform !== "win32";
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: options.inheritedFileDescriptor === void 0 ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe", options.inheritedFileDescriptor],
+      detached: useProcessGroup,
+      windowsHide: true
+    });
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let outputExceeded = false;
+    let timedOut = false;
+    const terminate = () => {
+      if (useProcessGroup && child.pid !== void 0) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+          return;
+        } catch {
+        }
+      }
+      child.kill("SIGKILL");
+    };
+    const timeout = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
+      timedOut = true;
+      terminate();
+    }, options.timeoutMs);
+    const collect = (target, stream, chunk) => {
+      if (outputExceeded) return;
+      if (stream === "stdout") stdoutBytes += chunk.length;
+      else stderrBytes += chunk.length;
+      if (options.maxOutputBytes !== void 0 && (stdoutBytes > options.maxOutputBytes || stderrBytes > options.maxOutputBytes)) {
+        outputExceeded = true;
+        terminate();
+        return;
+      }
+      target.push(chunk);
+    };
+    child.stdout.on("data", (chunk) => collect(stdout, "stdout", chunk));
+    child.stderr.on("data", (chunk) => collect(stderr, "stderr", chunk));
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (timeout) clearTimeout(timeout);
+      const exitCode = code ?? 1;
+      const result = { stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr), exitCode };
+      if (timedOut) {
+        reject(new Error(`${command} exceeded the ${options.timeoutMs}ms execution timeout.`));
+        return;
+      }
+      if (outputExceeded) {
+        reject(new Error(`${command} exceeded the provider output limit.`));
+        return;
+      }
+      if (!(options.allowExitCodes ?? [0]).includes(exitCode)) {
+        const detail = options.includeFailureOutput === false ? "" : result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim();
+        reject(new Error(`${command} exited ${exitCode}${detail ? `: ${detail}` : ""}`));
+        return;
+      }
+      resolve11(result);
+    });
+    if (options.input !== void 0) child.stdin.end(options.input);
+    else child.stdin.end();
+  });
+}
+
+// src/mutation/session-ownership.ts
+var safeSingleLineSchema = z5.string().max(4096).refine(
+  (value) => !/[\r\n\u0000-\u001f\u007f]/u.test(value),
+  { message: "must be a single printable line" }
+);
+var opaqueRefSchema = z5.string().regex(/^[a-z][a-z0-9-]{0,63}:[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/);
+var graphNodeStatusSchema = z5.enum(["active", "waiting", "blocked", "quiet", "closed"]);
+var graphNodeSchema = z5.object({
+  id: safeSingleLineSchema.pipe(z5.string().min(1)),
+  agent: safeSingleLineSchema.pipe(z5.string().min(1)),
+  tmuxTarget: safeSingleLineSchema,
+  roleProfile: safeSingleLineSchema.optional().default(""),
+  title: safeSingleLineSchema.optional().default(""),
+  summary: safeSingleLineSchema.optional().default(""),
+  status: graphNodeStatusSchema,
+  domains: z5.array(safeSingleLineSchema).optional().default([]),
+  runtimeUuid: z5.string().uuid().nullable().optional().default(null),
+  refs: z5.array(opaqueRefSchema).optional().default([]),
+  createdAt: z5.string().datetime(),
+  lastSeenAt: z5.string().datetime().optional()
+}).passthrough();
+var sessionGraphSchema = z5.object({
+  schema: z5.literal("agent-mesh.session-graph.v1"),
+  generatedAt: z5.string().datetime(),
+  nodes: z5.array(graphNodeSchema)
+}).passthrough();
+var liveStatuses = /* @__PURE__ */ new Set(["active", "waiting", "blocked"]);
+var runtimeUuidSchema = z5.string().uuid();
+function agentMeshGraphPath() {
+  if (process.env.AGENT_MESH_GRAPH_PATH) return resolve3(process.env.AGENT_MESH_GRAPH_PATH);
+  const stateRoot = process.env.XDG_STATE_HOME ? resolve3(process.env.XDG_STATE_HOME) : join2(homedir2(), ".local", "state");
+  return join2(stateRoot, "agent-mesh", "graph", "graph.json");
+}
+function agentwheelResourceRef(gitCommonDir, repositoryRelativePath) {
+  const commonDir = resolve3(gitCommonDir);
+  const normalizedPath = normalizeRepositoryRelativePath(repositoryRelativePath);
+  const digest = createHash2("sha256").update(commonDir).update("\0").update(normalizedPath).digest("hex");
+  return `agentwheel-resource:${digest}`;
+}
+async function resourceRefsForRepositoryPaths(repositoryRoot, paths) {
+  const result = await runProcess("git", [
+    "-C",
+    repositoryRoot,
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-common-dir"
+  ]);
+  const gitCommonDir = result.stdout.toString("utf8").trim();
+  if (!gitCommonDir || !isAbsolute3(gitCommonDir)) {
+    throw new Error("Git did not return an absolute common directory for ownership diagnostics.");
+  }
+  return new Map([...paths].map((path) => [path, agentwheelResourceRef(gitCommonDir, path)]));
+}
+async function lookupResourceOwners(refs) {
+  const requested = [...new Set(refs)];
+  const graph = await readSessionGraph();
+  if (!graph.ok) {
+    return new Map(requested.map((ref) => [ref, { kind: "unknown", reason: graph.reason }]));
+  }
+  return new Map(requested.map((ref) => [ref, ownershipForNodes(
+    graph.nodes.filter((node) => node.refs.includes(ref))
+  )]));
+}
+async function lookupRuntimeOwner(runtimeUuid) {
+  const graph = await readSessionGraph();
+  if (!graph.ok) return { kind: "unknown", reason: graph.reason };
+  const normalized = runtimeUuid.toLowerCase();
+  return ownershipForNodes(graph.nodes.filter((node) => node.runtimeUuid?.toLowerCase() === normalized));
+}
+async function describeDirtyPathOwnershipByPath(repositoryRoot, paths) {
+  let refs;
+  try {
+    refs = await resourceRefsForRepositoryPaths(repositoryRoot, paths);
+  } catch {
+    return new Map(paths.map((path) => [path, `${path}: ${unknownNextAction("resource identity could not be computed")}`]));
+  }
+  const ownership = await lookupResourceOwners(refs.values());
+  return new Map(paths.map((path) => {
+    const match = ownership.get(refs.get(path));
+    if (match?.kind === "unique") {
+      return [path, `${path}: belongs to ${describeSession(match.owner)}. Wait for that session's handoff or ask the rollout coordinator before retrying.`];
+    }
+    if (match?.kind === "ambiguous") {
+      return [path, `${path}: owner unknown because multiple live sessions claim this resource. Candidates: ${match.candidates.map(describeSession).join("; ")}. Ask the rollout coordinator to disambiguate the candidates before retrying; do not remove the safety block.`];
+    }
+    return [path, `${path}: ${unknownNextAction(reasonText(match?.kind === "unknown" ? match.reason : "no-live-match"))}`];
+  }));
+}
+async function describeMutationLockOwner(owner) {
+  if (!owner) {
+    return unknownNextAction("the lock owner metadata is missing or malformed");
+  }
+  const facts = [
+    owner.operationId ? `operation ${owner.operationId}` : void 0,
+    owner.pid !== void 0 ? `pid ${owner.pid}` : void 0,
+    owner.runtimeUuid ? `runtime UUID ${owner.runtimeUuid}` : void 0,
+    owner.createdAt ? `lock created at ${owner.createdAt}` : void 0
+  ].filter(Boolean).join(", ");
+  if (!owner.runtimeUuid) {
+    return `Lock owner facts: ${facts || "none"}. ${unknownNextAction("no runtime UUID was recorded")}`;
+  }
+  const match = await lookupRuntimeOwner(owner.runtimeUuid);
+  if (match.kind === "unique") {
+    return `Lock owner facts: ${facts}. Correlated to ${describeSession(match.owner)}. Wait for that session's handoff or ask the rollout coordinator before retrying.`;
+  }
+  if (match.kind === "ambiguous") {
+    return `Lock owner facts: ${facts}. Owner unknown because the runtime UUID matches multiple live sessions. Candidates: ${match.candidates.map(describeSession).join("; ")}. Ask the rollout coordinator to disambiguate before retrying; do not remove the lock.`;
+  }
+  return `Lock owner facts: ${facts}. ${unknownNextAction(reasonText(match.reason))}`;
+}
+function runtimeUuidForCurrentProcess() {
+  for (const name of ["AGENT_MESH_RUNTIME_UUID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "CLAUDE_CODE_SESSION_ID"]) {
+    const value = process.env[name]?.trim();
+    if (value && runtimeUuidSchema.safeParse(value).success) return value.toLowerCase();
+  }
+  return void 0;
+}
+function ownershipForNodes(nodes) {
+  const live = nodes.filter((node) => liveStatuses.has(node.status)).map(sessionFacts);
+  if (live.length === 1) return { kind: "unique", owner: live[0] };
+  if (live.length > 1) return { kind: "ambiguous", candidates: live.sort((a, b) => a.sessionId.localeCompare(b.sessionId)) };
+  if (nodes.length > 0) return { kind: "unknown", reason: "only-inactive-matches" };
+  return { kind: "unknown", reason: "no-live-match" };
+}
+async function readSessionGraph() {
+  let raw;
+  try {
+    raw = await readFile3(agentMeshGraphPath(), "utf8");
+  } catch (error) {
+    if (isMissing(error)) return { ok: false, reason: "missing-graph" };
+    return { ok: false, reason: "malformed-graph" };
+  }
+  try {
+    const graph = sessionGraphSchema.parse(JSON.parse(raw));
+    return { ok: true, nodes: graph.nodes };
+  } catch {
+    return { ok: false, reason: "malformed-graph" };
+  }
+}
+function sessionFacts(node) {
+  return {
+    nodeId: node.id,
+    sessionId: node.tmuxTarget || node.runtimeUuid || node.id,
+    agent: node.agent,
+    runtimeUuid: node.runtimeUuid,
+    status: node.status,
+    domains: [...node.domains],
+    createdAt: node.createdAt,
+    summary: node.summary,
+    title: node.title
+  };
+}
+function describeSession(owner) {
+  const context = owner.summary || owner.title || owner.domains.join(", ");
+  return `session ${owner.sessionId}, ${owner.status} since ${owner.createdAt}${context ? ` on ${context}` : ""}`;
+}
+function unknownNextAction(reason) {
+  return `Owner unknown because ${reason}. Inspect the Agent Mesh session graph or ask the rollout coordinator to identify or clear the owner before retrying; do not remove the safety block based on this diagnostic.`;
+}
+function reasonText(reason) {
+  switch (reason) {
+    case "missing-graph":
+      return "the Agent Mesh graph projection is missing";
+    case "malformed-graph":
+      return "the Agent Mesh graph projection is malformed";
+    case "only-inactive-matches":
+      return "only quiet or closed session claims were found";
+    case "no-live-match":
+      return "no live session claim matches this resource";
+  }
+}
+function normalizeRepositoryRelativePath(path) {
+  if (!path || isAbsolute3(path) || path.includes("\\") || path.includes("\0")) {
+    throw new Error("Ownership paths must be normalized repository-relative paths.");
+  }
+  const normalized = posix2.normalize(path);
+  if (normalized !== path || path.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error("Ownership paths must be normalized repository-relative paths.");
+  }
+  return normalized;
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/mutation/receipts.ts
+var preexistingPathSchema = z6.object({
+  path: z6.string().min(1).max(4096),
+  sha256: z6.string().regex(/^[a-f0-9]{64}$/).nullable()
 }).strict();
-var receiptStatusSchema = z5.enum([
+var receiptStatusSchema = z6.enum([
   "prepared",
   "handler-succeeded",
   "mutation-applied",
@@ -830,35 +1094,35 @@ var receiptStatusSchema = z5.enum([
   "postcheck-failed",
   "failed"
 ]);
-var runtimeJournalSchema = z5.object({
-  path: z5.string().min(1).max(4096),
-  status: z5.enum(["reserved", "pending", "resolving", "resolved"]),
-  transport: z5.enum(["local", "ssh"]),
-  transportDescription: z5.string().min(1).max(1024),
-  journalDigest: z5.string().regex(/^[a-f0-9]{64}$/)
+var runtimeJournalSchema = z6.object({
+  path: z6.string().min(1).max(4096),
+  status: z6.enum(["reserved", "pending", "resolving", "resolved"]),
+  transport: z6.enum(["local", "ssh"]),
+  transportDescription: z6.string().min(1).max(1024),
+  journalDigest: z6.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var mutationReceiptBaseSchema = z5.object({
-  version: z5.literal(1),
-  revision: z5.number().int().min(1),
-  receiptDigest: z5.string().regex(/^[a-f0-9]{64}$/),
+var mutationReceiptBaseSchema = z6.object({
+  version: z6.literal(1),
+  revision: z6.number().int().min(1),
+  receiptDigest: z6.string().regex(/^[a-f0-9]{64}$/),
   operationId: mutationOperationIdSchema,
-  commandName: z5.string().min(1).max(256),
-  reason: z5.string().min(1).max(4096),
-  noCommit: z5.boolean(),
-  workspaceRoot: z5.string().min(1),
-  repositoryRoot: z5.string().min(1).nullable(),
-  expectedHead: z5.string().min(1).max(256).nullable(),
-  expectedManifestDigest: z5.string().regex(/^[a-f0-9]{64}$/).nullable(),
-  revisionMode: z5.enum(["off", "commit-after-verify"]),
+  commandName: z6.string().min(1).max(256),
+  reason: z6.string().min(1).max(4096),
+  noCommit: z6.boolean(),
+  workspaceRoot: z6.string().min(1),
+  repositoryRoot: z6.string().min(1).nullable(),
+  expectedHead: z6.string().min(1).max(256).nullable(),
+  expectedManifestDigest: z6.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  revisionMode: z6.enum(["off", "commit-after-verify"]),
   provider: revisionProviderConfigSchema.nullable(),
-  preexistingPaths: z5.array(preexistingPathSchema),
-  paths: z5.array(revisionPathSchema),
-  runtimeJournals: z5.array(runtimeJournalSchema).default([]),
+  preexistingPaths: z6.array(preexistingPathSchema),
+  paths: z6.array(revisionPathSchema),
+  runtimeJournals: z6.array(runtimeJournalSchema).default([]),
   status: receiptStatusSchema,
-  createdAt: z5.string().datetime(),
-  updatedAt: z5.string().datetime(),
+  createdAt: z6.string().datetime(),
+  updatedAt: z6.string().datetime(),
   providerResponse: revisionProviderResultSchema.optional(),
-  error: z5.string().min(1).max(4096).optional()
+  error: z6.string().min(1).max(4096).optional()
 }).strict();
 var mutationReceiptSchema = mutationReceiptBaseSchema.superRefine((receipt, ctx) => {
   const expected = mutationReceiptDigest(receipt);
@@ -870,8 +1134,18 @@ var mutationReceiptSchema = mutationReceiptBaseSchema.superRefine((receipt, ctx)
     });
   }
 });
+var MutationLockContentionError = class extends Error {
+  constructor(lockPath, owner, diagnostic) {
+    super(`Another Agentwheel mutation owns the repository lock at ${lockPath}. ${diagnostic}`);
+    this.lockPath = lockPath;
+    this.owner = owner;
+    this.name = "MutationLockContentionError";
+  }
+  lockPath;
+  owner;
+};
 function mutationStateRoot() {
-  return resolve3(process.env.AGENTWHEEL_MUTATION_STATE_ROOT ?? join2(homedir2(), ".agentwheel", "mutations"));
+  return resolve4(process.env.AGENTWHEEL_MUTATION_STATE_ROOT ?? join3(homedir3(), ".agentwheel", "mutations"));
 }
 async function createMutationReceipt(receipt) {
   const path = receiptPath(receipt.operationId);
@@ -932,48 +1206,50 @@ async function readMutationReceipt(operationId) {
   const id = mutationOperationIdSchema.parse(operationId);
   const path = receiptPath(id);
   try {
-    return mutationReceiptSchema.parse(JSON.parse(await readFile3(path, "utf8")));
+    return mutationReceiptSchema.parse(JSON.parse(await readFile4(path, "utf8")));
   } catch (error) {
-    if (isMissing(error)) throw new Error(`Unknown mutation operation '${id}'.`);
+    if (isMissing2(error)) throw new Error(`Unknown mutation operation '${id}'.`);
     throw error;
   }
 }
 async function listMutationReceipts() {
-  const root = join2(mutationStateRoot(), "receipts");
+  const root = join3(mutationStateRoot(), "receipts");
   let names;
   try {
     names = await readdir2(root);
   } catch (error) {
-    if (isMissing(error)) return [];
+    if (isMissing2(error)) return [];
     throw error;
   }
   const receipts = [];
   for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
-    receipts.push(mutationReceiptSchema.parse(JSON.parse(await readFile3(join2(root, name), "utf8"))));
+    receipts.push(mutationReceiptSchema.parse(JSON.parse(await readFile4(join3(root, name), "utf8"))));
   }
   return receipts.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
 }
 async function acquireMutationLock(repositoryRoot, operationId) {
   const root = mutationStateRoot();
-  const digest = createHash2("sha256").update(resolve3(repositoryRoot)).digest("hex");
-  const lockPath = join2(root, "locks", `${digest}.lock`);
-  await mkdir2(join2(root, "locks"), { recursive: true, mode: 448 });
-  await chmod(join2(root, "locks"), 448);
+  const digest = createHash3("sha256").update(resolve4(repositoryRoot)).digest("hex");
+  const lockPath = join3(root, "locks", `${digest}.lock`);
+  await mkdir2(join3(root, "locks"), { recursive: true, mode: 448 });
+  await chmod(join3(root, "locks"), 448);
   try {
     await mkdir2(lockPath, { mode: 448 });
   } catch (error) {
     if (!isAlreadyExists(error)) throw error;
     if (!await reapStaleLock(lockPath)) {
-      throw new Error(`Another Agentwheel mutation owns the repository lock at ${lockPath}.`);
+      const owner = await readMutationLockOwner(lockPath);
+      throw new MutationLockContentionError(lockPath, owner, await describeMutationLockOwner(owner));
     }
     await mkdir2(lockPath, { mode: 448 });
   }
-  const ownerPath = join2(lockPath, "owner.json");
+  const ownerPath = join3(lockPath, "owner.json");
   await writeSecureJson(ownerPath, {
     version: 1,
     operationId,
     pid: process.pid,
-    repositoryRoot: resolve3(repositoryRoot),
+    runtimeUuid: runtimeUuidForCurrentProcess(),
+    repositoryRoot: resolve4(repositoryRoot),
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   let released = false;
@@ -986,14 +1262,33 @@ async function acquireMutationLock(repositoryRoot, operationId) {
     }
   };
 }
+async function readMutationLockOwner(lockPath) {
+  try {
+    const parsed = JSON.parse(await readFile4(join3(lockPath, "owner.json"), "utf8"));
+    const owner = {};
+    if (typeof parsed.operationId === "string" && /^[a-z0-9][a-z0-9_-]{0,62}$/i.test(parsed.operationId)) {
+      owner.operationId = parsed.operationId;
+    }
+    if (typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0) owner.pid = parsed.pid;
+    if (typeof parsed.runtimeUuid === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(parsed.runtimeUuid)) {
+      owner.runtimeUuid = parsed.runtimeUuid.toLowerCase();
+    }
+    if (typeof parsed.createdAt === "string" && !Number.isNaN(Date.parse(parsed.createdAt))) {
+      owner.createdAt = parsed.createdAt;
+    }
+    return Object.keys(owner).length > 0 ? owner : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function receiptPath(operationId) {
-  return join2(mutationStateRoot(), "receipts", `${mutationOperationIdSchema.parse(operationId)}.json`);
+  return join3(mutationStateRoot(), "receipts", `${mutationOperationIdSchema.parse(operationId)}.json`);
 }
 async function ensureStateDirectory() {
   const root = mutationStateRoot();
-  await mkdir2(join2(root, "receipts"), { recursive: true, mode: 448 });
+  await mkdir2(join3(root, "receipts"), { recursive: true, mode: 448 });
   await chmod(root, 448);
-  await chmod(join2(root, "receipts"), 448);
+  await chmod(join3(root, "receipts"), 448);
 }
 async function writeReceipt(path, receipt) {
   await writeSecureJson(path, receipt);
@@ -1004,7 +1299,7 @@ function sealMutationReceipt(value) {
 }
 function mutationReceiptDigest(receipt) {
   const { receiptDigest: _ignored, ...payload } = receipt;
-  return createHash2("sha256").update(canonicalJson2(payload)).digest("hex");
+  return createHash3("sha256").update(canonicalJson2(payload)).digest("hex");
 }
 function canonicalJson2(value) {
   if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson2(entry === void 0 ? null : entry)).join(",")}]`;
@@ -1057,7 +1352,7 @@ async function acquireReceiptUpdateLock(path, operationId) {
 }
 async function reapStaleReceiptUpdateLock(lockPath) {
   try {
-    const owner = JSON.parse(await readFile3(lockPath, "utf8"));
+    const owner = JSON.parse(await readFile4(lockPath, "utf8"));
     if (typeof owner.pid !== "number" || processIsAlive(owner.pid)) return false;
   } catch {
     return false;
@@ -1096,16 +1391,16 @@ async function fsyncDirectory(path) {
 }
 async function fileExists(path) {
   try {
-    await readFile3(path);
+    await readFile4(path);
     return true;
   } catch (error) {
-    if (isMissing(error)) return false;
+    if (isMissing2(error)) return false;
     throw error;
   }
 }
 async function reapStaleLock(lockPath) {
   try {
-    const owner = JSON.parse(await readFile3(join2(lockPath, "owner.json"), "utf8"));
+    const owner = JSON.parse(await readFile4(join3(lockPath, "owner.json"), "utf8"));
     if (typeof owner.pid !== "number" || processIsAlive(owner.pid)) return false;
   } catch (error) {
     return false;
@@ -1130,19 +1425,19 @@ function processIsAlive(pid) {
 function isAlreadyExists(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
 }
-function isMissing(error) {
+function isMissing2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/mutation/declarations.ts
 var active;
-function beginMutationPathDeclarations(repositoryRoot, operationIdInput, blockedPaths = []) {
+function beginMutationPathDeclarations(repositoryRoot, operationIdInput, blockedPaths = [], blockedPathDescriptions = /* @__PURE__ */ new Map()) {
   if (active) throw new Error("A mutation path declaration scope is already active.");
   const operationId = mutationOperationIdSchema.parse(operationIdInput);
-  const root = join3(mutationStateRoot(), "declarations");
+  const root = join4(mutationStateRoot(), "declarations");
   mkdirSync(root, { recursive: true, mode: 448 });
   chmodSync(root, 448);
-  const journalPath = join3(root, `${operationId}.jsonl`);
+  const journalPath = join4(root, `${operationId}.jsonl`);
   const journal = openSync(journalPath, "wx", 384);
   try {
     fsyncSync(journal);
@@ -1156,38 +1451,41 @@ function beginMutationPathDeclarations(repositoryRoot, operationIdInput, blocked
     closeSync(directory);
   }
   active = {
-    repositoryRoot: resolve4(repositoryRoot),
+    repositoryRoot: resolve5(repositoryRoot),
     operationId,
     journalPath,
     paths: /* @__PURE__ */ new Set(),
-    blockedPaths: new Set(blockedPaths)
+    blockedPaths: new Set(blockedPaths),
+    blockedPathDescriptions
   };
 }
 function resumeMutationPathDeclarations(repositoryRoot, operationIdInput, blockedPaths = []) {
   if (active) throw new Error("A mutation path declaration scope is already active.");
   const operationId = mutationOperationIdSchema.parse(operationIdInput);
-  const journalPath = join3(mutationStateRoot(), "declarations", `${operationId}.jsonl`);
+  const journalPath = join4(mutationStateRoot(), "declarations", `${operationId}.jsonl`);
   const paths = readMutationPathDeclarations(operationId);
   if (paths.length === 0) {
     const journal = openSync(journalPath, "r");
     closeSync(journal);
   }
   active = {
-    repositoryRoot: resolve4(repositoryRoot),
+    repositoryRoot: resolve5(repositoryRoot),
     operationId,
     journalPath,
     paths: new Set(paths),
-    blockedPaths: new Set(blockedPaths)
+    blockedPaths: new Set(blockedPaths),
+    blockedPathDescriptions: /* @__PURE__ */ new Map()
   };
 }
 function declareMutationPath(path) {
   if (!active) return;
-  const absolute = isAbsolute3(path) ? resolve4(path) : resolve4(process.cwd(), path);
+  const absolute = isAbsolute4(path) ? resolve5(path) : resolve5(process.cwd(), path);
   const relativePath = relative(active.repositoryRoot, absolute);
-  if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute3(relativePath)) return;
+  if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute4(relativePath)) return;
   const normalized = relativePath.split(sep).join("/");
   if (active.blockedPaths.has(normalized)) {
-    throw new Error(`Mutation intended path is already dirty and cannot be claimed: ${normalized}.`);
+    const description = active.blockedPathDescriptions.get(normalized);
+    throw new Error(`Mutation intended path is already dirty and cannot be claimed: ${normalized}.${description ? ` ${description}` : ""}`);
   }
   if (active.paths.has(normalized)) return;
   active.paths.add(normalized);
@@ -1208,7 +1506,7 @@ function endMutationPathDeclarations() {
 }
 function readMutationPathDeclarations(operationIdInput) {
   const operationId = mutationOperationIdSchema.parse(operationIdInput);
-  const path = join3(mutationStateRoot(), "declarations", `${operationId}.jsonl`);
+  const path = join4(mutationStateRoot(), "declarations", `${operationId}.jsonl`);
   let content;
   try {
     content = readFileSync(path, "utf8");
@@ -1228,15 +1526,15 @@ function readMutationPathDeclarations(operationIdInput) {
 }
 
 // src/model/workspace.ts
-var artifactSelectorListSchema = z6.array(z6.string().min(1));
+var artifactSelectorListSchema = z7.array(z7.string().min(1));
 var CURRENT_WORKSPACE_SCHEMA_VERSION = 4;
-var workspaceSelectionImportSchema = z6.object({
-  export: z6.string().min(1),
+var workspaceSelectionImportSchema = z7.object({
+  export: z7.string().min(1),
   add: artifactSelectorListSchema.optional(),
   exclude: artifactSelectorListSchema.optional()
 }).strict();
-var workspaceSelectionExportSchema = z6.object({
-  extends: z6.string().min(1).optional(),
+var workspaceSelectionExportSchema = z7.object({
+  extends: z7.string().min(1).optional(),
   select: artifactSelectorListSchema.optional(),
   add: artifactSelectorListSchema.optional(),
   exclude: artifactSelectorListSchema.optional()
@@ -1256,29 +1554,29 @@ var workspaceSelectionExportSchema = z6.object({
     });
   }
 });
-var workspaceExportsSchema = z6.object({
-  selections: z6.record(z6.string().min(1), workspaceSelectionExportSchema).default({})
+var workspaceExportsSchema = z7.object({
+  selections: z7.record(z7.string().min(1), workspaceSelectionExportSchema).default({})
 }).strict();
-var workspacePackageBaseSchema = z6.object({
-  name: z6.string().min(1),
-  source: z6.string().min(1),
-  driver: z6.enum(["local", "git", "skillkit", "vercel-skills", "mcp-registry", "clawhub"]).default("local"),
-  adapter: z6.string().min(1).default("openclaw"),
-  adapterConfig: z6.string().min(1).optional(),
-  adapterModule: z6.string().min(1).optional(),
-  adapterCodeHash: z6.string().min(16).optional(),
+var workspacePackageBaseSchema = z7.object({
+  name: z7.string().min(1),
+  source: z7.string().min(1),
+  driver: z7.enum(["local", "git", "skillkit", "vercel-skills", "mcp-registry", "clawhub"]).default("local"),
+  adapter: z7.string().min(1).default("openclaw"),
+  adapterConfig: z7.string().min(1).optional(),
+  adapterModule: z7.string().min(1).optional(),
+  adapterCodeHash: z7.string().min(16).optional(),
   installationType: installationTypeSchema.optional(),
-  mode: z6.enum(["pinned", "tracking"]).default("pinned"),
-  version: z6.string().min(1).refine(isSupportedVersionRange, {
+  mode: z7.enum(["pinned", "tracking"]).default("pinned"),
+  version: z7.string().min(1).refine(isSupportedVersionRange, {
     message: "Version policy must be an exact semver, ~range, ^range, comparator range, or *"
   }).optional(),
-  requestedRef: z6.string().min(1).optional(),
-  select: z6.array(z6.string().min(1)).optional(),
-  skills: z6.array(z6.string().min(1)).optional(),
-  withSuggestions: z6.boolean().optional(),
-  suggestions: z6.array(z6.string().min(1)).optional(),
-  aliases: z6.record(z6.string(), z6.string().min(1)).optional(),
-  overrides: z6.array(z6.string().min(1)).optional()
+  requestedRef: z7.string().min(1).optional(),
+  select: z7.array(z7.string().min(1)).optional(),
+  skills: z7.array(z7.string().min(1)).optional(),
+  withSuggestions: z7.boolean().optional(),
+  suggestions: z7.array(z7.string().min(1)).optional(),
+  aliases: z7.record(z7.string(), z7.string().min(1)).optional(),
+  overrides: z7.array(z7.string().min(1)).optional()
 });
 var workspacePackageSchema = workspacePackageBaseSchema.extend({
   selection: workspaceSelectionImportSchema.optional()
@@ -1292,43 +1590,43 @@ var workspacePackageSchema = workspacePackageBaseSchema.extend({
   }
 });
 var workspacePackageV1Schema = workspacePackageBaseSchema.extend({
-  selection: z6.never().optional()
+  selection: z7.never().optional()
 });
-var commandSchema = z6.array(z6.string().min(1)).min(1);
-var commandListSchema = z6.array(commandSchema).min(1).optional();
-var installStateKeySchema = z6.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i);
-var fleetIdSchema = z6.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i);
-var registeredFleetSchema = z6.object({
-  root: z6.string().min(1),
-  requiredPackages: z6.array(z6.string().min(1)).min(1)
+var commandSchema = z7.array(z7.string().min(1)).min(1);
+var commandListSchema = z7.array(commandSchema).min(1).optional();
+var installStateKeySchema = z7.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i);
+var fleetIdSchema = z7.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i);
+var registeredFleetSchema = z7.object({
+  root: z7.string().min(1),
+  requiredPackages: z7.array(z7.string().min(1)).min(1)
 }).strict().superRefine((fleet, ctx) => {
   if (new Set(fleet.requiredPackages).size !== fleet.requiredPackages.length) {
     ctx.addIssue({ code: "custom", path: ["requiredPackages"], message: "Required fleet packages must be unique." });
   }
 });
-var workspaceProfileRuntimeSchema = z6.object({
-  agent: z6.string().min(1).optional(),
-  adapter: z6.string().min(1).default("openclaw"),
-  adapterConfig: z6.string().min(1).optional(),
-  adapterModule: z6.string().min(1).optional(),
+var workspaceProfileRuntimeSchema = z7.object({
+  agent: z7.string().min(1).optional(),
+  adapter: z7.string().min(1).default("openclaw"),
+  adapterConfig: z7.string().min(1).optional(),
+  adapterModule: z7.string().min(1).optional(),
   installationType: installationTypeSchema.optional(),
   stateKey: installStateKeySchema.optional(),
-  targetRoot: z6.string().min(1).optional(),
-  executePlugins: z6.boolean().optional(),
-  reloadRuntimes: z6.boolean().optional(),
+  targetRoot: z7.string().min(1).optional(),
+  executePlugins: z7.boolean().optional(),
+  reloadRuntimes: z7.boolean().optional(),
   reloadCommands: commandListSchema
 });
-var workspaceProfileMemberSchema = z6.object({
-  id: z6.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i),
-  workspace: z6.string().min(1),
-  profile: z6.string().min(1),
+var workspaceProfileMemberSchema = z7.object({
+  id: z7.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i),
+  workspace: z7.string().min(1),
+  profile: z7.string().min(1),
   fleet: fleetIdSchema.optional(),
-  transport: z6.enum(["local", "ssh"]).default("local"),
-  host: z6.string().min(1).optional(),
-  user: z6.string().min(1).optional(),
-  port: z6.number().int().positive().optional(),
-  identityFile: z6.string().min(1).optional(),
-  refreshTtlSeconds: z6.number().int().positive().optional()
+  transport: z7.enum(["local", "ssh"]).default("local"),
+  host: z7.string().min(1).optional(),
+  user: z7.string().min(1).optional(),
+  port: z7.number().int().positive().optional(),
+  identityFile: z7.string().min(1).optional(),
+  refreshTtlSeconds: z7.number().int().positive().optional()
 }).strict().superRefine((member, ctx) => {
   if (member.transport === "ssh" && !member.host) {
     ctx.addIssue({ code: "custom", path: ["host"], message: "SSH profile members require host" });
@@ -1337,14 +1635,14 @@ var workspaceProfileMemberSchema = z6.object({
     ctx.addIssue({ code: "custom", path: ["workspace"], message: "SSH profile member workspaces must be absolute" });
   }
 });
-var workspaceLeafProfileSchema = z6.object({
-  runtimes: z6.array(workspaceProfileRuntimeSchema).min(1),
-  members: z6.never().optional()
+var workspaceLeafProfileSchema = z7.object({
+  runtimes: z7.array(workspaceProfileRuntimeSchema).min(1),
+  members: z7.never().optional()
 }).strict();
-var workspaceCompositeProfileSchema = z6.object({
-  members: z6.array(workspaceProfileMemberSchema).min(1),
-  runtimes: z6.never().optional(),
-  refreshTtlSeconds: z6.number().int().positive().default(86400)
+var workspaceCompositeProfileSchema = z7.object({
+  members: z7.array(workspaceProfileMemberSchema).min(1),
+  runtimes: z7.never().optional(),
+  refreshTtlSeconds: z7.number().int().positive().default(86400)
 }).strict().superRefine((profile, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, member] of profile.members.entries()) {
@@ -1354,32 +1652,32 @@ var workspaceCompositeProfileSchema = z6.object({
     seen.add(member.id);
   }
 });
-var workspaceProfileSchema = z6.union([
+var workspaceProfileSchema = z7.union([
   workspaceLeafProfileSchema,
   workspaceCompositeProfileSchema
 ]);
-var workspaceRegistrySchema = z6.object({
-  sources: z6.array(z6.string().min(1)).optional(),
-  ttlSeconds: z6.number().int().positive().optional()
+var workspaceRegistrySchema = z7.object({
+  sources: z7.array(z7.string().min(1)).optional(),
+  ttlSeconds: z7.number().int().positive().optional()
 }).default({});
-var workspaceTrustSchema = z6.object({
-  allow: z6.array(z6.string().min(1)).optional(),
-  acceptedSources: z6.array(z6.string().min(1)).optional(),
-  denyArtifactTypes: z6.array(artifactTypeSchema).optional(),
-  requireReviewForTransitive: z6.boolean().optional()
+var workspaceTrustSchema = z7.object({
+  allow: z7.array(z7.string().min(1)).optional(),
+  acceptedSources: z7.array(z7.string().min(1)).optional(),
+  denyArtifactTypes: z7.array(artifactTypeSchema).optional(),
+  requireReviewForTransitive: z7.boolean().optional()
 }).default({});
-var workspaceAgentSchema = z6.object({
-  adapter: z6.string().min(1),
-  adapterConfig: z6.string().min(1).optional(),
-  adapterModule: z6.string().min(1).optional(),
-  root: z6.string().min(1),
+var workspaceAgentSchema = z7.object({
+  adapter: z7.string().min(1),
+  adapterConfig: z7.string().min(1).optional(),
+  adapterModule: z7.string().min(1).optional(),
+  root: z7.string().min(1),
   installationType: installationTypeSchema.optional(),
   stateKey: installStateKeySchema.optional(),
-  transport: z6.enum(["local", "ssh"]).default("local"),
-  host: z6.string().min(1).optional(),
-  user: z6.string().min(1).optional(),
-  port: z6.number().int().positive().optional(),
-  identityFile: z6.string().min(1).optional(),
+  transport: z7.enum(["local", "ssh"]).default("local"),
+  host: z7.string().min(1).optional(),
+  user: z7.string().min(1).optional(),
+  port: z7.number().int().positive().optional(),
+  identityFile: z7.string().min(1).optional(),
   reloadCommands: commandListSchema
 }).superRefine((agent, ctx) => {
   if (agent.transport !== "ssh") return;
@@ -1391,39 +1689,39 @@ var workspaceAgentSchema = z6.object({
     });
   }
 });
-var workspaceConfigBaseSchema = z6.object({
-  bootstrapSkills: z6.boolean().optional(),
+var workspaceConfigBaseSchema = z7.object({
+  bootstrapSkills: z7.boolean().optional(),
   registry: workspaceRegistrySchema,
   trust: workspaceTrustSchema,
-  profiles: z6.record(z6.string(), workspaceProfileSchema).default({}),
-  agents: z6.record(z6.string(), workspaceAgentSchema).default({})
+  profiles: z7.record(z7.string(), workspaceProfileSchema).default({}),
+  agents: z7.record(z7.string(), workspaceAgentSchema).default({})
 });
 var workspaceConfigV1Schema = workspaceConfigBaseSchema.extend({
-  schemaVersion: z6.literal(1),
-  packages: z6.array(workspacePackageV1Schema).default([]),
-  exports: z6.never().optional()
+  schemaVersion: z7.literal(1),
+  packages: z7.array(workspacePackageV1Schema).default([]),
+  exports: z7.never().optional()
 }).strict();
 var workspaceConfigV2Schema = workspaceConfigBaseSchema.extend({
-  schemaVersion: z6.literal(2),
-  packages: z6.array(workspacePackageSchema).default([]),
+  schemaVersion: z7.literal(2),
+  packages: z7.array(workspacePackageSchema).default([]),
   exports: workspaceExportsSchema.default({ selections: {} })
 }).strict();
 var workspaceConfigV3Schema = workspaceConfigBaseSchema.extend({
-  schemaVersion: z6.literal(3),
-  packages: z6.array(workspacePackageSchema).default([]),
+  schemaVersion: z7.literal(3),
+  packages: z7.array(workspacePackageSchema).default([]),
   exports: workspaceExportsSchema.default({ selections: {} }),
   fleetId: fleetIdSchema.optional(),
-  fleets: z6.record(fleetIdSchema, registeredFleetSchema).default({})
+  fleets: z7.record(fleetIdSchema, registeredFleetSchema).default({})
 }).strict();
 var workspaceConfigV4Schema = workspaceConfigBaseSchema.extend({
-  schemaVersion: z6.literal(CURRENT_WORKSPACE_SCHEMA_VERSION),
-  packages: z6.array(workspacePackageSchema).default([]),
+  schemaVersion: z7.literal(CURRENT_WORKSPACE_SCHEMA_VERSION),
+  packages: z7.array(workspacePackageSchema).default([]),
   exports: workspaceExportsSchema.default({ selections: {} }),
   fleetId: fleetIdSchema.optional(),
-  fleets: z6.record(fleetIdSchema, registeredFleetSchema).default({}),
+  fleets: z7.record(fleetIdSchema, registeredFleetSchema).default({}),
   mutationPolicy: mutationPolicySchema.optional()
 }).strict();
-var workspaceConfigSchema = z6.discriminatedUnion("schemaVersion", [
+var workspaceConfigSchema = z7.discriminatedUnion("schemaVersion", [
   workspaceConfigV1Schema,
   workspaceConfigV2Schema,
   workspaceConfigV3Schema,
@@ -1433,12 +1731,12 @@ function supportsFleetConfig(config) {
   return config.schemaVersion === 3 || config.schemaVersion === 4;
 }
 function workspaceConfigPath(workspaceRoot) {
-  return join4(workspaceRoot, ".agentwheel", "config.json");
+  return join5(workspaceRoot, ".agentwheel", "config.json");
 }
 async function readWorkspaceConfig(workspaceRoot) {
   const path = workspaceConfigPath(workspaceRoot);
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile4(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile5(path, "utf8")));
 }
 async function writeWorkspaceConfig(workspaceRoot, config) {
   const path = workspaceConfigPath(workspaceRoot);
@@ -1452,20 +1750,20 @@ function upsertPackage(config, entry) {
   packages.sort((a, b) => a.name.localeCompare(b.name));
   return workspaceConfigSchema.parse({ ...parsed, packages });
 }
-function globalWorkspaceConfigPath(globalRoot = homedir3()) {
-  return join4(globalRoot, ".agentwheel", "config.json");
+function globalWorkspaceConfigPath(globalRoot = homedir4()) {
+  return join5(globalRoot, ".agentwheel", "config.json");
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current = resolve5(start);
+  let current = resolve6(start);
   while (true) {
     if (await pathExists(workspaceConfigPath(current))) return current;
     const parent = dirname4(current);
-    if (parent === current) return resolve5(start);
+    if (parent === current) return resolve6(start);
     current = parent;
   }
 }
 async function findExistingWorkspaceRoot(start = process.cwd()) {
-  let current = resolve5(start);
+  let current = resolve6(start);
   while (true) {
     if (await pathExists(workspaceConfigPath(current))) return current;
     const parent = dirname4(current);
@@ -1500,9 +1798,9 @@ function mergeWorkspaceConfig(global, project) {
   });
 }
 function resolveConfigPath(path, baseRoot) {
-  if (path.startsWith("~/")) return resolve5(homedir3(), path.slice(2));
-  if (path === "~") return homedir3();
-  return path.startsWith("/") ? resolve5(path) : resolve5(baseRoot, path);
+  if (path.startsWith("~/")) return resolve6(homedir4(), path.slice(2));
+  if (path === "~") return homedir4();
+  return path.startsWith("/") ? resolve6(path) : resolve6(baseRoot, path);
 }
 function emptyWorkspaceConfig() {
   return { schemaVersion: 1, packages: [], registry: {}, trust: {}, profiles: {}, agents: {} };
@@ -1512,7 +1810,7 @@ function isCompositeWorkspaceProfile(profile) {
 }
 async function readConfigPath(path) {
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile4(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile5(path, "utf8")));
 }
 function mergeWorkspaceTrust(global, project) {
   return {
@@ -1527,87 +1825,15 @@ function sortedUnique(values) {
 }
 
 // src/mutation/providers.ts
-import { createHash as createHash4 } from "crypto";
-import { chmod as chmod2, mkdtemp, open as open2, readFile as readFile6, rename as rename3, rm as rm3, rmdir, stat, writeFile as writeFile2 } from "fs/promises";
+import { createHash as createHash5 } from "crypto";
+import { chmod as chmod2, mkdtemp, open as open2, readFile as readFile7, rename as rename3, rm as rm3, rmdir, stat, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import { isAbsolute as isAbsolute4, join as join5, resolve as resolve7 } from "path";
-
-// src/mutation/repository.ts
-import { createHash as createHash3 } from "crypto";
-import { lstat, readFile as readFile5, readlink, readdir as readdir3 } from "fs/promises";
-import { posix as posix2, relative as relative2, resolve as resolve6, sep as sep2 } from "path";
-
-// src/mutation/process.ts
-import { spawn as spawn2 } from "child_process";
-async function runProcess(command, args, options = {}) {
-  return new Promise((resolve10, reject) => {
-    const useProcessGroup = options.killProcessGroup === true && process.platform !== "win32";
-    const child = spawn2(command, args, {
-      cwd: options.cwd,
-      env: options.env,
-      stdio: options.inheritedFileDescriptor === void 0 ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe", options.inheritedFileDescriptor],
-      detached: useProcessGroup,
-      windowsHide: true
-    });
-    const stdout = [];
-    const stderr = [];
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-    let outputExceeded = false;
-    let timedOut = false;
-    const terminate = () => {
-      if (useProcessGroup && child.pid !== void 0) {
-        try {
-          process.kill(-child.pid, "SIGKILL");
-          return;
-        } catch {
-        }
-      }
-      child.kill("SIGKILL");
-    };
-    const timeout = options.timeoutMs === void 0 ? void 0 : setTimeout(() => {
-      timedOut = true;
-      terminate();
-    }, options.timeoutMs);
-    const collect = (target, stream, chunk) => {
-      if (outputExceeded) return;
-      if (stream === "stdout") stdoutBytes += chunk.length;
-      else stderrBytes += chunk.length;
-      if (options.maxOutputBytes !== void 0 && (stdoutBytes > options.maxOutputBytes || stderrBytes > options.maxOutputBytes)) {
-        outputExceeded = true;
-        terminate();
-        return;
-      }
-      target.push(chunk);
-    };
-    child.stdout.on("data", (chunk) => collect(stdout, "stdout", chunk));
-    child.stderr.on("data", (chunk) => collect(stderr, "stderr", chunk));
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (timeout) clearTimeout(timeout);
-      const exitCode = code ?? 1;
-      const result = { stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr), exitCode };
-      if (timedOut) {
-        reject(new Error(`${command} exceeded the ${options.timeoutMs}ms execution timeout.`));
-        return;
-      }
-      if (outputExceeded) {
-        reject(new Error(`${command} exceeded the provider output limit.`));
-        return;
-      }
-      if (!(options.allowExitCodes ?? [0]).includes(exitCode)) {
-        const detail = options.includeFailureOutput === false ? "" : result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim();
-        reject(new Error(`${command} exited ${exitCode}${detail ? `: ${detail}` : ""}`));
-        return;
-      }
-      resolve10(result);
-    });
-    if (options.input !== void 0) child.stdin.end(options.input);
-    else child.stdin.end();
-  });
-}
+import { isAbsolute as isAbsolute5, join as join6, resolve as resolve8 } from "path";
 
 // src/mutation/repository.ts
+import { createHash as createHash4 } from "crypto";
+import { lstat, readFile as readFile6, readlink, readdir as readdir3 } from "fs/promises";
+import { posix as posix3, relative as relative2, resolve as resolve7, sep as sep2 } from "path";
 async function discoverGitRepository(start) {
   const probe = await runProcess("git", ["-C", start, "rev-parse", "--show-toplevel"], { allowExitCodes: [0, 128] });
   if (probe.exitCode !== 0) return void 0;
@@ -1630,7 +1856,7 @@ async function assertGitPreflight(repository) {
     if (result.exitCode === 0) throw new Error(`Revisioning refuses an in-progress Git operation (${marker}) in ${gitDir}.`);
   }
   for (const marker of ["rebase-merge", "rebase-apply"]) {
-    if (await exists(resolve6(gitDir, marker))) throw new Error(`Revisioning refuses an in-progress Git operation (${marker}) in ${gitDir}.`);
+    if (await exists(resolve7(gitDir, marker))) throw new Error(`Revisioning refuses an in-progress Git operation (${marker}) in ${gitDir}.`);
   }
 }
 async function snapshotRepository(repositoryRoot) {
@@ -1695,29 +1921,29 @@ async function hashHeadPath(repositoryRoot, head, path) {
   return sha256(result.stdout);
 }
 async function hashWorkingPath(repositoryRoot, path) {
-  const absolute = resolve6(repositoryRoot, ...path.split("/"));
+  const absolute = resolve7(repositoryRoot, ...path.split("/"));
   let stats;
   try {
     stats = await lstat(absolute);
   } catch (error) {
-    if (isMissing2(error)) return null;
+    if (isMissing3(error)) return null;
     throw error;
   }
   if (stats.isSymbolicLink()) return sha256(Buffer.from(await readlink(absolute), "utf8"));
-  if (stats.isFile()) return sha256(await readFile5(absolute));
+  if (stats.isFile()) return sha256(await readFile6(absolute));
   if (stats.isDirectory()) return hashDirectory(absolute);
   throw new Error(`Unsupported repository path kind: ${path}`);
 }
 async function hashDirectory(root) {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   async function walk(dir) {
     for (const entry of (await readdir3(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
       if (entry.name === ".git" || entry.name === "node_modules") continue;
-      const absolute = resolve6(dir, entry.name);
+      const absolute = resolve7(dir, entry.name);
       const relativePath = normalizeRepoPath(relative2(root, absolute));
       if (entry.isDirectory()) await walk(absolute);
       else if (entry.isSymbolicLink()) hash.update(relativePath).update("\0").update(await readlink(absolute)).update("\0");
-      else if (entry.isFile()) hash.update(relativePath).update("\0").update(await readFile5(absolute)).update("\0");
+      else if (entry.isFile()) hash.update(relativePath).update("\0").update(await readFile6(absolute)).update("\0");
     }
   }
   await walk(root);
@@ -1727,12 +1953,12 @@ function splitNull(value) {
   return value.toString("utf8").split("\0").filter(Boolean);
 }
 function normalizeRepoPath(path) {
-  return sep2 === "/" ? path : path.split(sep2).join(posix2.sep);
+  return sep2 === "/" ? path : path.split(sep2).join(posix3.sep);
 }
 function sha256(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
-function isMissing2(error) {
+function isMissing3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 async function exists(path) {
@@ -1740,7 +1966,7 @@ async function exists(path) {
     await lstat(path);
     return true;
   } catch (error) {
-    if (isMissing2(error)) return false;
+    if (isMissing3(error)) return false;
     throw error;
   }
 }
@@ -1845,7 +2071,7 @@ async function readVerifiedExecutable(executable, expectedSha256) {
     const info = await handle.stat();
     if (!info.isFile()) throw new Error(`Revision provider executable must be a regular file: ${executable}.`);
     const bytes = await handle.readFile();
-    const actualSha256 = createHash4("sha256").update(bytes).digest("hex");
+    const actualSha256 = createHash5("sha256").update(bytes).digest("hex");
     if (actualSha256 !== expectedSha256) {
       throw new Error(
         `Revision provider executable hash mismatch for ${executable}: expected ${expectedSha256}, found ${actualSha256}.`
@@ -1862,8 +2088,8 @@ async function openImmutableExecutableSnapshot(bytes) {
       `Command revision providers require an unlinked immutable executable snapshot, which is unsupported on ${process.platform}.`
     );
   }
-  const root = await mkdtemp(join5(tmpdir(), "agentwheel-revision-command-"));
-  const path = join5(root, "entrypoint");
+  const root = await mkdtemp(join6(tmpdir(), "agentwheel-revision-command-"));
+  const path = join6(root, "entrypoint");
   let snapshot;
   try {
     await chmod2(root, 448);
@@ -1958,7 +2184,7 @@ async function assertProviderSemantics(request, response) {
 }
 async function invokeGitProvider(providerId, request) {
   const repository = await discoverGitRepository(request.repositoryRoot);
-  if (!repository || repository.root !== resolve7(request.repositoryRoot)) {
+  if (!repository || repository.root !== resolve8(request.repositoryRoot)) {
     throw new Error(`Git revision provider requires the repository root itself: ${request.repositoryRoot}.`);
   }
   if (request.action === "check" || request.action === "preflight") {
@@ -2003,8 +2229,8 @@ async function finalizeGit(providerId, request) {
   const indexLease = await captureIndexLease(request.repositoryRoot);
   await assertIndexTree(request.repositoryRoot, request.expectedHead);
   const hookBaseline = await snapshotRepository(request.repositoryRoot);
-  const tempRoot = await mkdtemp(join5(tmpdir(), "agentwheel-git-index-"));
-  const indexPath = join5(tempRoot, "index");
+  const tempRoot = await mkdtemp(join6(tmpdir(), "agentwheel-git-index-"));
+  const indexPath = join6(tempRoot, "index");
   const env = { ...process.env, GIT_INDEX_FILE: indexPath };
   let commitSha;
   try {
@@ -2015,14 +2241,14 @@ async function finalizeGit(providerId, request) {
     await verifyTemporaryIndexPaths(request, env);
     await runProcess("git", ["-C", request.repositoryRoot, "diff", "--cached", "--check"], { env });
     const tree = (await runProcess("git", ["-C", request.repositoryRoot, "write-tree"], { env })).stdout.toString("utf8").trim();
-    const messagePath = join5(tempRoot, "COMMIT_EDITMSG");
+    const messagePath = join6(tempRoot, "COMMIT_EDITMSG");
     await writeFile2(messagePath, commitMessage(request, planDigest), { encoding: "utf8", mode: 384 });
     await runCommitHooks(request, env, messagePath);
     assertRepositorySnapshotEqual(hookBaseline, await snapshotRepository(request.repositoryRoot), "Git commit hooks");
     const stagedAfterHooks = splitNull2((await runProcess("git", ["-C", request.repositoryRoot, "diff", "--cached", "--name-only", "-z"], { env })).stdout);
     assertExactSet(stagedAfterHooks, request.paths.map((entry) => entry.path), "temporary Git index after hooks");
     await verifyTemporaryIndexPaths(request, env);
-    const message = await readFile6(messagePath, "utf8");
+    const message = await readFile7(messagePath, "utf8");
     assertCommitMessageContract(message, request, planDigest);
     commitSha = (await runProcess("git", ["-C", request.repositoryRoot, "commit-tree", tree, "-p", request.expectedHead], {
       env,
@@ -2053,12 +2279,12 @@ async function runCommitHooks(request, env, messagePath) {
     ["commit-msg", [messagePath]]
   ]) {
     const rawPath = (await runProcess("git", ["-C", request.repositoryRoot, "rev-parse", "--git-path", `hooks/${name}`])).stdout.toString("utf8").trim();
-    const hookPath = isAbsolute4(rawPath) ? rawPath : resolve7(request.repositoryRoot, rawPath);
+    const hookPath = isAbsolute5(rawPath) ? rawPath : resolve8(request.repositoryRoot, rawPath);
     let executable = false;
     try {
       executable = ((await stat(hookPath)).mode & 73) !== 0;
     } catch (error) {
-      if (!isMissing3(error)) throw error;
+      if (!isMissing4(error)) throw error;
     }
     if (!executable) continue;
     try {
@@ -2137,25 +2363,25 @@ async function realignIndexAfterRecoveredCommit(repositoryRoot, expectedHead, co
 }
 async function captureIndexLease(repositoryRoot) {
   const rawPath = (await runProcess("git", ["-C", repositoryRoot, "rev-parse", "--git-path", "index"])).stdout.toString("utf8").trim();
-  const path = isAbsolute4(rawPath) ? rawPath : resolve7(repositoryRoot, rawPath);
+  const path = isAbsolute5(rawPath) ? rawPath : resolve8(repositoryRoot, rawPath);
   try {
-    const [content, info] = await Promise.all([readFile6(path), stat(path)]);
+    const [content, info] = await Promise.all([readFile7(path), stat(path)]);
     return { path, sha256: sha2562(content), mode: info.mode & 511 };
   } catch (error) {
-    if (isMissing3(error)) return { path, sha256: null, mode: 384 };
+    if (isMissing4(error)) return { path, sha256: null, mode: 384 };
     throw error;
   }
 }
 async function replaceIndexCas(repositoryRoot, lease, commitSha) {
-  const tempRoot = await mkdtemp(join5(tmpdir(), "agentwheel-index-replacement-"));
-  const replacementPath = join5(tempRoot, "index");
+  const tempRoot = await mkdtemp(join6(tmpdir(), "agentwheel-index-replacement-"));
+  const replacementPath = join6(tempRoot, "index");
   const lockPath = `${lease.path}.lock`;
   let handle;
   try {
     await runProcess("git", ["-C", repositoryRoot, "read-tree", commitSha], {
       env: { ...process.env, GIT_INDEX_FILE: replacementPath }
     });
-    const replacement = await readFile6(replacementPath);
+    const replacement = await readFile7(replacementPath);
     handle = await open2(lockPath, "wx", lease.mode);
     const current = await readOptionalFile(lease.path);
     const currentSha256 = current ? sha2562(current) : null;
@@ -2197,16 +2423,16 @@ async function hashGitObject(repositoryRoot, spec) {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile6(path);
+    return await readFile7(path);
   } catch (error) {
-    if (isMissing3(error)) return null;
+    if (isMissing4(error)) return null;
     throw error;
   }
 }
 function sha2562(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
-function isMissing3(error) {
+function isMissing4(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 async function assertGitProviderCompatible(repositoryRoot) {
@@ -2352,15 +2578,18 @@ var GovernedMutation = class _GovernedMutation {
         runtimeJournals: [],
         status: "prepared"
       });
-      if (policy.revisioning.mode === "commit-after-verify" && options.requireCleanWorkingTree && baseline && baseline.changed.size > 0) {
+      const blockedPathDescriptions = baseline && repository && baseline.changed.size > 0 ? await describeDirtyPathOwnershipByPath(repository.root, [...baseline.changed.keys()]) : /* @__PURE__ */ new Map();
+      const dirtyDeclaredPaths = baseline && repository ? dirtyRepositoryPaths(repository.root, baseline, options.anticipatedPaths ?? []) : [];
+      if (dirtyDeclaredPaths.length > 0) {
         throw new Error(
-          `This governed command computes declarative paths during planning and requires a clean working tree before runtime mutation; found: ${[...baseline.changed.keys()].sort().join(", ")}.`
+          `Mutation declared paths are already dirty and cannot be claimed: ${dirtyDeclaredPaths.join(", ")}. ${dirtyDeclaredPaths.map((path) => blockedPathDescriptions.get(path)).join(" ")}`
         );
       }
       beginMutationPathDeclarations(
         repository?.root ?? options.workspaceRoot,
         operationId,
-        baseline?.changed.keys()
+        baseline?.changed.keys(),
+        blockedPathDescriptions
       );
       for (const path of options.anticipatedPaths ?? []) declareMutationPath(path);
       if (policy.revisioning.mode === "commit-after-verify" && repository) {
@@ -2511,6 +2740,17 @@ var GovernedMutation = class _GovernedMutation {
     await this.lock.release();
   }
 };
+function dirtyRepositoryPaths(repositoryRoot, baseline, paths) {
+  const conflicts = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const absolute = isAbsolute6(path) ? resolve9(path) : resolve9(process.cwd(), path);
+    const relativePath = relative3(repositoryRoot, absolute);
+    if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep3}`) || isAbsolute6(relativePath)) continue;
+    const normalized = relativePath.split(sep3).join("/");
+    if (baseline.changed.has(normalized)) conflicts.add(normalized);
+  }
+  return [...conflicts].sort((left, right) => left.localeCompare(right));
+}
 var activeMutation;
 function activeMutationMetadata() {
   return activeMutation?.metadata();
@@ -2625,8 +2865,8 @@ async function recoverMutationRuntime(operationId, options = {}) {
     }
     mutation = GovernedMutation.activateExisting(receipt, baseline, lock);
     const [{ recoverPendingApply }, { readLinkedLocalApplyJournal: readLinkedLocalApplyJournal2, removeApplyJournal: removeApplyJournal2, localPathExists: localPathExists2 }] = await Promise.all([
-      import("./apply-OEKVIYBV.js"),
-      import("./transaction-D7VRZZX5.js")
+      import("./apply-JBULQGW5.js"),
+      import("./transaction-EPP7GHXD.js")
     ]);
     let missingReservation = false;
     for (const entry of pending) {
@@ -2714,10 +2954,10 @@ async function checkMutationProvider(workspaceRoot, globalRoot) {
   });
   return invokeRevisionProvider(policy.revisioning.provider, request, { workspaceRoot });
 }
-async function mutationPolicyForWorkspace(workspaceRoot, globalRoot = homedir4()) {
+async function mutationPolicyForWorkspace(workspaceRoot, globalRoot = homedir5()) {
   const scopedConfig = await readWorkspaceConfig(workspaceRoot);
   const scoped = scopedConfig.schemaVersion === 4 ? scopedConfig.mutationPolicy : void 0;
-  if (resolve8(workspaceRoot) === resolve8(globalRoot)) return scoped;
+  if (resolve9(workspaceRoot) === resolve9(globalRoot)) return scoped;
   const globalConfig = await readWorkspaceConfig(globalRoot);
   const global = globalConfig.schemaVersion === 4 ? globalConfig.mutationPolicy : void 0;
   return mergeMutationPolicies(global, scoped);
@@ -2790,17 +3030,17 @@ function upsertRuntimeJournal(entries, link2, status) {
 // src/install/transaction.ts
 function applyLockPath(targetRoot, adapter, scope = {}) {
   const installationType = scope.installationType ?? "local";
-  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
+  return join7(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
 }
 function applyJournalPath(targetRoot, adapter, scope = {}) {
-  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-journal.json`);
+  return join7(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-journal.json`);
 }
 function applyBackupDir(targetRoot, adapter, scope = {}) {
-  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-backups`);
+  return join7(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-backups`);
 }
 async function acquireApplyLock(targetRoot, adapter, transport = localTransport, options = {}, scope = {}) {
   const lockPath = applyLockPath(targetRoot, adapter, scope);
-  const ownerPath = join6(lockPath, "owner.json");
+  const ownerPath = join7(lockPath, "owner.json");
   const metadata = {
     pid: process.pid,
     adapter,
@@ -2864,7 +3104,7 @@ async function listApplyJournals(targetRoot, adapter, transport = localTransport
   const found = [];
   for (const fileName of await transport.listDir(metadataDir(targetRoot))) {
     if (!fileName.endsWith(suffix)) continue;
-    const path = join6(metadataDir(targetRoot), fileName);
+    const path = join7(metadataDir(targetRoot), fileName);
     const journal = parseApplyJournal(JSON.parse(await transport.readFile(path)));
     if (journal.adapter !== adapter || (journal.installationType ?? "local") !== installationType) continue;
     found.push({ path, journal });
@@ -2876,15 +3116,15 @@ async function listAllApplyJournals(targetRoot, adapter, transport = localTransp
   const found = [];
   for (const fileName of await transport.listDir(metadataDir(targetRoot))) {
     if (!fileName.endsWith(suffix)) continue;
-    const path = join6(metadataDir(targetRoot), fileName);
+    const path = join7(metadataDir(targetRoot), fileName);
     const journal = parseApplyJournal(JSON.parse(await transport.readFile(path)));
     if (journal.adapter === adapter) found.push({ path, journal });
   }
   return found.sort((a, b) => a.path.localeCompare(b.path));
 }
 async function readLinkedLocalApplyJournal(path, operationId, expectedDigest, expectedTransportDescription) {
-  const absolutePath = resolve9(path);
-  const journal = parseApplyJournal(JSON.parse(await readFile7(absolutePath, "utf8")));
+  const absolutePath = resolve10(path);
+  const journal = parseApplyJournal(JSON.parse(await readFile8(absolutePath, "utf8")));
   if (journal.version !== 2 || !journal.mutation) {
     throw new Error(`Runtime apply journal ${absolutePath} is not linked to a governed mutation.`);
   }
@@ -2902,7 +3142,7 @@ async function readLinkedLocalApplyJournal(path, operationId, expectedDigest, ex
   }) !== expectedDigest) {
     throw new Error(`Runtime apply journal ${absolutePath} digest does not match its durable receipt.`);
   }
-  const expectedPath = resolve9(applyJournalPath(journal.targetRoot, journal.adapter, {
+  const expectedPath = resolve10(applyJournalPath(journal.targetRoot, journal.adapter, {
     installationType: journal.installationType,
     stateKey: journal.stateKey
   }));
@@ -2926,7 +3166,7 @@ async function abortApplyJournal(targetRoot, adapter, transport = localTransport
     const journalPath = applyJournalPath(targetRoot, adapter, scope);
     if (!await transport.pathExists(journalPath)) return void 0;
     const stateKey = stateKeyFor(adapter, scope);
-    const archivePath = join6(metadataDir(targetRoot), "archive", `${stateKey}.apply-journal.failed-${journalTimestamp(/* @__PURE__ */ new Date())}.json`);
+    const archivePath = join7(metadataDir(targetRoot), "archive", `${stateKey}.apply-journal.failed-${journalTimestamp(/* @__PURE__ */ new Date())}.json`);
     const content = await transport.readFile(journalPath);
     const journal = parseApplyJournal(JSON.parse(content));
     await transport.writeFileAtomic(archivePath, content.endsWith("\n") ? content : `${content}
@@ -2958,7 +3198,7 @@ function assertGovernedRuntimeTransportSupported(transport) {
 }
 function applyJournalLinkDigest(journal, transport) {
   if (!journal.mutation) throw new Error("Cannot digest an unlinked runtime apply journal.");
-  return createHash5("sha256").update(canonicalJson3({
+  return createHash6("sha256").update(canonicalJson3({
     version: journal.version,
     mutation: {
       operationId: journal.mutation.operationId,
@@ -2970,11 +3210,12 @@ function applyJournalLinkDigest(journal, transport) {
     adapter: journal.adapter,
     installationType: journal.installationType ?? null,
     stateKey: journal.stateKey ?? null,
-    targetRoot: resolve9(journal.targetRoot),
+    targetRoot: resolve10(journal.targetRoot),
     baseRevision: journal.baseRevision,
     graphLockDigest: journal.graphLockDigest ?? null,
     graphLockPath: journal.graphLockPath ?? null,
     graphLockRemovePath: journal.graphLockRemovePath ?? null,
+    stateRemoveKey: journal.stateRemoveKey ?? null,
     workspaceConfigPath: journal.workspaceConfigPath ?? null,
     operations: journal.operations
   })).digest("hex");
@@ -3041,7 +3282,7 @@ async function recordBackup(operation, index, targetRoot, adapter, transport = l
       hadExisting
     };
   }
-  const backupPath = join6(applyBackupDir(targetRoot, adapter, scope), String(index));
+  const backupPath = join7(applyBackupDir(targetRoot, adapter, scope), String(index));
   await rm4(backupPath, { recursive: true, force: true });
   await mkdir3(dirname5(backupPath), { recursive: true });
   await cp(operation.destPath, backupPath, { recursive: operation.kind === "dir", dereference: true });