agentwheel 0.14.6 → 0.14.7

package/dist/index.js

@@ -10,9 +10,9 @@ import {
 
 // src/cli/index.ts
 import { existsSync } from "fs";
-import { mkdir as mkdir20, rm as rm11, writeFile as writeFile19 } from "fs/promises";
+import { mkdir as mkdir21, rm as rm11, writeFile as writeFile20 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname28, join as join40, resolve as resolve20 } from "path";
+import { dirname as dirname30, join as join41, resolve as resolve20 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 
@@ -111,6 +111,7 @@ var targetMappingSchema = z2.object({
     "codex-plugin",
     "hermes-plugin",
     "copilot-plugin",
+    "openclaw-subagent",
     "codex-subagent",
     "copilot-instruction",
     "copilot-prompt",
@@ -376,6 +377,9 @@ var openClawAdapter = {
       local: { enabled: true, dest: "skills" },
       user: { enabled: true, root: "home", dest: ".openclaw/skills" }
     },
+    subagents: {
+      user: { enabled: true, root: "home", dest: ".openclaw/workspace-subagents", semantic: "openclaw-subagent" }
+    },
     mcp: {
       user: { enabled: true, root: "home", dest: ".openclaw/openclaw.json", merge: "openclaw-json-deep" }
     },
@@ -469,7 +473,7 @@ async function resolveAdapter(options) {
 import { execFile as execFile3 } from "child_process";
 import { mkdtemp as mkdtemp2, rm as rm4, writeFile as writeFile9 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { basename as basename3, join as join5 } from "path";
+import { basename as basename3, dirname as dirname10, join as join5 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/model/graph-lock.ts
@@ -892,11 +896,33 @@ async function mergeOpenClawJsonFile(sourcePath, destPath) {
     sourcePath
   );
   const current = await pathExists(destPath) ? JSON.parse(await readFile6(destPath, "utf8")) : {};
-  const merged = deepMerge(current, source);
+  const merged = mergeOpenClawJson(current, source);
   await mkdir4(dirname5(destPath), { recursive: true });
   await writeFile5(destPath, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
 }
+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 (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 expandEnvPlaceholders(value, sourcePath) {
   if (typeof value === "string") {
     return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
@@ -934,6 +960,24 @@ function normalizeOpenClawMcpServer(server) {
   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;
+}
 
 // src/install/manifest.ts
 import { createHash as createHash2 } from "crypto";
@@ -1908,7 +1952,7 @@ async function applyOperation(operation, context) {
     if (operation.mergeStrategy === "json-deep") {
       await mergeWithTransport(operation.sourcePath, operation.destPath, transport, mergeJsonFile);
     } else if (operation.mergeStrategy === "openclaw-json-deep") {
-      await mergeWithTransport(operation.sourcePath, operation.destPath, transport, mergeOpenClawJsonFile);
+      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") {
@@ -2258,13 +2302,58 @@ async function mergeWithTransport(sourcePath, destPath, transport, merge) {
     await rm4(tempRoot, { recursive: true, force: true });
   }
 }
+async function mergeOpenClawJsonWithTransport(sourcePath, destPath, transport) {
+  const tempRoot = await mkdtemp2(join5(tmpdir3(), "agentwheel-openclaw-merge-"));
+  const localDest = join5(tempRoot, basename3(destPath) || "openclaw.json");
+  const validationPath = transport.kind === "local" ? localDest : `${destPath}.validate-agentwheel-${process.pid}-${Date.now()}`;
+  try {
+    if (await transport.pathExists(destPath)) {
+      await writeFile9(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 rm4(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 = dirname10(destPath);
+  const bundledBin = join5(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]);
+}
 
 // src/install/plan.ts
-import { basename as basename7, join as join15, relative as relative3 } from "path";
+import { basename as basename8, join as join16, relative as relative3 } from "path";
 
 // src/staging/codex-subagents.ts
 import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile10 } from "fs/promises";
-import { basename as basename4, dirname as dirname10, join as join6 } from "path";
+import { basename as basename4, dirname as dirname11, join as join6 } from "path";
 var requiredCodexAgentFields = ["name", "description", "developer_instructions"];
 async function renderCodexSubagents(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "codex") return artifacts;
@@ -2309,7 +2398,7 @@ async function renderCodexSubagent(artifact, stageRoot) {
   }
   const markdown = await readFile10(markdownPath, "utf8");
   const toml = markdownToCodexAgentToml(agentName, markdown);
-  await mkdir8(dirname10(renderedPath), { recursive: true });
+  await mkdir8(dirname11(renderedPath), { recursive: true });
   await writeFile10(renderedPath, toml, "utf8");
   return {
     ...artifact,
@@ -2379,7 +2468,7 @@ function escapeRegExp(value) {
 
 // src/staging/copilot-artifacts.ts
 import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile11 } from "fs/promises";
-import { basename as basename5, dirname as dirname11, join as join7 } from "path";
+import { basename as basename5, dirname as dirname12, join as join7 } from "path";
 async function renderCopilotArtifacts(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "copilot") return artifacts;
   const names = /* @__PURE__ */ new Set();
@@ -2410,7 +2499,7 @@ async function renderCopilotSubagent(artifact, stageRoot) {
     throw new Error(`Copilot subagent ${artifact.relativePath} must be a .md file or directory containing AGENTS.md.`);
   }
   const markdown = await readFile11(markdownPath, "utf8");
-  await mkdir9(dirname11(renderedPath), { recursive: true });
+  await mkdir9(dirname12(renderedPath), { recursive: true });
   await writeFile11(renderedPath, ensureCopilotAgentDescription(agentName, markdown), "utf8");
   return {
     ...artifact,
@@ -2463,15 +2552,84 @@ function yamlString(value) {
   return JSON.stringify(value);
 }
 
+// src/staging/openclaw-subagents.ts
+import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile12 } from "fs/promises";
+import { basename as basename6, dirname as dirname13, join as join8 } from "path";
+async function renderOpenClawSubagents(artifacts, stageRoot, adapter) {
+  if (adapter?.name !== "openclaw") return artifacts;
+  const names = /* @__PURE__ */ new Set();
+  const rendered = [];
+  for (const artifact of artifacts) {
+    if (artifact.type !== "subagents") {
+      rendered.push(artifact);
+      continue;
+    }
+    const next = await renderOpenClawSubagent(artifact, stageRoot);
+    if (names.has(next.name)) {
+      throw new Error(`OpenClaw subagents produce duplicate agent id '${next.name}'.`);
+    }
+    names.add(next.name);
+    rendered.push(next);
+  }
+  return rendered;
+}
+async function renderOpenClawSubagent(artifact, stageRoot) {
+  const sourcePath = artifact.stagedPath ?? artifact.sourcePath;
+  const agentId = openClawAgentId(artifact);
+  const markdownPath = artifact.kind === "dir" ? join8(sourcePath, "AGENTS.md") : sourcePath;
+  if (artifact.kind === "dir" && !await pathExists(markdownPath)) {
+    throw new Error(`OpenClaw subagent directory ${artifact.relativePath} must contain AGENTS.md.`);
+  }
+  if (artifact.kind === "file" && !artifact.name.toLowerCase().endsWith(".md") && !sourcePath.toLowerCase().endsWith(".md")) {
+    throw new Error(`OpenClaw subagent ${artifact.relativePath} must be a .md file or directory containing AGENTS.md.`);
+  }
+  const parsed = splitFrontmatter3(await readFile12(markdownPath, "utf8"));
+  const body = parsed.body.trim().length > 0 ? parsed.body.trim() : `# ${titleFromAgentId(agentId)}
+
+${parsed.description ?? `OpenClaw subagent ${agentId}.`}`;
+  const renderedPath = join8(stageRoot, ".agentwheel-rendered", "openclaw-subagents", agentId, "AGENTS.md");
+  await mkdir10(dirname13(renderedPath), { recursive: true });
+  await writeFile12(renderedPath, `${body}
+`, "utf8");
+  const renderedDir = dirname13(renderedPath);
+  return {
+    ...artifact,
+    name: agentId,
+    sourcePath: renderedDir,
+    stagedPath: renderedDir,
+    relativePath: join8("subagents", agentId),
+    kind: "dir",
+    hash: await hashPath(renderedDir)
+  };
+}
+function openClawAgentId(artifact) {
+  const raw = artifact.kind === "dir" ? artifact.name : basename6(artifact.name);
+  return raw.replace(/\.agent\.md$/i, "").replace(/\.md$/i, "");
+}
+function splitFrontmatter3(markdown) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(markdown);
+  if (!match) return { body: markdown };
+  const frontmatter = match[1] ?? "";
+  const body = markdown.slice(match[0].length);
+  const description = frontmatter.split(/\r?\n/).map((line) => /^description:\s*(?:"([^"]*)"|'([^']*)'|(.+))\s*$/.exec(line.trim())).find((item) => item !== null);
+  return {
+    body,
+    description: description ? (description[1] ?? description[2] ?? description[3] ?? "").trim() : void 0
+  };
+}
+function titleFromAgentId(agentId) {
+  return agentId.split(/[-_]/g).filter(Boolean).map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+
 // src/targets/plugins/claude.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/targets/plugins/common.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join9 } from "path";
 import { parseDocument } from "yaml";
 function pluginStateRoot(request) {
-  return join8(
+  return join9(
     request.targetRoot,
     ".agentwheel",
     "plugins",
@@ -2489,16 +2647,16 @@ function safeNameSegment(value) {
   return normalized.length > 0 ? normalized : "unnamed";
 }
 async function jsonPluginName(root, relativeManifestPath, fallback) {
-  const manifestPath = join8(root, relativeManifestPath);
+  const manifestPath = join9(root, relativeManifestPath);
   if (!await pathExists(manifestPath)) return fallback;
-  const parsed = JSON.parse(await readFile12(manifestPath, "utf8"));
+  const parsed = JSON.parse(await readFile13(manifestPath, "utf8"));
   return typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : fallback;
 }
 async function yamlPluginName(root, relativeManifestPaths, fallback) {
   for (const relativeManifestPath of relativeManifestPaths) {
-    const manifestPath = join8(root, relativeManifestPath);
+    const manifestPath = join9(root, relativeManifestPath);
     if (!await pathExists(manifestPath)) continue;
-    const document = parseDocument(await readFile12(manifestPath, "utf8"));
+    const document = parseDocument(await readFile13(manifestPath, "utf8"));
     const parsed = document.toJSON();
     if (!isRecord4(parsed)) continue;
     for (const key of ["name", "module", "package"]) {
@@ -2527,7 +2685,7 @@ async function claudePluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const marketplaceRoot = join9(stateRoot, "marketplace");
+  const marketplaceRoot = join10(stateRoot, "marketplace");
   const scope = claudeScope(request.installationType);
   const selector = `${pluginName}@${marketplaceName}`;
   return {
@@ -2552,7 +2710,7 @@ function claudeScope(installationType) {
 }
 
 // src/targets/plugins/codex.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 async function codexPluginSpec(request) {
   const pluginName = await jsonPluginName(request.sourcePath, ".codex-plugin/plugin.json", request.installName);
   const marketplaceName = agentwheelMarketplaceName(request.artifact.packageName, pluginName);
@@ -2563,7 +2721,7 @@ async function codexPluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const marketplaceRoot = join10(stateRoot, "marketplace");
+  const marketplaceRoot = join11(stateRoot, "marketplace");
   const selector = `${pluginName}@${marketplaceName}`;
   return {
     runtime: "codex",
@@ -2582,7 +2740,7 @@ async function codexPluginSpec(request) {
 }
 
 // src/targets/plugins/copilot.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 async function copilotPluginSpec(request) {
   if (request.installationType !== "user") {
     throw new Error("Copilot plugins are persistent user-level installs only; pass --installation-type user.");
@@ -2595,7 +2753,7 @@ async function copilotPluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const pluginRoot = join11(stateRoot, "plugin");
+  const pluginRoot = join12(stateRoot, "plugin");
   return {
     runtime: "copilot",
     pluginName,
@@ -2606,7 +2764,7 @@ async function copilotPluginSpec(request) {
 }
 
 // src/targets/plugins/hermes.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 async function hermesPluginSpec(request) {
   if (request.installationType !== "user") {
     throw new Error("Hermes plugins are user-level installs only; pass --installation-type user.");
@@ -2619,7 +2777,7 @@ async function hermesPluginSpec(request) {
     packageName: request.artifact.packageName,
     installName: request.installName
   });
-  const repoRoot = join12(stateRoot, "repo");
+  const repoRoot = join13(stateRoot, "repo");
   return {
     runtime: "hermes",
     pluginName,
@@ -2630,8 +2788,8 @@ async function hermesPluginSpec(request) {
 }
 
 // src/targets/plugins/openclaw.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join14 } from "path";
 function openClawPluginInstallCommand(request) {
   return ["openclaw", "plugins", "install", "--force", request.path];
 }
@@ -2658,19 +2816,19 @@ async function openClawPluginSpec(request) {
 }
 async function openClawPluginName(root, fallback) {
   for (const manifestName of ["plugin.json", "openclaw.plugin.json"]) {
-    const manifestPath = join13(root, manifestName);
+    const manifestPath = join14(root, manifestName);
     if (!await pathExists(manifestPath)) continue;
-    const parsed = JSON.parse(await readFile13(manifestPath, "utf8"));
+    const parsed = JSON.parse(await readFile14(manifestPath, "utf8"));
     if (typeof parsed.name === "string" && parsed.name.trim().length > 0) return parsed.name.trim();
   }
   return fallback;
 }
 async function openClawClawHubPluginMetadata(root, fallback) {
-  const metadataPath = join13(root, "clawhub.json");
+  const metadataPath = join14(root, "clawhub.json");
   if (!await pathExists(metadataPath)) {
     throw new Error("OpenClaw ClawHub plugins must contain clawhub.json");
   }
-  const parsed = JSON.parse(await readFile13(metadataPath, "utf8"));
+  const parsed = JSON.parse(await readFile14(metadataPath, "utf8"));
   const installSpec = stringField(parsed.installSpec);
   if (!installSpec?.startsWith("clawhub:")) {
     throw new Error("OpenClaw ClawHub plugin metadata must declare installSpec starting with clawhub:");
@@ -2710,8 +2868,8 @@ async function semanticPluginSpecForArtifact(request) {
 }
 
 // src/validation/artifacts.ts
-import { readFile as readFile14 } from "fs/promises";
-import { basename as basename6, join as join14 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { basename as basename7, join as join15 } from "path";
 import { parseDocument as parseDocument2 } from "yaml";
 
 // src/model/selection.ts
@@ -2875,7 +3033,7 @@ async function inferArtifactFormat(artifact, target) {
     return void 0;
   }
   if (artifact.type === "plugins" && target.semantic === "openclaw-plugin") {
-    if (artifact.kind === "dir" && await pathExists(join14(artifactPath(artifact), "clawhub.json"))) return "openclaw-clawhub-plugin";
+    if (artifact.kind === "dir" && await pathExists(join15(artifactPath(artifact), "clawhub.json"))) return "openclaw-clawhub-plugin";
     if (artifact.kind === "dir" && (await openClawPluginManifestPaths(artifact)).length > 0) return "openclaw-plugin";
   }
   return void 0;
@@ -2927,7 +3085,7 @@ async function validateGenericStructure(artifact, target) {
   const issues = [];
   if (artifact.type === "skills") {
     if (artifact.kind === "dir") {
-      const skillMd = join14(artifactPath(artifact), "SKILL.md");
+      const skillMd = join15(artifactPath(artifact), "SKILL.md");
       if (!await pathExists(skillMd)) {
         issues.push({ artifact, message: "skill directory must contain SKILL.md" });
       } else {
@@ -2939,10 +3097,17 @@ async function validateGenericStructure(artifact, target) {
       issues.push(...await validateSkillFrontmatter(artifact, artifactPath(artifact)));
     }
   }
-  if (target.merge === "json-deep") {
+  if (target.merge === "json-deep" || target.merge === "openclaw-json-deep") {
     const parsed = await parseJsonObjectArtifact(artifact);
     if (!parsed.ok) issues.push({ artifact, message: parsed.message });
   }
+  if (artifact.type === "subagents" && target.semantic === "openclaw-subagent") {
+    if (artifact.kind !== "dir") {
+      issues.push({ artifact, message: "OpenClaw subagent artifacts must render to a workspace directory containing AGENTS.md" });
+    } else if (!await pathExists(join15(artifactPath(artifact), "AGENTS.md"))) {
+      issues.push({ artifact, message: "OpenClaw subagent workspace directory must contain AGENTS.md" });
+    }
+  }
   if (target.merge === "yaml-deep") {
     const parsed = await parseYamlObjectArtifact(artifact);
     if (!parsed.ok) issues.push({ artifact, message: parsed.message });
@@ -2960,7 +3125,7 @@ async function validateGenericStructure(artifact, target) {
 async function validateSkillFrontmatter(artifact, skillMdPath) {
   let content;
   try {
-    content = await readFile14(skillMdPath, "utf8");
+    content = await readFile15(skillMdPath, "utf8");
   } catch (error) {
     return [{ artifact, message: `could not read SKILL.md: ${errorMessage(error)}` }];
   }
@@ -3013,7 +3178,7 @@ function validatePluginArtifact(artifact, format) {
 async function validateJsonPluginDescriptor(artifact, relativeManifestPath, label) {
   const generic = validatePluginArtifact(artifact, `${label.toLowerCase()}-plugin`);
   if (generic.length > 0) return generic;
-  const manifestPath = join14(artifactPath(artifact), relativeManifestPath);
+  const manifestPath = join15(artifactPath(artifact), relativeManifestPath);
   if (!await pathExists(manifestPath)) {
     return [{ artifact, message: `${label} plugins must contain ${relativeManifestPath}` }];
   }
@@ -3024,26 +3189,26 @@ async function validateHermesPlugin(artifact) {
   const generic = validatePluginArtifact(artifact, "hermes-plugin");
   if (generic.length > 0) return generic;
   const root = artifactPath(artifact);
-  const manifestPaths = [join14(root, "plugin.yaml"), join14(root, "plugin.yml")];
+  const manifestPaths = [join15(root, "plugin.yaml"), join15(root, "plugin.yml")];
   const manifestPath = await firstExistingPath(manifestPaths);
   if (!manifestPath) {
     return [{ artifact, message: "Hermes plugins must contain plugin.yaml or plugin.yml" }];
   }
   try {
-    const document = parseDocument2(await readFile14(manifestPath, "utf8"));
+    const document = parseDocument2(await readFile15(manifestPath, "utf8"));
     if (document.errors.length > 0) {
-      return [{ artifact, message: `Hermes ${basename6(manifestPath)} must be valid YAML: ${document.errors[0]?.message ?? "parse error"}` }];
+      return [{ artifact, message: `Hermes ${basename7(manifestPath)} must be valid YAML: ${document.errors[0]?.message ?? "parse error"}` }];
     }
     const parsed = document.toJSON();
     if (!isUnknownRecord(parsed)) {
-      return [{ artifact, message: `Hermes ${basename6(manifestPath)} must contain a YAML object` }];
+      return [{ artifact, message: `Hermes ${basename7(manifestPath)} must contain a YAML object` }];
     }
     if (!hasStringField(parsed, "name") && !hasStringField(parsed, "module") && !hasStringField(parsed, "package") && !hasNestedPackageName(parsed)) {
-      return [{ artifact, message: `Hermes ${basename6(manifestPath)} must declare a non-empty name, module, or package name` }];
+      return [{ artifact, message: `Hermes ${basename7(manifestPath)} must declare a non-empty name, module, or package name` }];
     }
     return [];
   } catch (error) {
-    return [{ artifact, message: `Hermes ${basename6(manifestPath)} must be valid YAML: ${errorMessage(error)}` }];
+    return [{ artifact, message: `Hermes ${basename7(manifestPath)} must be valid YAML: ${errorMessage(error)}` }];
   }
 }
 async function firstExistingPath(paths) {
@@ -3054,16 +3219,16 @@ async function firstExistingPath(paths) {
 }
 async function parseJsonPluginManifest(manifestPath, label) {
   try {
-    const parsed = JSON.parse(await readFile14(manifestPath, "utf8"));
+    const parsed = JSON.parse(await readFile15(manifestPath, "utf8"));
     if (!isRecord5(parsed)) {
-      return { ok: false, message: `${label} ${basename6(manifestPath)} must be a JSON object` };
+      return { ok: false, message: `${label} ${basename7(manifestPath)} must be a JSON object` };
     }
     if (typeof parsed.name !== "string" || parsed.name.trim().length === 0) {
-      return { ok: false, message: `${label} ${basename6(manifestPath)} must declare a non-empty name` };
+      return { ok: false, message: `${label} ${basename7(manifestPath)} must declare a non-empty name` };
     }
     return { ok: true, name: parsed.name.trim() };
   } catch (error) {
-    return { ok: false, message: `${label} ${basename6(manifestPath)} must be valid JSON: ${errorMessage(error)}` };
+    return { ok: false, message: `${label} ${basename7(manifestPath)} must be valid JSON: ${errorMessage(error)}` };
   }
 }
 async function validateOpenClawPlugin(artifact) {
@@ -3096,12 +3261,12 @@ async function validateOpenClawClawHubPlugin(artifact) {
   if (artifact.kind !== "dir") {
     return [{ artifact, message: "OpenClaw ClawHub plugins must be directory artifacts" }];
   }
-  const metadataPath = join14(artifactPath(artifact), "clawhub.json");
+  const metadataPath = join15(artifactPath(artifact), "clawhub.json");
   if (!await pathExists(metadataPath)) {
     return [{ artifact, message: "OpenClaw ClawHub plugins must contain clawhub.json" }];
   }
   try {
-    const parsed = JSON.parse(await readFile14(metadataPath, "utf8"));
+    const parsed = JSON.parse(await readFile15(metadataPath, "utf8"));
     if (!isRecord5(parsed)) {
       return [{ artifact, message: "OpenClaw ClawHub clawhub.json must be a JSON object" }];
     }
@@ -3118,14 +3283,14 @@ async function validateOpenClawClawHubPlugin(artifact) {
 }
 async function openClawPluginManifestPaths(artifact) {
   const root = artifactPath(artifact);
-  const candidates = [join14(root, "plugin.json"), join14(root, "openclaw.plugin.json")];
+  const candidates = [join15(root, "plugin.json"), join15(root, "openclaw.plugin.json")];
   const existing = await Promise.all(candidates.map(async (candidate) => await pathExists(candidate) ? candidate : void 0));
   return existing.filter((candidate) => candidate !== void 0);
 }
 async function parseOpenClawPluginManifest(manifestPath) {
-  const manifestName = basename6(manifestPath);
+  const manifestName = basename7(manifestPath);
   try {
-    const parsed = JSON.parse(await readFile14(manifestPath, "utf8"));
+    const parsed = JSON.parse(await readFile15(manifestPath, "utf8"));
     if (!isRecord5(parsed)) {
       return { ok: false, path: manifestPath, message: `OpenClaw ${manifestName} must be a JSON object` };
     }
@@ -3142,7 +3307,7 @@ async function parseJsonObjectArtifact(artifact) {
     return { ok: false, message: "merge artifacts must be JSON files" };
   }
   try {
-    const parsed = JSON.parse(await readFile14(artifactPath(artifact), "utf8"));
+    const parsed = JSON.parse(await readFile15(artifactPath(artifact), "utf8"));
     if (!isRecord5(parsed)) return { ok: false, message: "merge artifacts must contain a JSON object" };
     return { ok: true, value: parsed };
   } catch (error) {
@@ -3154,7 +3319,7 @@ async function parseYamlObjectArtifact(artifact) {
     return { ok: false, message: "merge artifacts must be YAML files" };
   }
   try {
-    const document = parseDocument2(await readFile14(artifactPath(artifact), "utf8"));
+    const document = parseDocument2(await readFile15(artifactPath(artifact), "utf8"));
     if (document.errors.length > 0) {
       return { ok: false, message: `merge artifact must be valid YAML: ${document.errors[0]?.message ?? "parse error"}` };
     }
@@ -3181,7 +3346,7 @@ function artifactLabel(artifact) {
   return `${owner}${artifact.type}/${artifact.name}`;
 }
 function hasExtension(artifact, extension) {
-  return basename6(artifact.name).toLowerCase().endsWith(extension) || basename6(artifactPath(artifact)).toLowerCase().endsWith(extension);
+  return basename7(artifact.name).toLowerCase().endsWith(extension) || basename7(artifactPath(artifact)).toLowerCase().endsWith(extension);
 }
 function isPluginFormat(value) {
   return value !== void 0 && pluginFormats.includes(value);
@@ -3359,7 +3524,7 @@ async function createPlanFromOperations(desiredOps, adapter, targetRoot, manifes
   for (const entry of effectiveEntries) {
     if (desired.has(entry.path)) continue;
     const semanticPlugin = entry.semanticPlugin;
-    const destPath = semanticPlugin ? targetRoot : join15(targetRoot, entry.path);
+    const destPath = semanticPlugin ? targetRoot : join16(targetRoot, entry.path);
     if (!semanticPlugin && !await transport.pathExists(destPath)) continue;
     const currentHash = semanticPlugin ? entry.hash : await currentEntryHash(entry, destPath, transport);
     if (workspaceOwner && !entryOwnedByWorkspace(entry, workspaceOwner)) {
@@ -3508,15 +3673,15 @@ async function prepareManagedBlockOperations(desiredOps, adapter, targetRoot, tr
   return prepared;
 }
 async function shouldSkipClaudeBridge(adapter, op, targetRoot, transport) {
-  if (adapter.name !== "claude" || op.artifactType !== "instructions" || basename7(op.destPath).toLowerCase() !== "claude.md") {
+  if (adapter.name !== "claude" || op.artifactType !== "instructions" || basename8(op.destPath).toLowerCase() !== "claude.md") {
     return false;
   }
-  const agentsPath = join15(targetRoot, "AGENTS.md");
+  const agentsPath = join16(targetRoot, "AGENTS.md");
   return claudeInstructionBridgesAgents(op.destPath, agentsPath, transport);
 }
 async function warnOnCopilotDoubleRead(adapter, op, targetRoot, transport, options) {
-  if (adapter.name !== "claude" || op.artifactType !== "instructions" || basename7(op.destPath).toLowerCase() !== "claude.md") return;
-  const agentsPath = join15(targetRoot, "AGENTS.md");
+  if (adapter.name !== "claude" || op.artifactType !== "instructions" || basename8(op.destPath).toLowerCase() !== "claude.md") return;
+  const agentsPath = join16(targetRoot, "AGENTS.md");
   if (!await transport.pathExists(agentsPath)) return;
   if (await claudeInstructionBridgesAgents(op.destPath, agentsPath, transport)) return;
   options.warn?.("CLAUDE.md and AGENTS.md are separate instruction files; if Copilot is active it may read the managed instructions twice.");
@@ -3600,7 +3765,7 @@ async function canStrictlyAdoptLegacyEntry(entry, op, targetRoot, transport) {
   if (entry.artifactType !== op.artifactType || entry.artifactName !== op.artifactName) return false;
   if (!op.desiredHash || entry.sourceHash !== op.desiredHash) return false;
   if (!packageIdentityMatches(entry, op)) return false;
-  const destPath = join15(targetRoot, entry.path);
+  const destPath = join16(targetRoot, entry.path);
   if (!await transport.pathExists(destPath)) return false;
   return await transport.hashPath(destPath) === entry.hash;
 }
@@ -3731,7 +3896,7 @@ function keepForeignManifestEntryOperation(entry, targetRoot, workspaceOwner, op
     artifactType: entry.artifactType,
     artifactName: entry.artifactName,
     kind: entry.kind,
-    destPath: operation?.destPath ?? join15(targetRoot, entry.path),
+    destPath: operation?.destPath ?? join16(targetRoot, entry.path),
     relativeDestPath: entry.path,
     desiredHash: entry.sourceHash,
     currentHash: currentHash ?? operation?.currentHash ?? entry.hash,
@@ -3799,7 +3964,7 @@ async function operationForArtifact(artifact, adapter, targetRoot, installationT
     }
   }
   if (artifact.type === "subagents" && target.semantic === "codex-subagent") {
-    const destPath2 = join15(targetRoot, target.dest, `${installName.replace(/\.toml$/i, "")}.toml`);
+    const destPath2 = join16(targetRoot, target.dest, `${installName.replace(/\.toml$/i, "")}.toml`);
     return {
       action: "create",
       artifactType: artifact.type,
@@ -3817,7 +3982,7 @@ async function operationForArtifact(artifact, adapter, targetRoot, installationT
       installName: installName.replace(/\.toml$/i, "")
     };
   }
-  const destPath = artifact.type === "instructions" || artifact.type === "settings" || isFileTarget(target.dest) ? join15(targetRoot, target.dest) : join15(targetRoot, target.dest, installName);
+  const destPath = artifact.type === "instructions" || artifact.type === "settings" || isFileTarget(target.dest) ? join16(targetRoot, target.dest) : join16(targetRoot, target.dest, installName);
   return {
     action: "create",
     artifactType: artifact.type,
@@ -3896,12 +4061,12 @@ function isPendingInstallOperation(operation) {
 }
 
 // src/install/uninstall.ts
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function createUninstallPlan(manifest, transport = localTransport) {
   const operations = [];
   for (const entry of manifest.entries) {
     const semanticPlugin = "semanticPlugin" in entry ? entry.semanticPlugin : void 0;
-    const destPath = semanticPlugin ? manifest.targetRoot : join16(manifest.targetRoot, entry.path);
+    const destPath = semanticPlugin ? manifest.targetRoot : join17(manifest.targetRoot, entry.path);
     if (!semanticPlugin && !await transport.pathExists(destPath)) continue;
     const currentHash = semanticPlugin ? entry.hash : await currentEntryHash2(entry, destPath, transport);
     if (currentHash !== entry.hash) {
@@ -3972,7 +4137,7 @@ async function createOwnershipUninstallPlan(manifest, remainingDesired, adapter,
   const operations = [];
   for (const entry of manifest.entries) {
     const semanticPlugin = "semanticPlugin" in entry ? entry.semanticPlugin : void 0;
-    const destPath = semanticPlugin ? manifest.targetRoot : join16(manifest.targetRoot, entry.path);
+    const destPath = semanticPlugin ? manifest.targetRoot : join17(manifest.targetRoot, entry.path);
     if (!semanticPlugin && !await transport.pathExists(destPath)) continue;
     const currentHash = semanticPlugin ? entry.hash : await currentEntryHash2(entry, destPath, transport);
     const remainingOwners = ownersByPath.get(entry.path) ?? [];
@@ -4291,17 +4456,17 @@ function ownerChains(lock, nodeId) {
 }
 
 // src/source/clawhub.ts
-import { mkdir as mkdir10, rm as rm5, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename9, dirname as dirname12, join as join19, resolve as resolve6 } from "path";
+import { mkdir as mkdir11, rm as rm5, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename10, dirname as dirname14, join as join20, resolve as resolve6 } from "path";
 
 // src/source/local.ts
 import { createHash as createHash4 } from "crypto";
 import { readdir, stat as stat3 } from "fs/promises";
-import { basename as basename8, join as join18, relative as relative4, resolve as resolve5 } from "path";
+import { basename as basename9, join as join19, relative as relative4, resolve as resolve5 } from "path";
 
 // src/model/package.ts
-import { readFile as readFile15 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile16 } from "fs/promises";
+import { join as join18 } from "path";
 import { parse as parse3, printParseErrorCode as printParseErrorCode2 } from "jsonc-parser";
 import { z as z5 } from "zod";
 var legacyArtifactTypeSchema = z5.enum([
@@ -4384,7 +4549,7 @@ var packageManifestNames = [...openPackManifestNames, ...legacyPackageManifestNa
 var warnedLegacyManifestPaths = /* @__PURE__ */ new Set();
 async function findPackageManifestPath(root, options = {}) {
   for (const name of packageManifestNames) {
-    const candidate = join17(root, name);
+    const candidate = join18(root, name);
     if (!await pathExists(candidate)) continue;
     if (isLegacyPackageManifestName(name) && options.warnLegacy !== false && !warnedLegacyManifestPaths.has(candidate)) {
       warnedLegacyManifestPaths.add(candidate);
@@ -4397,7 +4562,7 @@ async function findPackageManifestPath(root, options = {}) {
 async function readPackageManifest(root) {
   const path = await findPackageManifestPath(root);
   if (!path) return void 0;
-  const content = await readFile15(path, "utf8");
+  const content = await readFile16(path, "utf8");
   const errors = [];
   const parsed = parse3(content, errors, { allowTrailingComma: true, disallowComments: false });
   if (errors.length > 0) {
@@ -4480,29 +4645,29 @@ var LocalSourceDriver = class {
     }
     const artifacts = [];
     const root = resolved.resolvedPath;
-    const instructions = await firstExisting([join18(root, "instructions.md"), join18(root, "AGENTS.md")]);
+    const instructions = await firstExisting([join19(root, "instructions.md"), join19(root, "AGENTS.md")]);
     if (instructions) {
       artifacts.push({
         type: "instructions",
-        name: basename8(instructions),
+        name: basename9(instructions),
         sourcePath: instructions,
-        relativePath: basename8(instructions),
+        relativePath: basename9(instructions),
         kind: "file",
         hash: await hashPath(instructions),
         packageName: resolved.packageName,
         channel: "managed"
       });
     }
-    const rulesDir = join18(root, "rules");
+    const rulesDir = join19(root, "rules");
     if (await pathExists(rulesDir)) {
       for (const entry of await sortedDirEntries(rulesDir)) {
-        const full = join18(rulesDir, entry.name);
+        const full = join19(rulesDir, entry.name);
         if (entry.isFile()) {
           artifacts.push({
             type: "rules",
             name: entry.name,
             sourcePath: full,
-            relativePath: join18("rules", entry.name),
+            relativePath: join19("rules", entry.name),
             kind: "file",
             hash: await hashPath(full),
             packageName: resolved.packageName,
@@ -4511,16 +4676,16 @@ var LocalSourceDriver = class {
         }
       }
     }
-    const fragmentsDir = join18(root, "fragments");
+    const fragmentsDir = join19(root, "fragments");
     if (await pathExists(fragmentsDir)) {
       for (const entry of await sortedDirEntries(fragmentsDir)) {
-        const full = join18(fragmentsDir, entry.name);
+        const full = join19(fragmentsDir, entry.name);
         if (entry.isFile()) {
           artifacts.push({
             type: "fragments",
             name: entry.name,
             sourcePath: full,
-            relativePath: join18("fragments", entry.name),
+            relativePath: join19("fragments", entry.name),
             kind: "file",
             hash: await hashPath(full),
             packageName: resolved.packageName,
@@ -4529,16 +4694,16 @@ var LocalSourceDriver = class {
         }
       }
     }
-    const skillsDir = join18(root, "skills");
+    const skillsDir = join19(root, "skills");
     if (await pathExists(skillsDir)) {
       for (const entry of await sortedDirEntries(skillsDir)) {
-        const full = join18(skillsDir, entry.name);
+        const full = join19(skillsDir, entry.name);
         if (entry.isDirectory()) {
           artifacts.push({
             type: "skills",
             name: entry.name,
             sourcePath: full,
-            relativePath: join18("skills", entry.name),
+            relativePath: join19("skills", entry.name),
             kind: "dir",
             hash: await hashPath(full),
             packageName: resolved.packageName,
@@ -4549,7 +4714,7 @@ var LocalSourceDriver = class {
             type: "skills",
             name: entry.name.replace(/\.md$/, ""),
             sourcePath: full,
-            relativePath: join18("skills", entry.name),
+            relativePath: join19("skills", entry.name),
             kind: "file",
             hash: await hashPath(full),
             packageName: resolved.packageName,
@@ -4559,7 +4724,7 @@ var LocalSourceDriver = class {
       }
     }
     for (const type of ["commands", "subagents", "mcp", "hooks", "settings", "plugins"]) {
-      const dir = join18(root, type);
+      const dir = join19(root, type);
       if (!await pathExists(dir)) continue;
       artifacts.push(...await listGenericArtifacts(type, dir, type, resolved.packageName));
     }
@@ -4575,7 +4740,7 @@ var LocalSourceDriver = class {
       findings.push({ level: "warning", message: "No instructions.md or AGENTS.md found", path: resolved.resolvedPath });
     }
     for (const artifact of artifacts.filter((item) => item.type === "skills" && item.kind === "dir")) {
-      if (!await pathExists(join18(artifact.sourcePath, "SKILL.md"))) {
+      if (!await pathExists(join19(artifact.sourcePath, "SKILL.md"))) {
         findings.push({ level: "warning", message: `Skill directory has no SKILL.md: ${artifact.name}`, path: artifact.sourcePath });
       }
     }
@@ -4599,7 +4764,7 @@ async function hashLocalSource(root, manifest) {
   }
   const provides = [...manifest.provides].sort((a, b) => `${a.type}\0${a.path}`.localeCompare(`${b.type}\0${b.path}`));
   for (const provide of provides) {
-    const full = join18(root, provide.path);
+    const full = join19(root, provide.path);
     if (!await pathExists(full)) continue;
     hash.update("provide\0");
     hash.update(provide.type).update("\0");
@@ -4622,27 +4787,27 @@ async function listFromManifest(root, packageName) {
   if (!manifest) return [];
   const artifacts = [];
   for (const provide of manifest.provides) {
-    const full = join18(root, provide.path);
+    const full = join19(root, provide.path);
     if (!await pathExists(full)) continue;
     const stats = await stat3(full);
     if (provide.type === "instructions") {
       if (stats.isFile()) {
-        artifacts.push(await artifactForFile(provide.type, basename8(full), full, provide.path, packageName, provide, manifest, basename8(full)));
+        artifacts.push(await artifactForFile(provide.type, basename9(full), full, provide.path, packageName, provide, manifest, basename9(full)));
       }
       continue;
     }
     if (stats.isDirectory()) {
       for (const entry of await sortedDirEntries(full)) {
-        const child = join18(full, entry.name);
+        const child = join19(full, entry.name);
         if ((provide.type === "skills" || provide.type === "plugins" || provide.type === "subagents") && entry.isDirectory()) {
-          artifacts.push(await artifactForDir(provide.type, entry.name, child, join18(provide.path, entry.name), packageName, provide, manifest, entry.name));
+          artifacts.push(await artifactForDir(provide.type, entry.name, child, join19(provide.path, entry.name), packageName, provide, manifest, entry.name));
         } else if (entry.isFile()) {
           const name = provide.type === "rules" && entry.name.endsWith(".md") ? entry.name : entry.name;
-          artifacts.push(await artifactForFile(provide.type, name, child, join18(provide.path, entry.name), packageName, provide, manifest, name));
+          artifacts.push(await artifactForFile(provide.type, name, child, join19(provide.path, entry.name), packageName, provide, manifest, name));
         }
       }
     } else if (stats.isFile()) {
-      artifacts.push(await artifactForFile(provide.type, basename8(full), full, provide.path, packageName, provide, manifest, basename8(full)));
+      artifacts.push(await artifactForFile(provide.type, basename9(full), full, provide.path, packageName, provide, manifest, basename9(full)));
     }
   }
   return artifacts;
@@ -4650,11 +4815,11 @@ async function listFromManifest(root, packageName) {
 async function listGenericArtifacts(type, dir, relativeRoot, packageName) {
   const artifacts = [];
   for (const entry of await sortedDirEntries(dir)) {
-    const full = join18(dir, entry.name);
+    const full = join19(dir, entry.name);
     if (entry.isDirectory()) {
-      artifacts.push(await artifactForDir(type, entry.name, full, join18(relativeRoot, entry.name), packageName));
+      artifacts.push(await artifactForDir(type, entry.name, full, join19(relativeRoot, entry.name), packageName));
     } else if (entry.isFile()) {
-      artifacts.push(await artifactForFile(type, entry.name, full, join18(relativeRoot, entry.name), packageName));
+      artifacts.push(await artifactForFile(type, entry.name, full, join19(relativeRoot, entry.name), packageName));
     }
   }
   return artifacts;
@@ -4771,7 +4936,7 @@ var ClawHubSourceDriver = class {
     return this.local.list({ ...resolved, driver: "local" });
   }
   async scan(resolved) {
-    if (!await pathExists(join19(resolved.resolvedPath, "plugins"))) {
+    if (!await pathExists(join20(resolved.resolvedPath, "plugins"))) {
       return { ok: false, findings: [{ level: "error", message: "ClawHub source has no generated plugin artifact" }] };
     }
     return { ok: true, findings: [] };
@@ -4823,10 +4988,10 @@ async function writeGeneratedPackage(root, packageInfo) {
     artifact: packageInfo.artifact,
     verification: packageInfo.verification
   };
-  const pluginPath = join19(root, "plugins", pluginId, "clawhub.json");
+  const pluginPath = join20(root, "plugins", pluginId, "clawhub.json");
   await rm5(root, { recursive: true, force: true });
-  await mkdir10(dirname12(pluginPath), { recursive: true });
-  await writeFile12(join19(root, "openpack.json"), `${JSON.stringify({
+  await mkdir11(dirname14(pluginPath), { recursive: true });
+  await writeFile13(join20(root, "openpack.json"), `${JSON.stringify({
     schemaVersion: 2,
     name: `clawhub/${name}`,
     version: packageInfo.latestVersion ?? "latest",
@@ -4842,23 +5007,23 @@ async function writeGeneratedPackage(root, packageInfo) {
     ]
   }, null, 2)}
 `, "utf8");
-  await writeFile12(pluginPath, `${JSON.stringify(plugin, null, 2)}
+  await writeFile13(pluginPath, `${JSON.stringify(plugin, null, 2)}
 `, "utf8");
 }
 function installNameFor2(value) {
-  return basename9(value).replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "clawhub-plugin";
+  return basename10(value).replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "clawhub-plugin";
 }
 function cachePathFor(packageName, cacheRoot) {
-  const root = cacheRoot ? resolve6(cacheRoot) : join19(process.env.HOME ?? ".", ".agentwheel", "cache");
+  const root = cacheRoot ? resolve6(cacheRoot) : join20(process.env.HOME ?? ".", ".agentwheel", "cache");
   const slug2 = `clawhub-${packageName}`.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "");
-  return join19(root, slug2 || "clawhub-package");
+  return join20(root, slug2 || "clawhub-package");
 }
 
 // src/source/git.ts
 import { execFile as execFile4 } from "child_process";
-import { cp as cp2, mkdir as mkdir11, rename as rename3, rm as rm6, writeFile as writeFile13 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir12, rename as rename3, rm as rm6, writeFile as writeFile14 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename10, dirname as dirname13, join as join20, resolve as resolve7 } from "path";
+import { basename as basename11, dirname as dirname15, join as join21, resolve as resolve7 } from "path";
 import { promisify as promisify4 } from "util";
 var execFileAsync4 = promisify4(execFile4);
 var GitSourceDriver = class {
@@ -4881,8 +5046,8 @@ var GitSourceDriver = class {
   async fetch(resolved) {
     return withFilesystemLock(`${resolved.resolvedPath}.lock`, resolved.cacheLockTimeoutMs ?? 3e4, async () => {
       const parsed = parseGitSource(resolved.source);
-      await mkdir11(resolve7(resolved.resolvedPath, ".."), { recursive: true });
-      if (!await pathExists(join20(resolved.resolvedPath, ".git"))) {
+      await mkdir12(resolve7(resolved.resolvedPath, ".."), { recursive: true });
+      if (!await pathExists(join21(resolved.resolvedPath, ".git"))) {
         if (resolved.frozenLock) {
           throw new Error(`Frozen lock requires cached git checkout at ${resolved.resolvedPath}`);
         }
@@ -4949,20 +5114,20 @@ function parseGitSource(source) {
   throw new Error(`Invalid git source: ${source}`);
 }
 function cachePathFor2(url, cacheRoot) {
-  const root = cacheRoot ? resolve7(cacheRoot) : join20(homedir2(), ".agentwheel", "cache");
+  const root = cacheRoot ? resolve7(cacheRoot) : join21(homedir2(), ".agentwheel", "cache");
   const slug2 = url.replace(/^[a-z]+:\/\//i, "").replace(/\.git$/i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "");
-  return join20(root, slug2 || basename10(url));
+  return join21(root, slug2 || basename11(url));
 }
 async function git(args) {
   return execFileAsync4("git", args, { maxBuffer: 1024 * 1024 * 10 });
 }
 async function snapshotCheckout(checkoutPath, commit) {
-  const snapshotPath = join20(dirname13(checkoutPath), `${basename10(checkoutPath)}-${commit.slice(0, 12)}`);
+  const snapshotPath = join21(dirname15(checkoutPath), `${basename11(checkoutPath)}-${commit.slice(0, 12)}`);
   if (await pathExists(snapshotPath)) return snapshotPath;
-  const tempPath = join20(dirname13(checkoutPath), `${basename10(snapshotPath)}.tmp-${process.pid}-${Date.now()}`);
+  const tempPath = join21(dirname15(checkoutPath), `${basename11(snapshotPath)}.tmp-${process.pid}-${Date.now()}`);
   await rm6(tempPath, { recursive: true, force: true });
   await cp2(checkoutPath, tempPath, { recursive: true, dereference: true });
-  await rm6(join20(tempPath, ".git"), { recursive: true, force: true });
+  await rm6(join21(tempPath, ".git"), { recursive: true, force: true });
   try {
     await rename3(tempPath, snapshotPath);
   } catch (error) {
@@ -4973,12 +5138,12 @@ async function snapshotCheckout(checkoutPath, commit) {
   return snapshotPath;
 }
 async function withFilesystemLock(lockPath, timeoutMs, fn) {
-  await mkdir11(dirname13(lockPath), { recursive: true });
+  await mkdir12(dirname15(lockPath), { recursive: true });
   const started = Date.now();
   while (true) {
     try {
-      await mkdir11(lockPath);
-      await writeFile13(join20(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf8");
+      await mkdir12(lockPath);
+      await writeFile14(join21(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf8");
       break;
     } catch (error) {
       if (!isAlreadyExists2(error)) throw error;
@@ -4999,8 +5164,8 @@ function isAlreadyExists2(error) {
 }
 
 // src/source/mcp-registry.ts
-import { mkdir as mkdir12, writeFile as writeFile14 } from "fs/promises";
-import { basename as basename11, dirname as dirname14, join as join21, resolve as resolve8 } from "path";
+import { mkdir as mkdir13, writeFile as writeFile15 } from "fs/promises";
+import { basename as basename12, dirname as dirname16, join as join22, resolve as resolve8 } from "path";
 var registryBaseUrl = "https://registry.modelcontextprotocol.io/v0.1";
 var sourcePrefix2 = "mcp-registry:";
 var McpRegistrySourceDriver = class {
@@ -5066,7 +5231,7 @@ var McpRegistrySourceDriver = class {
     return this.local.list({ ...resolved, driver: "local" });
   }
   async scan(resolved) {
-    if (!await pathExists(join21(resolved.resolvedPath, "mcp"))) {
+    if (!await pathExists(join22(resolved.resolvedPath, "mcp"))) {
       return { ok: false, findings: [{ level: "error", message: "MCP registry source has no generated mcp artifact" }] };
     }
     return { ok: true, findings: [] };
@@ -5106,16 +5271,16 @@ function isSafeHttpUrl(value) {
 }
 async function writeGeneratedPackage2(root, server) {
   const serverId = installNameFor3(server.serverName);
-  const mcpPath = join21(root, "mcp", `${serverId}.json`);
-  await mkdir12(dirname14(mcpPath), { recursive: true });
-  await writeFile14(join21(root, "openpack.json"), `${JSON.stringify({
+  const mcpPath = join22(root, "mcp", `${serverId}.json`);
+  await mkdir13(dirname16(mcpPath), { recursive: true });
+  await writeFile15(join22(root, "openpack.json"), `${JSON.stringify({
     schemaVersion: 2,
     name: `mcp-registry/${server.serverName}`,
     version: server.version ?? "latest",
     provides: [{ type: "mcp", path: "mcp" }]
   }, null, 2)}
 `, "utf8");
-  await writeFile14(mcpPath, `${JSON.stringify({
+  await writeFile15(mcpPath, `${JSON.stringify({
     mcpServers: {
       [serverId]: {
         type: "streamable-http",
@@ -5126,23 +5291,23 @@ async function writeGeneratedPackage2(root, server) {
 `, "utf8");
 }
 function installNameFor3(serverName) {
-  return basename11(serverName).replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "mcp-server";
+  return basename12(serverName).replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "mcp-server";
 }
 function cachePathFor3(serverName, cacheRoot) {
-  const root = cacheRoot ? resolve8(cacheRoot) : join21(process.env.HOME ?? ".", ".agentwheel", "cache");
+  const root = cacheRoot ? resolve8(cacheRoot) : join22(process.env.HOME ?? ".", ".agentwheel", "cache");
   const slug2 = `mcp-registry-${serverName}`.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "");
-  return join21(root, slug2 || "mcp-registry-server");
+  return join22(root, slug2 || "mcp-registry-server");
 }
 
 // src/source/skillkit.ts
-import { cp as cp3, mkdir as mkdir13, readFile as readFile16, rm as rm7 } from "fs/promises";
+import { cp as cp3, mkdir as mkdir14, readFile as readFile17, rm as rm7 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { basename as basename13, dirname as dirname16, join as join23, resolve as resolve9 } from "path";
+import { basename as basename14, dirname as dirname18, join as join24, resolve as resolve9 } from "path";
 import * as defaultSkillKit from "@skillkit/core";
 
 // src/source/skill-artifacts.ts
 import { readdir as readdir2, stat as stat4 } from "fs/promises";
-import { basename as basename12, dirname as dirname15, extname as extname2, join as join22 } from "path";
+import { basename as basename13, dirname as dirname17, extname as extname2, join as join23 } from "path";
 async function artifactsFromSkillPaths(paths, packageName) {
   const artifacts = [];
   const seen = /* @__PURE__ */ new Set();
@@ -5164,28 +5329,28 @@ async function discoverSkillPaths(root) {
 async function artifactFromSkillPath(item, packageName) {
   const stats = await stat4(item.path);
   if (stats.isDirectory()) {
-    const skillMd = join22(item.path, "SKILL.md");
+    const skillMd = join23(item.path, "SKILL.md");
     if (!await pathExists(skillMd)) return void 0;
-    const name = sanitizeSkillName(item.name ?? basename12(item.path));
+    const name = sanitizeSkillName(item.name ?? basename13(item.path));
     return {
       type: "skills",
       name,
       sourcePath: item.path,
-      relativePath: join22("skills", name),
+      relativePath: join23("skills", name),
       kind: "dir",
       hash: await hashPath(item.path),
       packageName,
       channel: "managed"
     };
   }
-  if (stats.isFile() && basename12(item.path).toLowerCase() === "skill.md") {
-    const dir = dirname15(item.path);
-    const name = sanitizeSkillName(item.name ?? basename12(dir));
+  if (stats.isFile() && basename13(item.path).toLowerCase() === "skill.md") {
+    const dir = dirname17(item.path);
+    const name = sanitizeSkillName(item.name ?? basename13(dir));
     return {
       type: "skills",
       name,
       sourcePath: dir,
-      relativePath: join22("skills", name),
+      relativePath: join23("skills", name),
       kind: "dir",
       hash: await hashPath(dir),
       packageName,
@@ -5193,12 +5358,12 @@ async function artifactFromSkillPath(item, packageName) {
     };
   }
   if (stats.isFile() && extname2(item.path).toLowerCase() === ".md") {
-    const name = sanitizeSkillName(item.name ?? basename12(item.path, ".md"));
+    const name = sanitizeSkillName(item.name ?? basename13(item.path, ".md"));
     return {
       type: "skills",
       name,
       sourcePath: item.path,
-      relativePath: join22("skills", `${name}.md`),
+      relativePath: join23("skills", `${name}.md`),
       kind: "file",
       hash: await hashPath(item.path),
       packageName,
@@ -5216,7 +5381,7 @@ async function walk(dir, paths) {
   }
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     if (!entry.isDirectory() || entry.name === ".git" || entry.name === "node_modules") continue;
-    await walk(join22(dir, entry.name), paths);
+    await walk(join23(dir, entry.name), paths);
   }
 }
 function sanitizeSkillName(name) {
@@ -5238,7 +5403,7 @@ var SkillKitSourceDriver = class {
         driver: this.name,
         source,
         resolvedPath,
-        packageName: `skillkit/${basename13(resolvedPath)}`,
+        packageName: `skillkit/${basename14(resolvedPath)}`,
         mode: options.mode ?? "pinned",
         sourceHash: await hashPath(resolvedPath)
       };
@@ -5272,7 +5437,7 @@ var SkillKitSourceDriver = class {
     if (!provider?.clone) {
       throw new Error("SkillKit provider API unavailable or cannot resolve source. Expected @skillkit/core detectProvider().clone().");
     }
-    await mkdir13(dirname16(resolved.resolvedPath), { recursive: true });
+    await mkdir14(dirname18(resolved.resolvedPath), { recursive: true });
     const result = await provider.clone(providerSpec, resolved.resolvedPath, {});
     if (!result.success || !result.path) {
       throw new Error(`SkillKit provider failed to fetch ${spec}: ${result.error ?? "unknown error"}`);
@@ -5316,9 +5481,9 @@ var SkillKitSourceDriver = class {
       throw new Error("SkillKit translateSkill API unavailable");
     }
     for (const skill of this.discover(resolved.resolvedPath)) {
-      const skillMd = join23(skill.path, "SKILL.md");
+      const skillMd = join24(skill.path, "SKILL.md");
       if (await pathExists(skillMd)) {
-        this.core.translateSkill(await readFile16(skillMd, "utf8"), "openclaw", { sourceFilename: "SKILL.md" });
+        this.core.translateSkill(await readFile17(skillMd, "utf8"), "openclaw", { sourceFilename: "SKILL.md" });
       }
     }
     return resolved;
@@ -5347,8 +5512,8 @@ function normalizeProviderSource(spec) {
   return spec;
 }
 function cachePathFor4(spec, cacheRoot) {
-  const root = cacheRoot ? resolve9(cacheRoot) : join23(homedir3(), ".agentwheel", "cache");
-  return join23(root, "skillkit", packageSlug(spec));
+  const root = cacheRoot ? resolve9(cacheRoot) : join24(homedir3(), ".agentwheel", "cache");
+  return join24(root, "skillkit", packageSlug(spec));
 }
 function packageSlug(spec) {
   return spec.replace(/^[a-z]+:\/\//i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "source";
@@ -5361,7 +5526,7 @@ function mapSeverity(severity) {
 
 // src/source/vercel-skills.ts
 import { stat as stat5 } from "fs/promises";
-import { basename as basename14, join as join24, relative as relative5, resolve as resolve10 } from "path";
+import { basename as basename15, join as join25, relative as relative5, resolve as resolve10 } from "path";
 var VercelSkillsSourceDriver = class {
   name = "vercel-skills";
   git = new GitSourceDriver();
@@ -5376,7 +5541,7 @@ var VercelSkillsSourceDriver = class {
         driver: this.name,
         source,
         resolvedPath,
-        packageName: `vercel/${basename14(resolvedPath)}`,
+        packageName: `vercel/${basename15(resolvedPath)}`,
         mode: options.mode ?? "pinned",
         sourceHash: await hashPath(resolvedPath)
       };
@@ -5424,7 +5589,7 @@ var VercelSkillsSourceDriver = class {
 };
 async function resolveVercelSkillSubpath(root, subpath) {
   if (!subpath) return root;
-  const candidates = [join24(root, subpath), join24(root, "skills", subpath)];
+  const candidates = [join25(root, subpath), join25(root, "skills", subpath)];
   for (const candidate of candidates) {
     if (await pathExists(candidate)) return candidate;
   }
@@ -5494,14 +5659,14 @@ function getSourceDriver(name = "local") {
 }
 
 // src/staging/staging.ts
-import { chmod, cp as cp5, mkdir as mkdir15, mkdtemp as mkdtemp3, readdir as readdir5, stat as stat8 } from "fs/promises";
-import { basename as basename17, dirname as dirname19, join as join27, relative as relative7, resolve as resolve12, sep as sep2 } from "path";
+import { chmod, cp as cp5, mkdir as mkdir16, mkdtemp as mkdtemp3, readdir as readdir5, stat as stat8 } from "fs/promises";
+import { basename as basename18, dirname as dirname21, join as join28, relative as relative7, resolve as resolve12, sep as sep2 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 
 // src/compose/markdown.ts
 import { createHash as createHash5 } from "crypto";
-import { readdir as readdir3, readFile as readFile17, stat as stat6, writeFile as writeFile15 } from "fs/promises";
-import { basename as basename15, dirname as dirname17, extname as extname3, join as join25, relative as relative6, resolve as resolve11, sep } from "path";
+import { readdir as readdir3, readFile as readFile18, stat as stat6, writeFile as writeFile16 } from "fs/promises";
+import { basename as basename16, dirname as dirname19, extname as extname3, join as join26, relative as relative6, resolve as resolve11, sep } from "path";
 var includePattern = /<!--\s*openpack:include(\?)?\s+([^>]+?)\s*-->/g;
 var escapedIncludePattern = /<!--\s*openpack\\:include(\?)?\s+([^>]+?)\s*-->/g;
 var generatedPattern = /<!--\s*(?:BEGIN|END)\s+openpack:include\b/;
@@ -5516,7 +5681,7 @@ async function expandMarkdownIncludes(artifacts, packageRoot, options = {}) {
     const composedFrom = [];
     for (const file of files) {
       const result = await expandFile(file, packageRoot, composeEntriesForFile(artifact, file), artifactPaths, options);
-      if (result.changed) await writeFile15(file, result.content, "utf8");
+      if (result.changed) await writeFile16(file, result.content, "utf8");
       composedFrom.push(...result.composedFrom);
     }
     const stagedPath = artifact.stagedPath ?? artifact.sourcePath;
@@ -5538,7 +5703,7 @@ async function validateMarkdownIncludes(artifacts, packageRoot, options = {}) {
   }
 }
 async function expandFile(file, packageRoot, appendEntries, artifactPaths, options) {
-  const raw = await readFile17(file, "utf8");
+  const raw = await readFile18(file, "utf8");
   const owner = ownerSelector(packageRoot, file, options.nodeId);
   const expanded = await expandContent(raw, packageRoot, [owner], artifactPaths, options);
   let content = expanded.content;
@@ -5631,7 +5796,7 @@ async function expandInclude(selector, packageRoot, artifactPaths, options) {
   if (!stats.isFile()) {
     throw new Error(`OpenPack include is not a file: ${displaySelector}`);
   }
-  const raw = sourceContent ?? await readFile17(sourcePath, "utf8");
+  const raw = sourceContent ?? await readFile18(sourcePath, "utf8");
   const { optional: _optional, markers: _markers, chain: _chain, ...childOptions } = options;
   const expanded = await expandContent(raw, includePackageRoot, [...options.chain, displaySelector], includeArtifactPaths, {
     ...childOptions,
@@ -5707,7 +5872,7 @@ async function listMarkdownFiles(root) {
   const out = [];
   async function walk2(dir) {
     for (const entry of (await readdir3(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = join25(dir, entry.name);
+      const full = join26(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
       } else if (entry.isFile() && extname3(entry.name).toLowerCase() === ".md") {
@@ -5721,7 +5886,7 @@ async function listMarkdownFiles(root) {
 function composeEntriesForFile(artifact, file) {
   if (!artifact.compose?.length) return [];
   if (artifact.kind === "file") return [resolve11(artifact.stagedPath ?? artifact.sourcePath), resolve11(file)].every(Boolean) && resolve11(artifact.stagedPath ?? artifact.sourcePath) === resolve11(file) ? artifact.compose : [];
-  return basename15(file) === "SKILL.md" && dirname17(file) === resolve11(artifact.stagedPath ?? artifact.sourcePath) ? artifact.compose : [];
+  return basename16(file) === "SKILL.md" && dirname19(file) === resolve11(artifact.stagedPath ?? artifact.sourcePath) ? artifact.compose : [];
 }
 function orderedForExpansion(artifacts) {
   return [...artifacts].sort((a, b) => Number(a.type === "fragments") - Number(b.type === "fragments"));
@@ -5767,8 +5932,8 @@ function artifactPathMap(artifacts) {
 }
 
 // src/staging/customize.ts
-import { cp as cp4, mkdir as mkdir14, readdir as readdir4, readFile as readFile18, writeFile as writeFile16 } from "fs/promises";
-import { dirname as dirname18, join as join26 } from "path";
+import { cp as cp4, mkdir as mkdir15, readdir as readdir4, readFile as readFile19, writeFile as writeFile17 } from "fs/promises";
+import { dirname as dirname20, join as join27 } from "path";
 async function applyCustomizations(artifacts, options) {
   let next = [...artifacts];
   next = await applyReplacements2(next, options, "override", installableArtifactTypes());
@@ -5784,16 +5949,16 @@ async function applyFragmentCustomizations(artifacts, options) {
   return next.sort((a, b) => `${a.type}:${a.name}:${a.channel}`.localeCompare(`${b.type}:${b.name}:${b.channel}`));
 }
 async function applyInstructionOverlay(artifacts, options) {
-  const overlayPath = join26(options.workspaceRoot, ".agentwheel", "overlays", options.adapter.name, "instructions.local.md");
+  const overlayPath = join27(options.workspaceRoot, ".agentwheel", "overlays", options.adapter.name, "instructions.local.md");
   if (!await pathExists(overlayPath)) return artifacts;
   const index = artifacts.findIndex((artifact2) => artifact2.type === "instructions");
   if (index < 0) return artifacts;
   const artifact = artifacts[index];
-  const managed = await readFile18(artifact.stagedPath ?? artifact.sourcePath, "utf8");
-  const local = await readFile18(overlayPath, "utf8");
-  const composedPath = join26(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
-  await mkdir14(dirname18(composedPath), { recursive: true });
-  await writeFile16(
+  const managed = await readFile19(artifact.stagedPath ?? artifact.sourcePath, "utf8");
+  const local = await readFile19(overlayPath, "utf8");
+  const composedPath = join27(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
+  await mkdir15(dirname20(composedPath), { recursive: true });
+  await writeFile17(
     composedPath,
     [
       "<!-- BEGIN agentwheel managed: upstream -->",
@@ -5819,19 +5984,19 @@ async function applyInstructionOverlay(artifacts, options) {
   return [...artifacts.slice(0, index), updated, ...artifacts.slice(index + 1)];
 }
 async function applyAdditions(artifacts, options) {
-  const additionsRoot = join26(options.workspaceRoot, ".agentwheel", "additions");
-  const rulesRoot = join26(additionsRoot, "rules");
+  const additionsRoot = join27(options.workspaceRoot, ".agentwheel", "additions");
+  const rulesRoot = join27(additionsRoot, "rules");
   if (!await pathExists(rulesRoot)) return artifacts;
   const additions = [];
   for (const entry of await sortedDirEntries2(rulesRoot)) {
-    const full = join26(rulesRoot, entry.name);
+    const full = join27(rulesRoot, entry.name);
     if (!entry.isFile()) continue;
     additions.push({
       type: "rules",
       name: entry.name,
       sourcePath: full,
       stagedPath: full,
-      relativePath: join26("additions", "rules", entry.name),
+      relativePath: join27("additions", "rules", entry.name),
       kind: "file",
       hash: await hashPath(full),
       packageName: options.packageName,
@@ -5855,17 +6020,17 @@ async function applyReplacements2(artifacts, options, channel, artifactTypes) {
       );
     }
     for (const type of artifactTypes) {
-      const typeRoot = join26(root, type);
+      const typeRoot = join27(root, type);
       if (!await pathExists(typeRoot)) continue;
       for (const entry of await sortedDirEntries2(typeRoot)) {
         const artifactMapKey = `${type}:${entry.name}`;
         if (seen.has(artifactMapKey)) continue;
         seen.add(artifactMapKey);
-        const full = join26(typeRoot, entry.name);
+        const full = join27(typeRoot, entry.name);
         const artifactKind = entry.isDirectory() ? "dir" : "file";
         const existing = byKey.get(artifactMapKey);
-        const stagedPath = join26(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
-        await mkdir14(dirname18(stagedPath), { recursive: true });
+        const stagedPath = join27(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
+        await mkdir15(dirname20(stagedPath), { recursive: true });
         await cp4(full, stagedPath, { recursive: artifactKind === "dir", dereference: true });
         byKey.set(artifactMapKey, {
           ...existing,
@@ -5873,7 +6038,7 @@ async function applyReplacements2(artifacts, options, channel, artifactTypes) {
           name: entry.name,
           sourcePath: full,
           stagedPath,
-          relativePath: existing?.relativePath ?? join26(type, entry.name),
+          relativePath: existing?.relativePath ?? join27(type, entry.name),
           kind: artifactKind,
           hash: await hashPath(stagedPath),
           packageName,
@@ -5888,13 +6053,13 @@ function replacementRoots(options, channel) {
   const stateDir = channel === "override" ? "overrides" : "ejected";
   const roots = [];
   if (options.graphNodeId) {
-    roots.push({ root: join26(options.workspaceRoot, ".agentwheel", stateDir, ...options.graphNodeId.split("/")), kind: "node" });
+    roots.push({ root: join27(options.workspaceRoot, ".agentwheel", stateDir, ...options.graphNodeId.split("/")), kind: "node" });
   }
   if (options.packageName && options.packageVersion) {
-    roots.push({ root: join26(options.workspaceRoot, ".agentwheel", stateDir, ...`${options.packageName}@${options.packageVersion}`.split("/")), kind: "version" });
+    roots.push({ root: join27(options.workspaceRoot, ".agentwheel", stateDir, ...`${options.packageName}@${options.packageVersion}`.split("/")), kind: "version" });
   }
   if (options.packageName) {
-    roots.push({ root: join26(options.workspaceRoot, ".agentwheel", stateDir, ...options.packageName.split("/")), kind: "package" });
+    roots.push({ root: join27(options.workspaceRoot, ".agentwheel", stateDir, ...options.packageName.split("/")), kind: "package" });
   }
   return roots;
 }
@@ -5921,15 +6086,15 @@ async function stageResolvedSourceRaw(driver, resolved) {
   return stageResolvedArtifactsRaw(resolved, artifacts);
 }
 async function stageResolvedArtifactsRaw(resolved, artifacts) {
-  const root = await mkdtemp3(join27(tmpdir4(), "agentwheel-stage-"));
+  const root = await mkdtemp3(join28(tmpdir4(), "agentwheel-stage-"));
   const stagedArtifacts = [];
   for (const artifact of artifacts) {
-    const stagedPath = join27(root, artifact.relativePath);
-    await mkdir15(dirname19(stagedPath), { recursive: true });
+    const stagedPath = join28(root, artifact.relativePath);
+    await mkdir16(dirname21(stagedPath), { recursive: true });
     await cp5(artifact.sourcePath, stagedPath, {
       recursive: artifact.kind === "dir",
       dereference: true,
-      filter: (path) => !isIgnoredGeneratedEntry(basename17(path))
+      filter: (path) => !isIgnoredGeneratedEntry(basename18(path))
     });
     await composeAssets(artifact, resolved.resolvedPath, stagedPath);
     stagedArtifacts.push({
@@ -5958,7 +6123,8 @@ async function renderStagedBundle(bundle, options = {}) {
   const runtimeSelectedSet = new Set(normalizeArtifactSelectors(options.select, options.skills) ?? []);
   const runtimeArtifacts = options.adapter ? filterArtifactsByRuntime(selectedArtifacts, options.adapter.name, runtimeSelectedSet) : selectedArtifacts;
   const codexRenderedArtifacts = await renderCodexSubagents(runtimeArtifacts, root, options.adapter);
-  const renderedArtifacts = await renderCopilotArtifacts(codexRenderedArtifacts, root, options.adapter);
+  const openClawRenderedArtifacts = await renderOpenClawSubagents(codexRenderedArtifacts, root, options.adapter);
+  const renderedArtifacts = await renderCopilotArtifacts(openClawRenderedArtifacts, root, options.adapter);
   const finalArtifacts = options.workspaceRoot && options.adapter ? await applyCustomizations(renderedArtifacts, {
     workspaceRoot: options.workspaceRoot,
     adapter: options.adapter,
@@ -6010,16 +6176,16 @@ async function composeAssets(artifact, packageRoot, stagedPath) {
   }
   for (const asset of artifact.assets) {
     const source = resolvePackagePath(packageRoot, asset.from);
-    const dest = join27(stagedPath, asset.into);
+    const dest = join28(stagedPath, asset.into);
     await copyAsset(asset, source, dest);
   }
 }
 async function copyAsset(asset, source, dest) {
   const sourceStats = await stat8(source);
   if (sourceStats.isFile()) {
-    if (matchesAny(basename17(source), asset.include)) {
-      await mkdir15(dest, { recursive: true });
-      await copyAssetFile(source, join27(dest, basename17(source)), asset);
+    if (matchesAny(basename18(source), asset.include)) {
+      await mkdir16(dest, { recursive: true });
+      await copyAssetFile(source, join28(dest, basename18(source)), asset);
     }
     return;
   }
@@ -6027,19 +6193,19 @@ async function copyAsset(asset, source, dest) {
     throw new Error(`Asset include source is not a file or directory: ${source}`);
   }
   if (!asset.include?.length) {
-    await mkdir15(dirname19(dest), { recursive: true });
+    await mkdir16(dirname21(dest), { recursive: true });
     await cp5(source, dest, { recursive: true, dereference: true });
     if (asset.mode === "copy") await normalizeCopiedModes(dest);
     return;
   }
   for (const file of await listFiles(source)) {
     const rel = relative7(source, file).replaceAll("\\", "/");
-    if (!matchesAny(rel, asset.include) && !matchesAny(basename17(file), asset.include)) continue;
-    await copyAssetFile(file, join27(dest, rel), asset);
+    if (!matchesAny(rel, asset.include) && !matchesAny(basename18(file), asset.include)) continue;
+    await copyAssetFile(file, join28(dest, rel), asset);
   }
 }
 async function copyAssetFile(source, dest, asset) {
-  await mkdir15(dirname19(dest), { recursive: true });
+  await mkdir16(dirname21(dest), { recursive: true });
   await cp5(source, dest, { dereference: true });
   if (asset.mode === "copy") await chmod(dest, 420);
 }
@@ -6055,7 +6221,7 @@ async function listFiles(root) {
   const out = [];
   async function walk2(dir) {
     for (const entry of (await readdir5(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = join27(dir, entry.name);
+      const full = join28(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
       } else if (entry.isFile()) {
@@ -6074,7 +6240,7 @@ async function normalizeCopiedModes(path) {
   }
   if (!stats.isDirectory()) return;
   for (const entry of await readdir5(path, { withFileTypes: true })) {
-    await normalizeCopiedModes(join27(path, entry.name));
+    await normalizeCopiedModes(join28(path, entry.name));
   }
 }
 function matchesAny(path, patterns) {
@@ -6087,9 +6253,9 @@ function matchesGlob(path, pattern) {
 }
 
 // src/model/workspace.ts
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile20 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname20, join as join28, resolve as resolve13 } from "path";
+import { dirname as dirname22, join as join29, resolve as resolve13 } from "path";
 import { z as z6 } from "zod";
 var workspacePackageSchema = z6.object({
   name: z6.string().min(1),
@@ -6160,12 +6326,12 @@ var workspaceConfigSchema = z6.object({
   agents: z6.record(z6.string(), workspaceAgentSchema).default({})
 });
 function workspaceConfigPath(workspaceRoot) {
-  return join28(workspaceRoot, ".agentwheel", "config.json");
+  return join29(workspaceRoot, ".agentwheel", "config.json");
 }
 async function readWorkspaceConfig(workspaceRoot) {
   const path = workspaceConfigPath(workspaceRoot);
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile19(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile20(path, "utf8")));
 }
 async function writeWorkspaceConfig(workspaceRoot, config) {
   await writeJsonAtomic(workspaceConfigPath(workspaceRoot), workspaceConfigSchema.parse(config));
@@ -6178,13 +6344,13 @@ function upsertPackage(config, entry) {
   return { schemaVersion: 1, packages, bootstrapSkills: parsed.bootstrapSkills, registry: parsed.registry ?? {}, trust: parsed.trust ?? {}, profiles: parsed.profiles ?? {}, agents: parsed.agents ?? {} };
 }
 function globalWorkspaceConfigPath(globalRoot = homedir4()) {
-  return join28(globalRoot, ".agentwheel", "config.json");
+  return join29(globalRoot, ".agentwheel", "config.json");
 }
 async function findWorkspaceRoot(start = process.cwd()) {
   let current = resolve13(start);
   while (true) {
     if (await pathExists(workspaceConfigPath(current))) return current;
-    const parent = dirname20(current);
+    const parent = dirname22(current);
     if (parent === current) return resolve13(start);
     current = parent;
   }
@@ -6220,7 +6386,7 @@ function emptyWorkspaceConfig() {
 }
 async function readConfigPath(path) {
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile19(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile20(path, "utf8")));
 }
 function mergeWorkspaceTrust(global, project) {
   return {
@@ -6235,23 +6401,23 @@ function sortedUnique2(values) {
 }
 
 // src/lifecycle/customization.ts
-import { appendFile, cp as cp6, mkdir as mkdir16, rm as rm9 } from "fs/promises";
-import { dirname as dirname22, join as join31 } from "path";
+import { appendFile, cp as cp6, mkdir as mkdir17, rm as rm9 } from "fs/promises";
+import { dirname as dirname24, join as join32 } from "path";
 
 // src/resolve/graph.ts
 import { createHash as createHash6 } from "crypto";
-import { mkdtemp as mkdtemp4, readdir as readdir6, readFile as readFile21, stat as stat10 } from "fs/promises";
+import { mkdtemp as mkdtemp4, readdir as readdir6, readFile as readFile22, stat as stat10 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { basename as basename18, extname as extname4, join as join30 } from "path";
+import { basename as basename19, extname as extname4, join as join31 } from "path";
 
 // src/resolve/identity.ts
 import { homedir as homedir6 } from "os";
 import { resolve as resolve15 } from "path";
 
 // src/registry/client.ts
-import { readFile as readFile20, rm as rm8, stat as stat9 } from "fs/promises";
+import { readFile as readFile21, rm as rm8, stat as stat9 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname21, join as join29, resolve as resolve14 } from "path";
+import { dirname as dirname23, join as join30, resolve as resolve14 } from "path";
 import { fileURLToPath } from "url";
 
 // src/model/registry.ts
@@ -6355,7 +6521,7 @@ var RegistryClient = class {
   }
   async readCache() {
     if (!await pathExists(this.cachePath)) return void 0;
-    return registryCacheSchema.parse(JSON.parse(await readFile20(this.cachePath, "utf8")));
+    return registryCacheSchema.parse(JSON.parse(await readFile21(this.cachePath, "utf8")));
   }
   isExpired(cache, ttlMs) {
     return this.now().getTime() - new Date(cache.fetchedAt).getTime() > ttlMs;
@@ -6374,10 +6540,10 @@ var RegistryClient = class {
     if (await pathExists(filePath)) {
       const fullPath = resolve14(filePath);
       const stats = await stat9(fullPath);
-      return readFile20(stats.isDirectory() ? join29(fullPath, "index.json") : fullPath, "utf8");
+      return readFile21(stats.isDirectory() ? join30(fullPath, "index.json") : fullPath, "utf8");
     }
-    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join29(dirname21(this.cachePath), "registry-repos") }));
-    return readFile20(join29(resolved.resolvedPath, "index.json"), "utf8");
+    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join30(dirname23(this.cachePath), "registry-repos") }));
+    return readFile21(join30(resolved.resolvedPath, "index.json"), "utf8");
   }
   warnCompatibility(entries) {
     for (const entry of entries) {
@@ -6415,7 +6581,7 @@ function mergeIndexes(indexes) {
   return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 function defaultRegistryCachePath() {
-  return join29(homedir5(), ".agentwheel", "registry-cache.json");
+  return join30(homedir5(), ".agentwheel", "registry-cache.json");
 }
 function sameSources(a, b) {
   return a.length === b.length && a.every((source, index) => source === b[index]);
@@ -6665,7 +6831,7 @@ function compareSemver(a, b) {
 var cacheLocks = /* @__PURE__ */ new Map();
 async function resolveDependencyGraph(roots, options) {
   if (roots.length === 0) throw new Error("At least one graph root is required.");
-  const graphRoot = await mkdtemp4(join30(tmpdir5(), "agentwheel-graph-"));
+  const graphRoot = await mkdtemp4(join31(tmpdir5(), "agentwheel-graph-"));
   const fetchCache = /* @__PURE__ */ new Map();
   const nodesByKey = /* @__PURE__ */ new Map();
   const rootResults = [];
@@ -7128,7 +7294,7 @@ async function collectIncludeNeeds(artifact, artifactsByRelativePath) {
     const file = stack.shift();
     if (scanned.has(file)) continue;
     scanned.add(file);
-    const content = await readFile21(file, "utf8");
+    const content = await readFile22(file, "utf8");
     for (const include of extractOpenPackIncludeSelectors(content)) {
       await collectIncludeSelector(include.raw, include.optional, artifactsByRelativePath, scanned, stack, needs);
     }
@@ -7171,7 +7337,7 @@ async function listMarkdownFiles2(root) {
   const out = [];
   async function walk2(dir) {
     for (const entry of (await readdir6(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = join30(dir, entry.name);
+      const full = join31(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
       } else if (entry.isFile() && extname4(entry.name).toLowerCase() === ".md") {
@@ -7206,7 +7372,7 @@ async function fetchPackage(normalized, mode, options, fetchCache, refOverride)
   const promise = (async () => {
     const driver = getSourceDriver(normalized.driver);
     const resolved = await driver.resolve(normalized.source, {
-      cacheRoot: options.cacheRoot ?? join30(options.workspaceRoot, ".agentwheel", "cache"),
+      cacheRoot: options.cacheRoot ?? join31(options.workspaceRoot, ".agentwheel", "cache"),
       mode,
       ref: refOverride ?? normalized.requestedRef,
       frozenLock: hardLockedCheckout
@@ -7216,7 +7382,7 @@ async function fetchPackage(normalized, mode, options, fetchCache, refOverride)
     const exported = await driver.export(translated);
     const manifest = await readPackageManifest(exported.resolvedPath);
     const artifacts = await driver.list(exported);
-    const name = manifest?.name ?? exported.packageName ?? basename18(exported.resolvedPath);
+    const name = manifest?.name ?? exported.packageName ?? basename19(exported.resolvedPath);
     const version = manifest?.version ?? exported.packageVersion ?? "0.0.0";
     const sourceHash = exported.sourceHash ?? await hashPath(exported.resolvedPath);
     return {
@@ -7413,8 +7579,8 @@ async function mapLimit(items, limit, fn) {
 
 // src/lifecycle/customization.ts
 async function remember(workspaceRoot, runtime, text) {
-  const overlayPath = join31(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
-  await mkdir16(dirname22(overlayPath), { recursive: true });
+  const overlayPath = join32(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
+  await mkdir17(dirname24(overlayPath), { recursive: true });
   await appendFile(overlayPath, `${text.trim()}
 `, "utf8");
   return { overlayPath };
@@ -7437,8 +7603,8 @@ async function ejectArtifact(workspaceRoot, item) {
       throw new Error(`Artifact not found: ${item}`);
     }
     const ejectedIdentity = parsed.packageIdentity === parsed.packageName ? parsed.packageIdentity : candidate.nodeId === parsed.packageIdentity ? candidate.nodeId : `${candidate.packageName}@${candidate.packageVersion}`;
-    const ejectedPath = join31(workspaceRoot, ".agentwheel", "ejected", ...ejectedIdentity.split("/"), parsed.type, parsed.name);
-    await mkdir16(dirname22(ejectedPath), { recursive: true });
+    const ejectedPath = join32(workspaceRoot, ".agentwheel", "ejected", ...ejectedIdentity.split("/"), parsed.type, parsed.name);
+    await mkdir17(dirname24(ejectedPath), { recursive: true });
     await rm9(ejectedPath, { recursive: true, force: true });
     await cp6(artifact.stagedPath ?? artifact.sourcePath, ejectedPath, { recursive: artifact.kind === "dir", dereference: true });
     return {
@@ -7480,7 +7646,7 @@ async function stageEjectCandidate(workspaceRoot, pkg) {
   const adapter = pkg.adapterConfig ? await loadAdapterConfig(pkg.adapterConfig) : getAdapter(pkg.adapter);
   const bundle = await stageSource(driver, normalized.source, {
     adapter,
-    cacheRoot: join31(workspaceRoot, ".agentwheel", "cache"),
+    cacheRoot: join32(workspaceRoot, ".agentwheel", "cache"),
     mode: pkg.mode,
     ref: normalized.requestedRef ?? pkg.requestedRef
   });
@@ -7531,8 +7697,8 @@ import { rm as rm10 } from "fs/promises";
 
 // src/lifecycle/source-plan.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdir as mkdir18 } from "fs/promises";
-import { dirname as dirname24, join as join34, resolve as resolve16 } from "path";
+import { mkdir as mkdir19 } from "fs/promises";
+import { dirname as dirname26, join as join35, resolve as resolve16 } from "path";
 
 // src/resolve/graph-diff.ts
 function diffGraphLocks(previous, next) {
@@ -7654,11 +7820,11 @@ function short(hash) {
 
 // src/resolve/render.ts
 import { createHash as createHash7 } from "crypto";
-import { readFile as readFile22, mkdtemp as mkdtemp5 } from "fs/promises";
+import { readFile as readFile23, mkdtemp as mkdtemp5 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 async function renderGraphForTarget(graph, targetContext = {}) {
-  const root = await mkdtemp5(join32(tmpdir6(), "agentwheel-render-"));
+  const root = await mkdtemp5(join33(tmpdir6(), "agentwheel-render-"));
   const artifacts = [];
   const stagedNodes = /* @__PURE__ */ new Map();
   const includeEdges = /* @__PURE__ */ new Map();
@@ -7731,7 +7897,8 @@ async function renderGraphForTarget(graph, targetContext = {}) {
     const runtimeSelectedSet = new Set(normalizeArtifactSelectors(rawNode.node.selected) ?? []);
     const runtimeArtifacts = targetContext.adapter ? filterArtifactsByRuntime2(selectedArtifacts, targetContext.adapter.name, runtimeSelectedSet) : selectedArtifacts;
     const codexRenderedArtifacts = await renderCodexSubagents(runtimeArtifacts, staged.root, targetContext.adapter);
-    const runtimeRenderedArtifacts = await renderCopilotArtifacts(codexRenderedArtifacts, staged.root, targetContext.adapter);
+    const openClawRenderedArtifacts = await renderOpenClawSubagents(codexRenderedArtifacts, staged.root, targetContext.adapter);
+    const runtimeRenderedArtifacts = await renderCopilotArtifacts(openClawRenderedArtifacts, staged.root, targetContext.adapter);
     const renderedArtifacts = targetContext.workspaceRoot && targetContext.adapter ? await applyCustomizations(runtimeRenderedArtifacts, {
       workspaceRoot: targetContext.workspaceRoot,
       adapter: targetContext.adapter,
@@ -7778,7 +7945,7 @@ async function artifactContentMap(artifacts) {
   const out = /* @__PURE__ */ new Map();
   for (const artifact of artifacts) {
     if (artifact.kind !== "file") continue;
-    out.set(artifact.relativePath.replaceAll("\\", "/"), await readFile22(artifact.stagedPath ?? artifact.sourcePath, "utf8"));
+    out.set(artifact.relativePath.replaceAll("\\", "/"), await readFile23(artifact.stagedPath ?? artifact.sourcePath, "utf8"));
   }
   return out;
 }
@@ -8041,9 +8208,9 @@ function lockArtifactFor(artifact) {
 }
 
 // src/lifecycle/trust.ts
-import { mkdir as mkdir17, readFile as readFile23 } from "fs/promises";
+import { mkdir as mkdir18, readFile as readFile24 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname23, join as join33 } from "path";
+import { dirname as dirname25, join as join34 } from "path";
 import { z as z8 } from "zod";
 var trustStoreSchema = z8.object({
   version: z8.literal(1),
@@ -8117,14 +8284,14 @@ function sortedUnique4(values) {
 }
 async function readTrustStore(path) {
   if (!await pathExists(path)) return { version: 1, acceptedSources: [] };
-  return trustStoreSchema.parse(JSON.parse(await readFile23(path, "utf8")));
+  return trustStoreSchema.parse(JSON.parse(await readFile24(path, "utf8")));
 }
 async function writeTrustStore(path, store) {
-  await mkdir17(dirname23(path), { recursive: true });
+  await mkdir18(dirname25(path), { recursive: true });
   await writeJsonAtomic(path, trustStoreSchema.parse(store));
 }
 function defaultTrustStorePath() {
-  return process.env.AGENTWHEEL_TRUST_STORE ?? join33(homedir7(), ".agentwheel", "trust.json");
+  return process.env.AGENTWHEEL_TRUST_STORE ?? join34(homedir7(), ".agentwheel", "trust.json");
 }
 
 // src/lifecycle/source-plan.ts
@@ -8162,7 +8329,7 @@ async function createGraphSourcePlan(options) {
   const registryClient = new RegistryClient({ workspaceRoot, offline: lockMode, offlineLabel: lockLabel, warn });
   const graph = await resolveDependencyGraph(options.roots, {
     workspaceRoot,
-    cacheRoot: join34(workspaceRoot, ".agentwheel", "cache"),
+    cacheRoot: join35(workspaceRoot, ".agentwheel", "cache"),
     registryClient,
     noDeps: options.noDeps,
     includeSuggestions: options.includeSuggestions,
@@ -8262,7 +8429,7 @@ async function readExistingGraphLock(path) {
   return readGraphLock(path);
 }
 function pathForGraphLock(workspaceRoot, targetKey, adapter, targetFingerprint) {
-  return join34(workspaceRoot, ".agentwheel", "locks", sanitizePathSegment(targetKey), sanitizePathSegment(adapter), `${targetFingerprint}.graph-lock.json`);
+  return join35(workspaceRoot, ".agentwheel", "locks", sanitizePathSegment(targetKey), sanitizePathSegment(adapter), `${targetFingerprint}.graph-lock.json`);
 }
 function sanitizePathSegment(value) {
   return value.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "default";
@@ -8326,7 +8493,7 @@ ${sources.map((source) => `- ${source}`).join("\n")}`);
 }
 
 // src/runtime/target.ts
-import { basename as basename19, dirname as dirname25, join as join35, resolve as resolve17 } from "path";
+import { basename as basename20, dirname as dirname27, join as join36, resolve as resolve17 } from "path";
 var runtimeMarkers = [
   { adapter: "openclaw", dirs: [".openclaw", ".clawdbot", ".moltbot"] },
   { adapter: "claude", dirs: [".claude"] },
@@ -8437,9 +8604,9 @@ async function detectRuntimeTargets(cwd = process.cwd(), adapterFilter) {
   for (const marker of runtimeMarkers) {
     if (adapterFilter && marker.adapter !== adapterFilter) continue;
     for (const dir of marker.dirs) {
-      if (basename19(root) === dir) {
-        matches.push({ adapter: marker.adapter, targetRoot: dirname25(root) });
-      } else if (await pathExists(join35(root, dir))) {
+      if (basename20(root) === dir) {
+        matches.push({ adapter: marker.adapter, targetRoot: dirname27(root) });
+      } else if (await pathExists(join36(root, dir))) {
         matches.push({ adapter: marker.adapter, targetRoot: root });
       }
     }
@@ -8478,7 +8645,7 @@ function dedupeTargets(matches) {
 function runtimeScanRoot(request) {
   const root = resolve17(request.targetRoot ?? request.cwd ?? process.cwd());
   if (request.targetRoot) return root;
-  return runtimeMarkers.some((marker) => marker.dirs.includes(basename19(root))) ? dirname25(root) : root;
+  return runtimeMarkers.some((marker) => marker.dirs.includes(basename20(root))) ? dirname27(root) : root;
 }
 
 // src/lifecycle/profile.ts
@@ -8762,9 +8929,9 @@ function shellQuoteArg(value) {
 }
 
 // src/cli/update-check.ts
-import { mkdir as mkdir19, readFile as readFile24, writeFile as writeFile17 } from "fs/promises";
+import { mkdir as mkdir20, readFile as readFile25, writeFile as writeFile18 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname26, join as join36 } from "path";
+import { dirname as dirname28, join as join37 } from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 300;
 var REGISTRY_URL = "https://registry.npmjs.org/agentwheel";
@@ -8772,7 +8939,7 @@ async function maybeCheckForUpdate(options) {
   if (isDisabled(options)) return;
   const now = options.now?.() ?? /* @__PURE__ */ new Date();
   const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
-  const cachePath = options.cachePath ?? join36(homedir8(), ".agentwheel", "update-check.json");
+  const cachePath = options.cachePath ?? join37(homedir8(), ".agentwheel", "update-check.json");
   try {
     const cached = await readCache(cachePath);
     if (cached && now.getTime() - Date.parse(cached.checkedAt) < ttlMs) {
@@ -8809,7 +8976,7 @@ async function fetchLatestVersion(fetchImpl, timeoutMs) {
 }
 async function readCache(path) {
   try {
-    const parsed = JSON.parse(await readFile24(path, "utf8"));
+    const parsed = JSON.parse(await readFile25(path, "utf8"));
     if (typeof parsed.checkedAt !== "string" || typeof parsed.latest !== "string") return void 0;
     return { checkedAt: parsed.checkedAt, latest: parsed.latest };
   } catch {
@@ -8817,8 +8984,8 @@ async function readCache(path) {
   }
 }
 async function writeCache(path, cache) {
-  await mkdir19(dirname26(path), { recursive: true });
-  await writeFile17(path, `${JSON.stringify(cache, null, 2)}
+  await mkdir20(dirname28(path), { recursive: true });
+  await writeFile18(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
 function warnIfNewer(latest, current, stderr = process.stderr) {
@@ -8981,13 +9148,13 @@ function isCrossPackageSelector(value) {
 }
 
 // src/model/package-migrate.ts
-import { readFile as readFile25, rename as rename4, writeFile as writeFile18 } from "fs/promises";
-import { join as join38, resolve as resolve19 } from "path";
+import { readFile as readFile26, rename as rename4, writeFile as writeFile19 } from "fs/promises";
+import { join as join39, resolve as resolve19 } from "path";
 import { applyEdits, modify, parse as parse4 } from "jsonc-parser";
 async function migratePackageManifest(root) {
   const packageRoot = resolve19(root);
   for (const name of openPackManifestNames) {
-    const path = join38(packageRoot, name);
+    const path = join39(packageRoot, name);
     if (await pathExists(path)) {
       return { changed: false, to: path, message: `Package already uses ${name}.` };
     }
@@ -8996,18 +9163,18 @@ async function migratePackageManifest(root) {
   if (!legacyName) {
     throw new Error(`No legacy package manifest found at ${packageRoot}`);
   }
-  const from = join38(packageRoot, legacyName);
+  const from = join39(packageRoot, legacyName);
   const toName = legacyName.endsWith(".jsonc") ? "openpack.jsonc" : "openpack.json";
-  const to = join38(packageRoot, toName);
-  const content = await readFile25(from, "utf8");
+  const to = join39(packageRoot, toName);
+  const content = await readFile26(from, "utf8");
   const updated = updateSchemaVersion(content);
   await rename4(from, to);
-  await writeFile18(to, updated, "utf8");
+  await writeFile19(to, updated, "utf8");
   return { changed: true, from, to, message: `Migrated ${legacyName} to ${toName}.` };
 }
 async function firstExistingLegacyManifest(root) {
   for (const name of legacyPackageManifestNames) {
-    if (await pathExists(join38(root, name))) return name;
+    if (await pathExists(join39(root, name))) return name;
   }
   return void 0;
 }
@@ -9025,20 +9192,20 @@ function updateSchemaVersion(content) {
 
 // src/cli/version.ts
 import { readFileSync } from "fs";
-import { dirname as dirname27, join as join39 } from "path";
+import { dirname as dirname29, join as join40 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var FALLBACK_VERSION = "0.0.0";
 function resolveCliVersion() {
-  let dir = dirname27(fileURLToPath2(import.meta.url));
+  let dir = dirname29(fileURLToPath2(import.meta.url));
   while (true) {
     try {
-      const pkg = JSON.parse(readFileSync(join39(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync(join40(dir, "package.json"), "utf8"));
       if (pkg.name === "agentwheel" && typeof pkg.version === "string") {
         return pkg.version;
       }
     } catch {
     }
-    const parent = dirname27(dir);
+    const parent = dirname29(dir);
     if (parent === dir) return FALLBACK_VERSION;
     dir = parent;
   }
@@ -9086,7 +9253,7 @@ program.command("list").description("list artifacts exposed by a package source"
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const selectedArtifacts = selectedArtifactsFromOptionsOrRegistry(options, resolvedInput.registryEntry);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
-  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join40(targetRoot, ".agentwheel", "cache") }))));
+  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join41(targetRoot, ".agentwheel", "cache") }))));
   const artifacts = filterArtifactsBySelection(await driver.list(resolved), selectedArtifacts);
   for (const artifact of artifacts) {
     console.log(`${artifact.type}	${artifact.name}	${artifact.relativePath}`);
@@ -9096,7 +9263,7 @@ program.command("scan").description("scan a package source for validation findin
   const targetRoot = normalizeTargetRoot(options.targetRoot);
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
-  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join40(targetRoot, ".agentwheel", "cache") }))));
+  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join41(targetRoot, ".agentwheel", "cache") }))));
   const result = await driver.scan(resolved);
   if (result.findings.length === 0) {
     console.log("Scan ok: no findings");
@@ -9393,7 +9560,7 @@ async function packageEntryFromSource(source, targetRoot, options) {
   const bundle = await stageSource(driver, resolvedSource, {
     workspaceRoot: targetRoot,
     adapter,
-    cacheRoot: join40(targetRoot, ".agentwheel", "cache"),
+    cacheRoot: join41(targetRoot, ".agentwheel", "cache"),
     mode: options.mode,
     frozenLock: lockMode,
     select: selectedArtifacts
@@ -9751,7 +9918,7 @@ function keepManifestEntryOperation(entry, targetRoot, rootId, operation, option
     artifactType: entry.artifactType,
     artifactName: entry.artifactName,
     kind: entry.kind,
-    destPath: operation?.destPath ?? join40(targetRoot, entry.path),
+    destPath: operation?.destPath ?? join41(targetRoot, entry.path),
     relativeDestPath: entry.path,
     desiredHash: entry.sourceHash,
     currentHash: operation?.currentHash ?? entry.hash,
@@ -10011,12 +10178,12 @@ async function printDoctor(target, options) {
   const requestedSkills = doctorSkillRequests(target, options);
   const skills = [];
   for (const request of requestedSkills) {
-    const skillPath = join40(state.installRoot, targetMapping.dest, request.name);
+    const skillPath = join41(state.installRoot, targetMapping.dest, request.name);
     const exists = await pathExists(skillPath);
     const manifestEntry = manifest?.entries.find((entry) => {
       if (entry.artifactType !== "skills") return false;
       const legacyInstallName = "installName" in entry && typeof entry.installName === "string" ? entry.installName : void 0;
-      return entry.artifactName === request.name || legacyInstallName === request.name || entry.path === join40(targetMapping.dest, request.name);
+      return entry.artifactName === request.name || legacyInstallName === request.name || entry.path === join41(targetMapping.dest, request.name);
     });
     const status = manifestEntry ? "managed" : exists ? "present-unmanaged" : "missing";
     skills.push({
@@ -10096,7 +10263,7 @@ function doctorSkillLabel(name) {
   return `${name} skill`;
 }
 function isSyncwheelWorkspace(targetRoot) {
-  return existsSync(join40(targetRoot, ".syncwheel", "manifest.json"));
+  return existsSync(join41(targetRoot, ".syncwheel", "manifest.json"));
 }
 function skillInstallCommand(adapter, installationType, options, skill, behavior = {}) {
   const args = [
@@ -10238,10 +10405,10 @@ function filterUninstallPlanBySelection(plan, selected) {
   };
 }
 async function initPackage(root) {
-  await mkdir20(join40(root, "instructions"), { recursive: true });
-  await mkdir20(join40(root, "rules"), { recursive: true });
-  await mkdir20(join40(root, "skills"), { recursive: true });
-  const manifestPath = join40(root, "openpack.json");
+  await mkdir21(join41(root, "instructions"), { recursive: true });
+  await mkdir21(join41(root, "rules"), { recursive: true });
+  await mkdir21(join41(root, "skills"), { recursive: true });
+  const manifestPath = join41(root, "openpack.json");
   const manifest = {
     schemaVersion: 2,
     name: "example/agentwheel-package",
@@ -10252,12 +10419,12 @@ async function initPackage(root) {
       { type: "skills", path: "skills" }
     ]
   };
-  await writeFile19(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await writeFile20(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  await writeFile19(join40(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
+  await writeFile20(join41(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
 }
 async function defaultBootstrapPackage(_root) {
-  const packageRoot = await findAgentwheelPackageRoot(dirname28(fileURLToPath3(import.meta.url)));
+  const packageRoot = await findAgentwheelPackageRoot(dirname30(fileURLToPath3(import.meta.url)));
   if (!packageRoot) return void 0;
   return {
     name: "agentwheel",
@@ -10304,7 +10471,7 @@ async function findAgentwheelPackageRoot(start) {
   let current = resolve20(start);
   while (true) {
     if (await findPackageManifestPath(current, { warnLegacy: false })) return current;
-    const parent = dirname28(current);
+    const parent = dirname30(current);
     if (parent === current) return void 0;
     current = parent;
   }