agentwheel 0.19.10 → 0.20.1

package/dist/chunk-BJEZXIXX.js

@@ -0,0 +1,3163 @@
+#!/usr/bin/env node
+import {
+  atomicCopy,
+  hashPath,
+  pathExists,
+  writeJsonAtomic
+} 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";
+
+// src/transport/local.ts
+import { execFile } from "child_process";
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var localTransport = {
+  kind: "local",
+  description: "local filesystem",
+  pathExists,
+  async mkdirExclusive(path) {
+    await mkdir(dirname(path), { recursive: true });
+    await mkdir(path);
+  },
+  hashPath,
+  readFile: (path) => readFile(path, "utf8"),
+  async listDir(path) {
+    try {
+      return await readdir(path);
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+  },
+  async writeFileAtomic(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    await writeFile(temp, content, "utf8");
+    await rename(temp, path);
+  },
+  writeJsonAtomic,
+  atomicCopy,
+  rm: (path) => rm(path, { recursive: true, force: true }),
+  async execFile(command, args, options = {}) {
+    await execFileAsync(command, args, { cwd: options.cwd });
+  }
+};
+
+// src/transport/ssh.ts
+import { execFile as execFile2, spawn } from "child_process";
+import { basename, dirname as dirname2 } from "path";
+import { dirname as posixDirname } from "path/posix";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function createSshTransport(config) {
+  const endpoint = config.user ? `${config.user}@${config.host}` : config.host;
+  const args = baseSshArgs(config, endpoint);
+  async function run(command) {
+    const { stdout } = await execFileAsync2("ssh", [...args, command], { maxBuffer: 20 * 1024 * 1024 });
+    return stdout;
+  }
+  async function runWithInput(command, input) {
+    await spawnWithInput("ssh", [...args, command], input);
+  }
+  return {
+    kind: "ssh",
+    description: `ssh://${endpoint}`,
+    async pathExists(path) {
+      try {
+        await run(`test -e ${quoteSh(path)}`);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async mkdirExclusive(path) {
+      const dir = posixDirname(path);
+      try {
+        await run(`mkdir -p ${quoteSh(dir)} && mkdir ${quoteSh(path)}`);
+      } catch (error) {
+        if (isFileExistsError(error)) throw asAlreadyExists(error);
+        throw error;
+      }
+    },
+    async hashPath(path) {
+      return (await run(`node -e ${quoteSh(remoteHashScript)} -- ${quoteSh(path)}`)).trim();
+    },
+    readFile(path) {
+      return run(`cat -- ${quoteSh(path)}`);
+    },
+    async listDir(path) {
+      const output = await run(`ls -A -- ${quoteSh(path)} 2>/dev/null || true`);
+      return output.split("\n").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    },
+    writeFileAtomic(path, content) {
+      const dir = posixDirname(path);
+      const temp = `${path}.tmp-agentwheel-${process.pid}-${Date.now()}`;
+      return runWithInput(`mkdir -p ${quoteSh(dir)} && cat > ${quoteSh(temp)} && mv ${quoteSh(temp)} ${quoteSh(path)}`, content);
+    },
+    writeJsonAtomic(path, data) {
+      return this.writeFileAtomic(path, `${JSON.stringify(data, null, 2)}
+`);
+    },
+    atomicCopy(source, dest) {
+      return copyViaTar(source, dest, args);
+    },
+    rm(path) {
+      return run(`rm -rf -- ${quoteSh(path)}`).then(() => void 0);
+    },
+    execFile(command, commandArgs, options = {}) {
+      const quoted = [command, ...commandArgs].map(quoteSh).join(" ");
+      const remoteCommand = options.cwd ? `cd ${quoteSh(options.cwd)} && ${quoted}` : quoted;
+      return run(remoteCommand).then(() => void 0);
+    }
+  };
+}
+function baseSshArgs(config, endpoint) {
+  const args = ["-o", "BatchMode=yes"];
+  if (config.port) args.push("-p", String(config.port));
+  if (config.identityFile) args.push("-i", config.identityFile);
+  args.push(endpoint);
+  return args;
+}
+async function copyViaTar(source, dest, sshArgs) {
+  const sourceParent = dirname2(source);
+  const sourceBase = basename(source);
+  const destParent = posixDirname(dest);
+  const temp = `${dest}.tmp-agentwheel-${process.pid}-${Date.now()}`;
+  const remoteCommand = [
+    `rm -rf -- ${quoteSh(temp)}`,
+    `mkdir -p ${quoteSh(temp)} ${quoteSh(destParent)}`,
+    `tar -xf - -C ${quoteSh(temp)}`,
+    `rm -rf -- ${quoteSh(dest)}`,
+    `mv ${quoteSh(`${temp}/${sourceBase}`)} ${quoteSh(dest)}`,
+    `rmdir ${quoteSh(temp)}`
+  ].join(" && ");
+  const tar = spawn("tar", ["-cf", "-", "-C", sourceParent, sourceBase], { stdio: ["ignore", "pipe", "pipe"] });
+  const ssh = spawn("ssh", [...sshArgs, remoteCommand], { stdio: ["pipe", "pipe", "pipe"] });
+  tar.stdout.pipe(ssh.stdin);
+  const [tarResult, sshResult] = await Promise.all([waitForProcess(tar, "tar"), waitForProcess(ssh, "ssh")]);
+  if (tarResult.stderr) throw new Error(tarResult.stderr);
+  if (sshResult.stderr) throw new Error(sshResult.stderr);
+}
+async function spawnWithInput(command, args, input) {
+  const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+  child.stdin.end(input);
+  const result = await waitForProcess(child, command);
+  if (result.stderr) throw new Error(result.stderr);
+}
+function waitForProcess(child, label) {
+  return new Promise((resolve10, 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: "" });
+      else reject(new Error(`${label} exited ${code}${message ? `: ${message}` : ""}`));
+    });
+  });
+}
+function quoteSh(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function isFileExistsError(error) {
+  const text = typeof error === "object" && error !== null ? `${"message" in error ? String(error.message) : ""}
+${"stderr" in error ? String(error.stderr) : ""}` : String(error);
+  return text.includes("File exists");
+}
+function asAlreadyExists(error) {
+  const out = error instanceof Error ? error : new Error(String(error));
+  out.code = "EEXIST";
+  return out;
+}
+var remoteHashScript = String.raw`
+const { createHash } = require("node:crypto");
+const { readdirSync, readFileSync, statSync } = require("node:fs");
+const { join, relative } = require("node:path");
+const target = process.argv[1];
+const ignoredNames = new Set([".git", "node_modules", "__pycache__", ".DS_Store"]);
+const ignoredSuffixes = [".pyc", ".pyo"];
+function isIgnoredGeneratedEntry(name) {
+  return ignoredNames.has(name) || ignoredSuffixes.some((suffix) => name.endsWith(suffix));
+}
+function hashPath(path) {
+  const stats = statSync(path);
+  if (stats.isFile()) {
+    return createHash("sha256").update("file\0").update(readFileSync(path)).digest("hex");
+  }
+  if (!stats.isDirectory()) throw new Error("Unsupported path kind: " + path);
+  const hash = createHash("sha256").update("dir\0");
+  for (const file of listFiles(path)) {
+    hash.update(relative(path, file).replaceAll("\\", "/")).update("\0");
+    hash.update(hashPath(file)).update("\0");
+  }
+  return hash.digest("hex");
+}
+function listFiles(root) {
+  const out = [];
+  function walk(dir) {
+    for (const entry of readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (isIgnoredGeneratedEntry(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.isFile()) out.push(full);
+    }
+  }
+  walk(root);
+  return out;
+}
+process.stdout.write(hashPath(target));
+`;
+
+// src/transport/index.ts
+function transportForTarget(target) {
+  if (target.transport === "local") return localTransport;
+  if (!target.ssh) throw new Error(`SSH target ${target.agentName ?? target.targetRoot} is missing SSH connection details.`);
+  return createSshTransport(target.ssh);
+}
+
+// src/install/paths.ts
+import { join } from "path";
+
+// src/model/adapter.ts
+import { readFile as readFile2 } from "fs/promises";
+import { homedir } from "os";
+import { parse, printParseErrorCode } from "jsonc-parser";
+import { z as z2 } from "zod";
+
+// src/model/artifact.ts
+import { z } from "zod";
+var artifactTypeSchema = z.enum([
+  "instructions",
+  "rules",
+  "skills",
+  "commands",
+  "subagents",
+  "mcp",
+  "hooks",
+  "settings",
+  "plugins",
+  "fragments"
+]);
+var fileKindSchema = z.enum(["file", "dir"]);
+var artifactFormatSchema = z.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i, "artifact format must be a stable identifier");
+var packageAssetSchema = z.object({
+  from: z.string().min(1),
+  into: z.string().min(1),
+  include: z.array(z.string().min(1)).optional(),
+  mode: z.enum(["preserve", "copy"]).default("preserve")
+});
+var packageComposeEntrySchema = z.object({
+  include: z.string().min(1),
+  markers: z.boolean().optional(),
+  optional: z.boolean().optional()
+});
+var packageCompositionRuleSchema = z.object({
+  target: z.string().min(1),
+  include: z.string().min(1),
+  exclude: z.array(z.string().min(1)).optional(),
+  runtimes: z.array(z.string().min(1)).optional(),
+  markers: z.boolean().optional()
+});
+var packageSupersedesEntrySchema = z.object({
+  package: z.string().min(1),
+  selector: z.string().min(1),
+  reason: z.string().min(1)
+});
+var packageItemRequireObjectSchema = z.object({
+  selector: z.string().min(1),
+  optional: z.boolean().optional(),
+  runtimes: z.array(z.string().min(1)).optional()
+}).passthrough();
+var packageItemRequireSchema = z.union([
+  z.string().min(1),
+  packageItemRequireObjectSchema
+]);
+var packageItemSuggestObjectSchema = z.object({
+  alias: z.string().min(1),
+  select: z.array(z.string().min(1)).optional(),
+  optional: z.boolean().optional(),
+  runtimes: z.array(z.string().min(1)).optional(),
+  reason: z.string().min(1).optional(),
+  when: z.string().min(1).optional()
+}).passthrough();
+var packageItemSuggestSchema = z.union([
+  z.string().min(1),
+  packageItemSuggestObjectSchema
+]);
+var composedFromEntrySchema = z.object({
+  selector: z.string().min(1),
+  hash: z.string().min(16)
+});
+var artifactSchema = z.object({
+  type: artifactTypeSchema,
+  name: z.string().min(1),
+  sourcePath: z.string().min(1),
+  stagedPath: z.string().min(1).optional(),
+  relativePath: z.string().min(1),
+  kind: fileKindSchema,
+  hash: z.string().min(16),
+  format: artifactFormatSchema.optional(),
+  packageName: z.string().min(1).optional(),
+  channel: z.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed"),
+  assets: z.array(packageAssetSchema).optional(),
+  required: z.boolean().optional(),
+  requires: z.array(packageItemRequireSchema).optional(),
+  suggests: z.array(packageItemSuggestSchema).optional(),
+  compose: z.array(packageComposeEntrySchema).optional(),
+  supersedes: z.array(packageSupersedesEntrySchema).optional(),
+  runtimes: z.array(z.string().min(1)).optional(),
+  composedFrom: z.array(composedFromEntrySchema).optional()
+});
+
+// src/model/adapter.ts
+var defaultInstallationType = "local";
+var installationTypeSchema = z2.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i, "installation type must be a stable path-safe identifier");
+var targetMappingSchema = z2.object({
+  dest: z2.string().min(1),
+  enabled: z2.boolean().default(true),
+  root: z2.enum(["target", "home"]).optional(),
+  formats: z2.array(z2.string().min(1)).optional(),
+  semantic: z2.enum([
+    "openclaw-plugin",
+    "claude-plugin",
+    "codex-plugin",
+    "hermes-plugin",
+    "copilot-plugin",
+    "openclaw-subagent",
+    "codex-subagent",
+    "copilot-instruction",
+    "copilot-prompt",
+    "copilot-agent"
+  ]).optional(),
+  merge: z2.enum(["json-deep", "openclaw-json-deep", "yaml-deep", "codex-toml-mcp"]).optional(),
+  mode: z2.enum(["managed-block"]).optional()
+});
+var targetRegistrySchema = z2.record(installationTypeSchema, targetMappingSchema);
+var targetRegistryInputSchema = z2.union([
+  targetMappingSchema.transform((mapping) => ({ [defaultInstallationType]: mapping })),
+  targetRegistrySchema
+]);
+var adapterSchema = z2.object({
+  name: z2.string().regex(/^[a-z0-9][a-z0-9._-]*$/i, "adapter name must be a canonical path-safe identifier"),
+  displayName: z2.string().min(1).optional(),
+  targets: z2.partialRecord(
+    artifactTypeSchema,
+    targetRegistryInputSchema
+  ).default({})
+});
+function supportedInstallationTypes(adapter, artifactType) {
+  const registries = artifactType ? [adapter.targets[artifactType]] : Object.entries(adapter.targets).filter(([type]) => type !== "fragments").map(([, registry]) => registry);
+  const types = /* @__PURE__ */ new Set();
+  for (const registry of registries) {
+    for (const [installationType, target] of Object.entries(registry ?? {})) {
+      if (target.enabled) types.add(installationType);
+    }
+  }
+  return [...types].sort((a, b) => a.localeCompare(b));
+}
+function adapterTargetSupport(adapter, artifactType, installationType) {
+  if (artifactType === "fragments") return { ok: true };
+  const registry = adapter.targets[artifactType];
+  const supported = supportedInstallationTypes(adapter, artifactType);
+  if (!registry) {
+    return { ok: false, reason: "adapter-target-unsupported", supportedInstallationTypes: supported };
+  }
+  const target = registry[installationType];
+  if (target?.enabled) return { ok: true };
+  if (target && !target.enabled) {
+    return { ok: false, reason: "adapter-target-disabled", supportedInstallationTypes: supported };
+  }
+  return { ok: false, reason: "adapter-target-unsupported", supportedInstallationTypes: supported };
+}
+function resolveInstallationTypeForArtifacts(adapter, artifactTypes, requested) {
+  const installableTypes = [...new Set(artifactTypes.filter((type) => type !== "fragments"))];
+  if (installableTypes.length === 0) {
+    return requested ?? resolveInstallationTypeForAdapter(adapter, requested);
+  }
+  for (const type of installableTypes) {
+    const supported = supportedInstallationTypes(adapter, type);
+    if (supported.length === 0) {
+      throw new Error(`Adapter ${adapter.name} does not support ${type} artifacts for any installation type.`);
+    }
+    if (requested && !supported.includes(requested)) {
+      throw new Error(`Adapter ${adapter.name} does not support ${type} artifacts for installation type '${requested}'. Supported: ${supported.join(", ")}`);
+    }
+  }
+  if (requested) return requested;
+  const [firstType, ...restTypes] = installableTypes;
+  let candidates = new Set(supportedInstallationTypes(adapter, firstType));
+  for (const type of restTypes) {
+    const supported = new Set(supportedInstallationTypes(adapter, type));
+    candidates = new Set([...candidates].filter((candidate) => supported.has(candidate)));
+  }
+  const available = [...candidates].sort((a, b) => a.localeCompare(b));
+  if (available.length === 1) return available[0];
+  if (available.length === 0) {
+    throw new Error(`Adapter ${adapter.name} has no common installation type for: ${installableTypes.join(", ")}`);
+  }
+  throw new Error(`Installation type required for ${adapter.name}; supported for selected artifacts: ${available.join(", ")}. Pass --installation-type <type>.`);
+}
+function resolveInstallationTypeForAdapter(adapter, requested) {
+  const supported = supportedInstallationTypes(adapter);
+  if (requested) {
+    if (!supported.includes(requested)) {
+      throw new Error(`Adapter ${adapter.name} does not support installation type '${requested}'. Supported: ${supported.join(", ") || "<none>"}`);
+    }
+    return requested;
+  }
+  if (supported.length === 1) return supported[0];
+  if (supported.length === 0) return defaultInstallationType;
+  throw new Error(`Installation type required for ${adapter.name}; supported: ${supported.join(", ")}. Pass --installation-type <type>.`);
+}
+function targetMappingForArtifact(adapter, artifactType, installationType) {
+  return adapter.targets[artifactType]?.[installationType];
+}
+function installRootForArtifacts(adapter, targetRoot, installationType, artifactTypes, isSsh = false) {
+  const roots = new Set(
+    [...new Set(artifactTypes.filter((type) => type !== "fragments"))].map((type) => targetMappingForArtifact(adapter, type, installationType)?.root ?? "target")
+  );
+  if (roots.has("home") && roots.has("target")) {
+    throw new Error(`Installation type '${installationType}' for ${adapter.name} mixes home-rooted and target-rooted artifacts.`);
+  }
+  return roots.has("home") && !isSsh ? userHomeRoot() : targetRoot;
+}
+function installRootForAdapterInstallationType(adapter, targetRoot, installationType, isSsh = false) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const registry of Object.values(adapter.targets)) {
+    const target = registry?.[installationType];
+    if (target?.enabled) roots.add(target.root ?? "target");
+  }
+  if (roots.has("home") && roots.has("target")) {
+    throw new Error(`Installation type '${installationType}' for ${adapter.name} mixes home-rooted and target-rooted artifacts.`);
+  }
+  return roots.has("home") && !isSsh ? userHomeRoot() : targetRoot;
+}
+function userHomeRoot() {
+  return process.env.AGENTWHEEL_TEST_HOME || process.env.HOME || homedir();
+}
+async function loadAdapterConfig(path) {
+  const content = await readFile2(path, "utf8");
+  const errors = [];
+  const parsed = parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
+    throw new Error(`Invalid adapter config ${path}: ${details}`);
+  }
+  return adapterSchema.parse(parsed);
+}
+
+// src/install/paths.ts
+function metadataDir(targetRoot) {
+  return join(targetRoot, ".agentwheel");
+}
+function stateKeyFor(adapter, scope = {}) {
+  assertPathSafeAdapterName(adapter);
+  if (scope.stateKey) {
+    const explicit = sanitizeStateKey(scope.stateKey);
+    const adapterScoped = scope.fleetId && explicit !== adapter && !explicit.startsWith(`${adapter}.`) ? `${adapter}.${explicit}` : explicit;
+    const fleetSuffix = scope.fleetId ? `.fleet-${sanitizeStateKey(scope.fleetId)}${scope.targetFingerprint ? `.${scope.targetFingerprint}` : ""}` : "";
+    return sanitizeStateKey(`${adapterScoped}${fleetSuffix}`);
+  }
+  const installationType = scope.installationType ?? defaultInstallationType;
+  const fingerprint = scope.targetFingerprint ? `.${scope.targetFingerprint}` : "";
+  return sanitizeStateKey(`${adapter}.${installationType}${fingerprint}`);
+}
+function assertPathSafeAdapterName(adapter) {
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(adapter)) {
+    throw new Error(`Adapter name '${adapter}' is not a canonical path-safe identifier.`);
+  }
+}
+function installManifestPath(targetRoot, adapter, scope = {}) {
+  return join(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.install-manifest.json`);
+}
+function sourceLockPath(targetRoot, adapter, scope = {}) {
+  return join(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.source-lock.json`);
+}
+function sanitizeStateKey(value) {
+  return value.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "default";
+}
+
+// src/mutation/coordinator.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { homedir as homedir4 } from "os";
+import { resolve as resolve8 } from "path";
+
+// src/model/mutation.ts
+import { z as z3 } from "zod";
+import { isAbsolute, resolve } from "path";
+var REVISION_PROVIDER_PROTOCOL_VERSION = 1;
+var providerIdSchema = z3.string().min(1).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/i);
+var sha256Schema = z3.string().regex(/^[a-f0-9]{64}$/);
+var gitRevisionProviderSchema = z3.object({
+  kind: z3.literal("git"),
+  id: providerIdSchema.default("git"),
+  protocolVersion: z3.literal(REVISION_PROVIDER_PROTOCOL_VERSION)
+}).strict();
+var commandRevisionProviderSchema = z3.object({
+  kind: z3.literal("command"),
+  id: providerIdSchema,
+  command: z3.array(z3.string().min(1)).min(1).superRefine((command, ctx) => {
+    const executable = command[0];
+    if (!isAbsolute(executable) || resolve(executable) !== executable || /[\r\n\0]/u.test(executable)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [0],
+        message: "Command provider executables must use an absolute normalized path"
+      });
+    }
+  }),
+  executableSha256: sha256Schema,
+  trustBoundary: z3.literal("entrypoint"),
+  timeoutMs: z3.number().int().min(100).max(3e5).default(3e4),
+  protocolVersion: z3.literal(REVISION_PROVIDER_PROTOCOL_VERSION)
+}).strict();
+var revisionProviderConfigSchema = z3.discriminatedUnion("kind", [
+  gitRevisionProviderSchema,
+  commandRevisionProviderSchema
+]);
+var revisioningOffSchema = z3.object({
+  mode: z3.literal("off")
+}).strict();
+var commitAfterVerifySchema = z3.object({
+  mode: z3.literal("commit-after-verify"),
+  allowNoCommitOverride: z3.boolean().default(false),
+  reasonInCommit: z3.literal("full"),
+  provider: revisionProviderConfigSchema
+}).strict();
+var mutationPolicySchema = z3.object({
+  reason: z3.enum(["optional", "required"]),
+  journal: z3.enum(["off", "required"]),
+  revisioning: z3.discriminatedUnion("mode", [revisioningOffSchema, commitAfterVerifySchema])
+}).strict().superRefine((policy, ctx) => {
+  if (policy.revisioning.mode === "commit-after-verify" && policy.journal !== "required") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["journal"],
+      message: "commit-after-verify requires durable mutation journaling"
+    });
+  }
+});
+
+// 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";
+
+// src/resolve/semver.ts
+var semverPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseSemver(value) {
+  const match = semverPattern.exec(value.trim());
+  if (!match) return void 0;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4]
+  };
+}
+function satisfiesVersionRange(version, range) {
+  if (!range || range.trim() === "" || range.trim() === "*") return true;
+  const parsedVersion = parseSemver(version);
+  const trimmed = range.trim();
+  if (!parsedVersion) {
+    return trimmed === "*" || trimmed === version;
+  }
+  const comparators = parseRange(trimmed);
+  if (!comparators) return trimmed === version;
+  return comparators.every((comparator) => compareWith(parsedVersion, comparator));
+}
+function semverMajorOrVersion(version) {
+  const parsed = parseSemver(version);
+  return parsed ? String(parsed.major) : version;
+}
+function compareSemverStrings(a, b) {
+  const parsedA = parseSemver(a);
+  const parsedB = parseSemver(b);
+  if (!parsedA || !parsedB) return a.localeCompare(b);
+  return compareSemver(parsedA, parsedB);
+}
+function isSupportedVersionRange(range) {
+  const trimmed = range.trim();
+  return trimmed === "*" || parseRange(trimmed) !== void 0;
+}
+function parseRange(range) {
+  if (range === "*") return [];
+  if (range.startsWith("^")) {
+    const base = parseSemver(range.slice(1));
+    if (!base) return void 0;
+    return [
+      { op: ">=", version: base },
+      { op: "<", version: caretUpperBound(base) }
+    ];
+  }
+  if (range.startsWith("~")) {
+    const base = parseSemver(range.slice(1));
+    if (!base) return void 0;
+    return [
+      { op: ">=", version: base },
+      { op: "<", version: { major: base.major, minor: base.minor + 1, patch: 0 } }
+    ];
+  }
+  const parts = range.split(/\s+/).filter(Boolean);
+  const comparators = [];
+  for (const part of parts) {
+    const match = /^(>=|<=|>|<|=)?(.+)$/.exec(part);
+    if (!match) return void 0;
+    const version = parseSemver(match[2] ?? "");
+    if (!version) return void 0;
+    comparators.push({ op: match[1] ?? "=", version });
+  }
+  return comparators;
+}
+function caretUpperBound(version) {
+  if (version.major > 0) return { major: version.major + 1, minor: 0, patch: 0 };
+  if (version.minor > 0) return { major: 0, minor: version.minor + 1, patch: 0 };
+  return { major: 0, minor: 0, patch: version.patch + 1 };
+}
+function compareWith(version, comparator) {
+  const order = compareSemver(version, comparator.version);
+  switch (comparator.op) {
+    case "=":
+      return order === 0;
+    case ">":
+      return order > 0;
+    case ">=":
+      return order >= 0;
+    case "<":
+      return order < 0;
+    case "<=":
+      return order <= 0;
+  }
+}
+function compareSemver(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  return a.prerelease.localeCompare(b.prerelease);
+}
+
+// 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";
+
+// src/mutation/protocol.ts
+import { createHash } from "crypto";
+import { isAbsolute as isAbsolute2, posix, resolve as resolve2 } from "path";
+import { z as z4 } from "zod";
+var sha256Schema2 = z4.string().regex(/^[a-f0-9]{64}$/);
+var nullableSha256Schema = sha256Schema2.nullable();
+var gitCommitShaSchema = z4.string().regex(/^[a-f0-9]{40}$/);
+var nullableGitCommitShaSchema = gitCommitShaSchema.nullable();
+var mutationOperationIdSchema = z4.string().min(1).max(63).regex(/^[a-z0-9][a-z0-9_-]*$/i);
+var mutationReasonSchema = z4.string().min(1).max(4096).refine((value) => !/[\u0000\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(value), {
+  message: "Mutation reasons may not contain control characters"
+});
+var revisionPathSchema = z4.object({
+  path: z4.string().min(1).max(4096).refine(isSafeRepoRelativePath, {
+    message: "Revision paths must be normalized repository-relative paths"
+  }),
+  beforeSha256: nullableSha256Schema,
+  afterSha256: nullableSha256Schema
+}).strict().superRefine((entry, ctx) => {
+  if (entry.beforeSha256 === entry.afterSha256) {
+    ctx.addIssue({ code: "custom", message: "Revision path hashes must describe a change" });
+  }
+});
+var revisionActionSchema = z4.enum(["check", "preflight", "finalize", "recover", "release"]);
+var requestBase = z4.object({
+  protocolVersion: z4.literal(REVISION_PROVIDER_PROTOCOL_VERSION),
+  action: revisionActionSchema,
+  operationId: mutationOperationIdSchema,
+  repositoryRoot: z4.string().min(1).max(4096).refine(isCanonicalAbsolutePath, {
+    message: "repositoryRoot must be an absolute normalized path"
+  }),
+  expectedHead: gitCommitShaSchema,
+  expectedManifestDigest: sha256Schema2.optional(),
+  commandName: z4.string().min(1).max(256).refine((value) => !/[\r\n\u0000-\u001f\u007f]/u.test(value), {
+    message: "commandName must be a single printable line"
+  }),
+  reason: mutationReasonSchema,
+  noCommit: z4.boolean(),
+  paths: z4.array(revisionPathSchema)
+}).strict();
+var revisionProviderRequestUnion = z4.discriminatedUnion("action", [
+  requestBase.extend({ action: z4.literal("check") }).strict(),
+  requestBase.extend({ action: z4.literal("preflight") }).strict(),
+  requestBase.extend({ action: z4.literal("finalize") }).strict(),
+  requestBase.extend({ action: z4.literal("recover") }).strict(),
+  requestBase.extend({ action: z4.literal("release") }).strict()
+]);
+var revisionProviderRequestSchema = revisionProviderRequestUnion.superRefine((request, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, entry] of request.paths.entries()) {
+    if (seen.has(entry.path)) {
+      ctx.addIssue({ code: "custom", path: ["paths", index, "path"], message: `Duplicate revision path: ${entry.path}` });
+    }
+    seen.add(entry.path);
+  }
+});
+var responseBase = z4.object({
+  protocolVersion: z4.literal(REVISION_PROVIDER_PROTOCOL_VERSION),
+  providerId: z4.string().min(1).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/i),
+  action: revisionActionSchema,
+  operationId: mutationOperationIdSchema,
+  ok: z4.literal(true),
+  status: z4.string().min(1).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/i)
+}).strict();
+var terminalResponseFields = {
+  expectedHead: gitCommitShaSchema,
+  resultingHead: gitCommitShaSchema,
+  productCommitSha: nullableGitCommitShaSchema,
+  draftStackId: z4.string().min(1).max(256).nullable(),
+  draftBranch: z4.string().min(1).max(1024).refine(isSafeGitBranch, { message: "draftBranch must be a valid branch name" }).nullable(),
+  draftTipSha: nullableGitCommitShaSchema,
+  controlCommitSha: nullableGitCommitShaSchema,
+  manifestDigest: sha256Schema2.nullable(),
+  unmappedIntegrationCommits: z4.array(gitCommitShaSchema).superRefine(rejectDuplicates),
+  published: z4.literal(false)
+};
+var terminalErrorResponseFields = {
+  expectedHead: nullableGitCommitShaSchema,
+  resultingHead: nullableGitCommitShaSchema,
+  productCommitSha: nullableGitCommitShaSchema,
+  draftStackId: z4.string().min(1).max(256).nullable(),
+  draftBranch: z4.string().min(1).max(1024).refine(isSafeGitBranch, { message: "draftBranch must be a valid branch name" }).nullable(),
+  draftTipSha: nullableGitCommitShaSchema,
+  controlCommitSha: nullableGitCommitShaSchema,
+  manifestDigest: sha256Schema2.nullable(),
+  unmappedIntegrationCommits: z4.array(gitCommitShaSchema).superRefine(rejectDuplicates),
+  published: z4.literal(false)
+};
+var revisionProviderResponseSchema = z4.discriminatedUnion("action", [
+  responseBase.extend({ action: z4.literal("check") }).strict(),
+  responseBase.extend({ action: z4.literal("preflight") }).strict(),
+  responseBase.extend({ action: z4.literal("release") }).strict(),
+  responseBase.extend({ action: z4.literal("finalize"), ...terminalResponseFields }).strict(),
+  responseBase.extend({ action: z4.literal("recover"), ...terminalResponseFields }).strict()
+]);
+var errorResponseBase = z4.object({
+  protocolVersion: z4.literal(REVISION_PROVIDER_PROTOCOL_VERSION),
+  providerId: z4.string().min(1).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/i),
+  operationId: z4.string().min(1).max(128),
+  ok: z4.literal(false),
+  status: z4.string().min(1).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/i),
+  error: z4.string().min(1).max(4096)
+});
+var unknownErrorActionSchema = z4.string().min(1).max(80).refine(
+  (value) => !revisionActionSchema.options.includes(value),
+  { message: "Known provider actions must use their action-specific error schema" }
+);
+var revisionProviderErrorResponseSchema = z4.union([
+  errorResponseBase.extend({ action: z4.literal("check") }).strict(),
+  errorResponseBase.extend({ action: z4.literal("preflight") }).strict(),
+  errorResponseBase.extend({ action: z4.literal("release") }).strict(),
+  errorResponseBase.extend({ action: z4.literal("finalize"), ...terminalErrorResponseFields }).strict(),
+  errorResponseBase.extend({ action: z4.literal("recover"), ...terminalErrorResponseFields }).strict(),
+  errorResponseBase.extend({ action: unknownErrorActionSchema }).strict()
+]);
+var revisionProviderResultSchema = z4.union([
+  revisionProviderResponseSchema,
+  revisionProviderErrorResponseSchema
+]);
+function revisionRequestDigest(request) {
+  return createHash("sha256").update(canonicalJson(request)).digest("hex");
+}
+function isSafeRepoRelativePath(value) {
+  if (isAbsolute2(value) || value.includes("\\") || value.includes("\0")) return false;
+  const normalized = posix.normalize(value);
+  const parts = value.split("/");
+  if (normalized !== value || parts.some((part) => part === "" || part === "." || part === "..")) return false;
+  const first = value.split("/", 1)[0];
+  if (first === ".git") return false;
+  if (value === ".syncwheel/manifest.json" || value === ".syncwheel/ledger" || value.startsWith(".syncwheel/ledger/")) return false;
+  return true;
+}
+function isCanonicalAbsolutePath(value) {
+  return isAbsolute2(value) && !value.includes("\0") && !/[\r\n]/u.test(value) && resolve2(value) === value;
+}
+function isSafeGitBranch(value) {
+  if (value.startsWith("/") || value.endsWith("/") || value.endsWith(".") || value.includes("@{")) return false;
+  if (/[\u0000-\u0020\u007f~^:?*\\[]/u.test(value) || value.includes("..") || value.includes("//")) return false;
+  return value.split("/").every((part) => part.length > 0 && part !== "." && part !== ".." && !part.endsWith(".lock"));
+}
+function rejectDuplicates(values, ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, value] of values.entries()) {
+    if (seen.has(value)) ctx.addIssue({ code: "custom", path: [index], message: `Duplicate value: ${value}` });
+    seen.add(value);
+  }
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+
+// 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 { homedir as homedir2 } from "os";
+import { dirname as dirname3, join as join2, 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()
+}).strict();
+var receiptStatusSchema = z5.enum([
+  "prepared",
+  "handler-succeeded",
+  "mutation-applied",
+  "succeeded",
+  "revisioning-skipped",
+  "no-repository-delta",
+  "commit-pending",
+  "precheck-failed",
+  "partial",
+  "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}$/)
+}).strict();
+var mutationReceiptBaseSchema = z5.object({
+  version: z5.literal(1),
+  revision: z5.number().int().min(1),
+  receiptDigest: z5.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"]),
+  provider: revisionProviderConfigSchema.nullable(),
+  preexistingPaths: z5.array(preexistingPathSchema),
+  paths: z5.array(revisionPathSchema),
+  runtimeJournals: z5.array(runtimeJournalSchema).default([]),
+  status: receiptStatusSchema,
+  createdAt: z5.string().datetime(),
+  updatedAt: z5.string().datetime(),
+  providerResponse: revisionProviderResultSchema.optional(),
+  error: z5.string().min(1).max(4096).optional()
+}).strict();
+var mutationReceiptSchema = mutationReceiptBaseSchema.superRefine((receipt, ctx) => {
+  const expected = mutationReceiptDigest(receipt);
+  if (receipt.receiptDigest !== expected) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["receiptDigest"],
+      message: `Mutation receipt digest mismatch: expected ${expected}`
+    });
+  }
+});
+function mutationStateRoot() {
+  return resolve3(process.env.AGENTWHEEL_MUTATION_STATE_ROOT ?? join2(homedir2(), ".agentwheel", "mutations"));
+}
+async function createMutationReceipt(receipt) {
+  const path = receiptPath(receipt.operationId);
+  await ensureStateDirectory();
+  const reservation = `${path}.reserve`;
+  try {
+    await open(reservation, "wx", 384).then(async (handle) => {
+      await handle.sync();
+      await handle.close();
+    });
+    await fsyncDirectory(dirname3(path));
+  } catch (error) {
+    if (isAlreadyExists(error)) throw new Error(`Mutation operation '${receipt.operationId}' already has a durable receipt.`);
+    throw error;
+  }
+  try {
+    if (await fileExists(path)) throw new Error(`Mutation operation '${receipt.operationId}' already has a durable receipt.`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const parsed = sealMutationReceipt({
+      ...receipt,
+      version: 1,
+      revision: 1,
+      receiptDigest: "0".repeat(64),
+      createdAt: now,
+      updatedAt: now
+    });
+    await writeReceipt(path, parsed);
+    return parsed;
+  } finally {
+    await rm2(reservation, { force: true });
+    await fsyncDirectory(dirname3(path));
+  }
+}
+async function updateMutationReceipt(receipt, patch) {
+  const path = receiptPath(receipt.operationId);
+  const release = await acquireReceiptUpdateLock(path, receipt.operationId);
+  try {
+    const current = await readMutationReceipt(receipt.operationId);
+    if (current.revision !== receipt.revision || current.receiptDigest !== receipt.receiptDigest) {
+      throw new Error(
+        `Mutation receipt '${receipt.operationId}' changed concurrently: expected revision ${receipt.revision}/${receipt.receiptDigest}, found ${current.revision}/${current.receiptDigest}.`
+      );
+    }
+    const next = sealMutationReceipt({
+      ...current,
+      ...patch,
+      revision: current.revision + 1,
+      receiptDigest: "0".repeat(64),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await writeReceipt(path, next);
+    return next;
+  } finally {
+    await release();
+  }
+}
+async function readMutationReceipt(operationId) {
+  const id = mutationOperationIdSchema.parse(operationId);
+  const path = receiptPath(id);
+  try {
+    return mutationReceiptSchema.parse(JSON.parse(await readFile3(path, "utf8")));
+  } catch (error) {
+    if (isMissing(error)) throw new Error(`Unknown mutation operation '${id}'.`);
+    throw error;
+  }
+}
+async function listMutationReceipts() {
+  const root = join2(mutationStateRoot(), "receipts");
+  let names;
+  try {
+    names = await readdir2(root);
+  } catch (error) {
+    if (isMissing(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"))));
+  }
+  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);
+  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}.`);
+    }
+    await mkdir2(lockPath, { mode: 448 });
+  }
+  const ownerPath = join2(lockPath, "owner.json");
+  await writeSecureJson(ownerPath, {
+    version: 1,
+    operationId,
+    pid: process.pid,
+    repositoryRoot: resolve3(repositoryRoot),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  let released = false;
+  return {
+    path: lockPath,
+    async release() {
+      if (released) return;
+      released = true;
+      await rm2(lockPath, { recursive: true, force: true });
+    }
+  };
+}
+function receiptPath(operationId) {
+  return join2(mutationStateRoot(), "receipts", `${mutationOperationIdSchema.parse(operationId)}.json`);
+}
+async function ensureStateDirectory() {
+  const root = mutationStateRoot();
+  await mkdir2(join2(root, "receipts"), { recursive: true, mode: 448 });
+  await chmod(root, 448);
+  await chmod(join2(root, "receipts"), 448);
+}
+async function writeReceipt(path, receipt) {
+  await writeSecureJson(path, receipt);
+}
+function sealMutationReceipt(value) {
+  const parsed = mutationReceiptBaseSchema.parse(value);
+  return mutationReceiptSchema.parse({ ...parsed, receiptDigest: mutationReceiptDigest(parsed) });
+}
+function mutationReceiptDigest(receipt) {
+  const { receiptDigest: _ignored, ...payload } = receipt;
+  return createHash2("sha256").update(canonicalJson2(payload)).digest("hex");
+}
+function canonicalJson2(value) {
+  if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson2(entry === void 0 ? null : entry)).join(",")}]`;
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  const record = value;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(record[key])}`).join(",")}}`;
+}
+async function acquireReceiptUpdateLock(path, operationId) {
+  const lockPath = `${path}.cas-lock`;
+  const candidatePath = `${lockPath}.candidate-${process.pid}-${randomUUID()}`;
+  const candidate = await open(candidatePath, "wx", 384);
+  try {
+    await candidate.writeFile(`${JSON.stringify({
+      version: 1,
+      operationId,
+      pid: process.pid,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    })}
+`, "utf8");
+    await candidate.sync();
+  } finally {
+    await candidate.close();
+  }
+  let acquired = false;
+  try {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        await link(candidatePath, lockPath);
+        await fsyncDirectory(dirname3(lockPath));
+        acquired = true;
+        break;
+      } catch (error) {
+        if (!isAlreadyExists(error)) throw error;
+        if (!await reapStaleReceiptUpdateLock(lockPath)) {
+          throw new Error(`Mutation receipt '${operationId}' has another active compare-and-swap writer.`);
+        }
+      }
+    }
+  } finally {
+    await rm2(candidatePath, { force: true });
+  }
+  if (!acquired) throw new Error(`Mutation receipt '${operationId}' compare-and-swap lock could not be acquired.`);
+  let released = false;
+  return async () => {
+    if (released) return;
+    released = true;
+    await rm2(lockPath, { force: true });
+    await fsyncDirectory(dirname3(lockPath));
+  };
+}
+async function reapStaleReceiptUpdateLock(lockPath) {
+  try {
+    const owner = JSON.parse(await readFile3(lockPath, "utf8"));
+    if (typeof owner.pid !== "number" || processIsAlive(owner.pid)) return false;
+  } catch {
+    return false;
+  }
+  const archive = `${lockPath}.stale-${process.pid}-${Date.now()}`;
+  try {
+    await rename2(lockPath, archive);
+    await rm2(archive, { force: true });
+    await fsyncDirectory(dirname3(lockPath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeSecureJson(path, value) {
+  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  const handle = await open(temp, "w", 384);
+  try {
+    await handle.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await rename2(temp, path);
+  await chmod(path, 384);
+  await fsyncDirectory(dirname3(path));
+}
+async function fsyncDirectory(path) {
+  const handle = await open(path, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function fileExists(path) {
+  try {
+    await readFile3(path);
+    return true;
+  } catch (error) {
+    if (isMissing(error)) return false;
+    throw error;
+  }
+}
+async function reapStaleLock(lockPath) {
+  try {
+    const owner = JSON.parse(await readFile3(join2(lockPath, "owner.json"), "utf8"));
+    if (typeof owner.pid !== "number" || processIsAlive(owner.pid)) return false;
+  } catch (error) {
+    return false;
+  }
+  const archive = `${lockPath}.stale-${Date.now()}`;
+  try {
+    await rename2(lockPath, archive);
+    await rm2(archive, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "EPERM";
+  }
+}
+function isAlreadyExists(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isMissing(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/mutation/declarations.ts
+var active;
+function beginMutationPathDeclarations(repositoryRoot, operationIdInput, blockedPaths = []) {
+  if (active) throw new Error("A mutation path declaration scope is already active.");
+  const operationId = mutationOperationIdSchema.parse(operationIdInput);
+  const root = join3(mutationStateRoot(), "declarations");
+  mkdirSync(root, { recursive: true, mode: 448 });
+  chmodSync(root, 448);
+  const journalPath = join3(root, `${operationId}.jsonl`);
+  const journal = openSync(journalPath, "wx", 384);
+  try {
+    fsyncSync(journal);
+  } finally {
+    closeSync(journal);
+  }
+  const directory = openSync(root, "r");
+  try {
+    fsyncSync(directory);
+  } finally {
+    closeSync(directory);
+  }
+  active = {
+    repositoryRoot: resolve4(repositoryRoot),
+    operationId,
+    journalPath,
+    paths: /* @__PURE__ */ new Set(),
+    blockedPaths: new Set(blockedPaths)
+  };
+}
+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 paths = readMutationPathDeclarations(operationId);
+  if (paths.length === 0) {
+    const journal = openSync(journalPath, "r");
+    closeSync(journal);
+  }
+  active = {
+    repositoryRoot: resolve4(repositoryRoot),
+    operationId,
+    journalPath,
+    paths: new Set(paths),
+    blockedPaths: new Set(blockedPaths)
+  };
+}
+function declareMutationPath(path) {
+  if (!active) return;
+  const absolute = isAbsolute3(path) ? resolve4(path) : resolve4(process.cwd(), path);
+  const relativePath = relative(active.repositoryRoot, absolute);
+  if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute3(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}.`);
+  }
+  if (active.paths.has(normalized)) return;
+  active.paths.add(normalized);
+  const fd = openSync(active.journalPath, "a", 384);
+  try {
+    writeSync(fd, `${JSON.stringify({ path: normalized })}
+`, void 0, "utf8");
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function declaredMutationPaths() {
+  return active ? [...active.paths].sort((a, b) => a.localeCompare(b)) : [];
+}
+function endMutationPathDeclarations() {
+  active = void 0;
+}
+function readMutationPathDeclarations(operationIdInput) {
+  const operationId = mutationOperationIdSchema.parse(operationIdInput);
+  const path = join3(mutationStateRoot(), "declarations", `${operationId}.jsonl`);
+  let content;
+  try {
+    content = readFileSync(path, "utf8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return [];
+    throw error;
+  }
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of content.split(/\r?\n/u).filter(Boolean)) {
+    const record = JSON.parse(line);
+    if (typeof record.path !== "string" || !record.path || record.path.startsWith("../") || record.path.includes("\\")) {
+      throw new Error(`Invalid mutation declaration journal for '${operationId}'.`);
+    }
+    paths.add(record.path);
+  }
+  return [...paths].sort((a, b) => a.localeCompare(b));
+}
+
+// src/model/workspace.ts
+var artifactSelectorListSchema = z6.array(z6.string().min(1));
+var CURRENT_WORKSPACE_SCHEMA_VERSION = 4;
+var workspaceSelectionImportSchema = z6.object({
+  export: z6.string().min(1),
+  add: artifactSelectorListSchema.optional(),
+  exclude: artifactSelectorListSchema.optional()
+}).strict();
+var workspaceSelectionExportSchema = z6.object({
+  extends: z6.string().min(1).optional(),
+  select: artifactSelectorListSchema.optional(),
+  add: artifactSelectorListSchema.optional(),
+  exclude: artifactSelectorListSchema.optional()
+}).strict().superRefine((selection, ctx) => {
+  if (selection.extends && selection.select) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["select"],
+      message: "Selection exports may use either select or extends, not both."
+    });
+  }
+  if (!selection.extends && !selection.select) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["select"],
+      message: "Selection exports without extends require select."
+    });
+  }
+});
+var workspaceExportsSchema = z6.object({
+  selections: z6.record(z6.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(),
+  installationType: installationTypeSchema.optional(),
+  mode: z6.enum(["pinned", "tracking"]).default("pinned"),
+  version: z6.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()
+});
+var workspacePackageSchema = workspacePackageBaseSchema.extend({
+  selection: workspaceSelectionImportSchema.optional()
+}).superRefine((pkg, ctx) => {
+  if (pkg.selection && (pkg.select !== void 0 || pkg.skills !== void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["selection"],
+      message: "Packages may use either selection or select/skills, not both."
+    });
+  }
+});
+var workspacePackageV1Schema = workspacePackageBaseSchema.extend({
+  selection: z6.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)
+}).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(),
+  installationType: installationTypeSchema.optional(),
+  stateKey: installStateKeySchema.optional(),
+  targetRoot: z6.string().min(1).optional(),
+  executePlugins: z6.boolean().optional(),
+  reloadRuntimes: z6.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),
+  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()
+}).strict().superRefine((member, ctx) => {
+  if (member.transport === "ssh" && !member.host) {
+    ctx.addIssue({ code: "custom", path: ["host"], message: "SSH profile members require host" });
+  }
+  if (member.transport === "ssh" && !member.workspace.startsWith("/")) {
+    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()
+}).strict();
+var workspaceCompositeProfileSchema = z6.object({
+  members: z6.array(workspaceProfileMemberSchema).min(1),
+  runtimes: z6.never().optional(),
+  refreshTtlSeconds: z6.number().int().positive().default(86400)
+}).strict().superRefine((profile, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, member] of profile.members.entries()) {
+    if (seen.has(member.id)) {
+      ctx.addIssue({ code: "custom", path: ["members", index, "id"], message: "Composite profile member ids must be unique" });
+    }
+    seen.add(member.id);
+  }
+});
+var workspaceProfileSchema = z6.union([
+  workspaceLeafProfileSchema,
+  workspaceCompositeProfileSchema
+]);
+var workspaceRegistrySchema = z6.object({
+  sources: z6.array(z6.string().min(1)).optional(),
+  ttlSeconds: z6.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()
+}).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),
+  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(),
+  reloadCommands: commandListSchema
+}).superRefine((agent, ctx) => {
+  if (agent.transport !== "ssh") return;
+  if (!agent.host) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["host"],
+      message: "SSH agents require host"
+    });
+  }
+});
+var workspaceConfigBaseSchema = z6.object({
+  bootstrapSkills: z6.boolean().optional(),
+  registry: workspaceRegistrySchema,
+  trust: workspaceTrustSchema,
+  profiles: z6.record(z6.string(), workspaceProfileSchema).default({}),
+  agents: z6.record(z6.string(), workspaceAgentSchema).default({})
+});
+var workspaceConfigV1Schema = workspaceConfigBaseSchema.extend({
+  schemaVersion: z6.literal(1),
+  packages: z6.array(workspacePackageV1Schema).default([]),
+  exports: z6.never().optional()
+}).strict();
+var workspaceConfigV2Schema = workspaceConfigBaseSchema.extend({
+  schemaVersion: z6.literal(2),
+  packages: z6.array(workspacePackageSchema).default([]),
+  exports: workspaceExportsSchema.default({ selections: {} })
+}).strict();
+var workspaceConfigV3Schema = workspaceConfigBaseSchema.extend({
+  schemaVersion: z6.literal(3),
+  packages: z6.array(workspacePackageSchema).default([]),
+  exports: workspaceExportsSchema.default({ selections: {} }),
+  fleetId: fleetIdSchema.optional(),
+  fleets: z6.record(fleetIdSchema, registeredFleetSchema).default({})
+}).strict();
+var workspaceConfigV4Schema = workspaceConfigBaseSchema.extend({
+  schemaVersion: z6.literal(CURRENT_WORKSPACE_SCHEMA_VERSION),
+  packages: z6.array(workspacePackageSchema).default([]),
+  exports: workspaceExportsSchema.default({ selections: {} }),
+  fleetId: fleetIdSchema.optional(),
+  fleets: z6.record(fleetIdSchema, registeredFleetSchema).default({}),
+  mutationPolicy: mutationPolicySchema.optional()
+}).strict();
+var workspaceConfigSchema = z6.discriminatedUnion("schemaVersion", [
+  workspaceConfigV1Schema,
+  workspaceConfigV2Schema,
+  workspaceConfigV3Schema,
+  workspaceConfigV4Schema
+]);
+function supportsFleetConfig(config) {
+  return config.schemaVersion === 3 || config.schemaVersion === 4;
+}
+function workspaceConfigPath(workspaceRoot) {
+  return join4(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")));
+}
+async function writeWorkspaceConfig(workspaceRoot, config) {
+  const path = workspaceConfigPath(workspaceRoot);
+  declareMutationPath(path);
+  await writeJsonAtomic(path, workspaceConfigSchema.parse(config));
+}
+function upsertPackage(config, entry) {
+  const parsed = workspaceConfigSchema.parse(config);
+  const packages = parsed.packages.filter((candidate) => candidate.name !== entry.name);
+  packages.push(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");
+}
+async function findWorkspaceRoot(start = process.cwd()) {
+  let current = resolve5(start);
+  while (true) {
+    if (await pathExists(workspaceConfigPath(current))) return current;
+    const parent = dirname4(current);
+    if (parent === current) return resolve5(start);
+    current = parent;
+  }
+}
+async function findExistingWorkspaceRoot(start = process.cwd()) {
+  let current = resolve5(start);
+  while (true) {
+    if (await pathExists(workspaceConfigPath(current))) return current;
+    const parent = dirname4(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+async function readMergedWorkspaceConfig(projectRoot, options = {}) {
+  const global = await readConfigPath(globalWorkspaceConfigPath(options.globalRoot));
+  const project = await readWorkspaceConfig(projectRoot);
+  return mergeWorkspaceConfig(global, project);
+}
+function mergeWorkspaceConfig(global, project) {
+  const schemaVersion = project.schemaVersion;
+  const exports = project.schemaVersion >= 2 ? project.exports : void 0;
+  return workspaceConfigSchema.parse({
+    schemaVersion,
+    packages: project.packages,
+    bootstrapSkills: project.bootstrapSkills,
+    registry: {
+      ...global.registry,
+      ...project.registry,
+      sources: project.registry.sources ?? global.registry.sources,
+      ttlSeconds: project.registry.ttlSeconds ?? global.registry.ttlSeconds
+    },
+    trust: mergeWorkspaceTrust(global.trust, project.trust),
+    profiles: project.profiles,
+    agents: project.agents,
+    ...exports ? { exports } : {},
+    ...supportsFleetConfig(project) ? { fleetId: project.fleetId, fleets: project.fleets } : {},
+    ...project.schemaVersion === 4 ? { mutationPolicy: project.mutationPolicy } : {}
+  });
+}
+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);
+}
+function emptyWorkspaceConfig() {
+  return { schemaVersion: 1, packages: [], registry: {}, trust: {}, profiles: {}, agents: {} };
+}
+function isCompositeWorkspaceProfile(profile) {
+  return "members" in profile && Array.isArray(profile.members);
+}
+async function readConfigPath(path) {
+  if (!await pathExists(path)) return emptyWorkspaceConfig();
+  return workspaceConfigSchema.parse(JSON.parse(await readFile4(path, "utf8")));
+}
+function mergeWorkspaceTrust(global, project) {
+  return {
+    allow: sortedUnique([...global?.allow ?? [], ...project?.allow ?? []]),
+    acceptedSources: sortedUnique([...global?.acceptedSources ?? [], ...project?.acceptedSources ?? []]),
+    denyArtifactTypes: sortedUnique([...global?.denyArtifactTypes ?? [], ...project?.denyArtifactTypes ?? []]),
+    requireReviewForTransitive: project?.requireReviewForTransitive ?? global?.requireReviewForTransitive
+  };
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+
+// 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 { 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();
+  });
+}
+
+// src/mutation/repository.ts
+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;
+  const root = probe.stdout.toString("utf8").trim();
+  const head = (await runProcess("git", ["-C", root, "rev-parse", "HEAD"])).stdout.toString("utf8").trim();
+  const branchProbe = await runProcess("git", ["-C", root, "symbolic-ref", "--quiet", "--short", "HEAD"], { allowExitCodes: [0, 1] });
+  if (branchProbe.exitCode !== 0) throw new Error(`Revisioning requires an attached Git branch at ${root}.`);
+  return { root, head, branch: branchProbe.stdout.toString("utf8").trim() };
+}
+async function assertGitPreflight(repository) {
+  const current = (await runProcess("git", ["-C", repository.root, "rev-parse", "HEAD"])).stdout.toString("utf8").trim();
+  if (current !== repository.head) throw new Error(`Git HEAD changed during mutation preflight: expected ${repository.head}, found ${current}.`);
+  const staged = await runProcess("git", ["-C", repository.root, "diff", "--cached", "--quiet"], { allowExitCodes: [0, 1] });
+  if (staged.exitCode !== 0) throw new Error("Revisioning requires a clean Git index; existing staged changes are not owned by this operation.");
+  const conflicts = (await runProcess("git", ["-C", repository.root, "diff", "--name-only", "--diff-filter=U", "-z"])).stdout;
+  if (conflicts.length > 0) throw new Error("Revisioning refuses a repository with unresolved Git conflicts.");
+  const gitDir = (await runProcess("git", ["-C", repository.root, "rev-parse", "--absolute-git-dir"])).stdout.toString("utf8").trim();
+  for (const marker of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
+    const result = await runProcess("git", ["-C", repository.root, "rev-parse", "--verify", "--quiet", marker], { allowExitCodes: [0, 1, 128] });
+    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}.`);
+  }
+}
+async function snapshotRepository(repositoryRoot) {
+  const paths = await changedRepositoryPaths(repositoryRoot);
+  const changed = /* @__PURE__ */ new Map();
+  for (const path of paths) changed.set(path, await hashWorkingPath(repositoryRoot, path));
+  return { changed };
+}
+async function collectIntroducedPaths(repositoryRoot, expectedHead, before, declaredPaths) {
+  const after = await snapshotRepository(repositoryRoot);
+  const touchedPreexisting = /* @__PURE__ */ new Set();
+  for (const [path, hash] of before.changed) {
+    if (!after.changed.has(path) || after.changed.get(path) !== hash) touchedPreexisting.add(path);
+  }
+  if (touchedPreexisting.size > 0) {
+    throw new Error(`Mutation touched pre-existing dirty paths: ${[...touchedPreexisting].sort().join(", ")}.`);
+  }
+  const introduced = [...after.changed.keys()].filter((path) => !before.changed.has(path)).sort((a, b) => a.localeCompare(b));
+  const allowed = new Set(declaredPaths);
+  const unexpected = introduced.filter((path) => !allowed.has(path));
+  if (unexpected.length > 0) {
+    throw new Error(`Mutation produced undeclared repository paths: ${unexpected.join(", ")}.`);
+  }
+  const result = [];
+  for (const path of introduced) {
+    result.push({
+      path,
+      beforeSha256: await hashHeadPath(repositoryRoot, expectedHead, path),
+      afterSha256: after.changed.get(path) ?? null
+    });
+  }
+  return result;
+}
+async function verifyRevisionPaths(repositoryRoot, expectedHead, paths) {
+  for (const entry of paths) {
+    const before = await hashHeadPath(repositoryRoot, expectedHead, entry.path);
+    const after = await hashWorkingPath(repositoryRoot, entry.path);
+    if (before !== entry.beforeSha256 || after !== entry.afterSha256) {
+      throw new Error(`Revision path lease changed for ${entry.path}.`);
+    }
+  }
+}
+async function currentHead(repositoryRoot) {
+  return (await runProcess("git", ["-C", repositoryRoot, "rev-parse", "HEAD"])).stdout.toString("utf8").trim();
+}
+async function changedRepositoryPaths(repositoryRoot) {
+  const result = await runProcess("git", [
+    "-C",
+    repositoryRoot,
+    "ls-files",
+    "-m",
+    "-d",
+    "-o",
+    "--exclude-standard",
+    "-z"
+  ]);
+  return [...new Set(splitNull(result.stdout).map(normalizeRepoPath))].sort((a, b) => a.localeCompare(b));
+}
+async function hashHeadPath(repositoryRoot, head, path) {
+  const result = await runProcess("git", ["-C", repositoryRoot, "show", `${head}:${path}`], { allowExitCodes: [0, 128] });
+  if (result.exitCode !== 0) return null;
+  return sha256(result.stdout);
+}
+async function hashWorkingPath(repositoryRoot, path) {
+  const absolute = resolve6(repositoryRoot, ...path.split("/"));
+  let stats;
+  try {
+    stats = await lstat(absolute);
+  } catch (error) {
+    if (isMissing2(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.isDirectory()) return hashDirectory(absolute);
+  throw new Error(`Unsupported repository path kind: ${path}`);
+}
+async function hashDirectory(root) {
+  const hash = createHash3("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 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");
+    }
+  }
+  await walk(root);
+  return hash.digest("hex");
+}
+function splitNull(value) {
+  return value.toString("utf8").split("\0").filter(Boolean);
+}
+function normalizeRepoPath(path) {
+  return sep2 === "/" ? path : path.split(sep2).join(posix2.sep);
+}
+function sha256(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function isMissing2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function exists(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (isMissing2(error)) return false;
+    throw error;
+  }
+}
+
+// src/mutation/providers.ts
+var RevisionProviderRejectedError = class extends Error {
+  constructor(response) {
+    super(`Revision provider '${response.providerId}' rejected ${response.action}: ${response.error}`);
+    this.response = response;
+    this.name = "RevisionProviderRejectedError";
+  }
+  response;
+};
+function revisionProviderRejection(error) {
+  return error instanceof RevisionProviderRejectedError ? error.response : void 0;
+}
+async function invokeRevisionProvider(configInput, input, options) {
+  const config = revisionProviderConfigSchema.parse(configInput);
+  const request = revisionProviderRequestSchema.parse(input);
+  const raw = config.kind === "git" ? await invokeGitProvider(config.id, request) : await invokeCommandProvider(
+    config.command,
+    config.executableSha256,
+    config.timeoutMs,
+    request,
+    options.afterCommandExecutablePinned
+  );
+  const failure = revisionProviderErrorResponseSchema.safeParse(raw);
+  if (failure.success) {
+    assertProviderCorrelation(config.id, request, failure.data);
+    throw new RevisionProviderRejectedError(failure.data);
+  }
+  const response = revisionProviderResponseSchema.parse(raw);
+  assertProviderCorrelation(config.id, request, response);
+  assertProviderStatus(response);
+  await assertProviderSemantics(request, response);
+  return response;
+}
+function assertProviderCorrelation(providerId, request, response) {
+  if (response.providerId !== providerId) {
+    throw new Error(`Revision provider id mismatch: expected ${providerId}, found ${response.providerId}.`);
+  }
+  if (response.action !== request.action) {
+    throw new Error(`Revision provider action mismatch: expected ${request.action}, found ${response.action}.`);
+  }
+  if (response.operationId !== request.operationId) {
+    throw new Error(`Revision provider operation mismatch: expected ${request.operationId}, found ${response.operationId}.`);
+  }
+}
+function assertProviderStatus(response) {
+  const allowed = {
+    check: ["ready"],
+    preflight: ["prepared", "product_committed", "stack_owned", "control_committed", "verified"],
+    release: ["released"],
+    finalize: ["verified", "already-verified", "revisioning-skipped", "no-repository-delta"],
+    recover: ["verified", "already-verified", "revisioning-skipped", "no-repository-delta"]
+  };
+  if (!allowed[response.action].includes(response.status)) {
+    throw new Error(`Revision provider returned invalid ${response.action} status '${response.status}'.`);
+  }
+}
+async function invokeCommandProvider(command, executableSha256, timeoutMs, request, afterExecutablePinned) {
+  const [executable, ...args] = command;
+  const descriptorPath = immutableDescriptorExecutablePath();
+  const executableBytes = await readVerifiedExecutable(executable, executableSha256);
+  const executableHandle = await openImmutableExecutableSnapshot(executableBytes);
+  let result;
+  try {
+    await afterExecutablePinned?.(executable);
+    result = await runProcess(descriptorPath, args, {
+      cwd: request.repositoryRoot,
+      input: `${JSON.stringify(request)}
+`,
+      allowExitCodes: [0, 2],
+      maxOutputBytes: 65536,
+      includeFailureOutput: false,
+      timeoutMs,
+      inheritedFileDescriptor: executableHandle.fd,
+      killProcessGroup: true
+    });
+  } finally {
+    await executableHandle.close();
+  }
+  const output = result.stdout.toString("utf8").trim();
+  if (!output) throw new Error(`Revision provider command '${executable}' returned no JSON response.`);
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    throw new Error(`Revision provider command '${executable}' returned invalid JSON.`);
+  }
+  if (result.exitCode === 2 && parsed.ok !== false) {
+    throw new Error(`Revision provider command '${executable}' exited 2 without a protocol rejection.`);
+  }
+  if (result.exitCode === 0 && parsed.ok === false) {
+    throw new Error(`Revision provider command '${executable}' returned a rejection with exit 0.`);
+  }
+  return parsed;
+}
+async function readVerifiedExecutable(executable, expectedSha256) {
+  const handle = await open2(executable, "r");
+  try {
+    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");
+    if (actualSha256 !== expectedSha256) {
+      throw new Error(
+        `Revision provider executable hash mismatch for ${executable}: expected ${expectedSha256}, found ${actualSha256}.`
+      );
+    }
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+async function openImmutableExecutableSnapshot(bytes) {
+  if (process.platform !== "linux") {
+    throw new Error(
+      `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");
+  let snapshot;
+  try {
+    await chmod2(root, 448);
+    const writer = await open2(path, "wx", 320);
+    try {
+      await writer.writeFile(bytes);
+      await writer.sync();
+    } finally {
+      await writer.close();
+    }
+    snapshot = await open2(path, "r");
+    await rm3(path);
+    await rmdir(root);
+    return snapshot;
+  } catch (error) {
+    await snapshot?.close().catch(() => void 0);
+    await rm3(root, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function immutableDescriptorExecutablePath() {
+  if (process.platform === "linux") return "/proc/self/fd/3";
+  throw new Error(
+    `Command revision providers require an unlinked immutable executable snapshot, which is unsupported on ${process.platform}.`
+  );
+}
+async function assertProviderSemantics(request, response) {
+  if (response.action !== "finalize" && response.action !== "recover") return;
+  if (response.expectedHead !== request.expectedHead) {
+    throw new Error(`Revision provider expectedHead mismatch: expected ${request.expectedHead}, found ${response.expectedHead}.`);
+  }
+  if (response.unmappedIntegrationCommits.length > 0) {
+    throw new Error(`Revision provider cannot report terminal success with unmapped integration commits: ${response.unmappedIntegrationCommits.join(", ")}.`);
+  }
+  const ownership = [response.draftStackId, response.draftBranch, response.draftTipSha, response.controlCommitSha];
+  const ownsDraft = ownership.some((value) => value !== null);
+  if (ownsDraft && ownership.some((value) => value === null)) {
+    throw new Error("Revision provider returned incomplete draft ownership fields.");
+  }
+  if (ownsDraft && response.manifestDigest === null) {
+    throw new Error("Revision provider returned draft ownership without a manifest digest.");
+  }
+  if (request.noCommit) {
+    if (response.status !== "revisioning-skipped") {
+      throw new Error(`noCommit requires revisioning-skipped, found ${response.status}.`);
+    }
+    if (response.productCommitSha || ownsDraft || response.resultingHead !== request.expectedHead) {
+      throw new Error("A noCommit response may not create product/control commits or draft ownership.");
+    }
+  } else if (request.paths.length === 0) {
+    if (response.status !== "no-repository-delta") {
+      throw new Error(`An empty path set requires no-repository-delta, found ${response.status}.`);
+    }
+    if (response.productCommitSha || ownsDraft || response.resultingHead !== request.expectedHead) {
+      throw new Error("A no-repository-delta response may not create product/control commits or draft ownership.");
+    }
+  } else {
+    if (!(/* @__PURE__ */ new Set(["verified", "already-verified"])).has(response.status) || !response.productCommitSha) {
+      throw new Error("A non-empty committed mutation requires a verified product commit.");
+    }
+    await verifyOperationCommit(
+      request,
+      response.productCommitSha
+    );
+    const terminalCommit = response.controlCommitSha ?? response.productCommitSha;
+    if (response.resultingHead !== terminalCommit) {
+      throw new Error(`Revision provider resultingHead ${response.resultingHead} does not match terminal commit ${terminalCommit}.`);
+    }
+    if (response.controlCommitSha) {
+      const parent = (await runProcess("git", ["-C", request.repositoryRoot, "rev-parse", `${response.controlCommitSha}^`])).stdout.toString("utf8").trim();
+      if (parent !== response.productCommitSha) {
+        throw new Error(`Revision provider control commit ${response.controlCommitSha} does not descend directly from the product commit.`);
+      }
+    }
+    if (response.draftBranch) {
+      await runProcess("git", ["-C", request.repositoryRoot, "check-ref-format", "--branch", response.draftBranch]);
+      const branchHead = (await runProcess(
+        "git",
+        ["-C", request.repositoryRoot, "rev-parse", "--verify", `refs/heads/${response.draftBranch}`]
+      )).stdout.toString("utf8").trim();
+      if (branchHead !== response.draftTipSha) {
+        throw new Error(
+          `Revision provider draft branch ${response.draftBranch} points to ${branchHead}, not draft tip ${response.draftTipSha}.`
+        );
+      }
+    }
+  }
+  const head = await currentHead(request.repositoryRoot);
+  if (head !== response.resultingHead) {
+    throw new Error(`Revision provider resultingHead ${response.resultingHead} does not match repository HEAD ${head}.`);
+  }
+}
+async function invokeGitProvider(providerId, request) {
+  const repository = await discoverGitRepository(request.repositoryRoot);
+  if (!repository || repository.root !== resolve7(request.repositoryRoot)) {
+    throw new Error(`Git revision provider requires the repository root itself: ${request.repositoryRoot}.`);
+  }
+  if (request.action === "check" || request.action === "preflight") {
+    if (repository.head !== request.expectedHead) {
+      if (request.action === "check") {
+        throw new Error(`Git HEAD lease mismatch: expected ${request.expectedHead}, found ${repository.head}.`);
+      }
+      const planDigest = providerPlanDigest(request);
+      const existing = await findOperationCommit(request.repositoryRoot, request.operationId, planDigest);
+      if (!existing) throw new Error(`Git HEAD lease mismatch: expected ${request.expectedHead}, found ${repository.head}.`);
+      await verifyOperationCommit(asTerminalRequest(request, "recover"), existing);
+      return revisionProviderResponseSchema.parse(baseResponse(providerId, request, "prepared"));
+    }
+    await assertGitPreflight(repository);
+    await assertGitProviderCompatible(request.repositoryRoot);
+    await assertGitIdentity(request.repositoryRoot);
+    return revisionProviderResponseSchema.parse(baseResponse(providerId, request, request.action === "check" ? "ready" : "prepared"));
+  }
+  if (request.action === "release") return revisionProviderResponseSchema.parse(baseResponse(providerId, request, "released"));
+  return finalizeGit(providerId, request);
+}
+async function finalizeGit(providerId, request) {
+  const planDigest = providerPlanDigest(request);
+  const existing = await findOperationCommit(request.repositoryRoot, request.operationId, planDigest);
+  if (existing) {
+    await verifyOperationCommit(request, existing);
+    await realignIndexAfterRecoveredCommit(request.repositoryRoot, request.expectedHead, existing);
+    return terminalResponse(providerId, request, "already-verified", existing, await currentHead(request.repositoryRoot));
+  }
+  const repository = await discoverGitRepository(request.repositoryRoot);
+  if (!repository) throw new Error(`No Git repository at ${request.repositoryRoot}.`);
+  if (repository.head !== request.expectedHead) {
+    throw new Error(`Git HEAD lease mismatch: expected ${request.expectedHead}, found ${repository.head}.`);
+  }
+  await assertGitPreflight(repository);
+  await assertGitProviderCompatible(request.repositoryRoot);
+  await assertGitIdentity(request.repositoryRoot);
+  await verifyRevisionPaths(request.repositoryRoot, request.expectedHead, request.paths);
+  if (request.noCommit || request.paths.length === 0) {
+    return terminalResponse(providerId, request, request.noCommit ? "revisioning-skipped" : "no-repository-delta", null, repository.head);
+  }
+  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 env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  let commitSha;
+  try {
+    await runProcess("git", ["-C", request.repositoryRoot, "read-tree", request.expectedHead], { env });
+    await runProcess("git", ["-C", request.repositoryRoot, "add", "--", ...request.paths.map((entry) => entry.path)], { env });
+    const staged = splitNull2((await runProcess("git", ["-C", request.repositoryRoot, "diff", "--cached", "--name-only", "-z"], { env })).stdout);
+    assertExactSet(staged, request.paths.map((entry) => entry.path), "temporary Git index");
+    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");
+    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");
+    assertCommitMessageContract(message, request, planDigest);
+    commitSha = (await runProcess("git", ["-C", request.repositoryRoot, "commit-tree", tree, "-p", request.expectedHead], {
+      env,
+      input: message
+    })).stdout.toString("utf8").trim();
+  } finally {
+    await rm3(tempRoot, { recursive: true, force: true });
+  }
+  const branchRef = (await runProcess("git", ["-C", request.repositoryRoot, "symbolic-ref", "HEAD"])).stdout.toString("utf8").trim();
+  await runProcess("git", [
+    "-C",
+    request.repositoryRoot,
+    "update-ref",
+    "-m",
+    `agentwheel ${request.operationId}`,
+    branchRef,
+    commitSha,
+    request.expectedHead
+  ]);
+  await replaceIndexCas(request.repositoryRoot, indexLease, commitSha);
+  await verifyOperationCommit(request, commitSha);
+  return terminalResponse(providerId, request, "verified", commitSha, commitSha);
+}
+async function runCommitHooks(request, env, messagePath) {
+  for (const [name, args] of [
+    ["pre-commit", []],
+    ["prepare-commit-msg", [messagePath, "message"]],
+    ["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);
+    let executable = false;
+    try {
+      executable = ((await stat(hookPath)).mode & 73) !== 0;
+    } catch (error) {
+      if (!isMissing3(error)) throw error;
+    }
+    if (!executable) continue;
+    try {
+      await runProcess(hookPath, [...args], {
+        cwd: request.repositoryRoot,
+        env: {
+          ...env,
+          AGENTWHEEL_OPERATION_ID: request.operationId,
+          AGENTWHEEL_COMMAND_NAME: request.commandName
+        },
+        maxOutputBytes: 65536,
+        includeFailureOutput: false
+      });
+    } catch {
+      throw new Error(`Git ${name} hook rejected Agentwheel mutation ${request.operationId}.`);
+    }
+  }
+}
+function assertCommitMessageContract(message, request, planDigest) {
+  if (!message.includes(request.reason.trim())) {
+    throw new Error("Git commit hooks removed or changed the full Agentwheel mutation reason.");
+  }
+  for (const trailer of [
+    `Agentwheel-Operation: ${request.operationId}`,
+    `Agentwheel-Plan: ${planDigest}`
+  ]) {
+    if (!message.split(/\r?\n/u).includes(trailer)) {
+      throw new Error(`Git commit hooks removed required trailer: ${trailer}.`);
+    }
+  }
+}
+function assertRepositorySnapshotEqual(before, after, label) {
+  const entries = (snapshot) => [...snapshot.changed.entries()].sort(([a], [b]) => a.localeCompare(b));
+  if (JSON.stringify(entries(before)) !== JSON.stringify(entries(after))) {
+    throw new Error(`${label} changed repository working state outside the governed commit contract.`);
+  }
+}
+async function findOperationCommit(repositoryRoot, operationId, planDigest) {
+  const output = (await runProcess("git", ["-C", repositoryRoot, "log", "--format=%H%x1f%B%x1e", "--max-count=500", "HEAD"])).stdout.toString("utf8");
+  for (const record of output.split("")) {
+    const separator = record.indexOf("");
+    if (separator < 0) continue;
+    const sha = record.slice(0, separator).trim();
+    const message = record.slice(separator + 1);
+    if (message.split(/\r?\n/u).includes(`Agentwheel-Operation: ${operationId}`) && message.split(/\r?\n/u).includes(`Agentwheel-Plan: ${planDigest}`)) return sha;
+  }
+  return void 0;
+}
+async function verifyOperationCommit(request, commitSha) {
+  const parent = (await runProcess("git", ["-C", request.repositoryRoot, "rev-parse", `${commitSha}^`])).stdout.toString("utf8").trim();
+  if (parent !== request.expectedHead) throw new Error(`Recovered operation commit ${commitSha} has unexpected parent ${parent}.`);
+  const committedPaths = splitNull2((await runProcess("git", [
+    "-C",
+    request.repositoryRoot,
+    "diff-tree",
+    "--no-commit-id",
+    "--name-only",
+    "-r",
+    "-z",
+    commitSha
+  ])).stdout);
+  assertExactSet(committedPaths, request.paths.map((entry) => entry.path), `operation commit ${commitSha}`);
+  for (const entry of request.paths) {
+    const after = await hashGitObject(request.repositoryRoot, `${commitSha}:${entry.path}`);
+    if (after !== entry.afterSha256) {
+      throw new Error(`Operation commit ${commitSha} content mismatch for ${entry.path}.`);
+    }
+  }
+}
+async function realignIndexAfterRecoveredCommit(repositoryRoot, expectedHead, commitSha) {
+  if (await currentHead(repositoryRoot) !== commitSha) return;
+  const staged = await runProcess("git", ["-C", repositoryRoot, "diff", "--cached", "--quiet"], { allowExitCodes: [0, 1] });
+  if (staged.exitCode === 0) return;
+  await assertIndexTree(repositoryRoot, expectedHead);
+  await replaceIndexCas(repositoryRoot, await captureIndexLease(repositoryRoot), commitSha);
+}
+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);
+  try {
+    const [content, info] = await Promise.all([readFile6(path), stat(path)]);
+    return { path, sha256: sha2562(content), mode: info.mode & 511 };
+  } catch (error) {
+    if (isMissing3(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 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);
+    handle = await open2(lockPath, "wx", lease.mode);
+    const current = await readOptionalFile(lease.path);
+    const currentSha256 = current ? sha2562(current) : null;
+    if (currentSha256 !== lease.sha256) {
+      throw new Error("Git index changed concurrently; the operation commit was preserved but index alignment was refused.");
+    }
+    await handle.writeFile(replacement);
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await chmod2(lockPath, lease.mode);
+    await rename3(lockPath, lease.path);
+  } finally {
+    await handle?.close().catch(() => void 0);
+    await rm3(lockPath, { force: true }).catch(() => void 0);
+    await rm3(tempRoot, { recursive: true, force: true });
+  }
+}
+async function assertIndexTree(repositoryRoot, expectedHead) {
+  const indexTree = (await runProcess("git", ["-C", repositoryRoot, "write-tree"])).stdout.toString("utf8").trim();
+  const expectedTree = (await runProcess("git", ["-C", repositoryRoot, "rev-parse", `${expectedHead}^{tree}`])).stdout.toString("utf8").trim();
+  if (indexTree !== expectedTree) {
+    throw new Error("Revisioning requires the real Git index to match the expected HEAD tree exactly.");
+  }
+}
+async function verifyTemporaryIndexPaths(request, env) {
+  for (const entry of request.paths) {
+    const result = await runProcess("git", ["-C", request.repositoryRoot, "show", `:${entry.path}`], {
+      env,
+      allowExitCodes: [0, 128]
+    });
+    const actual = result.exitCode === 0 ? sha2562(result.stdout) : null;
+    if (actual !== entry.afterSha256) throw new Error(`Temporary Git index content mismatch for ${entry.path}.`);
+  }
+}
+async function hashGitObject(repositoryRoot, spec) {
+  const result = await runProcess("git", ["-C", repositoryRoot, "show", spec], { allowExitCodes: [0, 128] });
+  return result.exitCode === 0 ? sha2562(result.stdout) : null;
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile6(path);
+  } catch (error) {
+    if (isMissing3(error)) return null;
+    throw error;
+  }
+}
+function sha2562(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
+function isMissing3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function assertGitProviderCompatible(repositoryRoot) {
+  const trackedSyncwheelManifest = await runProcess("git", [
+    "-C",
+    repositoryRoot,
+    "ls-files",
+    "--error-unmatch",
+    ".syncwheel/manifest.json"
+  ], { allowExitCodes: [0, 1] });
+  if (trackedSyncwheelManifest.exitCode === 0) {
+    throw new Error("The builtin Git revision provider refuses a tracked .syncwheel/manifest.json; configure an external coordination provider.");
+  }
+}
+async function assertGitIdentity(repositoryRoot) {
+  for (const identity of ["GIT_AUTHOR_IDENT", "GIT_COMMITTER_IDENT"]) {
+    const result = await runProcess("git", ["-C", repositoryRoot, "var", identity], { allowExitCodes: [0, 128] });
+    if (result.exitCode !== 0 || !result.stdout.toString("utf8").trim()) {
+      throw new Error(`Git revisioning requires a configured ${identity === "GIT_AUTHOR_IDENT" ? "author" : "committer"} identity.`);
+    }
+  }
+}
+function terminalResponse(providerId, request, status, productCommitSha, resultingHead) {
+  return revisionProviderResponseSchema.parse({
+    ...baseResponse(providerId, request, status),
+    expectedHead: request.expectedHead,
+    resultingHead,
+    productCommitSha,
+    draftStackId: null,
+    draftBranch: null,
+    draftTipSha: null,
+    controlCommitSha: null,
+    manifestDigest: request.expectedManifestDigest ?? null,
+    unmappedIntegrationCommits: [],
+    published: false
+  });
+}
+function baseResponse(providerId, request, status) {
+  return {
+    protocolVersion: request.protocolVersion,
+    providerId,
+    action: request.action,
+    operationId: request.operationId,
+    ok: true,
+    status
+  };
+}
+function providerPlanDigest(request) {
+  return revisionRequestDigest(revisionProviderRequestSchema.parse({ ...request, action: "finalize" }));
+}
+function asTerminalRequest(request, action) {
+  return revisionProviderRequestSchema.parse({ ...request, action });
+}
+function commitMessage(request, planDigest) {
+  const subjectCommand = request.commandName.replace(/\s+/gu, " ").trim().slice(0, 120);
+  return [
+    `chore(agentwheel): ${subjectCommand}`,
+    "",
+    request.reason.trim(),
+    "",
+    `Agentwheel-Operation: ${request.operationId}`,
+    `Agentwheel-Plan: ${planDigest}`,
+    ""
+  ].join("\n");
+}
+function assertExactSet(actualInput, expectedInput, label) {
+  const actual = [...new Set(actualInput)].sort((a, b) => a.localeCompare(b));
+  const expected = [...new Set(expectedInput)].sort((a, b) => a.localeCompare(b));
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(`Exact path mismatch in ${label}: expected [${expected.join(", ")}], found [${actual.join(", ")}].`);
+  }
+}
+function splitNull2(value) {
+  return value.toString("utf8").split("\0").filter(Boolean);
+}
+
+// src/mutation/coordinator.ts
+var GovernedMutation = class _GovernedMutation {
+  constructor(policy, receipt, baseline, lock) {
+    this.policy = policy;
+    this.receipt = receipt;
+    this.baseline = baseline;
+    this.lock = lock;
+    this.operationId = receipt.operationId;
+  }
+  policy;
+  receipt;
+  baseline;
+  lock;
+  operationId;
+  closed = false;
+  static async begin(options) {
+    const policy = await mutationPolicyForWorkspace(options.workspaceRoot, options.globalRoot);
+    if (!policy) {
+      if (options.noCommit) throw new Error("--no-commit requires an effective commit-after-verify mutation policy.");
+      return void 0;
+    }
+    const reason = normalizeReason(options.reason, options.commandName, policy);
+    if (policy.revisioning.mode === "off") {
+      if (options.noCommit) throw new Error("--no-commit is only valid when revisioning.mode is commit-after-verify.");
+      if (policy.journal === "off") return void 0;
+    } else if (options.noCommit && !policy.revisioning.allowNoCommitOverride) {
+      throw new Error("This workspace does not allow the audited --no-commit override.");
+    }
+    const operationId = mutationOperationIdSchema.parse(options.operationId ?? randomUUID2());
+    const repository = await discoverGitRepository(options.workspaceRoot);
+    if (policy.revisioning.mode === "commit-after-verify" && !repository) {
+      throw new Error(`commit-after-verify requires a Git repository containing ${options.workspaceRoot}.`);
+    }
+    if (policy.revisioning.mode === "commit-after-verify" && options.requiresDeclarativeRepositoryDelta) {
+      throw new Error(
+        `${options.commandName} is a runtime-only ownership transition with no durable declarative repository representation; commit-after-verify refuses it before writes.`
+      );
+    }
+    if (policy.revisioning.mode === "commit-after-verify" && repository) {
+      for (const additionalRoot of options.additionalWorkspaceRoots ?? []) {
+        const additionalRepository = await discoverGitRepository(additionalRoot);
+        if (!additionalRepository || additionalRepository.root !== repository.root) {
+          throw new Error(
+            "commit-after-verify refuses a mutation spanning multiple repositories or non-repository state; split it into governed single-repository operations."
+          );
+        }
+      }
+    }
+    const lock = await acquireMutationLock(repository?.root ?? options.workspaceRoot, operationId);
+    let baseline;
+    let receipt;
+    try {
+      baseline = repository ? await snapshotRepository(repository.root) : void 0;
+      receipt = await createMutationReceipt({
+        operationId,
+        commandName: options.commandName,
+        reason,
+        noCommit: options.noCommit === true,
+        workspaceRoot: options.workspaceRoot,
+        repositoryRoot: repository?.root ?? null,
+        expectedHead: repository?.head ?? null,
+        expectedManifestDigest: null,
+        revisionMode: policy.revisioning.mode,
+        provider: policy.revisioning.mode === "commit-after-verify" ? policy.revisioning.provider : null,
+        preexistingPaths: snapshotEntries(baseline),
+        paths: [],
+        runtimeJournals: [],
+        status: "prepared"
+      });
+      if (policy.revisioning.mode === "commit-after-verify" && options.requireCleanWorkingTree && baseline && baseline.changed.size > 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(", ")}.`
+        );
+      }
+      beginMutationPathDeclarations(
+        repository?.root ?? options.workspaceRoot,
+        operationId,
+        baseline?.changed.keys()
+      );
+      for (const path of options.anticipatedPaths ?? []) declareMutationPath(path);
+      if (policy.revisioning.mode === "commit-after-verify" && repository) {
+        await invokeRevisionProvider(policy.revisioning.provider, providerRequest(receipt, "check", []), {
+          workspaceRoot: options.workspaceRoot
+        });
+      }
+      const mutation = new _GovernedMutation(policy, receipt, baseline, lock);
+      activeMutation = mutation;
+      return mutation;
+    } catch (error) {
+      if (receipt) {
+        await updateMutationReceipt(receipt, { status: "precheck-failed", error: sanitizeError(error) }).catch(() => void 0);
+      }
+      endMutationPathDeclarations();
+      await lock.release();
+      throw error;
+    }
+  }
+  async complete(action = "finalize") {
+    if (this.closed) return this.receipt;
+    let paths;
+    try {
+      const pendingRuntimeJournals = this.receipt.runtimeJournals.filter((entry) => entry.status !== "resolved");
+      if (pendingRuntimeJournals.length > 0) {
+        throw new Error(
+          `Runtime apply verification is incomplete: ${pendingRuntimeJournals.map((entry) => entry.path).join(", ")}.`
+        );
+      }
+      this.receipt = await updateMutationReceipt(this.receipt, { status: "handler-succeeded" });
+      paths = await this.collectPaths();
+      this.receipt = await updateMutationReceipt(this.receipt, { paths, status: "mutation-applied" });
+    } catch (error) {
+      this.receipt = await updateMutationReceipt(this.receipt, {
+        status: "postcheck-failed",
+        error: sanitizeError(error)
+      });
+      await this.close();
+      throw new Error(`Agentwheel mutation ${this.operationId} failed its repository postcheck: ${sanitizeError(error)}`);
+    }
+    try {
+      if (this.policy.revisioning.mode === "off") {
+        this.receipt = await updateMutationReceipt(this.receipt, {
+          status: paths.length === 0 ? "no-repository-delta" : "succeeded"
+        });
+        return this.receipt;
+      }
+      const provider = this.policy.revisioning.provider;
+      await invokeRevisionProvider(provider, providerRequest(this.receipt, "preflight", paths), {
+        workspaceRoot: this.receipt.workspaceRoot
+      });
+      const response = await invokeRevisionProvider(provider, providerRequest(this.receipt, action, paths), {
+        workspaceRoot: this.receipt.workspaceRoot
+      });
+      this.receipt = await updateMutationReceipt(this.receipt, {
+        status: receiptStatusForProvider(response.status),
+        providerResponse: response
+      });
+      return this.receipt;
+    } catch (error) {
+      this.receipt = await updateMutationReceipt(this.receipt, {
+        status: "commit-pending",
+        ...revisionProviderRejection(error) ? { providerResponse: revisionProviderRejection(error) } : {},
+        error: sanitizeError(error)
+      });
+      throw new Error(`Agentwheel mutation ${this.operationId} is commit-pending: ${sanitizeError(error)}`);
+    } finally {
+      await this.close();
+    }
+  }
+  async fail(error) {
+    if (this.closed) return;
+    try {
+      let paths = this.receipt.paths;
+      try {
+        paths = await this.collectPaths();
+      } catch {
+      }
+      this.receipt = await updateMutationReceipt(this.receipt, {
+        paths,
+        status: "partial",
+        error: sanitizeError(error)
+      });
+      if (this.policy.revisioning.mode === "commit-after-verify") {
+        await invokeRevisionProvider(
+          this.policy.revisioning.provider,
+          providerRequest(this.receipt, "release", paths),
+          { workspaceRoot: this.receipt.workspaceRoot }
+        ).catch(() => void 0);
+      }
+    } finally {
+      await this.close();
+    }
+  }
+  metadata() {
+    return {
+      operationId: this.receipt.operationId,
+      reason: this.receipt.reason,
+      noCommit: this.receipt.noCommit,
+      revisionMode: this.receipt.revisionMode
+    };
+  }
+  async transitionRuntimeJournal(link2, status) {
+    const runtimeJournals = upsertRuntimeJournal(this.receipt.runtimeJournals, link2, status);
+    this.receipt = await updateMutationReceipt(this.receipt, { runtimeJournals });
+  }
+  async transitionExistingRuntimeJournal(path, status) {
+    const existing = this.receipt.runtimeJournals.find((entry) => entry.path === path);
+    if (!existing) throw new Error(`Mutation '${this.operationId}' has no runtime journal link for ${path}.`);
+    const runtimeJournals = upsertRuntimeJournal(this.receipt.runtimeJournals, existing, status);
+    this.receipt = await updateMutationReceipt(this.receipt, { runtimeJournals });
+  }
+  static activateExisting(receipt, baseline, lock) {
+    if (receipt.revisionMode === "commit-after-verify" && !receipt.provider) {
+      throw new Error(`Mutation '${receipt.operationId}' is missing its revision provider recovery policy.`);
+    }
+    const policy = mutationPolicySchema.parse(receipt.revisionMode === "commit-after-verify" ? {
+      reason: "required",
+      journal: "required",
+      revisioning: {
+        mode: "commit-after-verify",
+        allowNoCommitOverride: true,
+        reasonInCommit: "full",
+        provider: receipt.provider
+      }
+    } : {
+      reason: "required",
+      journal: "required",
+      revisioning: { mode: "off" }
+    });
+    const mutation = new _GovernedMutation(policy, receipt, baseline, lock);
+    activeMutation = mutation;
+    return mutation;
+  }
+  async collectPaths() {
+    if (!this.receipt.repositoryRoot || !this.receipt.expectedHead || !this.baseline) return [];
+    const declarations = [.../* @__PURE__ */ new Set([
+      ...declaredMutationPaths(),
+      ...readMutationPathDeclarations(this.receipt.operationId)
+    ])].sort((a, b) => a.localeCompare(b));
+    return collectIntroducedPaths(this.receipt.repositoryRoot, this.receipt.expectedHead, this.baseline, declarations);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (activeMutation === this) activeMutation = void 0;
+    endMutationPathDeclarations();
+    await this.lock.release();
+  }
+};
+var activeMutation;
+function activeMutationMetadata() {
+  return activeMutation?.metadata();
+}
+async function reserveActiveRuntimeJournal(link2) {
+  await activeMutation?.transitionRuntimeJournal(link2, "reserved");
+}
+async function activateActiveRuntimeJournal(link2) {
+  await activeMutation?.transitionRuntimeJournal(link2, "pending");
+}
+async function beginResolveMutationRuntimeJournal(operationId, path) {
+  await transitionMutationRuntimeJournal(operationId, path, "resolving");
+}
+async function resolveMutationRuntimeJournal(operationId, path) {
+  await transitionMutationRuntimeJournal(operationId, path, "resolved");
+}
+async function transitionMutationRuntimeJournal(operationId, path, status) {
+  if (activeMutation?.operationId === operationId) {
+    await activeMutation.transitionExistingRuntimeJournal(path, status);
+    return;
+  }
+  const receipt = await readMutationReceipt(operationId);
+  const existing = receipt.runtimeJournals.find((entry) => entry.path === path);
+  if (!existing) throw new Error(`Mutation '${operationId}' has no runtime journal link for ${path}.`);
+  await updateMutationReceipt(receipt, {
+    runtimeJournals: upsertRuntimeJournal(receipt.runtimeJournals, existing, status)
+  });
+}
+async function resumeMutation(operationId, action) {
+  let receipt = await readMutationReceipt(operationId);
+  if (["succeeded", "revisioning-skipped", "no-repository-delta"].includes(receipt.status)) return receipt;
+  if (["prepared", "precheck-failed", "partial", "postcheck-failed", "failed"].includes(receipt.status)) {
+    throw new Error(
+      `Mutation '${receipt.operationId}' is ${receipt.status}; finalize/recover is refused because handler success and runtime journal resolution were not verified.`
+    );
+  }
+  const pendingRuntimeJournals = receipt.runtimeJournals.filter((entry) => entry.status !== "resolved");
+  if (pendingRuntimeJournals.length > 0) {
+    throw new Error(
+      `Mutation '${receipt.operationId}' still has unresolved runtime apply journals: ${pendingRuntimeJournals.map((entry) => entry.path).join(", ")}.`
+    );
+  }
+  if (!receipt.provider || !receipt.repositoryRoot || !receipt.expectedHead || receipt.revisionMode !== "commit-after-verify") {
+    throw new Error(`Mutation '${receipt.operationId}' has no revision provider recovery contract.`);
+  }
+  const provider = receipt.provider;
+  const repositoryRoot = receipt.repositoryRoot;
+  const expectedHead = receipt.expectedHead;
+  const lock = await acquireMutationLock(repositoryRoot, receipt.operationId);
+  try {
+    let paths = receipt.paths;
+    const head = await currentHead(repositoryRoot);
+    if (paths.length === 0 && head === expectedHead) {
+      paths = await collectIntroducedPaths(
+        repositoryRoot,
+        expectedHead,
+        snapshotFromReceipt(receipt),
+        readMutationPathDeclarations(receipt.operationId)
+      );
+      receipt = await updateMutationReceipt(receipt, { paths, status: "mutation-applied" });
+    }
+    await invokeRevisionProvider(provider, providerRequest(receipt, "preflight", paths), {
+      workspaceRoot: receipt.workspaceRoot
+    });
+    const response = await invokeRevisionProvider(provider, providerRequest(receipt, action, paths), {
+      workspaceRoot: receipt.workspaceRoot
+    });
+    return updateMutationReceipt(receipt, {
+      status: receiptStatusForProvider(response.status),
+      providerResponse: response,
+      error: void 0
+    });
+  } catch (error) {
+    receipt = await updateMutationReceipt(receipt, {
+      status: "commit-pending",
+      ...revisionProviderRejection(error) ? { providerResponse: revisionProviderRejection(error) } : {},
+      error: sanitizeError(error)
+    });
+    throw error;
+  } finally {
+    await lock.release();
+  }
+}
+async function recoverMutationRuntime(operationId, options = {}) {
+  let receipt = await readMutationReceipt(operationId);
+  const lockRoot = receipt.repositoryRoot ?? receipt.workspaceRoot;
+  const lock = await acquireMutationLock(lockRoot, receipt.operationId);
+  try {
+    await options.afterLockAcquired?.();
+    receipt = await readMutationReceipt(operationId);
+    assertRuntimeRecoveryReceipt(receipt);
+  } catch (error) {
+    await lock.release();
+    throw error;
+  }
+  const pending = receipt.runtimeJournals.filter((entry) => entry.status !== "resolved");
+  const baseline = receipt.repositoryRoot ? snapshotFromReceipt(receipt) : void 0;
+  const declarationRoot = receipt.repositoryRoot ?? receipt.workspaceRoot;
+  let mutation;
+  resumeMutationPathDeclarations(declarationRoot, receipt.operationId, baseline?.changed.keys());
+  try {
+    if (receipt.repositoryRoot && receipt.expectedHead && baseline) {
+      const declarations = readMutationPathDeclarations(receipt.operationId);
+      const repository = await discoverGitRepository(receipt.repositoryRoot);
+      if (!repository || repository.root !== receipt.repositoryRoot || repository.head !== receipt.expectedHead) {
+        throw new Error(
+          `Mutation '${receipt.operationId}' repository HEAD lease changed before runtime recovery.`
+        );
+      }
+      await assertGitPreflight(repository);
+      await collectIntroducedPaths(receipt.repositoryRoot, receipt.expectedHead, baseline, declarations);
+    }
+    mutation = GovernedMutation.activateExisting(receipt, baseline, lock);
+    const [{ recoverPendingApply }, { readLinkedLocalApplyJournal: readLinkedLocalApplyJournal2, removeApplyJournal: removeApplyJournal2, localPathExists: localPathExists2 }] = await Promise.all([
+      import("./apply-R5VHCIUN.js"),
+      import("./transaction-ITXC7FFV.js")
+    ]);
+    let missingReservation = false;
+    for (const entry of pending) {
+      if (entry.transport !== "local") {
+        throw new Error(`Runtime recovery for ${entry.transportDescription} is unsupported until a durable remote recovery protocol exists.`);
+      }
+      const exists2 = await localPathExists2(entry.path);
+      if (!exists2) {
+        if (entry.status === "reserved") {
+          await resolveMutationRuntimeJournal(receipt.operationId, entry.path);
+          missingReservation = true;
+          continue;
+        }
+        if (entry.status === "resolving") {
+          await resolveMutationRuntimeJournal(receipt.operationId, entry.path);
+          continue;
+        }
+        throw new Error(`Runtime apply journal ${entry.path} disappeared while its receipt was ${entry.status}.`);
+      }
+      const journal = await readLinkedLocalApplyJournal2(
+        entry.path,
+        receipt.operationId,
+        entry.journalDigest,
+        entry.transportDescription
+      );
+      if (journal.mutation?.reason !== receipt.reason || journal.mutation.noCommit !== receipt.noCommit) {
+        throw new Error(`Runtime apply journal ${entry.path} mutation metadata does not match its durable receipt.`);
+      }
+      if (entry.status === "resolving") {
+        await removeApplyJournal2(journal.targetRoot, journal.adapter, void 0, {
+          installationType: journal.installationType,
+          stateKey: journal.stateKey
+        });
+        continue;
+      }
+      const recovered = await recoverPendingApply(journal.targetRoot, journal.adapter, void 0, {
+        installationType: journal.installationType,
+        stateKey: journal.stateKey
+      });
+      if (!recovered) throw new Error(`Runtime apply journal ${entry.path} could not be recovered deterministically.`);
+    }
+    if (missingReservation) {
+      throw new Error("A reserved runtime journal was never created, so the interrupted handler must be rerun as a new governed operation.");
+    }
+    return await mutation.complete("recover");
+  } catch (error) {
+    if (mutation) {
+      await mutation.fail(error).catch(() => void 0);
+    } else {
+      receipt = await updateMutationReceipt(receipt, { status: "partial", error: sanitizeError(error) });
+      endMutationPathDeclarations();
+      await lock.release();
+    }
+    throw new Error(`Agentwheel mutation ${receipt.operationId} runtime recovery failed: ${sanitizeError(error)}`);
+  }
+}
+function assertRuntimeRecoveryReceipt(receipt) {
+  const pending = receipt.runtimeJournals.filter((entry) => entry.status !== "resolved");
+  if (pending.length === 0) {
+    throw new Error(`Mutation '${receipt.operationId}' has no pending linked runtime apply journals.`);
+  }
+  if (!["prepared", "partial", "postcheck-failed", "handler-succeeded", "mutation-applied", "commit-pending"].includes(receipt.status)) {
+    throw new Error(`Mutation '${receipt.operationId}' is ${receipt.status}; runtime recovery is not allowed.`);
+  }
+  if (receipt.revisionMode === "commit-after-verify" && (!receipt.provider || !receipt.repositoryRoot || !receipt.expectedHead)) {
+    throw new Error(`Mutation '${receipt.operationId}' has no revision provider recovery contract.`);
+  }
+}
+async function checkMutationProvider(workspaceRoot, globalRoot) {
+  const policy = await mutationPolicyForWorkspace(workspaceRoot, globalRoot);
+  if (!policy || policy.revisioning.mode === "off") return void 0;
+  const repository = await discoverGitRepository(workspaceRoot);
+  if (!repository) throw new Error(`No Git repository contains ${workspaceRoot}.`);
+  const operationId = randomUUID2();
+  const request = revisionProviderRequestSchema.parse({
+    protocolVersion: policy.revisioning.provider.protocolVersion,
+    action: "check",
+    operationId,
+    repositoryRoot: repository.root,
+    expectedHead: repository.head,
+    commandName: "mutation check",
+    reason: "Check the configured Agentwheel revision provider",
+    noCommit: false,
+    paths: []
+  });
+  return invokeRevisionProvider(policy.revisioning.provider, request, { workspaceRoot });
+}
+async function mutationPolicyForWorkspace(workspaceRoot, globalRoot = homedir4()) {
+  const scopedConfig = await readWorkspaceConfig(workspaceRoot);
+  const scoped = scopedConfig.schemaVersion === 4 ? scopedConfig.mutationPolicy : void 0;
+  if (resolve8(workspaceRoot) === resolve8(globalRoot)) return scoped;
+  const globalConfig = await readWorkspaceConfig(globalRoot);
+  const global = globalConfig.schemaVersion === 4 ? globalConfig.mutationPolicy : void 0;
+  return mergeMutationPolicies(global, scoped);
+}
+function mergeMutationPolicies(global, scoped) {
+  if (!global) return scoped;
+  if (!scoped) return global;
+  const globalCommit = global.revisioning.mode === "commit-after-verify" ? global.revisioning : void 0;
+  const scopedCommit = scoped.revisioning.mode === "commit-after-verify" ? scoped.revisioning : void 0;
+  const chosen = scopedCommit ?? globalCommit;
+  const revisioning = chosen ? {
+    ...chosen,
+    allowNoCommitOverride: globalCommit && scopedCommit ? globalCommit.allowNoCommitOverride && scopedCommit.allowNoCommitOverride : chosen.allowNoCommitOverride
+  } : { mode: "off" };
+  return mutationPolicySchema.parse({
+    reason: global.reason === "required" || scoped.reason === "required" ? "required" : "optional",
+    journal: global.journal === "required" || scoped.journal === "required" || chosen ? "required" : "off",
+    revisioning
+  });
+}
+function providerRequest(receipt, action, paths) {
+  if (!receipt.repositoryRoot || !receipt.expectedHead || !receipt.provider) {
+    throw new Error(`Mutation '${receipt.operationId}' is missing revision provider request state.`);
+  }
+  return revisionProviderRequestSchema.parse({
+    protocolVersion: receipt.provider.protocolVersion,
+    action,
+    operationId: receipt.operationId,
+    repositoryRoot: receipt.repositoryRoot,
+    expectedHead: receipt.expectedHead,
+    ...receipt.expectedManifestDigest ? { expectedManifestDigest: receipt.expectedManifestDigest } : {},
+    commandName: receipt.commandName,
+    reason: receipt.reason,
+    noCommit: receipt.noCommit,
+    paths
+  });
+}
+function normalizeReason(input, commandName, policy) {
+  const normalized = input?.replace(/\r\n?/gu, "\n").trim();
+  if (!normalized && policy.reason === "required") throw new Error(`Mutation reason required: pass --reason <why> for '${commandName}'.`);
+  return mutationReasonSchema.parse(normalized || `Run Agentwheel ${commandName}`);
+}
+function snapshotEntries(snapshot) {
+  if (!snapshot) return [];
+  return [...snapshot.changed.entries()].map(([path, sha2563]) => ({ path, sha256: sha2563 })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function snapshotFromReceipt(receipt) {
+  return { changed: new Map(receipt.preexistingPaths.map((entry) => [entry.path, entry.sha256])) };
+}
+function sanitizeError(error) {
+  const value = (error instanceof Error ? error.message : String(error)).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/gu, " ").trim();
+  return (value || "Unknown mutation failure").slice(0, 4096);
+}
+function receiptStatusForProvider(status) {
+  if (status === "revisioning-skipped") return "revisioning-skipped";
+  if (status === "no-repository-delta") return "no-repository-delta";
+  return "succeeded";
+}
+function upsertRuntimeJournal(entries, link2, status) {
+  const existing = entries.find((entry) => entry.path === link2.path);
+  if (existing && (existing.transport !== link2.transport || existing.transportDescription !== link2.transportDescription || existing.journalDigest !== link2.journalDigest)) {
+    throw new Error(`Runtime journal link collision for ${link2.path}.`);
+  }
+  return [
+    ...entries.filter((entry) => entry.path !== link2.path),
+    { ...link2, status }
+  ].sort((a, b) => a.path.localeCompare(b.path));
+}
+
+// src/install/transaction.ts
+function applyLockPath(targetRoot, adapter, scope = {}) {
+  const installationType = scope.installationType ?? "local";
+  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
+}
+function applyJournalPath(targetRoot, adapter, scope = {}) {
+  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-journal.json`);
+}
+function applyBackupDir(targetRoot, adapter, scope = {}) {
+  return join6(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 metadata = {
+    pid: process.pid,
+    adapter,
+    installationType: scope.installationType,
+    stateKey: scope.stateKey,
+    targetRoot,
+    transport: transport.description,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    await transport.mkdirExclusive(lockPath);
+  } catch (error) {
+    if (!isAlreadyExists2(error)) throw error;
+    await handleExistingLock(lockPath, ownerPath, transport, options);
+    await transport.mkdirExclusive(lockPath);
+  }
+  await transport.writeJsonAtomic(ownerPath, metadata);
+  return {
+    path: lockPath,
+    release: () => transport.rm(lockPath)
+  };
+}
+async function writeApplyJournal(journal, transport = localTransport) {
+  const path = applyJournalPath(journal.targetRoot, journal.adapter, {
+    installationType: journal.installationType,
+    stateKey: journal.stateKey
+  });
+  let link2;
+  if (journal.mutation) {
+    const digest = applyJournalLinkDigest(journal, transport);
+    if (journal.mutation.journalDigest && journal.mutation.journalDigest !== digest) {
+      throw new Error(`Runtime apply journal identity changed for ${path}.`);
+    }
+    if (journal.mutation.transport && (journal.mutation.transport.kind !== transport.kind || journal.mutation.transport.description !== transport.description)) {
+      throw new Error(`Runtime apply journal transport changed for ${path}.`);
+    }
+    journal.mutation.journalDigest = digest;
+    journal.mutation.transport = { kind: transport.kind, description: transport.description };
+    link2 = {
+      path,
+      transport: transport.kind,
+      transportDescription: transport.description,
+      journalDigest: digest
+    };
+    await reserveActiveRuntimeJournal(link2);
+  }
+  await transport.writeJsonAtomic(path, {
+    ...journal,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (link2) await activateActiveRuntimeJournal(link2);
+}
+async function readApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
+  const path = applyJournalPath(targetRoot, adapter, scope);
+  if (!await transport.pathExists(path)) return void 0;
+  return parseApplyJournal(JSON.parse(await transport.readFile(path)));
+}
+async function listApplyJournals(targetRoot, adapter, transport = localTransport, scope = {}) {
+  const installationType = scope.installationType ?? "local";
+  const suffix = ".apply-journal.json";
+  const found = [];
+  for (const fileName of await transport.listDir(metadataDir(targetRoot))) {
+    if (!fileName.endsWith(suffix)) continue;
+    const path = join6(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 });
+  }
+  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")));
+  if (journal.version !== 2 || !journal.mutation) {
+    throw new Error(`Runtime apply journal ${absolutePath} is not linked to a governed mutation.`);
+  }
+  if (journal.mutation.operationId !== mutationOperationIdSchema.parse(operationId)) {
+    throw new Error(
+      `Runtime apply journal ${absolutePath} belongs to mutation ${journal.mutation.operationId}, not ${operationId}.`
+    );
+  }
+  if (journal.mutation.transport?.kind !== "local" || journal.mutation.transport.description !== expectedTransportDescription) {
+    throw new Error(`Runtime apply journal ${absolutePath} transport metadata does not match its durable receipt.`);
+  }
+  if (journal.mutation.journalDigest !== expectedDigest || applyJournalLinkDigest(journal, {
+    kind: "local",
+    description: expectedTransportDescription
+  }) !== expectedDigest) {
+    throw new Error(`Runtime apply journal ${absolutePath} digest does not match its durable receipt.`);
+  }
+  const expectedPath = resolve9(applyJournalPath(journal.targetRoot, journal.adapter, {
+    installationType: journal.installationType,
+    stateKey: journal.stateKey
+  }));
+  if (absolutePath !== expectedPath) {
+    throw new Error(`Runtime apply journal path mismatch: expected ${expectedPath}, found ${absolutePath}.`);
+  }
+  return journal;
+}
+async function removeApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
+  const existing = await readApplyJournal(targetRoot, adapter, transport, scope);
+  const path = applyJournalPath(targetRoot, adapter, scope);
+  if (existing?.mutation) await beginResolveMutationRuntimeJournal(existing.mutation.operationId, path);
+  await transport.rm(applyJournalPath(targetRoot, adapter, scope));
+  await transport.rm(applyBackupDir(targetRoot, adapter, scope));
+  if (existing?.mutation) await resolveMutationRuntimeJournal(existing.mutation.operationId, path);
+}
+async function abortApplyJournal(targetRoot, adapter, transport = localTransport, scope = {}) {
+  assertGovernedRuntimeTransportSupported(transport);
+  const lock = await acquireApplyLock(targetRoot, adapter, transport, {}, scope);
+  try {
+    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 content = await transport.readFile(journalPath);
+    const journal = parseApplyJournal(JSON.parse(content));
+    await transport.writeFileAtomic(archivePath, content.endsWith("\n") ? content : `${content}
+`);
+    if (journal.mutation) await beginResolveMutationRuntimeJournal(journal.mutation.operationId, journalPath);
+    await transport.rm(journalPath);
+    await transport.rm(applyBackupDir(targetRoot, adapter, scope));
+    if (journal.mutation) await resolveMutationRuntimeJournal(journal.mutation.operationId, journalPath);
+    return { journalPath, archivePath };
+  } finally {
+    await lock.release();
+  }
+}
+function mutationMetadataForApplyJournal() {
+  const metadata = activeMutationMetadata();
+  return metadata ? {
+    operationId: mutationOperationIdSchema.parse(metadata.operationId),
+    reason: mutationReasonSchema.parse(metadata.reason),
+    noCommit: metadata.noCommit
+  } : void 0;
+}
+function assertGovernedRuntimeTransportSupported(transport) {
+  const active2 = activeMutationMetadata();
+  if (active2 && transport.kind !== "local") {
+    throw new Error(
+      `Governed runtime apply refuses ${transport.description} before writes; durable remote journal recovery is not implemented.`
+    );
+  }
+}
+function applyJournalLinkDigest(journal, transport) {
+  if (!journal.mutation) throw new Error("Cannot digest an unlinked runtime apply journal.");
+  return createHash5("sha256").update(canonicalJson3({
+    version: journal.version,
+    mutation: {
+      operationId: journal.mutation.operationId,
+      reason: journal.mutation.reason,
+      noCommit: journal.mutation.noCommit
+    },
+    transport,
+    mode: journal.mode ?? "apply",
+    adapter: journal.adapter,
+    installationType: journal.installationType ?? null,
+    stateKey: journal.stateKey ?? null,
+    targetRoot: resolve9(journal.targetRoot),
+    baseRevision: journal.baseRevision,
+    graphLockDigest: journal.graphLockDigest ?? null,
+    graphLockPath: journal.graphLockPath ?? null,
+    graphLockRemovePath: journal.graphLockRemovePath ?? null,
+    workspaceConfigPath: journal.workspaceConfigPath ?? null,
+    operations: journal.operations
+  })).digest("hex");
+}
+function assertApplyJournalRecoveryAllowed(journal) {
+  const active2 = activeMutationMetadata();
+  if (!active2) return;
+  if (journal.version === 1) {
+    throw new Error(
+      "A governed mutation refuses automatic recovery of a legacy v1 apply journal; inspect it and use an explicit journal recovery/abort workflow first."
+    );
+  }
+  if (!journal.mutation || journal.mutation.operationId !== active2.operationId) {
+    throw new Error(
+      `Pending apply journal belongs to mutation ${journal.mutation?.operationId ?? "unknown"}; current mutation ${active2.operationId} may not adopt it.`
+    );
+  }
+}
+function parseApplyJournal(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid Agentwheel apply journal.");
+  const journal = value;
+  if (journal.version !== 1 && journal.version !== 2) throw new Error(`Unsupported Agentwheel apply journal version: ${String(journal.version)}.`);
+  if (journal.version === 1 && journal.mutation) throw new Error("Legacy Agentwheel apply journals may not contain mutation metadata.");
+  if (journal.version === 2 && journal.mutation) {
+    journal.mutation = {
+      operationId: mutationOperationIdSchema.parse(journal.mutation.operationId),
+      reason: mutationReasonSchema.parse(journal.mutation.reason),
+      noCommit: journal.mutation.noCommit === true,
+      transport: parseMutationTransport(journal.mutation.transport),
+      journalDigest: parseJournalDigest(journal.mutation.journalDigest)
+    };
+  }
+  return journal;
+}
+function parseMutationTransport(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Governed runtime apply journal is missing transport metadata.");
+  }
+  const record = value;
+  if (record.kind !== "local" && record.kind !== "ssh" || typeof record.description !== "string" || record.description.length === 0 || record.description.length > 1024) {
+    throw new Error("Governed runtime apply journal has invalid transport metadata.");
+  }
+  return { kind: record.kind, description: record.description };
+}
+function parseJournalDigest(value) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)) {
+    throw new Error("Governed runtime apply journal is missing its durable link digest.");
+  }
+  return value;
+}
+function canonicalJson3(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson3(item === void 0 ? null : item)).join(",")}]`;
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  const record = value;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0 && typeof record[key] !== "function").sort().map((key) => `${JSON.stringify(key)}:${canonicalJson3(record[key])}`).join(",")}}`;
+}
+async function recordBackup(operation, index, targetRoot, adapter, transport = localTransport, scope = {}) {
+  const hadExisting = await transport.pathExists(operation.destPath);
+  if (!hadExisting || transport.kind !== "local" || operation.action !== "update" && operation.action !== "remove" && operation.action !== "create") {
+    return {
+      index,
+      destPath: operation.destPath,
+      kind: operation.kind,
+      hadExisting
+    };
+  }
+  const backupPath = join6(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 });
+  return {
+    index,
+    destPath: operation.destPath,
+    kind: operation.kind,
+    hadExisting,
+    backupPath
+  };
+}
+async function rollbackCompletedOperations(completed, transport = localTransport) {
+  for (const item of [...completed].sort((a, b) => b.index - a.index)) {
+    if (item.hadExisting && item.backupPath) {
+      await transport.atomicCopy(item.backupPath, item.destPath, item.kind);
+    } else if (!item.hadExisting) {
+      await transport.rm(item.destPath);
+    } else {
+      throw new Error(`Cannot roll back ${item.destPath}: no backup was recorded for ${transport.description}`);
+    }
+  }
+}
+async function handleExistingLock(lockPath, ownerPath, transport, options) {
+  const owner = await readLockOwner(ownerPath, transport);
+  if (options.staleAfterMs !== void 0 && owner?.createdAt) {
+    const ageMs = Date.now() - Date.parse(owner.createdAt);
+    if (Number.isFinite(ageMs) && ageMs > options.staleAfterMs) {
+      await transport.rm(lockPath);
+      return;
+    }
+  }
+  const ownerDetails = owner ? ` created by pid ${owner.pid} at ${owner.createdAt}` : "";
+  throw new Error(`Apply lock already exists at ${lockPath}${ownerDetails}. Run recovery or remove the lock after verifying no sync is running.`);
+}
+async function readLockOwner(ownerPath, transport) {
+  try {
+    if (!await transport.pathExists(ownerPath)) return void 0;
+    return JSON.parse(await transport.readFile(ownerPath));
+  } catch {
+    return void 0;
+  }
+}
+function isAlreadyExists2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function journalTimestamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+async function localPathExists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  artifactTypeSchema,
+  fileKindSchema,
+  artifactFormatSchema,
+  packageAssetSchema,
+  packageComposeEntrySchema,
+  packageCompositionRuleSchema,
+  packageSupersedesEntrySchema,
+  packageItemRequireSchema,
+  packageItemSuggestSchema,
+  composedFromEntrySchema,
+  defaultInstallationType,
+  installationTypeSchema,
+  adapterSchema,
+  adapterTargetSupport,
+  resolveInstallationTypeForArtifacts,
+  resolveInstallationTypeForAdapter,
+  targetMappingForArtifact,
+  installRootForArtifacts,
+  installRootForAdapterInstallationType,
+  loadAdapterConfig,
+  readMutationReceipt,
+  listMutationReceipts,
+  declareMutationPath,
+  localTransport,
+  transportForTarget,
+  metadataDir,
+  stateKeyFor,
+  installManifestPath,
+  sourceLockPath,
+  parseSemver,
+  satisfiesVersionRange,
+  semverMajorOrVersion,
+  compareSemverStrings,
+  CURRENT_WORKSPACE_SCHEMA_VERSION,
+  workspaceSelectionImportSchema,
+  workspaceExportsSchema,
+  fleetIdSchema,
+  registeredFleetSchema,
+  workspaceConfigSchema,
+  supportsFleetConfig,
+  workspaceConfigPath,
+  readWorkspaceConfig,
+  writeWorkspaceConfig,
+  upsertPackage,
+  globalWorkspaceConfigPath,
+  findWorkspaceRoot,
+  findExistingWorkspaceRoot,
+  readMergedWorkspaceConfig,
+  resolveConfigPath,
+  isCompositeWorkspaceProfile,
+  GovernedMutation,
+  resumeMutation,
+  recoverMutationRuntime,
+  checkMutationProvider,
+  mutationPolicyForWorkspace,
+  applyLockPath,
+  applyJournalPath,
+  applyBackupDir,
+  acquireApplyLock,
+  writeApplyJournal,
+  readApplyJournal,
+  listApplyJournals,
+  readLinkedLocalApplyJournal,
+  removeApplyJournal,
+  abortApplyJournal,
+  mutationMetadataForApplyJournal,
+  assertGovernedRuntimeTransportSupported,
+  applyJournalLinkDigest,
+  assertApplyJournalRecoveryAllowed,
+  recordBackup,
+  rollbackCompletedOperations,
+  localPathExists
+};