agentwheel 0.19.10 → 0.20.0

package/dist/chunk-USHT7FGV.js

@@ -0,0 +1,2235 @@
+#!/usr/bin/env node
+import {
+  acquireApplyLock,
+  artifactFormatSchema,
+  artifactTypeSchema,
+  assertApplyJournalRecoveryAllowed,
+  assertGovernedRuntimeTransportSupported,
+  composedFromEntrySchema,
+  declareMutationPath,
+  defaultInstallationType,
+  fileKindSchema,
+  installManifestPath,
+  installationTypeSchema,
+  localPathExists,
+  localTransport,
+  metadataDir,
+  mutationMetadataForApplyJournal,
+  packageSupersedesEntrySchema,
+  readApplyJournal,
+  recordBackup,
+  removeApplyJournal,
+  rollbackCompletedOperations,
+  sourceLockPath,
+  writeApplyJournal
+} from "./chunk-HOYIIUL5.js";
+import {
+  pathExists,
+  writeJsonAtomic
+} from "./chunk-7VPI5J5Y.js";
+
+// src/install/apply.ts
+import { execFile } from "child_process";
+import { mkdtemp as mkdtemp2, readFile as readFile8, rm as rm2, writeFile as writeFile8 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname8, join as join3 } from "path";
+import { promisify } from "util";
+
+// src/model/graph-lock.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { z as z2 } from "zod";
+
+// src/model/cache-identity.ts
+import { z } from "zod";
+var immutableCacheIdentitySchema = z.string().regex(
+  /^(?:[0-9a-f]{40}|content-[0-9a-f]{64})$/i,
+  "Expected a Git commit or content-addressed SHA-256 cache identity"
+);
+function normalizeImmutableCacheIdentity(value) {
+  return value === void 0 ? void 0 : immutableCacheIdentitySchema.parse(value).toLowerCase();
+}
+
+// src/model/graph-lock.ts
+var CURRENT_GRAPH_LOCK_VERSION = 1;
+var graphLockNodeSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  version: z2.string().min(1),
+  source: z2.string().min(1),
+  normalizedSource: z2.string().min(1),
+  driver: z2.string().min(1),
+  requestedRef: z2.string().min(1).optional(),
+  resolvedCommit: z2.string().min(1).optional(),
+  cacheIdentity: immutableCacheIdentitySchema.optional(),
+  sourceHash: z2.string().min(16),
+  mode: z2.enum(["pinned", "tracking"]),
+  requiredBy: z2.array(z2.string().min(1)),
+  selected: z2.array(z2.string().min(1)),
+  selectionReasons: z2.record(z2.string(), z2.array(z2.string().min(1))).optional()
+});
+var graphLockRootSchema = z2.object({
+  rootId: z2.string().min(1),
+  source: z2.string().min(1),
+  normalizedSource: z2.string().min(1),
+  graphNodeId: z2.string().min(1),
+  mode: z2.enum(["pinned", "tracking"]),
+  selected: z2.array(z2.string().min(1)),
+  aliases: z2.record(z2.string(), z2.string().min(1)).optional(),
+  overrides: z2.array(z2.string().min(1)).optional(),
+  selectionImport: z2.object({
+    configPath: z2.string().min(1),
+    configHash: z2.string().min(16),
+    exportHash: z2.string().min(16),
+    exportName: z2.string().min(1),
+    extends: z2.array(z2.string().min(1)),
+    inherited: z2.array(z2.string().min(1)),
+    additions: z2.array(z2.string().min(1)),
+    exclusions: z2.array(z2.string().min(1)),
+    effective: z2.array(z2.string().min(1))
+  }).optional()
+});
+var graphLockEdgeSchema = z2.object({
+  from: z2.string().min(1),
+  to: z2.string().min(1),
+  alias: z2.string().min(1),
+  source: z2.string().min(1),
+  normalizedSource: z2.string().min(1),
+  requestedRef: z2.string().min(1).optional(),
+  version: z2.string().min(1).optional(),
+  mode: z2.enum(["pinned", "tracking"]),
+  optional: z2.boolean().default(false),
+  selected: z2.array(z2.string().min(1))
+});
+var graphLockIncludeEdgeSchema = z2.object({
+  fromNodeId: z2.string().min(1),
+  alias: z2.string().min(1),
+  toNodeId: z2.string().min(1),
+  selector: z2.string().min(1),
+  sourceHash: z2.string().min(16)
+});
+var graphLockArtifactSchema = z2.object({
+  graphNodeId: z2.string().min(1),
+  dependencyRole: z2.enum(["root", "direct", "transitive", "fragment"]),
+  type: artifactTypeSchema,
+  name: z2.string().min(1),
+  installName: z2.string().min(1),
+  logicalSelector: z2.string().min(1),
+  owners: z2.array(z2.string().min(1)),
+  relativePath: z2.string().min(1),
+  kind: fileKindSchema,
+  hash: z2.string().min(16),
+  channel: z2.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed"),
+  composedFrom: z2.array(composedFromEntrySchema).optional(),
+  supersedes: z2.array(packageSupersedesEntrySchema).optional()
+});
+var graphLockPlainNameIncumbentSchema = z2.object({
+  adapter: z2.string().min(1),
+  targetFingerprint: z2.string().min(1),
+  type: artifactTypeSchema,
+  name: z2.string().min(1),
+  graphNodeId: z2.string().min(1)
+});
+var graphLockNamespacingSchema = z2.object({
+  graphNodeId: z2.string().min(1),
+  type: artifactTypeSchema,
+  name: z2.string().min(1),
+  installName: z2.string().min(1),
+  reason: z2.enum(["alias", "transitive-collision"])
+});
+var graphLockOverrideSchema = z2.object({
+  rootId: z2.string().min(1),
+  selector: z2.string().min(1),
+  graphNodeId: z2.string().min(1),
+  overriddenGraphNodeId: z2.string().min(1),
+  type: artifactTypeSchema,
+  name: z2.string().min(1),
+  installName: z2.string().min(1)
+});
+var graphLockCanonicalSchema = z2.object({
+  targetFingerprint: z2.string().min(1).optional(),
+  roots: z2.array(graphLockRootSchema),
+  nodes: z2.array(graphLockNodeSchema),
+  edges: z2.array(graphLockEdgeSchema),
+  includeEdges: z2.array(graphLockIncludeEdgeSchema).default([]),
+  artifacts: z2.array(graphLockArtifactSchema).default([]),
+  namespacing: z2.array(graphLockNamespacingSchema).default([]),
+  overrides: z2.array(graphLockOverrideSchema).default([]),
+  plainNameIncumbents: z2.array(graphLockPlainNameIncumbentSchema).default([])
+});
+var graphLockSchema = z2.object({
+  version: z2.literal(CURRENT_GRAPH_LOCK_VERSION),
+  generatedAt: z2.string().datetime().optional(),
+  canonical: graphLockCanonicalSchema
+});
+async function readGraphLock(path) {
+  return canonicalizeGraphLock(graphLockSchema.parse(JSON.parse(await readFile(path, "utf8"))));
+}
+async function writeGraphLock(path, lock) {
+  declareMutationPath(path);
+  await mkdir(dirname(path), { recursive: true });
+  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(temp, stringifyGraphLock(lock), "utf8");
+  await rename(temp, path);
+}
+function stringifyGraphLock(lock) {
+  return `${stableStringify(canonicalizeGraphLock(lock))}
+`;
+}
+function canonicalGraphLockJson(lock) {
+  return `${stableStringify(canonicalizeGraphLock(lock).canonical)}
+`;
+}
+function canonicalizeGraphLock(lock) {
+  const parsed = graphLockSchema.parse(lock);
+  return {
+    version: CURRENT_GRAPH_LOCK_VERSION,
+    canonical: {
+      targetFingerprint: parsed.canonical.targetFingerprint,
+      roots: [...parsed.canonical.roots].map((root) => ({
+        ...root,
+        selected: sortedUnique(root.selected),
+        overrides: root.overrides ? sortedUnique(root.overrides) : void 0,
+        selectionImport: root.selectionImport ? {
+          ...root.selectionImport,
+          inherited: sortedUnique(root.selectionImport.inherited),
+          additions: sortedUnique(root.selectionImport.additions),
+          exclusions: sortedUnique(root.selectionImport.exclusions),
+          effective: sortedUnique(root.selectionImport.effective)
+        } : void 0
+      })).sort((a, b) => `${a.rootId}:${a.graphNodeId}`.localeCompare(`${b.rootId}:${b.graphNodeId}`)),
+      nodes: [...parsed.canonical.nodes].map((node) => ({
+        ...node,
+        requiredBy: sortedUnique(node.requiredBy),
+        selected: sortedUnique(node.selected),
+        selectionReasons: canonicalSelectionReasons(node.selectionReasons)
+      })).sort((a, b) => a.id.localeCompare(b.id)),
+      edges: [...parsed.canonical.edges].map((edge) => ({ ...edge, selected: sortedUnique(edge.selected) })).sort((a, b) => `${a.from}:${a.alias}:${a.to}`.localeCompare(`${b.from}:${b.alias}:${b.to}`)),
+      includeEdges: [...parsed.canonical.includeEdges].sort((a, b) => `${a.fromNodeId}:${a.alias}:${a.toNodeId}:${a.selector}`.localeCompare(`${b.fromNodeId}:${b.alias}:${b.toNodeId}:${b.selector}`)),
+      artifacts: [...parsed.canonical.artifacts].map((artifact) => ({ ...artifact, owners: sortedUnique(artifact.owners) })).sort((a, b) => a.logicalSelector.localeCompare(b.logicalSelector)),
+      namespacing: [...parsed.canonical.namespacing].sort((a, b) => `${a.type}:${a.installName}:${a.graphNodeId}:${a.name}`.localeCompare(`${b.type}:${b.installName}:${b.graphNodeId}:${b.name}`)),
+      overrides: [...parsed.canonical.overrides].sort((a, b) => `${a.type}:${a.installName}:${a.graphNodeId}:${a.overriddenGraphNodeId}`.localeCompare(`${b.type}:${b.installName}:${b.graphNodeId}:${b.overriddenGraphNodeId}`)),
+      plainNameIncumbents: [...parsed.canonical.plainNameIncumbents].sort((a, b) => `${a.adapter}:${a.targetFingerprint}:${a.type}:${a.name}`.localeCompare(`${b.adapter}:${b.targetFingerprint}:${b.type}:${b.name}`))
+    }
+  };
+}
+function canonicalSelectionReasons(reasons) {
+  if (!reasons) return void 0;
+  const out = {};
+  for (const key of Object.keys(reasons).sort((a, b) => a.localeCompare(b))) {
+    out[key] = sortedUnique(reasons[key] ?? []);
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function computeTargetFingerprint(parts) {
+  return createHash("sha256").update(stableStringify(parts)).digest("hex");
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value), null, 2);
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const key of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
+    const item = value[key];
+    if (item !== void 0) out[key] = stableValue(item);
+  }
+  return out;
+}
+
+// src/install/json-merge.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+async function mergeJsonFile(sourcePath, destPath) {
+  const source = JSON.parse(await readFile2(sourcePath, "utf8"));
+  const current = await pathExists(destPath) ? JSON.parse(await readFile2(destPath, "utf8")) : {};
+  const merged = deepMerge(current, source);
+  await mkdir2(dirname2(destPath), { recursive: true });
+  await writeFile2(destPath, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+}
+function deepMerge(base, incoming) {
+  if (Array.isArray(base) && Array.isArray(incoming)) {
+    return dedupeArray([...base, ...incoming]);
+  }
+  if (isRecord(base) && isRecord(incoming)) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(incoming)) {
+      out[key] = key in out ? deepMerge(out[key], value) : value;
+    }
+    return out;
+  }
+  return incoming;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function dedupeArray(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const key = JSON.stringify(value);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(value);
+  }
+  return out;
+}
+
+// src/install/openclaw-json-merge.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+async function mergeOpenClawJsonFile(sourcePath, destPath) {
+  const source = await renderOpenClawJsonMergeSource(sourcePath);
+  const current = await pathExists(destPath) ? JSON.parse(await readFile3(destPath, "utf8")) : {};
+  const merged = mergeOpenClawJson(current, source);
+  await mkdir3(dirname3(destPath), { recursive: true });
+  await writeFile3(destPath, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+}
+async function renderOpenClawJsonMergeSource(sourcePath) {
+  return expandEnvPlaceholders(
+    normalizeOpenClawConfig(JSON.parse(await readFile3(sourcePath, "utf8"))),
+    sourcePath
+  );
+}
+function mergeOpenClawJson(base, incoming, path = []) {
+  if (isMcpServerCodexAgentsPath(path) && Array.isArray(incoming)) {
+    return incoming;
+  }
+  if (path.join(".") === "agents.list" && Array.isArray(base) && Array.isArray(incoming)) {
+    return mergeOpenClawAgentsById(base, incoming);
+  }
+  if (isAgentwheelSkillRouterRepositoriesPath(path) && Array.isArray(base) && Array.isArray(incoming)) {
+    return mergeOpenClawRecordsByKey(base, incoming, "name");
+  }
+  if (Array.isArray(base) && Array.isArray(incoming)) {
+    return deepMerge(base, incoming);
+  }
+  if (isRecord(base) && isRecord(incoming)) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(incoming)) {
+      out[key] = key in out ? mergeOpenClawJson(out[key], value, [...path, key]) : value;
+    }
+    return out;
+  }
+  return incoming;
+}
+function isMcpServerCodexAgentsPath(path) {
+  return path.length === 5 && path[0] === "mcp" && path[1] === "servers" && path[3] === "codex" && path[4] === "agents";
+}
+function isAgentwheelSkillRouterRepositoriesPath(path) {
+  return path.join(".") === "plugins.entries.agentwheel-skill-router.config.repositories";
+}
+function expandEnvPlaceholders(value, sourcePath) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+      const replacement = process.env[name];
+      if (replacement === void 0) {
+        throw new Error(`Missing environment variable ${name} while rendering OpenClaw JSON merge artifact ${sourcePath}`);
+      }
+      return replacement;
+    });
+  }
+  if (Array.isArray(value)) return value.map((item) => expandEnvPlaceholders(item, sourcePath));
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, expandEnvPlaceholders(child, sourcePath)])
+  );
+}
+function normalizeOpenClawConfig(value) {
+  if (!isRecord(value)) return value;
+  const rootMcpServers = isRecord(value.mcpServers) ? value.mcpServers : void 0;
+  if (!rootMcpServers) return value;
+  const out = { ...value };
+  const normalizedServers = {};
+  for (const [name, server] of Object.entries(rootMcpServers)) {
+    if (isRecord(server)) normalizedServers[name] = normalizeOpenClawMcpServer(server);
+  }
+  const mcp = isRecord(out.mcp) ? out.mcp : {};
+  out.mcp = deepMerge(mcp, { servers: normalizedServers });
+  delete out.mcpServers;
+  return out;
+}
+function normalizeOpenClawMcpServer(server) {
+  const out = { ...server };
+  const type = typeof out.type === "string" ? out.type : void 0;
+  if (type && typeof out.transport !== "string") out.transport = type;
+  delete out.type;
+  return out;
+}
+function mergeOpenClawAgentsById(base, incoming) {
+  const out = [...base];
+  const indexById = /* @__PURE__ */ new Map();
+  for (const [index, value] of out.entries()) {
+    const id = isRecord(value) && typeof value.id === "string" ? value.id : void 0;
+    if (id) indexById.set(id, index);
+  }
+  for (const value of incoming) {
+    const id = isRecord(value) && typeof value.id === "string" ? value.id : void 0;
+    if (!id || !indexById.has(id)) {
+      out.push(value);
+      if (id) indexById.set(id, out.length - 1);
+      continue;
+    }
+    out[indexById.get(id)] = value;
+  }
+  return out;
+}
+function mergeOpenClawRecordsByKey(base, incoming, key) {
+  const replacements = /* @__PURE__ */ new Map();
+  for (const value of incoming) {
+    const recordKey = isRecord(value) && typeof value[key] === "string" ? value[key] : void 0;
+    if (recordKey) replacements.set(recordKey, value);
+  }
+  const out = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const value of base) {
+    const recordKey = isRecord(value) && typeof value[key] === "string" ? value[key] : void 0;
+    const replacement = recordKey ? replacements.get(recordKey) : void 0;
+    if (!recordKey || !replacement) {
+      out.push(value);
+      continue;
+    }
+    if (!emitted.has(recordKey)) {
+      out.push(replacement);
+      emitted.add(recordKey);
+    }
+  }
+  for (const value of incoming) {
+    const recordKey = isRecord(value) && typeof value[key] === "string" ? value[key] : void 0;
+    if (!recordKey || !emitted.has(recordKey)) {
+      out.push(value);
+      if (recordKey) emitted.add(recordKey);
+    }
+  }
+  return out;
+}
+
+// src/install/manifest.ts
+import { createHash as createHash2 } from "crypto";
+import { join, resolve } from "path";
+
+// src/model/manifest.ts
+import { z as z3 } from "zod";
+var mergeValueSchema = z3.lazy(() => z3.union([
+  z3.null(),
+  z3.boolean(),
+  z3.number(),
+  z3.string(),
+  z3.array(mergeValueSchema),
+  z3.record(z3.string(), mergeValueSchema)
+]));
+var mergeRemovalSchema = z3.record(z3.string(), mergeValueSchema);
+var dependencyRoleSchema = z3.enum(["root", "direct", "transitive", "fragment"]);
+var legacyUnownedWorkspaceOwner = "legacy:unowned";
+var CURRENT_INSTALL_MANIFEST_VERSION = 2;
+var CURRENT_SOURCE_LOCK_VERSION = 1;
+var semanticPluginSpecSchema = z3.object({
+  runtime: z3.enum(["openclaw", "claude", "codex", "copilot", "hermes"]),
+  pluginName: z3.string().min(1),
+  marketplaceName: z3.string().min(1).optional(),
+  stateRoot: z3.string().min(1).optional(),
+  installCommands: z3.array(z3.array(z3.string()).min(1)).min(1),
+  uninstallCommands: z3.array(z3.array(z3.string()).min(1)).min(1),
+  enableCommands: z3.array(z3.array(z3.string()).min(1)).optional(),
+  disableCommands: z3.array(z3.array(z3.string()).min(1)).optional()
+});
+var manifestEntryV1Schema = z3.object({
+  path: z3.string().min(1),
+  artifactType: artifactTypeSchema,
+  artifactName: z3.string().min(1),
+  kind: fileKindSchema,
+  hash: z3.string().min(16),
+  sourceHash: z3.string().min(16),
+  updatedAt: z3.string().datetime(),
+  channel: z3.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed"),
+  packageName: z3.string().min(1).optional(),
+  semanticCommand: z3.array(z3.string()).optional(),
+  semanticPlugin: semanticPluginSpecSchema.optional(),
+  executed: z3.boolean().optional(),
+  mergeStrategy: z3.enum(["json-deep", "openclaw-json-deep", "yaml-deep", "codex-toml-mcp"]).optional(),
+  mergeRemoval: mergeRemovalSchema.optional(),
+  mergeCreatedDestination: z3.boolean().optional(),
+  mode: z3.enum(["managed-block"]).optional(),
+  composedFrom: z3.array(composedFromEntrySchema).optional()
+});
+var manifestEntrySchema = manifestEntryV1Schema.extend({
+  installName: z3.string().min(1),
+  logicalSelector: z3.string().min(1).optional(),
+  graphNodeId: z3.string().min(1).optional(),
+  dependencyRole: dependencyRoleSchema.default("root"),
+  owners: z3.array(z3.string().min(1)).min(1),
+  refCount: z3.number().int().positive(),
+  workspaceOwner: z3.string().min(1).default(legacyUnownedWorkspaceOwner),
+  graphLockDigest: z3.string().min(1).optional()
+}).transform((entry) => {
+  const owners = [...new Set(entry.owners)].sort();
+  return {
+    ...entry,
+    owners,
+    refCount: owners.length
+  };
+});
+var installManifestV1Schema = z3.object({
+  version: z3.literal(1),
+  adapter: z3.string().min(1),
+  targetRoot: z3.string().min(1),
+  generatedAt: z3.string().datetime(),
+  adapterCode: z3.object({
+    modulePath: z3.string().min(1),
+    hash: z3.string().min(16)
+  }).optional(),
+  entries: z3.array(manifestEntryV1Schema)
+}).transform((manifest) => ({
+  ...manifest,
+  legacy: true
+}));
+var installManifestV2Schema = z3.object({
+  version: z3.literal(CURRENT_INSTALL_MANIFEST_VERSION),
+  adapter: z3.string().min(1),
+  installationType: installationTypeSchema.default(defaultInstallationType),
+  stateKey: z3.string().min(1).optional(),
+  targetRoot: z3.string().min(1),
+  generatedAt: z3.string().datetime(),
+  revision: z3.string().min(16),
+  adapterCode: z3.object({
+    modulePath: z3.string().min(1),
+    hash: z3.string().min(16)
+  }).optional(),
+  entries: z3.array(manifestEntrySchema)
+}).transform((manifest) => ({
+  ...manifest,
+  legacy: false
+}));
+var installManifestSchema = z3.union([installManifestV2Schema, installManifestV1Schema]);
+var sourceLockSchema = z3.object({
+  version: z3.literal(CURRENT_SOURCE_LOCK_VERSION),
+  driver: z3.string().min(1),
+  source: z3.string().min(1),
+  resolvedPath: z3.string().min(1),
+  packageName: z3.string().min(1).optional(),
+  packageVersion: z3.string().min(1).optional(),
+  mode: z3.enum(["pinned", "tracking"]).default("pinned"),
+  requestedRef: z3.string().min(1).optional(),
+  resolvedCommit: z3.string().min(1).optional(),
+  cacheIdentity: immutableCacheIdentitySchema.optional(),
+  sourceHash: z3.string().min(16).optional(),
+  generatedAt: z3.string().datetime(),
+  artifacts: z3.array(
+    z3.object({
+      type: artifactTypeSchema,
+      name: z3.string().min(1),
+      relativePath: z3.string().min(1),
+      kind: fileKindSchema,
+      hash: z3.string().min(16),
+      format: artifactFormatSchema.optional(),
+      composedFrom: z3.array(composedFromEntrySchema).optional()
+    })
+  )
+});
+
+// src/install/manifest.ts
+async function readInstallManifest(targetRoot, adapter, transport = localTransport, scope = {}) {
+  const path = installManifestPath(targetRoot, adapter, scope);
+  if (!await transport.pathExists(path)) return void 0;
+  const raw = JSON.parse(await transport.readFile(path));
+  const parsed = installManifestSchema.parse(raw);
+  return {
+    ...parsed,
+    revision: computeManifestRevision(raw)
+  };
+}
+async function listInstallManifests(targetRoot, adapter, transport = localTransport) {
+  const dir = metadataDir(targetRoot);
+  const suffix = ".install-manifest.json";
+  const prefix = `${adapter}.`;
+  const found = [];
+  for (const fileName of await transport.listDir(dir)) {
+    if (!fileName.endsWith(suffix)) continue;
+    const stateKey = fileName.slice(0, -suffix.length);
+    if (stateKey !== adapter && !stateKey.startsWith(prefix)) continue;
+    const path = join(dir, fileName);
+    try {
+      const raw = JSON.parse(await transport.readFile(path));
+      const parsed = installManifestSchema.parse(raw);
+      found.push({ path, fileName, stateKey, manifest: { ...parsed, revision: computeManifestRevision(raw) } });
+    } catch (error) {
+      throw new Error(`Unreadable install manifest at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return found.sort((a, b) => a.fileName.localeCompare(b.fileName));
+}
+async function writeInstallManifest(manifest, transport = localTransport) {
+  const next = withManifestRevision(manifest);
+  await transport.writeJsonAtomic(installManifestPath(next.targetRoot, next.adapter, {
+    installationType: next.installationType,
+    stateKey: next.stateKey
+  }), stripReadOnlyManifestFields(next));
+}
+async function writeSourceLock(targetRoot, adapter, lock, transport = localTransport, scope = {}) {
+  await transport.writeJsonAtomic(sourceLockPath(targetRoot, adapter, scope), lock);
+}
+async function removeStateFiles(targetRoot, adapter, transport = localTransport, scope = {}) {
+  await transport.rm(installManifestPath(targetRoot, adapter, scope));
+  await transport.rm(sourceLockPath(targetRoot, adapter, scope));
+}
+function normalizeTargetRoot(path) {
+  return resolve(path);
+}
+function withManifestRevision(manifest) {
+  if (manifest.version !== 2) {
+    throw new Error("Install manifest writes must use version 2");
+  }
+  const raw = stripReadOnlyManifestFields(manifest);
+  const normalized = installManifestV2Schema.parse({
+    installationType: defaultInstallationType,
+    ...raw
+  });
+  const withoutRevision = stripRuntimeManifestFields(normalized);
+  return {
+    ...normalized,
+    legacy: false,
+    revision: computeManifestRevision(withoutRevision)
+  };
+}
+function computeManifestRevision(manifest) {
+  return createHash2("sha256").update(canonicalJson(stripRuntimeManifestFields(manifest))).digest("hex");
+}
+function canonicalInstallManifestJson(manifest) {
+  return canonicalJson(stripRuntimeManifestFields(manifest));
+}
+function stripRuntimeManifestFields(value) {
+  if (Array.isArray(value)) return value.map(stripRuntimeManifestFields);
+  if (!value || typeof value !== "object") return value;
+  const record = value;
+  const out = {};
+  for (const [key, item] of Object.entries(record)) {
+    if (key === "revision" || key === "legacy" || item === void 0) continue;
+    out[key] = stripRuntimeManifestFields(item);
+  }
+  return out;
+}
+function stripReadOnlyManifestFields(value) {
+  if (Array.isArray(value)) return value.map(stripReadOnlyManifestFields);
+  if (!value || typeof value !== "object") return value;
+  const record = value;
+  const out = {};
+  for (const [key, item] of Object.entries(record)) {
+    if (key === "legacy" || item === void 0) continue;
+    out[key] = stripReadOnlyManifestFields(item);
+  }
+  return out;
+}
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  if (!value || 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/install/path-safety.ts
+import { isAbsolute, relative, resolve as resolve2 } from "path";
+function assertSafeInstallName(name, label) {
+  if (!name || name === "." || name === "..") {
+    throw new Error(`Invalid install name for ${label}: ${JSON.stringify(name)}`);
+  }
+  if (name.includes("/") || name.includes("\\")) {
+    throw new Error(`Invalid install name for ${label}: path separators are not allowed (${JSON.stringify(name)})`);
+  }
+}
+function assertOperationContained(operation, targetRoot) {
+  const root = resolve2(targetRoot);
+  const dest = resolve2(operation.destPath);
+  const rel = relative(root, dest);
+  if (rel === "" || !rel.startsWith("..") && !isAbsolute(rel)) return;
+  throw new Error(`Refusing operation outside target root: ${operation.relativeDestPath} -> ${operation.destPath}`);
+}
+
+// src/install/toml-merge.ts
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+async function mergeCodexTomlMcp(sourcePath, destPath) {
+  const source = JSON.parse(await readFile4(sourcePath, "utf8"));
+  const servers = extractMcpServers(source);
+  const current = await pathExists(destPath) ? await readFile4(destPath, "utf8") : "";
+  const withoutManaged = removeManagedMcpSections(current, Object.keys(servers));
+  const merged = appendMcpServers(withoutManaged, servers);
+  await mkdir4(dirname4(destPath), { recursive: true });
+  await writeFile4(destPath, merged, "utf8");
+}
+function mismatchedCodexTomlMcpServers(source, currentContent) {
+  const servers = extractMcpServers(source);
+  return Object.entries(servers).filter(([name, server]) => extractMcpServerBlock(currentContent, name) !== formatMcpServer(name, server)).map(([name]) => name);
+}
+function extractMcpServers(source) {
+  const raw = isRecord2(source.mcpServers) ? source.mcpServers : source;
+  const servers = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (!isRecord2(value)) continue;
+    servers[name] = value;
+  }
+  if (Object.keys(servers).length === 0) {
+    throw new Error("Codex MCP TOML merge needs a JSON object with mcpServers");
+  }
+  return servers;
+}
+function removeManagedMcpSections(content, serverNames) {
+  if (serverNames.length === 0 || content.trim() === "") return content;
+  const names = new Set(serverNames);
+  const lines = content.split(/\r?\n/);
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    const section = line.match(/^\s*\[([^\]]+)]\s*$/)?.[1];
+    if (section) {
+      const match = section.match(/^mcp_servers\.([^.\]]+)(?:\.|$)/);
+      skipping = match ? names.has(unquoteTomlKey(match[1] ?? "")) : false;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}$/g, "\n\n");
+}
+function appendMcpServers(content, servers) {
+  const blocks = Object.entries(servers).sort(([a], [b]) => a.localeCompare(b)).map(([name, server]) => formatMcpServer(name, server));
+  const prefix = content.trimEnd();
+  return `${prefix ? `${prefix}
+
+` : ""}${blocks.join("\n\n")}
+`;
+}
+function formatMcpServer(name, server) {
+  const env = isRecord2(server.env) ? server.env : void 0;
+  const lines = [`[mcp_servers.${quoteTomlKey(name)}]`];
+  for (const [key, value] of Object.entries(server)) {
+    if (key === "env" || value === void 0) continue;
+    lines.push(`${quoteTomlKey(key)} = ${formatTomlValue(value)}`);
+  }
+  if (env && Object.keys(env).length > 0) {
+    lines.push("", `[mcp_servers.${quoteTomlKey(name)}.env]`);
+    for (const [key, value] of Object.entries(env)) {
+      lines.push(`${quoteTomlKey(key)} = ${formatTomlValue(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function extractMcpServerBlock(content, serverName) {
+  const lines = content.split(/\r?\n/);
+  const blocks = [];
+  let block;
+  let collecting = false;
+  for (const line of lines) {
+    const section = line.match(/^\s*\[([^\]]+)]\s*$/)?.[1];
+    if (section) {
+      const match = section.match(/^mcp_servers\.([^\.\]]+)(?:\.|$)/);
+      const name = match?.[1] ? unquoteTomlKey(match[1]) : void 0;
+      if (collecting && block) {
+        while (block.at(-1)?.trim() === "") block.pop();
+        blocks.push(block);
+      }
+      collecting = name === serverName;
+      block = collecting ? [] : void 0;
+    }
+    if (collecting) block?.push(line);
+  }
+  if (collecting && block) {
+    while (block.at(-1)?.trim() === "") block.pop();
+    blocks.push(block);
+  }
+  if (blocks.length === 0) return void 0;
+  return blocks.map((lines2) => lines2.join("\n")).join("\n\n");
+}
+function formatTomlValue(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.map(formatTomlValue).join(", ")}]`;
+  if (isRecord2(value)) {
+    const entries = Object.entries(value).map(([key, child]) => `${quoteTomlKey(key)} = ${formatTomlValue(child)}`);
+    return `{ ${entries.join(", ")} }`;
+  }
+  return '""';
+}
+function quoteTomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+function unquoteTomlKey(key) {
+  if (!key.startsWith('"')) return key;
+  try {
+    return JSON.parse(key);
+  } catch {
+    return key;
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/install/yaml-merge.ts
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+import { parse, stringify } from "yaml";
+async function mergeYamlFile(sourcePath, destPath) {
+  const source = parseYamlValue(await readFile5(sourcePath, "utf8"));
+  const current = await pathExists(destPath) ? parseYamlValue(await readFile5(destPath, "utf8")) : {};
+  const merged = deepMerge2(current, source);
+  await mkdir5(dirname5(destPath), { recursive: true });
+  await writeFile5(destPath, stringify(merged), "utf8");
+}
+function parseYamlValue(content) {
+  return normalizeYamlValue(parse(content));
+}
+function normalizeYamlValue(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(normalizeYamlValue);
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = normalizeYamlValue(child);
+    }
+    return out;
+  }
+  return value === void 0 ? null : String(value);
+}
+function deepMerge2(base, incoming) {
+  if (Array.isArray(base) && Array.isArray(incoming)) {
+    return dedupeArray2([...base, ...incoming]);
+  }
+  if (isRecord3(base) && isRecord3(incoming)) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(incoming)) {
+      out[key] = key in out ? deepMerge2(out[key], value) : value;
+    }
+    return out;
+  }
+  return incoming;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function dedupeArray2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    const key = JSON.stringify(value);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(value);
+  }
+  return out;
+}
+
+// src/install/merge-removal.ts
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var MergeAdoptionMismatchError = class extends Error {
+};
+function assertExactMergeContribution(contribution, strategy, currentContent) {
+  if (strategy === "codex-toml-mcp") {
+    assertExactMcpMergeContribution(contribution, strategy, currentContent);
+    return;
+  }
+  const current = parseMergeDestination(currentContent, strategy);
+  const mismatch = strategy === "openclaw-json-deep" ? firstOpenClawContributionMismatch(current, contribution) : firstMergeContributionMismatch(current, contribution);
+  if (mismatch) {
+    throw new MergeAdoptionMismatchError(`exact merge contribution differs or is missing at ${mismatch}`);
+  }
+}
+async function assertMergedSourceContribution(sourcePath, strategy, currentContent) {
+  assertExactMergeContribution(await readMergeSource(sourcePath, strategy), strategy, currentContent);
+}
+function assertExactMcpMergeContribution(removal, strategy, currentContent) {
+  if (strategy === "codex-toml-mcp") {
+    const mismatched = mismatchedCodexTomlMcpServers(removal, currentContent);
+    if (mismatched.length > 0) {
+      throw new MergeAdoptionMismatchError(`exact MCP retirement precondition failed: Codex MCP server content differs or is missing for ${mismatched.join(", ")}`);
+    }
+    return;
+  }
+  if (strategy !== "json-deep") {
+    throw new MergeAdoptionMismatchError(`exact MCP retirement precondition failed: strategy ${strategy} is not supported`);
+  }
+  const mismatch = firstMcpContributionMismatch(parseMergeDestination(currentContent, strategy), removal);
+  if (mismatch) {
+    throw new MergeAdoptionMismatchError(`exact MCP retirement precondition failed: destination differs or is missing at ${mismatch}`);
+  }
+}
+function combineMergeRemovals(existing, incoming) {
+  return combineMergeValues(existing, incoming);
+}
+function hasMergeRemovalContent(removal) {
+  if (!removal) return false;
+  return Object.entries(removal).some(([key, value]) => {
+    return !(key === "mcpServers" && isRecord4(value) && Object.keys(value).length === 0);
+  });
+}
+async function mergeRemovalForInstall(sourcePath, strategy, currentContent, options = {}) {
+  const source = await readMergeSource(sourcePath, strategy);
+  if (currentContent === void 0) return source;
+  if (options.adoptExisting) {
+    if (strategy === "codex-toml-mcp") {
+      const mismatched = mismatchedCodexTomlMcpServers(source, currentContent);
+      if (mismatched.length > 0) {
+        throw new MergeAdoptionMismatchError(`cannot adopt merged contribution: Codex MCP server content differs or is missing for ${mismatched.join(", ")}`);
+      }
+      return source;
+    }
+    const current = parseMergeDestination(currentContent, strategy);
+    const mismatch = options.adoptExisting === "mcp" ? firstMcpContributionMismatch(current, source) : strategy === "openclaw-json-deep" ? firstOpenClawContributionMismatch(current, source) : firstMergeContributionMismatch(current, source);
+    if (mismatch) {
+      throw new MergeAdoptionMismatchError(`cannot adopt merged contribution: destination differs or is missing at ${mismatch}`);
+    }
+    return source;
+  }
+  if (strategy === "codex-toml-mcp") {
+    const existingServers = codexTomlMcpServerNames(currentContent);
+    const servers = isRecord4(source.mcpServers) ? source.mcpServers : source;
+    return { mcpServers: Object.fromEntries(Object.entries(servers).filter(([name]) => !existingServers.has(name))) };
+  }
+  return introducedMergeContent(parseMergeDestination(currentContent, strategy), source);
+}
+async function removeMergeContribution(destPath, strategy, removal) {
+  const content = await readFile6(destPath, "utf8");
+  if (strategy === "codex-toml-mcp") {
+    const servers = isRecord4(removal.mcpServers) ? removal.mcpServers : removal;
+    await writeFile6(destPath, removeCodexTomlMcpSections(content, Object.keys(servers)), "utf8");
+    return;
+  }
+  const current = parseMergeDestination(content, strategy);
+  removeIntroducedContent(current, removal);
+  await mkdir6(dirname6(destPath), { recursive: true });
+  await writeFile6(destPath, strategy === "yaml-deep" ? stringify2(current) : `${JSON.stringify(current, null, 2)}
+`, "utf8");
+}
+function mergeContributionAbsent(removal, strategy, currentContent) {
+  if (strategy === "codex-toml-mcp") {
+    const servers = isRecord4(removal.mcpServers) ? removal.mcpServers : removal;
+    const currentServers = codexTomlMcpServerNames(currentContent);
+    return Object.keys(servers).every((name) => !currentServers.has(name));
+  }
+  return !containsRemovalContribution(parseMergeDestination(currentContent, strategy), removal);
+}
+async function readMergeSource(sourcePath, strategy) {
+  if (strategy === "openclaw-json-deep") {
+    return requireRecord(await renderOpenClawJsonMergeSource(sourcePath), "OpenClaw JSON merge source");
+  }
+  const content = await readFile6(sourcePath, "utf8");
+  if (strategy === "yaml-deep") return requireRecord(normalizeYamlValue2(parse2(content)), "YAML merge source");
+  return requireRecord(JSON.parse(content), "JSON merge source");
+}
+function parseMergeDestination(content, strategy) {
+  if (strategy === "yaml-deep") return requireRecord(normalizeYamlValue2(parse2(content)), "YAML merge destination");
+  return requireRecord(JSON.parse(content), "JSON merge destination");
+}
+function introducedMergeContent(base, incoming) {
+  const introduced = {};
+  for (const [key, incomingValue] of Object.entries(incoming)) {
+    if (!(key in base)) {
+      introduced[key] = incomingValue;
+      continue;
+    }
+    const baseValue = base[key];
+    if (isRecord4(baseValue) && isRecord4(incomingValue)) {
+      const nested = introducedMergeContent(baseValue, incomingValue);
+      if (Object.keys(nested).length > 0) introduced[key] = nested;
+    } else if (Array.isArray(baseValue) && Array.isArray(incomingValue)) {
+      const additions = incomingValue.filter((value) => !baseValue.some((existing) => sameValue(existing, value)));
+      if (additions.length > 0) introduced[key] = additions;
+    }
+  }
+  return introduced;
+}
+function firstMcpContributionMismatch(current, incoming) {
+  if (!isRecord4(current) || !isRecord4(incoming)) return "$";
+  if (!isRecord4(current.mcpServers) || !isRecord4(incoming.mcpServers)) return "$.mcpServers";
+  for (const [name, incomingServer] of Object.entries(incoming.mcpServers)) {
+    if (!(name in current.mcpServers) || !sameMcpValue(current.mcpServers[name], incomingServer)) {
+      return `$.mcpServers.${name}`;
+    }
+  }
+  for (const [key, incomingValue] of Object.entries(incoming)) {
+    if (key === "mcpServers") continue;
+    if (!(key in current) || !sameMcpValue(current[key], incomingValue)) return `$.${key}`;
+  }
+  return void 0;
+}
+function firstMergeContributionMismatch(current, contribution, path = "$") {
+  if (isRecord4(contribution)) {
+    if (!isRecord4(current)) return path;
+    for (const [key, value] of Object.entries(contribution)) {
+      if (!(key in current)) return `${path}.${key}`;
+      const mismatch = firstMergeContributionMismatch(current[key], value, `${path}.${key}`);
+      if (mismatch) return mismatch;
+    }
+    return void 0;
+  }
+  if (Array.isArray(contribution)) {
+    if (!Array.isArray(current)) return path;
+    for (const value of contribution) {
+      if (!current.some((candidate) => sameMcpValue(candidate, value))) return path;
+    }
+    return void 0;
+  }
+  return current === contribution ? void 0 : path;
+}
+function firstOpenClawContributionMismatch(current, contribution, path = []) {
+  const displayPath = path.length === 0 ? "$" : `$.${path.join(".")}`;
+  if (isOpenClawExactArrayPath(path)) {
+    return sameMcpValue(current, contribution) ? void 0 : displayPath;
+  }
+  const keyedBy = openClawKeyedArrayField(path);
+  if (keyedBy) {
+    if (!Array.isArray(current) || !Array.isArray(contribution)) return displayPath;
+    const currentByKey = groupRecordsByStringKey(current, keyedBy);
+    for (const [key, entries] of currentByKey) {
+      if (entries.length !== 1) return `${displayPath}[${keyedBy}=${JSON.stringify(key)}]`;
+    }
+    const incomingByKey = groupRecordsByStringKey(contribution, keyedBy);
+    for (const [key, entries] of incomingByKey) {
+      if (entries.length !== 1) return `${displayPath}[${keyedBy}=${JSON.stringify(key)}]`;
+      const matches = currentByKey.get(key);
+      if (!matches || matches.length !== 1 || !sameMcpValue(matches[0], entries[0])) {
+        return `${displayPath}[${keyedBy}=${JSON.stringify(key)}]`;
+      }
+    }
+    for (const value of contribution.filter((entry) => recordStringKey(entry, keyedBy) === void 0)) {
+      if (!current.some((candidate) => sameMcpValue(candidate, value))) return displayPath;
+    }
+    return void 0;
+  }
+  if (isRecord4(contribution)) {
+    if (!isRecord4(current)) return displayPath;
+    for (const [key, value] of Object.entries(contribution)) {
+      if (!(key in current)) return `${displayPath}.${key}`;
+      const mismatch = firstOpenClawContributionMismatch(current[key], value, [...path, key]);
+      if (mismatch) return mismatch;
+    }
+    return void 0;
+  }
+  if (Array.isArray(contribution)) {
+    if (!Array.isArray(current)) return displayPath;
+    for (const value of contribution) {
+      if (!current.some((candidate) => sameMcpValue(candidate, value))) return displayPath;
+    }
+    return void 0;
+  }
+  return current === contribution ? void 0 : displayPath;
+}
+function isOpenClawExactArrayPath(path) {
+  return path.length === 5 && path[0] === "mcp" && path[1] === "servers" && path[3] === "codex" && path[4] === "agents";
+}
+function openClawKeyedArrayField(path) {
+  if (path.join(".") === "agents.list") return "id";
+  if (path.join(".") === "plugins.entries.agentwheel-skill-router.config.repositories") return "name";
+  return void 0;
+}
+function groupRecordsByStringKey(values, key) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const recordKey = recordStringKey(value, key);
+    if (recordKey === void 0) continue;
+    grouped.set(recordKey, [...grouped.get(recordKey) ?? [], value]);
+  }
+  return grouped;
+}
+function recordStringKey(value, key) {
+  return isRecord4(value) && typeof value[key] === "string" ? value[key] : void 0;
+}
+function combineMergeValues(existing, incoming) {
+  if (isRecord4(existing) && isRecord4(incoming)) {
+    const combined = { ...existing };
+    for (const [key, incomingValue] of Object.entries(incoming)) {
+      combined[key] = key in combined ? combineMergeValues(combined[key], incomingValue) : incomingValue;
+    }
+    return combined;
+  }
+  if (Array.isArray(existing) && Array.isArray(incoming)) {
+    return [...existing, ...incoming.filter((value) => !existing.some((current) => sameValue(current, value)))];
+  }
+  return incoming;
+}
+function removeIntroducedContent(current, removal) {
+  for (const [key, removalValue] of Object.entries(removal)) {
+    if (!(key in current)) continue;
+    const currentValue = current[key];
+    if (isRecord4(currentValue) && isRecord4(removalValue)) {
+      removeIntroducedContent(currentValue, removalValue);
+      if (Object.keys(currentValue).length === 0) delete current[key];
+    } else if (Array.isArray(currentValue) && Array.isArray(removalValue)) {
+      const remaining = currentValue.filter((value) => !removalValue.some((removed) => sameValue(removed, value)));
+      if (remaining.length === 0) delete current[key];
+      else current[key] = remaining;
+    } else delete current[key];
+  }
+}
+function containsRemovalContribution(current, removal) {
+  for (const [key, removalValue] of Object.entries(removal)) {
+    if (!(key in current)) continue;
+    const currentValue = current[key];
+    if (isRecord4(currentValue) && isRecord4(removalValue) && Object.keys(removalValue).length > 0) {
+      if (containsRemovalContribution(currentValue, removalValue)) return true;
+      continue;
+    }
+    if (Array.isArray(currentValue) && Array.isArray(removalValue) && removalValue.length > 0) {
+      if (removalValue.some((removed) => currentValue.some((candidate) => sameValue(candidate, removed)))) return true;
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+function codexTomlMcpServerNames(content) {
+  const names = /* @__PURE__ */ new Set();
+  for (const line of content.split(/\r?\n/)) {
+    const section = line.match(/^\s*\[([^\]]+)]\s*$/)?.[1];
+    const match = section?.match(/^mcp_servers\.([^.\]]+)(?:\.|$)/);
+    if (match?.[1]) names.add(unquoteTomlKey2(match[1]));
+  }
+  return names;
+}
+function removeCodexTomlMcpSections(content, serverNames) {
+  if (serverNames.length === 0 || content.trim() === "") return content;
+  const names = new Set(serverNames);
+  const kept = [];
+  let skipping = false;
+  for (const line of content.split(/\r?\n/)) {
+    const section = line.match(/^\s*\[([^\]]+)]\s*$/)?.[1];
+    if (section) {
+      const match = section.match(/^mcp_servers\.([^.\]]+)(?:\.|$)/);
+      skipping = match ? names.has(unquoteTomlKey2(match[1] ?? "")) : false;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}$/g, "\n\n");
+}
+function normalizeYamlValue2(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(normalizeYamlValue2);
+  if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, normalizeYamlValue2(child)]));
+  return value === void 0 ? null : String(value);
+}
+function requireRecord(value, label) {
+  if (!isRecord4(value)) throw new Error(`${label} must be an object`);
+  return value;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function sameMcpValue(left, right) {
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameMcpValue(value, right[index]));
+  }
+  if (isRecord4(left) || isRecord4(right)) {
+    if (!isRecord4(left) || !isRecord4(right)) return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && sameMcpValue(left[key], right[key]));
+  }
+  return left === right;
+}
+function unquoteTomlKey2(key) {
+  if (!key.startsWith('"')) return key;
+  try {
+    return JSON.parse(key);
+  } catch {
+    return key;
+  }
+}
+
+// src/install/desired.ts
+function normalizeOwners(owners) {
+  const normalized = [...new Set(owners.map((owner) => owner.trim()).filter(Boolean))].sort();
+  if (normalized.length === 0) {
+    throw new Error("Desired artifacts must declare at least one owner");
+  }
+  return normalized;
+}
+
+// src/install/instructions-block.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdtemp, readFile as readFile7, realpath, rm, writeFile as writeFile7 } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname as dirname7, join as join2, relative as relative2 } from "path";
+var managedInstructionBlockMode = "managed-block";
+var managedInstructionBanner = "<!-- agentwheel-managed: edit fragments, not this block -->";
+async function desiredManagedInstructionBlockHash(sourcePath) {
+  const source = await readFile7(sourcePath, "utf8");
+  return hashText(managedBlockBody(source));
+}
+async function readManagedInstructionBlockState(destPath, selector, transport) {
+  if (!await transport.pathExists(destPath)) {
+    return { exists: false, hasBlock: false, drifted: false };
+  }
+  const content = await transport.readFile(destPath);
+  const block = findManagedInstructionBlock(content, selector);
+  if (!block) return { exists: true, hasBlock: false, drifted: false };
+  const hash = hashText(block.body);
+  return {
+    exists: true,
+    hasBlock: true,
+    hash,
+    markerHash: block.markerHash,
+    drifted: hash !== block.markerHash
+  };
+}
+async function writeManagedInstructionBlock(sourcePath, destPath, selector, transport, options = {}) {
+  const source = await readFile7(sourcePath, "utf8");
+  const desired = renderManagedInstructionBlock(selector, source);
+  const existing = await readOptionalText(destPath, transport);
+  const merged = upsertManagedInstructionBlock(existing ?? "", selector, desired.block, options);
+  await writeTextWithTransport(destPath, merged, transport);
+  return desired.hash;
+}
+async function removeManagedInstructionBlock(destPath, selector, transport, options = {}) {
+  if (!await transport.pathExists(destPath)) return;
+  const existing = await transport.readFile(destPath);
+  const updated = removeManagedBlockFromContent(existing, selector, options);
+  await writeTextWithTransport(destPath, updated, transport);
+}
+async function managedInstructionBlockLanded(destPath, selector, expectedHash, transport) {
+  if (!expectedHash) return false;
+  const state = await readManagedInstructionBlockState(destPath, selector, transport);
+  return state.exists && state.hasBlock && !state.drifted && state.hash === expectedHash;
+}
+async function managedInstructionPhysicalKey(destPath, transport) {
+  if (transport.kind !== "local" || !await transport.pathExists(destPath)) return destPath;
+  return realpath(destPath);
+}
+async function claudeInstructionBridgesAgents(claudePath, agentsPath, transport) {
+  if (!await transport.pathExists(claudePath)) return false;
+  if (await samePhysicalPath(claudePath, agentsPath, transport)) return true;
+  const claudeContent = await transport.readFile(claudePath);
+  return referencesAgentsMd(claudeContent, claudePath, agentsPath);
+}
+function managedInstructionSelector(selector, artifactType, artifactName) {
+  if (!selector) return `${artifactType}/${artifactName}`;
+  const unscoped = selector.split(":").at(-1);
+  return unscoped?.includes("/") ? unscoped : selector;
+}
+function renderManagedInstructionBlock(selector, source) {
+  const body = managedBlockBody(source);
+  const hash = hashText(body);
+  return {
+    block: `<!-- BEGIN openpack:include ${selector} sha256:${hash} -->
+${body}<!-- END openpack:include ${selector} -->
+`,
+    hash
+  };
+}
+function upsertManagedInstructionBlock(content, selector, block, options) {
+  const { expectedHash, allowDrift = false } = options;
+  const existing = findManagedInstructionBlock(content, selector);
+  if (!existing) {
+    if (expectedHash) throw new Error(`Managed instruction block missing for ${selector}`);
+    return appendManagedInstructionBlock(content, block);
+  }
+  if (!allowDrift) {
+    assertCleanBlock(existing, selector);
+    if (expectedHash && hashText(existing.body) !== expectedHash) {
+      throw new Error(`Managed instruction block drift detected for ${selector}`);
+    }
+  }
+  return `${content.slice(0, existing.start)}${block}${content.slice(existing.end)}`;
+}
+function removeManagedBlockFromContent(content, selector, options) {
+  const { expectedHash, allowDrift = false } = options;
+  const existing = findManagedInstructionBlock(content, selector);
+  if (!existing) return content;
+  if (!allowDrift) {
+    assertCleanBlock(existing, selector);
+    if (expectedHash && hashText(existing.body) !== expectedHash) {
+      throw new Error(`Managed instruction block drift detected for ${selector}`);
+    }
+  }
+  return `${content.slice(0, existing.start)}${content.slice(existing.end)}`;
+}
+function findManagedInstructionBlock(content, selector) {
+  const beginPattern = new RegExp(`<!-- BEGIN openpack:include ${escapeRegex(selector)} sha256:([a-f0-9]+) -->\\r?\\n?`);
+  const begin = beginPattern.exec(content);
+  if (!begin || begin.index === void 0) return void 0;
+  const markerHash = begin[1];
+  const bodyStart = begin.index + begin[0].length;
+  const endMarker = `<!-- END openpack:include ${selector} -->`;
+  const endIndex = content.indexOf(endMarker, bodyStart);
+  if (endIndex < 0) {
+    return {
+      start: begin.index,
+      end: content.length,
+      body: content.slice(bodyStart),
+      markerHash
+    };
+  }
+  let blockEnd = endIndex + endMarker.length;
+  if (content[blockEnd] === "\r" && content[blockEnd + 1] === "\n") blockEnd += 2;
+  else if (content[blockEnd] === "\n") blockEnd += 1;
+  return {
+    start: begin.index,
+    end: blockEnd,
+    body: content.slice(bodyStart, endIndex),
+    markerHash
+  };
+}
+function managedBlockBody(source) {
+  return `${managedInstructionBanner}
+${ensureTrailingNewline(source)}`;
+}
+function appendManagedInstructionBlock(content, block) {
+  if (content.length === 0) return block;
+  const separator = content.endsWith("\n\n") ? "" : content.endsWith("\n") ? "\n" : "\n\n";
+  return `${content}${separator}${block}`;
+}
+function assertCleanBlock(block, selector) {
+  const actual = hashText(block.body);
+  if (actual !== block.markerHash) {
+    throw new Error(`Managed instruction block drift detected for ${selector}`);
+  }
+}
+function referencesAgentsMd(content, claudePath, agentsPath) {
+  const claudeDir = dirname7(claudePath);
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const atImport = /^@import\s+(.+)$/i.exec(line);
+    const atPath = /^@(.+AGENTS\.md)$/i.exec(line);
+    const referenced = atImport?.[1] ?? atPath?.[1];
+    if (!referenced) continue;
+    const cleaned = referenced.trim().replace(/^["']|["']$/g, "");
+    if (!/AGENTS\.md$/i.test(cleaned)) continue;
+    const candidate = cleaned.startsWith("/") ? cleaned : join2(claudeDir, cleaned);
+    if (relative2(dirname7(agentsPath), candidate).replaceAll("\\", "/") === "AGENTS.md") return true;
+    if (candidate === agentsPath) return true;
+  }
+  return false;
+}
+async function samePhysicalPath(left, right, transport) {
+  if (transport.kind !== "local") return false;
+  if (!await transport.pathExists(left) || !await transport.pathExists(right)) return false;
+  return await realpath(left) === await realpath(right);
+}
+async function readOptionalText(path, transport) {
+  if (!await transport.pathExists(path)) return void 0;
+  return transport.readFile(path);
+}
+async function writeTextWithTransport(path, content, transport) {
+  if (transport.kind === "local") {
+    await transport.writeFileAtomic(path, content);
+    return;
+  }
+  const tempRoot = await mkdtemp(join2(tmpdir(), "agentwheel-instructions-"));
+  const localPath = join2(tempRoot, basename(path) || "instructions.md");
+  try {
+    await writeFile7(localPath, content, "utf8");
+    await transport.atomicCopy(localPath, path, "file");
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+function ensureTrailingNewline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function hashText(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/install/apply.ts
+var execFileAsync = promisify(execFile);
+async function applyInstallPlan(plan, sourceLock, options = {}) {
+  return applyPlanTransactionally(plan, { ...options, sourceLock });
+}
+async function applyCombinedInstallPlan(plan, options = {}) {
+  return applyPlanTransactionally(plan, options);
+}
+async function recoverPendingApply(targetRoot, adapter, transport = localTransport, scope = {}) {
+  assertGovernedRuntimeTransportSupported(transport);
+  const lock = await acquireApplyLock(targetRoot, adapter, transport, {}, scope);
+  try {
+    const journal = await readApplyJournal(targetRoot, adapter, transport, scope);
+    if (!journal) return void 0;
+    assertApplyJournalRecoveryAllowed(journal);
+    if (journal.operations.some((operation) => operation.action === "plugin" || operation.action === "program" || operation.semanticPlugin)) {
+      throw new Error("Cannot automatically recover a journal containing semantic plugin or programmatic operations");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entries = [];
+    const startedByIndex = new Map(journal.completed.map((operation) => [operation.index, operation]));
+    for (const [index, operation] of journal.operations.entries()) {
+      assertOperationContained(operation, journal.targetRoot);
+      const started = startedByIndex.get(index);
+      if (started?.completed || started && await operationLanded(operation, transport)) {
+        started.completed = true;
+        await writeApplyJournal(journal, transport);
+        const entry2 = await entryForCompletedOperation(operation, transport, now, journal.graphLockDigest);
+        if (entry2) entries.push(entry2);
+        continue;
+      }
+      if (operationNeedsSource(operation) && operation.sourcePath && !await localPathExists(operation.sourcePath)) {
+        await rollbackStartedOperations(journal, transport);
+        await removeApplyJournal(targetRoot, adapter, transport, scope);
+        return void 0;
+      }
+      const backup = started ?? await recordBackup(operation, index, targetRoot, adapter, transport, scope);
+      if (!started && isJournaledMutation(operation)) {
+        journal.completed.push(backup);
+        startedByIndex.set(index, backup);
+        await writeApplyJournal(journal, transport);
+      }
+      const entry = await applyOperation(operation, { transport, now, graphLockDigest: journal.graphLockDigest });
+      if (entry) entries.push(entry);
+      if (isJournaledMutation(operation)) {
+        backup.completed = true;
+        await writeApplyJournal(journal, transport);
+      }
+    }
+    return await commitJournalState(journal, transport, journal.mode === "uninstall" ? void 0 : entries, now);
+  } finally {
+    await lock.release();
+  }
+}
+async function applyPlanTransactionally(plan, options = {}) {
+  const transport = options.transport ?? localTransport;
+  const scope = { installationType: plan.installationType, stateKey: plan.stateKey };
+  if (plan.hasBlockingChanges) {
+    const blockers = plan.operations.filter((operation) => operation.action === "drift" || operation.action === "conflict");
+    throw new Error(`Refusing to apply with blocking changes: ${blockers.map((item) => item.relativeDestPath).join(", ")}`);
+  }
+  assertGovernedRuntimeTransportSupported(transport);
+  const lock = await acquireApplyLock(plan.targetRoot, plan.adapter, transport, options.lock, scope);
+  try {
+    await assertBaseRevision(plan, transport);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const graphLockDigest = options.graphLockDigest ?? plan.graphLockDigest;
+    const mutation = mutationMetadataForApplyJournal();
+    const journal = {
+      version: mutation ? 2 : 1,
+      ...mutation ? { mutation } : {},
+      adapter: plan.adapter,
+      installationType: plan.installationType,
+      stateKey: plan.stateKey,
+      targetRoot: plan.targetRoot,
+      baseRevision: plan.baseRevision,
+      graphLockDigest,
+      createdAt: now,
+      updatedAt: now,
+      operations: plan.operations,
+      completed: [],
+      manifest: {
+        version: 2,
+        adapter: plan.adapter,
+        installationType: plan.installationType,
+        stateKey: plan.stateKey,
+        targetRoot: plan.targetRoot,
+        generatedAt: now,
+        revision: "pending-apply-0000",
+        legacy: false,
+        adapterCode: plan.adapterCode,
+        entries: []
+      },
+      sourceLock: options.sourceLock,
+      graphLockPath: options.graphLock?.path,
+      graphLock: options.graphLock?.lock
+    };
+    await writeApplyJournal(journal, transport);
+    const entries = [];
+    for (const [index, operation] of plan.operations.entries()) {
+      assertOperationContained(operation, plan.targetRoot);
+      const backup = isJournaledMutation(operation) ? await recordBackup(operation, index, plan.targetRoot, plan.adapter, transport, scope) : void 0;
+      if (backup) {
+        journal.completed.push(backup);
+        await writeApplyJournal(journal, transport);
+      }
+      const entry = await applyOperation(operation, {
+        transport,
+        now,
+        executePlugins: options.executePlugins,
+        graphLockDigest,
+        plan
+      });
+      if (entry) entries.push(entry);
+      if (backup) {
+        backup.completed = true;
+        await writeApplyJournal(journal, transport);
+      }
+    }
+    return await commitJournalState(journal, transport, entries, now);
+  } finally {
+    await lock.release();
+  }
+}
+async function uninstall(plan, options = {}) {
+  const resolvedOptions = typeof options === "boolean" ? { dryRun: options } : options;
+  const transport = resolvedOptions.transport ?? localTransport;
+  const scope = { installationType: plan.installationType, stateKey: plan.stateKey };
+  if (resolvedOptions.keepFiles && resolvedOptions.force) {
+    throw new Error("--keep-files cannot be combined with --force.");
+  }
+  if (plan.hasBlockingChanges) {
+    const blockers = plan.operations.filter((operation) => operation.action === "conflict");
+    throw new Error(`Refusing to uninstall with blocking changes: ${blockers.map((item) => item.relativeDestPath).join(", ")}`);
+  }
+  const removable = plan.operations.filter((operation) => operation.action === "remove" || resolvedOptions.force && isForceRemovableKeep(operation)).map((operation) => operation.action === "keep" ? { ...operation, action: "remove", overrideDrift: true, reason: `${operation.reason}; force removing drifted managed file` } : operation);
+  const kept = plan.operations.filter((operation) => operation.action === "keep" && (!resolvedOptions.force || !isForceRemovableKeep(operation)));
+  const skipped = plan.operations.filter((operation) => operation.action === "skip");
+  const removedDrifted = resolvedOptions.force ? plan.operations.filter((operation) => operation.action === "keep" && isForceRemovableKeep(operation)).length : 0;
+  if (resolvedOptions.dryRun) return { removed: resolvedOptions.keepFiles ? 0 : removable.length, kept: kept.length, removedDrifted };
+  assertGovernedRuntimeTransportSupported(transport);
+  const preservedKept = resolvedOptions.keepFiles ? kept.filter((operation) => shouldPreserveKeptOperationWhenKeepingFiles(operation)) : kept;
+  const preserved = [...preservedKept, ...skipped].filter((operation) => operation.preserveInManifest !== false);
+  for (const operation of [...removable, ...preserved]) assertOperationContained(operation, plan.targetRoot);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const finalManifest = withManifestRevision({
+    version: 2,
+    adapter: plan.adapter,
+    installationType: plan.installationType,
+    stateKey: plan.stateKey,
+    targetRoot: plan.targetRoot,
+    generatedAt: now,
+    revision: "pending-uninstall-0",
+    legacy: false,
+    adapterCode: plan.adapterCode,
+    entries: preserved.map((operation) => {
+      if (!operation.manifestHash || !operation.desiredHash) {
+        throw new Error(`Invalid preserved operation missing manifest/source hash: ${operation.relativeDestPath}`);
+      }
+      return manifestEntryForOperation(operation, {
+        now,
+        hash: operation.manifestHash,
+        sourceHash: operation.desiredHash,
+        graphLockDigest: operation.graphLockDigest ?? plan.graphLockDigest
+      });
+    }).sort((a, b) => a.path.localeCompare(b.path))
+  });
+  const lock = await acquireApplyLock(plan.targetRoot, plan.adapter, transport, resolvedOptions.lock, scope);
+  try {
+    await assertBaseRevision(plan, transport);
+    await assertExactMergeRemovalPreconditions(removable, transport);
+    const mutation = mutationMetadataForApplyJournal();
+    const journal = {
+      version: mutation ? 2 : 1,
+      ...mutation ? { mutation } : {},
+      mode: "uninstall",
+      adapter: plan.adapter,
+      installationType: plan.installationType,
+      stateKey: plan.stateKey,
+      targetRoot: plan.targetRoot,
+      baseRevision: plan.baseRevision,
+      graphLockDigest: plan.graphLockDigest,
+      createdAt: now,
+      updatedAt: now,
+      operations: resolvedOptions.keepFiles ? [] : removable,
+      completed: [],
+      manifest: finalManifest,
+      graphLockPath: resolvedOptions.graphLock?.path,
+      graphLock: resolvedOptions.graphLock?.lock,
+      graphLockRemovePath: resolvedOptions.removeGraphLockPath,
+      workspaceConfigPath: resolvedOptions.workspaceConfig?.path,
+      workspaceConfig: resolvedOptions.workspaceConfig?.data
+    };
+    await writeApplyJournal(journal, transport);
+    for (const [index, operation] of (resolvedOptions.keepFiles ? [] : removable).entries()) {
+      const backup = await recordBackup(operation, index, plan.targetRoot, plan.adapter, transport, scope);
+      journal.completed.push(backup);
+      await writeApplyJournal(journal, transport);
+      await applyOperation(operation, { transport, now, graphLockDigest: plan.graphLockDigest });
+      backup.completed = true;
+      await writeApplyJournal(journal, transport);
+    }
+    await commitJournalState(journal, transport, void 0, now);
+  } finally {
+    await lock.release();
+  }
+  return { removed: resolvedOptions.keepFiles ? 0 : removable.length, kept: kept.length, removedDrifted };
+}
+function shouldPreserveKeptOperationWhenKeepingFiles(operation) {
+  return operation.preserveInManifest === true;
+}
+function isForceRemovableKeep(operation) {
+  return operation.action === "keep" && operation.preserveInManifest !== true;
+}
+async function commitJournalState(journal, transport, entries, now) {
+  const manifest = withManifestRevision({
+    ...journal.manifest,
+    generatedAt: now,
+    entries: entries ? entries.sort((a, b) => a.path.localeCompare(b.path)) : journal.manifest.entries
+  });
+  if (journal.mode === "uninstall" && manifest.entries.length === 0) {
+    await removeStateFiles(journal.targetRoot, journal.adapter, transport, {
+      installationType: journal.installationType,
+      stateKey: journal.stateKey
+    });
+  } else {
+    if (journal.sourceLock) await writeSourceLock(journal.targetRoot, journal.adapter, journal.sourceLock, transport, {
+      installationType: journal.installationType,
+      stateKey: journal.stateKey
+    });
+    await writeInstallManifest(manifest, transport);
+  }
+  if (journal.graphLockPath && journal.graphLock) await writeGraphLock(journal.graphLockPath, journal.graphLock);
+  if (journal.graphLockRemovePath) {
+    declareMutationPath(journal.graphLockRemovePath);
+    await rm2(journal.graphLockRemovePath, { force: true });
+  }
+  if (journal.workspaceConfigPath && journal.workspaceConfig) {
+    declareMutationPath(journal.workspaceConfigPath);
+    await writeJsonAtomic(journal.workspaceConfigPath, journal.workspaceConfig);
+  }
+  const verifiedManifest = await assertCommittedJournalState(journal, manifest, transport);
+  await removeApplyJournal(journal.targetRoot, journal.adapter, transport, {
+    installationType: journal.installationType,
+    stateKey: journal.stateKey
+  });
+  if (await readApplyJournal(journal.targetRoot, journal.adapter, transport, {
+    installationType: journal.installationType,
+    stateKey: journal.stateKey
+  })) {
+    throw new Error("Agentwheel apply journal remained after verified state commit.");
+  }
+  return verifiedManifest ?? manifest;
+}
+async function assertCommittedJournalState(journal, expectedManifest, transport) {
+  const scope = { installationType: journal.installationType, stateKey: journal.stateKey };
+  const actualManifest = await readInstallManifest(journal.targetRoot, journal.adapter, transport, scope);
+  if (journal.mode === "uninstall" && expectedManifest.entries.length === 0) {
+    if (actualManifest) throw new Error("Uninstall postcheck found an install manifest that should have been removed.");
+  } else if (!actualManifest) {
+    throw new Error(
+      `Install manifest postcheck failed: expected ${expectedManifest.revision}, found missing.`
+    );
+  } else if (canonicalInstallManifestJson(actualManifest) !== canonicalInstallManifestJson(expectedManifest)) {
+    throw new Error("Install manifest postcheck found content that differs from the verified apply result.");
+  }
+  for (const operation of journal.operations.filter(isJournaledMutation)) {
+    if (!await operationLanded(operation, transport)) {
+      throw new Error(`Runtime postcheck failed for ${operation.relativeDestPath}.`);
+    }
+  }
+  if (journal.graphLockPath && journal.graphLock) {
+    const actual = await readGraphLock(journal.graphLockPath);
+    if (canonicalGraphLockJson(actual) !== canonicalGraphLockJson(journal.graphLock)) {
+      throw new Error(`Graph-lock postcheck failed for ${journal.graphLockPath}.`);
+    }
+  }
+  if (journal.graphLockRemovePath && await pathExists(journal.graphLockRemovePath)) {
+    throw new Error(`Graph-lock removal postcheck failed for ${journal.graphLockRemovePath}.`);
+  }
+  if (journal.workspaceConfigPath && journal.workspaceConfig) {
+    const actual = JSON.parse(await readFile8(journal.workspaceConfigPath, "utf8"));
+    if (canonicalJson2(actual) !== canonicalJson2(journal.workspaceConfig)) {
+      throw new Error(`Workspace config postcheck failed for ${journal.workspaceConfigPath}.`);
+    }
+  }
+  return actualManifest;
+}
+function canonicalJson2(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson2(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).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(record[key])}`).join(",")}}`;
+}
+async function applyOperation(operation, context) {
+  const { transport, now } = context;
+  if (operation.action === "plugin") {
+    if (!operation.desiredHash) {
+      throw new Error(`Invalid plugin operation missing hash: ${operation.relativeDestPath}`);
+    }
+    if (context.executePlugins) {
+      await executePluginInstall(operation, transport);
+    }
+    return manifestEntryForOperation(operation, {
+      now,
+      hash: operation.desiredHash,
+      sourceHash: operation.desiredHash,
+      graphLockDigest: context.graphLockDigest,
+      executed: context.executePlugins === true
+    });
+  }
+  if (operation.action === "program") {
+    if (!context.plan?.adapterCode || !operation.desiredHash || !operation.programmaticOperation) {
+      throw new Error(`Invalid programmatic operation: ${operation.relativeDestPath}`);
+    }
+    if (operation.programmaticApply) {
+      if (transport.kind !== "local") {
+        throw new Error(`Cannot execute programmatic adapter operation over ${transport.description}.`);
+      }
+      await operation.programmaticApply(operation.programmaticOperation, {
+        targetRoot: context.plan.targetRoot,
+        adapterName: context.plan.adapter
+      });
+    }
+    return manifestEntryForOperation(operation, {
+      now,
+      hash: operation.desiredHash,
+      sourceHash: operation.desiredHash,
+      graphLockDigest: context.graphLockDigest
+    });
+  }
+  if (operation.action === "create" || operation.action === "update") {
+    if (!operation.sourcePath || !operation.desiredHash) {
+      throw new Error(`Invalid operation missing source/hash: ${operation.relativeDestPath}`);
+    }
+    if (operation.mode === managedInstructionBlockMode) {
+      const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
+      const hash2 = await writeManagedInstructionBlock(operation.sourcePath, operation.destPath, selector, transport, managedBlockMutationOptions(operation));
+      if (hash2 !== operation.desiredHash) {
+        throw new Error(`Managed block hash verification failed for ${operation.relativeDestPath}: expected ${operation.desiredHash}, got ${hash2}`);
+      }
+      return manifestEntryForOperation(operation, {
+        now,
+        hash: hash2,
+        sourceHash: operation.desiredHash,
+        graphLockDigest: context.graphLockDigest
+      });
+    }
+    if (operation.mergeStrategy === "json-deep") {
+      await mergeWithTransport(operation.sourcePath, operation.destPath, transport, mergeJsonFile);
+    } else if (operation.mergeStrategy === "openclaw-json-deep") {
+      await mergeOpenClawJsonWithTransport(operation.sourcePath, operation.destPath, transport);
+    } else if (operation.mergeStrategy === "yaml-deep") {
+      await mergeWithTransport(operation.sourcePath, operation.destPath, transport, mergeYamlFile);
+    } else if (operation.mergeStrategy === "codex-toml-mcp") {
+      await mergeWithTransport(operation.sourcePath, operation.destPath, transport, mergeCodexTomlMcp);
+    } else if (operation.mergeStrategy) {
+      throw new Error(`Merge strategy '${operation.mergeStrategy}' is not implemented by apply.`);
+    } else {
+      await transport.atomicCopy(operation.sourcePath, operation.destPath, operation.kind);
+    }
+    const hash = await transport.hashPath(operation.destPath);
+    if (!operation.mergeStrategy && hash !== operation.desiredHash) {
+      throw new Error(`Hash verification failed for ${operation.relativeDestPath}: expected ${operation.desiredHash}, got ${hash}`);
+    }
+    return manifestEntryForOperation(operation, {
+      now,
+      hash,
+      sourceHash: operation.desiredHash,
+      graphLockDigest: context.graphLockDigest
+    });
+  }
+  if (operation.action === "skip") {
+    if (!operation.desiredHash) {
+      throw new Error(`Invalid skip operation missing hash: ${operation.relativeDestPath}`);
+    }
+    return manifestEntryForOperation(operation, {
+      now,
+      hash: (operation.mergeStrategy || operation.mode === managedInstructionBlockMode) && operation.currentHash ? operation.currentHash : operation.desiredHash,
+      sourceHash: operation.desiredHash,
+      graphLockDigest: context.graphLockDigest
+    });
+  }
+  if (operation.action === "keep") {
+    if (!operation.manifestHash || !operation.desiredHash) {
+      throw new Error(`Invalid keep operation missing manifest/source hash: ${operation.relativeDestPath}`);
+    }
+    return manifestEntryForOperation(operation, {
+      now,
+      hash: operation.manifestHash,
+      sourceHash: operation.desiredHash,
+      graphLockDigest: operation.graphLockDigest ?? context.graphLockDigest
+    });
+  }
+  if (operation.action === "remove") {
+    if (operation.semanticPlugin) {
+      if (operation.execute !== false) await executePluginUninstall(operation, transport);
+      return void 0;
+    }
+    if (operation.mode === managedInstructionBlockMode) {
+      const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
+      await removeManagedInstructionBlock(operation.destPath, selector, transport, managedBlockMutationOptions(operation));
+    } else if (operation.mergeStrategy) {
+      if (operation.mergeCreatedDestination) {
+        await transport.rm(operation.destPath);
+      } else if (operation.mergeRemoval) {
+        if (operation.exactMergeRemoval) {
+          if (!await transport.pathExists(operation.destPath)) {
+            throw new Error(`Exact MCP retirement destination is missing: ${operation.relativeDestPath}`);
+          }
+          assertExactMcpMergeContribution(
+            operation.mergeRemoval,
+            operation.mergeStrategy,
+            await transport.readFile(operation.destPath)
+          );
+        }
+        await removeMergeWithTransport(operation.destPath, operation.mergeStrategy, operation.mergeRemoval, transport);
+      }
+    } else {
+      await transport.rm(operation.destPath);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+async function executePluginInstall(operation, transport) {
+  const commands = semanticInstallCommands(operation);
+  if (commands.length === 0) throw new Error(`Invalid plugin operation missing command: ${operation.relativeDestPath}`);
+  if (!operation.sourcePath) {
+    throw new Error(`Invalid plugin operation missing source path: ${operation.relativeDestPath}`);
+  }
+  if (operation.semanticPlugin?.stateRoot) {
+    await prepareSemanticPluginState(operation, transport);
+  }
+  await executeSemanticCommands(operation, commands, transport, { stageSource: operation.semanticPlugin?.stateRoot ? false : true });
+}
+async function executePluginUninstall(operation, transport) {
+  const commands = operation.semanticPlugin?.uninstallCommands ?? [];
+  if (commands.length === 0) throw new Error(`Invalid semantic plugin operation missing uninstall command: ${operation.relativeDestPath}`);
+  try {
+    await executeSemanticCommands(operation, commands, transport);
+  } catch (error) {
+    if (!isPluginAlreadyAbsentError(operation, error)) throw error;
+    console.warn(`WARNING plugin-already-absent ${operation.relativeDestPath}: ${firstErrorLine(error)}`);
+  }
+  if (operation.semanticPlugin?.stateRoot) {
+    await transport.rm(operation.semanticPlugin.stateRoot);
+  }
+}
+async function prepareSemanticPluginState(operation, transport) {
+  const spec = operation.semanticPlugin;
+  if (!spec?.stateRoot) return;
+  if (!operation.sourcePath) {
+    throw new Error(`Invalid semantic plugin operation missing source path: ${operation.relativeDestPath}`);
+  }
+  if (spec.runtime === "claude") {
+    await prepareClaudeMarketplace(operation, transport);
+    return;
+  }
+  if (spec.runtime === "codex") {
+    await prepareCodexMarketplace(operation, transport);
+    return;
+  }
+  if (spec.runtime === "copilot") {
+    await prepareCopilotPlugin(operation, transport);
+    return;
+  }
+  if (spec.runtime === "hermes") {
+    await prepareHermesGitShim(operation, transport);
+  }
+}
+async function prepareClaudeMarketplace(operation, transport) {
+  const spec = requireSemanticPluginState(operation);
+  const marketplaceName = requireMarketplaceName(operation);
+  const marketplaceRoot = join3(spec.stateRoot, "marketplace");
+  await transport.rm(spec.stateRoot);
+  await transport.atomicCopy(requireSourcePath(operation), join3(marketplaceRoot, "plugins", spec.pluginName), operation.kind);
+  await transport.writeJsonAtomic(join3(marketplaceRoot, ".claude-plugin", "marketplace.json"), {
+    name: marketplaceName,
+    owner: { name: "Agentwheel" },
+    plugins: [
+      {
+        name: spec.pluginName,
+        source: `./plugins/${spec.pluginName}`,
+        description: `Installed by Agentwheel${operation.packageName ? ` from ${operation.packageName}` : ""}`
+      }
+    ]
+  });
+}
+async function prepareCodexMarketplace(operation, transport) {
+  const spec = requireSemanticPluginState(operation);
+  const marketplaceName = requireMarketplaceName(operation);
+  const marketplaceRoot = join3(spec.stateRoot, "marketplace");
+  await transport.rm(spec.stateRoot);
+  await transport.atomicCopy(requireSourcePath(operation), join3(marketplaceRoot, "plugins", spec.pluginName), operation.kind);
+  await transport.writeJsonAtomic(join3(marketplaceRoot, ".agents", "plugins", "marketplace.json"), {
+    name: marketplaceName,
+    interface: {
+      displayName: "Agentwheel"
+    },
+    plugins: [
+      {
+        name: spec.pluginName,
+        source: {
+          source: "local",
+          path: `./plugins/${spec.pluginName}`
+        },
+        policy: {
+          installation: "AVAILABLE",
+          authentication: "ON_INSTALL"
+        },
+        category: "Agentwheel"
+      }
+    ]
+  });
+}
+async function prepareCopilotPlugin(operation, transport) {
+  const spec = requireSemanticPluginState(operation);
+  await transport.rm(spec.stateRoot);
+  await transport.atomicCopy(requireSourcePath(operation), join3(spec.stateRoot, "plugin"), operation.kind);
+}
+async function prepareHermesGitShim(operation, transport) {
+  const spec = requireSemanticPluginState(operation);
+  const repoRoot = join3(spec.stateRoot, "repo");
+  await transport.rm(spec.stateRoot);
+  await transport.atomicCopy(requireSourcePath(operation), repoRoot, operation.kind);
+  if (!transport.execFile) {
+    throw new Error(`Cannot prepare Hermes plugin git shim over ${transport.description}: transport does not support remote commands.`);
+  }
+  await transport.execFile("git", ["init", repoRoot], { cwd: operation.destPath });
+  await transport.execFile("git", ["-C", repoRoot, "add", "-A"], { cwd: operation.destPath });
+  await transport.execFile("git", [
+    "-C",
+    repoRoot,
+    "-c",
+    "user.name=agentwheel",
+    "-c",
+    "user.email=agentwheel@example.invalid",
+    "commit",
+    "-m",
+    `agentwheel plugin ${operation.desiredHash ?? "unknown"}`
+  ], { cwd: operation.destPath });
+}
+function requireSemanticPluginState(operation) {
+  const spec = operation.semanticPlugin;
+  if (!spec?.stateRoot) throw new Error(`Invalid semantic plugin operation missing state root: ${operation.relativeDestPath}`);
+  return spec;
+}
+function requireSourcePath(operation) {
+  if (!operation.sourcePath) throw new Error(`Invalid semantic plugin operation missing source path: ${operation.relativeDestPath}`);
+  return operation.sourcePath;
+}
+function requireMarketplaceName(operation) {
+  const marketplaceName = operation.semanticPlugin?.marketplaceName;
+  if (!marketplaceName) throw new Error(`Invalid semantic plugin operation missing marketplace name: ${operation.relativeDestPath}`);
+  return marketplaceName;
+}
+async function executeSemanticCommands(operation, commands, transport, options = {}) {
+  if (transport.kind === "local") {
+    for (const [command, ...args] of commands) {
+      if (!command) throw new Error(`Invalid semantic plugin command for ${operation.relativeDestPath}`);
+      await execFileAsync(command, args);
+    }
+    return;
+  }
+  if (!transport.execFile) {
+    throw new Error(`Cannot execute semantic plugin command over ${transport.description}: transport does not support remote commands.`);
+  }
+  if (!options.stageSource) {
+    for (const [command, ...args] of commands) {
+      if (!command) throw new Error(`Invalid semantic plugin command for ${operation.relativeDestPath}`);
+      await transport.execFile(command, args, { cwd: operation.destPath });
+    }
+    return;
+  }
+  if (!operation.sourcePath) {
+    throw new Error(`Invalid semantic plugin operation missing source path: ${operation.relativeDestPath}`);
+  }
+  const stagingRoot = join3(operation.destPath, ".agentwheel", "plugin-staging", `${process.pid}-${Date.now()}`);
+  const remoteSourcePath = join3(stagingRoot, basename2(operation.sourcePath));
+  try {
+    await transport.atomicCopy(operation.sourcePath, remoteSourcePath, operation.kind);
+    for (const [command, ...args] of commands) {
+      if (!command) throw new Error(`Invalid semantic plugin command for ${operation.relativeDestPath}`);
+      const remoteArgs = args.map((arg) => arg === operation.sourcePath ? remoteSourcePath : arg);
+      await transport.execFile(command, remoteArgs, { cwd: operation.destPath });
+    }
+  } finally {
+    await transport.rm(stagingRoot);
+  }
+}
+function isPluginAlreadyAbsentError(operation, error) {
+  const output = commandErrorOutput(error).toLowerCase();
+  if (!output || output.includes("command not found") || output.includes("module not found")) return false;
+  const pluginName = (operation.semanticPlugin?.pluginName ?? operation.artifactName).toLowerCase();
+  const escapedName = escapeRegExp(pluginName);
+  const namedAbsent = [
+    new RegExp(`${escapedName}.{0,120}\\b(not installed|not found|does not exist|absent)\\b`, "s"),
+    new RegExp(`\\b(not installed|not found|does not exist|absent)\\b.{0,120}${escapedName}`, "s"),
+    new RegExp(`\\bunknown plugin\\b.{0,120}${escapedName}`, "s"),
+    new RegExp(`${escapedName}.{0,120}\\bunknown plugin\\b`, "s")
+  ].some((pattern) => pattern.test(output));
+  const genericAbsent = /\b(no such|unknown)\s+plugins?\b/.test(output) || /\bplugins?\b.{0,80}\bnot installed\b/s.test(output);
+  return namedAbsent || genericAbsent;
+}
+function commandErrorOutput(error) {
+  if (typeof error === "object" && error !== null) {
+    const stderr = "stderr" in error ? String(error.stderr ?? "") : "";
+    if (stderr.trim()) return stderr;
+    const stdout = "stdout" in error ? String(error.stdout ?? "") : "";
+    if (stdout.trim()) return stdout;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function firstErrorLine(error) {
+  return commandErrorOutput(error).split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "plugin is already absent";
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function semanticInstallCommands(operation) {
+  if (operation.semanticPlugin) return operation.semanticPlugin.installCommands;
+  return operation.semanticCommand ? [operation.semanticCommand] : [];
+}
+function managedBlockMutationOptions(operation) {
+  return {
+    expectedHash: operation.overrideDrift ? void 0 : operation.manifestHash,
+    allowDrift: operation.overrideDrift === true
+  };
+}
+async function entryForCompletedOperation(operation, transport, now, graphLockDigest) {
+  if (operation.action === "remove") return void 0;
+  if (operation.action === "create" || operation.action === "update") {
+    if (operation.mode === managedInstructionBlockMode) {
+      const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
+      const state = await readManagedInstructionBlockState(operation.destPath, selector, transport);
+      return manifestEntryForOperation(operation, {
+        now,
+        hash: state.hash ?? requireDesiredHash(operation),
+        sourceHash: requireDesiredHash(operation),
+        graphLockDigest
+      });
+    }
+    return manifestEntryForOperation(operation, {
+      now,
+      hash: await transport.hashPath(operation.destPath),
+      sourceHash: requireDesiredHash(operation),
+      graphLockDigest
+    });
+  }
+  if (operation.action === "skip") {
+    return manifestEntryForOperation(operation, {
+      now,
+      hash: (operation.mergeStrategy || operation.mode === managedInstructionBlockMode) && operation.currentHash ? operation.currentHash : requireDesiredHash(operation),
+      sourceHash: requireDesiredHash(operation),
+      graphLockDigest
+    });
+  }
+  return void 0;
+}
+function manifestEntryForOperation(operation, values) {
+  const owners = normalizeOwners(operation.owners ?? [operation.packageName ?? operation.artifactName]);
+  return {
+    path: operation.relativeDestPath,
+    artifactType: operation.artifactType,
+    artifactName: operation.artifactName,
+    installName: operation.installName ?? operation.artifactName,
+    logicalSelector: operation.logicalSelector ?? `${operation.artifactType}/${operation.artifactName}`,
+    graphNodeId: operation.graphNodeId,
+    dependencyRole: operation.dependencyRole ?? "root",
+    owners,
+    refCount: owners.length,
+    workspaceOwner: operation.workspaceOwner ?? "workspace:unknown",
+    kind: operation.kind,
+    hash: values.hash,
+    sourceHash: values.sourceHash,
+    updatedAt: values.now,
+    channel: operation.channel,
+    packageName: operation.packageName,
+    semanticCommand: operation.semanticCommand,
+    semanticPlugin: operation.semanticPlugin,
+    executed: values.executed ?? operation.execute,
+    mergeStrategy: operation.mergeStrategy,
+    mergeRemoval: operation.mergeRemoval,
+    mergeCreatedDestination: operation.mergeCreatedDestination,
+    mode: operation.mode,
+    composedFrom: operation.composedFrom,
+    graphLockDigest: operation.graphLockDigest ?? values.graphLockDigest
+  };
+}
+async function assertBaseRevision(plan, transport) {
+  const current = await readInstallManifest(plan.targetRoot, plan.adapter, transport, {
+    installationType: plan.installationType,
+    stateKey: plan.stateKey
+  });
+  const currentRevision = current?.revision ?? null;
+  if (currentRevision !== plan.baseRevision) {
+    throw new Error(`Install manifest changed since planning for ${plan.adapter}; replan needed`);
+  }
+}
+async function assertExactMergeRemovalPreconditions(operations, transport) {
+  for (const operation of operations) {
+    if (!operation.exactMergeRemoval) continue;
+    if (!operation.mergeStrategy || !operation.mergeRemoval) {
+      throw new Error(`Invalid exact MCP retirement operation: ${operation.relativeDestPath}`);
+    }
+    if (!await transport.pathExists(operation.destPath)) {
+      throw new Error(`Exact MCP retirement destination is missing: ${operation.relativeDestPath}`);
+    }
+    assertExactMcpMergeContribution(
+      operation.mergeRemoval,
+      operation.mergeStrategy,
+      await transport.readFile(operation.destPath)
+    );
+  }
+}
+function isJournaledMutation(operation) {
+  if (operation.semanticPlugin && (operation.action === "plugin" || operation.action === "remove")) return false;
+  return operation.action === "create" || operation.action === "update" || operation.action === "remove";
+}
+function operationNeedsSource(operation) {
+  return operation.action === "create" || operation.action === "update";
+}
+async function operationLanded(operation, transport) {
+  if (operation.action === "remove") {
+    if (operation.mode === managedInstructionBlockMode) {
+      const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
+      const state = await readManagedInstructionBlockState(operation.destPath, selector, transport);
+      return !state.exists || !state.hasBlock;
+    }
+    if (operation.mergeStrategy) {
+      const exists = await transport.pathExists(operation.destPath);
+      if (operation.mergeCreatedDestination) return !exists;
+      if (!operation.mergeRemoval || !exists) return true;
+      return mergeContributionAbsent(
+        operation.mergeRemoval,
+        operation.mergeStrategy,
+        await transport.readFile(operation.destPath)
+      );
+    }
+    return !await transport.pathExists(operation.destPath);
+  }
+  if (operation.action !== "create" && operation.action !== "update") return false;
+  if (!await transport.pathExists(operation.destPath)) return false;
+  if (operation.mode === managedInstructionBlockMode) {
+    const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
+    return managedInstructionBlockLanded(operation.destPath, selector, operation.desiredHash, transport);
+  }
+  if (operation.mergeStrategy) {
+    if (!operation.sourcePath) return false;
+    try {
+      await assertMergedSourceContribution(
+        operation.sourcePath,
+        operation.mergeStrategy,
+        await transport.readFile(operation.destPath)
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  if (!operation.desiredHash) return false;
+  return await transport.hashPath(operation.destPath) === operation.desiredHash;
+}
+async function rollbackStartedOperations(journal, transport) {
+  if (transport.kind !== "local" && journal.completed.some((item) => item.hadExisting && !item.backupPath)) {
+    throw new Error(`Cannot automatically roll back ${transport.description}: remote journal has no restorable backups; restore manually or rerun with staged sources available to finish recovery.`);
+  }
+  await rollbackCompletedOperations(journal.completed, transport);
+}
+function requireDesiredHash(operation) {
+  if (!operation.desiredHash) throw new Error(`Invalid operation missing desired hash: ${operation.relativeDestPath}`);
+  return operation.desiredHash;
+}
+async function mergeWithTransport(sourcePath, destPath, transport, merge) {
+  if (transport.kind === "local") {
+    await merge(sourcePath, destPath);
+    return;
+  }
+  const tempRoot = await mkdtemp2(join3(tmpdir2(), "agentwheel-merge-"));
+  const localDest = join3(tempRoot, basename2(destPath) || "merged");
+  try {
+    if (await transport.pathExists(destPath)) {
+      await writeFile8(localDest, await transport.readFile(destPath), "utf8");
+    }
+    await merge(sourcePath, localDest);
+    await transport.atomicCopy(localDest, destPath, "file");
+  } finally {
+    await rm2(tempRoot, { recursive: true, force: true });
+  }
+}
+async function removeMergeWithTransport(destPath, strategy, removal, transport) {
+  if (transport.kind === "local") {
+    await removeMergeContribution(destPath, strategy, removal);
+    return;
+  }
+  const tempRoot = await mkdtemp2(join3(tmpdir2(), "agentwheel-merge-remove-"));
+  const localDest = join3(tempRoot, basename2(destPath) || "merged");
+  try {
+    await writeFile8(localDest, await transport.readFile(destPath), "utf8");
+    await removeMergeContribution(localDest, strategy, removal);
+    await transport.atomicCopy(localDest, destPath, "file");
+  } finally {
+    await rm2(tempRoot, { recursive: true, force: true });
+  }
+}
+async function mergeOpenClawJsonWithTransport(sourcePath, destPath, transport) {
+  const tempRoot = await mkdtemp2(join3(tmpdir2(), "agentwheel-openclaw-merge-"));
+  const localDest = join3(tempRoot, basename2(destPath) || "openclaw.json");
+  const validationPath = transport.kind === "local" ? localDest : `${destPath}.validate-agentwheel-${process.pid}-${Date.now()}`;
+  try {
+    if (await transport.pathExists(destPath)) {
+      await writeFile8(localDest, await transport.readFile(destPath), "utf8");
+    }
+    await mergeOpenClawJsonFile(sourcePath, localDest);
+    if (transport.kind !== "local") {
+      await transport.atomicCopy(localDest, validationPath, "file");
+    }
+    await validateOpenClawConfig(validationPath, destPath, transport);
+    await transport.atomicCopy(localDest, destPath, "file");
+  } finally {
+    if (transport.kind !== "local") await transport.rm(validationPath);
+    await rm2(tempRoot, { recursive: true, force: true });
+  }
+}
+async function validateOpenClawConfig(configPath, destPath, transport) {
+  if (!transport.execFile) {
+    throw new Error(`Cannot validate OpenClaw config over ${transport.description}: transport does not support command execution.`);
+  }
+  const openClawHome = dirname8(destPath);
+  const bundledBin = join3(openClawHome, "npm", "node_modules", ".bin", "openclaw");
+  const script = String.raw`
+set -euo pipefail
+cfg=$1
+bundled_bin=$2
+if [ -x "$bundled_bin" ]; then
+  bin="$bundled_bin"
+elif command -v openclaw >/dev/null 2>&1; then
+  bin="openclaw"
+else
+  echo "OpenClaw binary not found; cannot validate $cfg" >&2
+  exit 127
+fi
+out=$(OPENCLAW_CONFIG_PATH="$cfg" "$bin" config validate --json 2>&1) || {
+  printf '%s\n' "$out" >&2
+  exit 1
+}
+printf '%s' "$out" | node -e 'let s=""; process.stdin.on("data", c => s += c); process.stdin.on("end", () => { const data = JSON.parse(s); if (!data.valid) { console.error(JSON.stringify(data, null, 2)); process.exit(1); } });'
+`;
+  await transport.execFile("bash", ["-lc", script, "agentwheel-openclaw-validate", configPath, bundledBin]);
+}
+
+export {
+  normalizeImmutableCacheIdentity,
+  readGraphLock,
+  canonicalGraphLockJson,
+  canonicalizeGraphLock,
+  computeTargetFingerprint,
+  legacyUnownedWorkspaceOwner,
+  installManifestSchema,
+  readInstallManifest,
+  listInstallManifests,
+  writeInstallManifest,
+  normalizeTargetRoot,
+  withManifestRevision,
+  computeManifestRevision,
+  assertSafeInstallName,
+  assertOperationContained,
+  MergeAdoptionMismatchError,
+  assertExactMergeContribution,
+  combineMergeRemovals,
+  hasMergeRemovalContent,
+  mergeRemovalForInstall,
+  normalizeOwners,
+  managedInstructionBlockMode,
+  desiredManagedInstructionBlockHash,
+  readManagedInstructionBlockState,
+  managedInstructionPhysicalKey,
+  claudeInstructionBridgesAgents,
+  managedInstructionSelector,
+  applyInstallPlan,
+  applyCombinedInstallPlan,
+  recoverPendingApply,
+  uninstall
+};