agentwheel 0.6.0 → 0.7.0

package/README.md

@@ -33,10 +33,10 @@ No lock-in. No central gatekeeper. Your packages live in plain git repos, your c
 
 ---
 
-> **Status: early (v0.6).** The lifecycle core is real and tested — local/git/skillkit/vercel
+> **Status: early (v0.7).** The lifecycle core is real and tested — local/git/skillkit/vercel
 > sources, optional registry discovery, plan/sync/update/drift/uninstall, overlays, eject/remember,
 > profiles, runtime auto-detection, fleet targeting, asset-includes, selective installs,
-> update notifications, rich JSON merge, and pluggable adapters.
+> update notifications, full Claude/Codex adapters, rich JSON/TOML merge, and pluggable adapters.
 > Expect sharp edges.
 
 ## What it does
@@ -260,6 +260,20 @@ agentwheel sync ./my-pack --adapter-config ./myco-internal.jsonc
 Built-in adapters ship for common runtimes; declarative adapters need no code and stay private.
 Programmatic adapters, for private runtime logic beyond file placement, require explicit `--allow-adapter-code`.
 
+Built-in runtime targets:
+
+| Runtime | Main targets |
+|---|---|
+| **OpenClaw** | `.openclaw/AGENTS.md`, `.openclaw/skills`, `.openclaw/rules`, `.openclaw/commands`, MCP/hooks/settings, semantic plugin planning |
+| **Claude Code** | `.claude/CLAUDE.md`, `.claude/skills`, `.claude/commands`, `.claude/agents`, `.claude/rules`, `.claude/.mcp.json`, `.claude/settings.json` |
+| **Codex CLI** | `.codex/AGENTS.md`, `.codex/skills`, `.codex/commands`, `.codex/agents`, `.codex/rules`, `.codex/config.toml`, `.codex/hooks.json` |
+| **Hermes** | `.hermes/AGENTS.md`, `.hermes/skills`, `.hermes/rules`, `.hermes/commands`, MCP/hooks/settings |
+| **GitHub Copilot** | `.github/copilot-instructions.md`, `.github/instructions`, `.github/prompts` |
+
+Claude MCP and hooks/settings are merged as JSON. Codex MCP entries are merged into
+`[mcp_servers]` in `.codex/config.toml` without deleting unrelated user config; hooks use
+`.codex/hooks.json`.
+
 Copilot support is intentionally file-drop only: instructions, rules, and prompt/command files are
 placed in GitHub-native locations, while raw `SKILL.md` directories stay disabled until there is a
 clear conversion format.
@@ -272,6 +286,7 @@ clear conversion format.
 - [x] **v0.4** — runtime auto-detection; no `--target-root` needed for normal use; fleet config with named agents; global + project config merge; `--agent` and `--all`.
 - [x] **v0.5** — asset-includes compose shared files into skills at install time; executable bits preserved; hashes include composed assets.
 - [x] **v0.6** — selective installs with `--select`/`--skill`; required artifacts; cached npm update notifier.
+- [x] **v0.7** — full Claude/Codex adapters; Codex TOML MCP merge; subagent enumeration; `--skill` selector fix.
 
 ## Design docs
 

package/dist/index.js

@@ -8,7 +8,7 @@ import {
 } from "./chunk-N2LZY7LO.js";
 
 // src/cli/index.ts
-import { mkdir as mkdir8, rm as rm8, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir9, rm as rm8, writeFile as writeFile6 } from "fs/promises";
 import { join as join20 } from "path";
 import { Command } from "commander";
 
@@ -59,7 +59,7 @@ var targetMappingSchema = z2.object({
   dest: z2.string().min(1),
   enabled: z2.boolean().default(true),
   semantic: z2.enum(["openclaw-plugin"]).optional(),
-  merge: z2.enum(["json-deep"]).optional()
+  merge: z2.enum(["json-deep", "codex-toml-mcp"]).optional()
 });
 var adapterSchema = z2.object({
   name: z2.string().min(1),
@@ -86,8 +86,17 @@ async function loadAdapterConfig(path) {
 // src/adapters/claude.ts
 var claudeAdapter = {
   name: "claude",
-  displayName: "Claude",
-  targets: {}
+  displayName: "Claude Code",
+  targets: {
+    instructions: { enabled: true, dest: ".claude/CLAUDE.md" },
+    rules: { enabled: true, dest: ".claude/rules" },
+    skills: { enabled: true, dest: ".claude/skills" },
+    commands: { enabled: true, dest: ".claude/commands" },
+    subagents: { enabled: true, dest: ".claude/agents" },
+    mcp: { enabled: true, dest: ".claude/.mcp.json", merge: "json-deep" },
+    hooks: { enabled: true, dest: ".claude/settings.json", merge: "json-deep" },
+    settings: { enabled: true, dest: ".claude/settings.json", merge: "json-deep" }
+  }
 };
 
 // src/adapters/copilot.ts
@@ -107,8 +116,17 @@ var copilotAdapter = {
 // src/adapters/codex.ts
 var codexAdapter = {
   name: "codex",
-  displayName: "Codex",
-  targets: {}
+  displayName: "Codex CLI",
+  targets: {
+    instructions: { enabled: true, dest: ".codex/AGENTS.md" },
+    rules: { enabled: true, dest: ".codex/rules" },
+    skills: { enabled: true, dest: ".codex/skills" },
+    commands: { enabled: true, dest: ".codex/commands" },
+    subagents: { enabled: true, dest: ".codex/agents" },
+    mcp: { enabled: true, dest: ".codex/config.toml", merge: "codex-toml-mcp" },
+    hooks: { enabled: true, dest: ".codex/hooks.json", merge: "json-deep" },
+    settings: { enabled: true, dest: ".codex/settings.json", merge: "json-deep" }
+  }
 };
 
 // src/adapters/hermes.ts
@@ -282,7 +300,7 @@ var manifestEntrySchema = z3.object({
   packageName: z3.string().min(1).optional(),
   semanticCommand: z3.array(z3.string()).optional(),
   executed: z3.boolean().optional(),
-  mergeStrategy: z3.enum(["json-deep"]).optional()
+  mergeStrategy: z3.enum(["json-deep", "codex-toml-mcp"]).optional()
 });
 var installManifestSchema = z3.object({
   version: z3.literal(1),
@@ -355,6 +373,94 @@ function normalizeTargetRoot(path) {
   return resolve3(path);
 }
 
+// src/install/toml-merge.ts
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function mergeCodexTomlMcp(sourcePath, destPath) {
+  const source = JSON.parse(await readFile5(sourcePath, "utf8"));
+  const servers = extractMcpServers(source);
+  const current = await pathExists(destPath) ? await readFile5(destPath, "utf8") : "";
+  const withoutManaged = removeManagedMcpSections(current, Object.keys(servers));
+  const merged = appendMcpServers(withoutManaged, servers);
+  await mkdir2(dirname2(destPath), { recursive: true });
+  await writeFile3(destPath, merged, "utf8");
+}
+function extractMcpServers(source) {
+  const raw = isRecord2(source.mcpServers) ? source.mcpServers : source;
+  const servers = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (!isRecord2(value)) continue;
+    servers[name] = value;
+  }
+  if (Object.keys(servers).length === 0) {
+    throw new Error("Codex MCP TOML merge needs a JSON object with mcpServers");
+  }
+  return servers;
+}
+function removeManagedMcpSections(content, serverNames) {
+  if (serverNames.length === 0 || content.trim() === "") return content;
+  const names = new Set(serverNames);
+  const lines = content.split(/\r?\n/);
+  const kept = [];
+  let skipping = false;
+  for (const line of lines) {
+    const section = line.match(/^\s*\[([^\]]+)]\s*$/)?.[1];
+    if (section) {
+      const match = section.match(/^mcp_servers\.([^.\]]+)(?:\.|$)/);
+      skipping = match ? names.has(unquoteTomlKey(match[1] ?? "")) : false;
+    }
+    if (!skipping) kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}$/g, "\n\n");
+}
+function appendMcpServers(content, servers) {
+  const blocks = Object.entries(servers).sort(([a], [b]) => a.localeCompare(b)).map(([name, server]) => formatMcpServer(name, server));
+  const prefix = content.trimEnd();
+  return `${prefix ? `${prefix}
+
+` : ""}${blocks.join("\n\n")}
+`;
+}
+function formatMcpServer(name, server) {
+  const env = isRecord2(server.env) ? server.env : void 0;
+  const lines = [`[mcp_servers.${quoteTomlKey(name)}]`];
+  for (const [key, value] of Object.entries(server)) {
+    if (key === "env" || value === void 0) continue;
+    lines.push(`${quoteTomlKey(key)} = ${formatTomlValue(value)}`);
+  }
+  if (env && Object.keys(env).length > 0) {
+    lines.push("", `[mcp_servers.${quoteTomlKey(name)}.env]`);
+    for (const [key, value] of Object.entries(env)) {
+      lines.push(`${quoteTomlKey(key)} = ${formatTomlValue(value)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatTomlValue(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.map(formatTomlValue).join(", ")}]`;
+  if (isRecord2(value)) {
+    const entries = Object.entries(value).map(([key, child]) => `${quoteTomlKey(key)} = ${formatTomlValue(child)}`);
+    return `{ ${entries.join(", ")} }`;
+  }
+  return '""';
+}
+function quoteTomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+function unquoteTomlKey(key) {
+  if (!key.startsWith('"')) return key;
+  try {
+    return JSON.parse(key);
+  } catch {
+    return key;
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/install/apply.ts
 var execFileAsync = promisify(execFile);
 async function applyInstallPlan(plan, sourceLock, options = {}) {
@@ -420,6 +526,8 @@ async function applyInstallPlan(plan, sourceLock, options = {}) {
       }
       if (operation.mergeStrategy === "json-deep") {
         await mergeJsonFile(operation.sourcePath, operation.destPath);
+      } else if (operation.mergeStrategy === "codex-toml-mcp") {
+        await mergeCodexTomlMcp(operation.sourcePath, operation.destPath);
       } else {
         await atomicCopy(operation.sourcePath, operation.destPath, operation.kind);
       }
@@ -445,7 +553,7 @@ async function applyInstallPlan(plan, sourceLock, options = {}) {
         artifactType: operation.artifactType,
         artifactName: operation.artifactName,
         kind: operation.kind,
-        hash: operation.mergeStrategy === "json-deep" && operation.currentHash ? operation.currentHash : operation.desiredHash,
+        hash: operation.mergeStrategy && operation.currentHash ? operation.currentHash : operation.desiredHash,
         sourceHash: operation.desiredHash,
         updatedAt: now,
         channel: operation.channel,
@@ -574,7 +682,7 @@ async function createInstallPlan(bundle, adapter, targetRoot, manifest) {
       }
       continue;
     }
-    if (op.mergeStrategy === "json-deep") {
+    if (op.mergeStrategy) {
       const existing2 = manifestByPath.get(op.relativeDestPath);
       const exists2 = await pathExists(op.destPath);
       if (!exists2) {
@@ -682,7 +790,7 @@ function operationForArtifact(artifact, adapter, targetRoot) {
       semanticCommand: openClawPluginInstallCommand({ path: sourcePath, dryRun: true })
     };
   }
-  const destPath = artifact.type === "instructions" || artifact.type === "settings" ? join3(targetRoot, target.dest) : join3(targetRoot, target.dest, artifact.name);
+  const destPath = artifact.type === "instructions" || artifact.type === "settings" || isFileTarget(target.dest) ? join3(targetRoot, target.dest) : join3(targetRoot, target.dest, artifact.name);
   return {
     action: "create",
     artifactType: artifact.type,
@@ -698,6 +806,9 @@ function operationForArtifact(artifact, adapter, targetRoot) {
     mergeStrategy: target.merge
   };
 }
+function isFileTarget(dest) {
+  return /\.(json|jsonc|toml|md)$/i.test(dest);
+}
 function summarizePlan(plan) {
   const summary = {
     create: 0,
@@ -805,13 +916,13 @@ function formatPlan(plan) {
 
 // src/source/git.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdir as mkdir2, rm as rm3 } from "fs/promises";
+import { mkdir as mkdir3, rm as rm3 } from "fs/promises";
 import { homedir } from "os";
 import { basename as basename2, join as join7, resolve as resolve5 } from "path";
 import { promisify as promisify2 } from "util";
 
 // src/model/package.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { join as join5 } from "path";
 import { parse as parse2, printParseErrorCode as printParseErrorCode2 } from "jsonc-parser";
 import { z as z4 } from "zod";
@@ -837,7 +948,7 @@ async function findPackageManifestPath(root) {
 async function readPackageManifest(root) {
   const path = await findPackageManifestPath(root);
   if (!path) return void 0;
-  const content = await readFile5(path, "utf8");
+  const content = await readFile6(path, "utf8");
   const errors = [];
   const parsed = parse2(content, errors, { allowTrailingComma: true, disallowComments: false });
   if (errors.length > 0) {
@@ -939,7 +1050,7 @@ var LocalSourceDriver = class {
         }
       }
     }
-    for (const type of ["commands", "mcp", "hooks", "settings", "plugins"]) {
+    for (const type of ["commands", "subagents", "mcp", "hooks", "settings", "plugins"]) {
       const dir = join6(root, type);
       if (!await pathExists(dir)) continue;
       artifacts.push(...await listGenericArtifacts(type, dir, type, resolved.packageName));
@@ -995,9 +1106,7 @@ async function listFromManifest(root, packageName) {
     if (stats.isDirectory()) {
       for (const entry of await sortedDirEntries(full)) {
         const child = join6(full, entry.name);
-        if (provide.type === "skills" && entry.isDirectory()) {
-          artifacts.push(await artifactForDir(provide.type, entry.name, child, join6(provide.path, entry.name), packageName, provide.assets, provide.required));
-        } else if (provide.type === "plugins" && entry.isDirectory()) {
+        if ((provide.type === "skills" || provide.type === "plugins" || provide.type === "subagents") && entry.isDirectory()) {
           artifacts.push(await artifactForDir(provide.type, entry.name, child, join6(provide.path, entry.name), packageName, provide.assets, provide.required));
         } else if (entry.isFile()) {
           const name = provide.type === "rules" && entry.name.endsWith(".md") ? entry.name : entry.name;
@@ -1070,7 +1179,7 @@ var GitSourceDriver = class {
   }
   async fetch(resolved) {
     const parsed = parseGitSource(resolved.source);
-    await mkdir2(resolve5(resolved.resolvedPath, ".."), { recursive: true });
+    await mkdir3(resolve5(resolved.resolvedPath, ".."), { recursive: true });
     if (!await pathExists(join7(resolved.resolvedPath, ".git"))) {
       await rm3(resolved.resolvedPath, { recursive: true, force: true });
       await git(["clone", "--no-tags", parsed.url, resolved.resolvedPath]);
@@ -1141,14 +1250,14 @@ async function git(args) {
 }
 
 // src/source/skillkit.ts
-import { cp, mkdir as mkdir3, readFile as readFile6, rm as rm4 } from "fs/promises";
+import { cp, mkdir as mkdir4, readFile as readFile7, rm as rm4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename4, dirname as dirname3, join as join9, resolve as resolve6 } from "path";
+import { basename as basename4, dirname as dirname4, join as join9, resolve as resolve6 } from "path";
 import * as defaultSkillKit from "@skillkit/core";
 
 // src/source/skill-artifacts.ts
 import { readdir as readdir2, stat as stat3 } from "fs/promises";
-import { basename as basename3, dirname as dirname2, extname as extname2, join as join8 } from "path";
+import { basename as basename3, dirname as dirname3, extname as extname2, join as join8 } from "path";
 async function artifactsFromSkillPaths(paths, packageName) {
   const artifacts = [];
   const seen = /* @__PURE__ */ new Set();
@@ -1185,7 +1294,7 @@ async function artifactFromSkillPath(item, packageName) {
     };
   }
   if (stats.isFile() && basename3(item.path).toLowerCase() === "skill.md") {
-    const dir = dirname2(item.path);
+    const dir = dirname3(item.path);
     const name = sanitizeSkillName(item.name ?? basename3(dir));
     return {
       type: "skills",
@@ -1268,7 +1377,7 @@ var SkillKitSourceDriver = class {
     if (!provider?.clone) {
       throw new Error("SkillKit provider API unavailable or cannot resolve source. Expected @skillkit/core detectProvider().clone().");
     }
-    await mkdir3(dirname3(resolved.resolvedPath), { recursive: true });
+    await mkdir4(dirname4(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"}`);
@@ -1314,7 +1423,7 @@ var SkillKitSourceDriver = class {
     for (const skill of this.discover(resolved.resolvedPath)) {
       const skillMd = join9(skill.path, "SKILL.md");
       if (await pathExists(skillMd)) {
-        this.core.translateSkill(await readFile6(skillMd, "utf8"), "openclaw", { sourceFilename: "SKILL.md" });
+        this.core.translateSkill(await readFile7(skillMd, "utf8"), "openclaw", { sourceFilename: "SKILL.md" });
       }
     }
     return resolved;
@@ -1482,13 +1591,13 @@ function getSourceDriver(name = "local") {
 }
 
 // src/staging/staging.ts
-import { chmod, cp as cp3, mkdir as mkdir5, mkdtemp, readdir as readdir4, stat as stat6 } from "fs/promises";
-import { basename as basename7, dirname as dirname5, join as join12, relative as relative2, resolve as resolve8, sep } from "path";
+import { chmod, cp as cp3, mkdir as mkdir6, mkdtemp, readdir as readdir4, stat as stat6 } from "fs/promises";
+import { basename as basename7, dirname as dirname6, join as join12, relative as relative2, resolve as resolve8, sep } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // src/staging/customize.ts
-import { cp as cp2, mkdir as mkdir4, readdir as readdir3, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname4, join as join11 } from "path";
+import { cp as cp2, mkdir as mkdir5, readdir as readdir3, readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname5, join as join11 } from "path";
 async function applyCustomizations(artifacts, options) {
   let next = [...artifacts];
   next = await applyReplacements(next, options, "override");
@@ -1503,11 +1612,11 @@ async function applyInstructionOverlay(artifacts, options) {
   const index = artifacts.findIndex((artifact2) => artifact2.type === "instructions");
   if (index < 0) return artifacts;
   const artifact = artifacts[index];
-  const managed = await readFile7(artifact.stagedPath ?? artifact.sourcePath, "utf8");
-  const local = await readFile7(overlayPath, "utf8");
+  const managed = await readFile8(artifact.stagedPath ?? artifact.sourcePath, "utf8");
+  const local = await readFile8(overlayPath, "utf8");
   const composedPath = join11(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
-  await mkdir4(dirname4(composedPath), { recursive: true });
-  await writeFile3(
+  await mkdir5(dirname5(composedPath), { recursive: true });
+  await writeFile4(
     composedPath,
     [
       "<!-- BEGIN agentwheel managed: upstream -->",
@@ -1568,7 +1677,7 @@ async function applyReplacements(artifacts, options, channel) {
       const kind = entry.isDirectory() ? "dir" : "file";
       const existing = byKey.get(`${type}:${entry.name}`);
       const stagedPath = join11(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
-      await mkdir4(dirname4(stagedPath), { recursive: true });
+      await mkdir5(dirname5(stagedPath), { recursive: true });
       await cp2(full, stagedPath, { recursive: kind === "dir", dereference: true });
       byKey.set(`${type}:${entry.name}`, {
         type,
@@ -1640,7 +1749,7 @@ async function stageSource(driver, source, options = {}) {
   const stagedArtifacts = [];
   for (const artifact of artifacts) {
     const stagedPath = join12(root, artifact.relativePath);
-    await mkdir5(dirname5(stagedPath), { recursive: true });
+    await mkdir6(dirname6(stagedPath), { recursive: true });
     await cp3(artifact.sourcePath, stagedPath, { recursive: artifact.kind === "dir", dereference: true });
     await composeAssets(artifact, resolved.resolvedPath, stagedPath);
     stagedArtifacts.push({
@@ -1699,7 +1808,7 @@ async function copyAsset(asset, source, dest) {
   const sourceStats = await stat6(source);
   if (sourceStats.isFile()) {
     if (matchesAny(basename7(source), asset.include)) {
-      await mkdir5(dest, { recursive: true });
+      await mkdir6(dest, { recursive: true });
       await copyAssetFile(source, join12(dest, basename7(source)), asset);
     }
     return;
@@ -1708,7 +1817,7 @@ async function copyAsset(asset, source, dest) {
     throw new Error(`Asset include source is not a file or directory: ${source}`);
   }
   if (!asset.include?.length) {
-    await mkdir5(dirname5(dest), { recursive: true });
+    await mkdir6(dirname6(dest), { recursive: true });
     await cp3(source, dest, { recursive: true, dereference: true });
     if (asset.mode === "copy") await normalizeCopiedModes(dest);
     return;
@@ -1720,7 +1829,7 @@ async function copyAsset(asset, source, dest) {
   }
 }
 async function copyAssetFile(source, dest, asset) {
-  await mkdir5(dirname5(dest), { recursive: true });
+  await mkdir6(dirname6(dest), { recursive: true });
   await cp3(source, dest, { dereference: true });
   if (asset.mode === "copy") await chmod(dest, 420);
 }
@@ -1768,9 +1877,9 @@ function matchesGlob(path, pattern) {
 }
 
 // src/model/workspace.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname6, join as join13, resolve as resolve9 } from "path";
+import { dirname as dirname7, join as join13, resolve as resolve9 } from "path";
 import { z as z5 } from "zod";
 var workspacePackageSchema = z5.object({
   name: z5.string().min(1),
@@ -1817,7 +1926,7 @@ function workspaceConfigPath(workspaceRoot) {
 async function readWorkspaceConfig(workspaceRoot) {
   const path = workspaceConfigPath(workspaceRoot);
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile8(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile9(path, "utf8")));
 }
 async function writeWorkspaceConfig(workspaceRoot, config) {
   await writeJsonAtomic(workspaceConfigPath(workspaceRoot), workspaceConfigSchema.parse(config));
@@ -1835,7 +1944,7 @@ async function findWorkspaceRoot(start = process.cwd()) {
   let current = resolve9(start);
   while (true) {
     if (await pathExists(workspaceConfigPath(current))) return current;
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current) return resolve9(start);
     current = parent;
   }
@@ -1869,15 +1978,15 @@ function emptyWorkspaceConfig() {
 }
 async function readConfigPath(path) {
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile8(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile9(path, "utf8")));
 }
 
 // src/lifecycle/customization.ts
-import { appendFile, cp as cp4, mkdir as mkdir6, rm as rm5 } from "fs/promises";
-import { dirname as dirname7, join as join14 } from "path";
+import { appendFile, cp as cp4, mkdir as mkdir7, rm as rm5 } from "fs/promises";
+import { dirname as dirname8, join as join14 } from "path";
 async function remember(workspaceRoot, runtime, text) {
   const overlayPath = join14(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
-  await mkdir6(dirname7(overlayPath), { recursive: true });
+  await mkdir7(dirname8(overlayPath), { recursive: true });
   await appendFile(overlayPath, `${text.trim()}
 `, "utf8");
   return { overlayPath };
@@ -1902,7 +2011,7 @@ async function ejectArtifact(workspaceRoot, item) {
       throw new Error(`Artifact not found: ${item}`);
     }
     const ejectedPath = join14(workspaceRoot, ".agentwheel", "ejected", ...parsed.packageName.split("/"), parsed.type, parsed.name);
-    await mkdir6(dirname7(ejectedPath), { recursive: true });
+    await mkdir7(dirname8(ejectedPath), { recursive: true });
     await rm5(ejectedPath, { recursive: true, force: true });
     await cp4(artifact.stagedPath ?? artifact.sourcePath, ejectedPath, { recursive: artifact.kind === "dir", dereference: true });
     return { ...parsed, ejectedPath };
@@ -1926,9 +2035,9 @@ import { rm as rm7 } from "fs/promises";
 import { join as join16 } from "path";
 
 // src/registry/client.ts
-import { readFile as readFile9, rm as rm6, stat as stat7 } from "fs/promises";
+import { readFile as readFile10, rm as rm6, stat as stat7 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname8, join as join15, resolve as resolve10 } from "path";
+import { dirname as dirname9, join as join15, resolve as resolve10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/model/registry.ts
@@ -2014,7 +2123,7 @@ var RegistryClient = class {
   }
   async readCache() {
     if (!await pathExists(this.cachePath)) return void 0;
-    return registryCacheSchema.parse(JSON.parse(await readFile9(this.cachePath, "utf8")));
+    return registryCacheSchema.parse(JSON.parse(await readFile10(this.cachePath, "utf8")));
   }
   isExpired(cache, ttlMs) {
     return this.now().getTime() - new Date(cache.fetchedAt).getTime() > ttlMs;
@@ -2033,10 +2142,10 @@ var RegistryClient = class {
     if (await pathExists(filePath)) {
       const fullPath = resolve10(filePath);
       const stats = await stat7(fullPath);
-      return readFile9(stats.isDirectory() ? join15(fullPath, "index.json") : fullPath, "utf8");
+      return readFile10(stats.isDirectory() ? join15(fullPath, "index.json") : fullPath, "utf8");
     }
-    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join15(dirname8(this.cachePath), "registry-repos") }));
-    return readFile9(join15(resolved.resolvedPath, "index.json"), "utf8");
+    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join15(dirname9(this.cachePath), "registry-repos") }));
+    return readFile10(join15(resolved.resolvedPath, "index.json"), "utf8");
   }
 };
 async function resolvePackageSource(source, workspaceRoot) {
@@ -2172,7 +2281,7 @@ function shouldUpdatePackage(pkg, lock) {
 }
 
 // src/runtime/target.ts
-import { basename as basename8, dirname as dirname9, join as join18, resolve as resolve11 } from "path";
+import { basename as basename8, dirname as dirname10, join as join18, resolve as resolve11 } from "path";
 var runtimeMarkers = [
   { adapter: "openclaw", dirs: [".openclaw", ".clawdbot", ".moltbot"] },
   { adapter: "claude", dirs: [".claude"] },
@@ -2226,7 +2335,7 @@ async function detectRuntimeTarget(cwd = process.cwd(), adapterFilter) {
     if (adapterFilter && marker.adapter !== adapterFilter) continue;
     for (const dir of marker.dirs) {
       if (basename8(root) === dir) {
-        matches.push({ adapter: marker.adapter, targetRoot: dirname9(root) });
+        matches.push({ adapter: marker.adapter, targetRoot: dirname10(root) });
       } else if (await pathExists(join18(root, dir))) {
         matches.push({ adapter: marker.adapter, targetRoot: root });
       }
@@ -2260,9 +2369,9 @@ function dedupeTargets(matches) {
 }
 
 // src/cli/update-check.ts
-import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile5 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname10, join as join19 } from "path";
+import { dirname as dirname11, join as join19 } from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 300;
 var REGISTRY_URL = "https://registry.npmjs.org/agentwheel";
@@ -2306,7 +2415,7 @@ async function fetchLatestVersion(fetchImpl, timeoutMs) {
 }
 async function readCache(path) {
   try {
-    const parsed = JSON.parse(await readFile10(path, "utf8"));
+    const parsed = JSON.parse(await readFile11(path, "utf8"));
     if (typeof parsed.checkedAt !== "string" || typeof parsed.latest !== "string") return void 0;
     return { checkedAt: parsed.checkedAt, latest: parsed.latest };
   } catch {
@@ -2314,8 +2423,8 @@ async function readCache(path) {
   }
 }
 async function writeCache(path, cache) {
-  await mkdir7(dirname10(path), { recursive: true });
-  await writeFile4(path, `${JSON.stringify(cache, null, 2)}
+  await mkdir8(dirname11(path), { recursive: true });
+  await writeFile5(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
 function warnIfNewer(latest, current, stderr = process.stderr) {
@@ -2338,7 +2447,7 @@ function normalizeVersion(version) {
 
 // src/cli/index.ts
 var program = new Command();
-program.name("agentwheel").description("Multi-runtime agent artifact orchestrator").version("0.6.0").option("--no-update-check", "disable npm version update check", false);
+program.name("agentwheel").description("Multi-runtime agent artifact orchestrator").version("0.7.0").option("--no-update-check", "disable npm version update check", false);
 program.command("init").argument("[kind]", "workspace or package", "workspace").option("--target-root <path>", "workspace root", process.cwd()).action(async (kind, options) => {
   const root = normalizeTargetRoot(options.targetRoot);
   if (kind === "package") {
@@ -2528,8 +2637,7 @@ async function buildPlan(source, target, options) {
     adapter,
     driver: options.driver,
     mode: options.mode,
-    select: options.select ?? selectedArtifactsFromOptions(options),
-    skills: options.skills
+    select: selectedArtifactsFromOptions(options)
   });
   return { plan: result.plan, bundle: result.bundle };
 }
@@ -2624,9 +2732,9 @@ function filterUninstallPlanBySelection(plan, selected) {
   };
 }
 async function initPackage(root) {
-  await mkdir8(join20(root, "instructions"), { recursive: true });
-  await mkdir8(join20(root, "rules"), { recursive: true });
-  await mkdir8(join20(root, "skills"), { recursive: true });
+  await mkdir9(join20(root, "instructions"), { recursive: true });
+  await mkdir9(join20(root, "rules"), { recursive: true });
+  await mkdir9(join20(root, "skills"), { recursive: true });
   const manifestPath = join20(root, "agentwheel.json");
   const manifest = {
     schemaVersion: 1,
@@ -2638,9 +2746,9 @@ async function initPackage(root) {
       { type: "skills", path: "skills" }
     ]
   };
-  await writeFile5(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await writeFile6(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  await writeFile5(join20(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
+  await writeFile6(join20(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
 }
 function formatUninstallResult(result) {
   const removedLabel = result.removed === 1 ? "managed file" : "managed files";
@@ -2660,7 +2768,7 @@ function printRegistryEntries(entries) {
 }
 async function main() {
   await maybeCheckForUpdate({
-    currentVersion: "0.6.0",
+    currentVersion: "0.7.0",
     argv: process.argv,
     env: process.env,
     isTTY: process.stderr.isTTY === true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",