agentwheel 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,10 +1,80 @@
 #!/usr/bin/env node
+import {
+  atomicCopy,
+  hashPath,
+  inferSourceDriverName,
+  pathExists,
+  writeJsonAtomic
+} from "./chunk-N2LZY7LO.js";
 
 // src/cli/index.ts
-import { mkdir as mkdir6, rm as rm6, writeFile as writeFile3 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir7, rm as rm8, writeFile as writeFile4 } from "fs/promises";
+import { join as join17 } from "path";
 import { Command } from "commander";
 
+// src/adapters/resolve.ts
+import { resolve as resolve2 } from "path";
+
+// src/model/adapter.ts
+import { readFile } from "fs/promises";
+import { parse, printParseErrorCode } from "jsonc-parser";
+import { z as z2 } from "zod";
+
+// src/model/artifact.ts
+import { z } from "zod";
+var artifactTypeSchema = z.enum([
+  "instructions",
+  "rules",
+  "skills",
+  "commands",
+  "subagents",
+  "mcp",
+  "hooks",
+  "settings",
+  "plugins"
+]);
+var fileKindSchema = z.enum(["file", "dir"]);
+var artifactSchema = z.object({
+  type: artifactTypeSchema,
+  name: z.string().min(1),
+  sourcePath: z.string().min(1),
+  stagedPath: z.string().min(1).optional(),
+  relativePath: z.string().min(1),
+  kind: fileKindSchema,
+  hash: z.string().min(16),
+  packageName: z.string().min(1).optional(),
+  channel: z.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed")
+});
+
+// src/model/adapter.ts
+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()
+});
+var adapterSchema = z2.object({
+  name: z2.string().min(1),
+  displayName: z2.string().min(1).optional(),
+  targets: z2.partialRecord(
+    artifactTypeSchema,
+    targetMappingSchema
+  ).default({})
+});
+async function loadAdapterConfig(path) {
+  const content = await readFile(path, "utf8");
+  const errors = [];
+  const parsed = parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
+    throw new Error(`Invalid adapter config ${path}: ${details}`);
+  }
+  return adapterSchema.parse(parsed);
+}
+
 // src/adapters/claude.ts
 var claudeAdapter = {
   name: "claude",
@@ -42,8 +112,9 @@ var hermesAdapter = {
     rules: { enabled: true, dest: ".hermes/rules" },
     skills: { enabled: true, dest: ".hermes/skills" },
     commands: { enabled: true, dest: ".hermes/commands" },
-    mcp: { enabled: true, dest: ".hermes/mcp" },
-    hooks: { enabled: true, dest: ".hermes/hooks" }
+    mcp: { enabled: true, dest: ".hermes/mcp", merge: "json-deep" },
+    hooks: { enabled: true, dest: ".hermes/hooks", merge: "json-deep" },
+    settings: { enabled: true, dest: ".hermes/settings.json", merge: "json-deep" }
   }
 };
 
@@ -56,8 +127,9 @@ var openClawAdapter = {
     rules: { enabled: true, dest: ".openclaw/rules" },
     skills: { enabled: true, dest: ".openclaw/skills" },
     commands: { enabled: true, dest: ".openclaw/commands" },
-    mcp: { enabled: true, dest: ".openclaw/mcp" },
-    hooks: { enabled: true, dest: ".openclaw/hooks" },
+    mcp: { enabled: true, dest: ".openclaw/mcp", merge: "json-deep" },
+    hooks: { enabled: true, dest: ".openclaw/hooks", merge: "json-deep" },
+    settings: { enabled: true, dest: ".openclaw/settings.json", merge: "json-deep" },
     plugins: { enabled: true, dest: ".openclaw/plugins", semantic: "openclaw-plugin" }
   }
 };
@@ -72,148 +144,121 @@ function getAdapter(name) {
   return adapter;
 }
 
-// src/model/adapter.ts
-import { readFile } from "fs/promises";
-import { parse, printParseErrorCode } from "jsonc-parser";
-import { z as z2 } from "zod";
-
-// src/model/artifact.ts
-import { z } from "zod";
-var artifactTypeSchema = z.enum([
-  "instructions",
-  "rules",
-  "skills",
-  "commands",
-  "subagents",
-  "mcp",
-  "hooks",
-  "plugins"
-]);
-var fileKindSchema = z.enum(["file", "dir"]);
-var artifactSchema = z.object({
-  type: artifactTypeSchema,
-  name: z.string().min(1),
-  sourcePath: z.string().min(1),
-  stagedPath: z.string().min(1).optional(),
-  relativePath: z.string().min(1),
-  kind: fileKindSchema,
-  hash: z.string().min(16),
-  packageName: z.string().min(1).optional(),
-  channel: z.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed")
-});
-
-// src/model/adapter.ts
-var targetMappingSchema = z2.object({
-  dest: z2.string().min(1),
-  enabled: z2.boolean().default(true),
-  semantic: z2.enum(["openclaw-plugin"]).optional()
-});
-var adapterSchema = z2.object({
-  name: z2.string().min(1),
-  displayName: z2.string().min(1).optional(),
-  targets: z2.partialRecord(
-    artifactTypeSchema,
-    targetMappingSchema
-  ).default({})
-});
-async function loadAdapterConfig(path) {
-  const content = await readFile(path, "utf8");
-  const errors = [];
-  const parsed = parse(content, errors, {
-    allowTrailingComma: true,
-    disallowComments: false
+// src/adapters/programmatic.ts
+import { stat, readFile as readFile2, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { pathToFileURL } from "url";
+import { extname, join, resolve } from "path";
+import ts from "typescript";
+async function loadProgrammaticAdapter(modulePath, options) {
+  if (!options.allowCode) {
+    throw new Error("Refusing to load adapter code without --allow-adapter-code");
+  }
+  if (modulePath.startsWith("http://") || modulePath.startsWith("https://") || modulePath.startsWith("github:") || modulePath.startsWith("git:")) {
+    throw new Error("Programmatic adapters must be loaded from an explicit local path");
+  }
+  const resolvedPath = resolve(modulePath);
+  const stats = await stat(resolvedPath);
+  if (!stats.isFile()) {
+    throw new Error(`Programmatic adapter module is not a file: ${resolvedPath}`);
+  }
+  const hash = await hashPath(resolvedPath);
+  const importPath = extname(resolvedPath) === ".ts" ? await transpileTypeScriptAdapter(resolvedPath, hash) : resolvedPath;
+  const imported = await import(`${pathToFileURL(importPath).href}?agentwheel=${Date.now()}`);
+  const candidate = imported.adapter;
+  if (!candidate || typeof candidate !== "object") {
+    throw new Error(`Programmatic adapter module must export "adapter": ${resolvedPath}`);
+  }
+  const parsed = adapterSchema.parse(candidate);
+  const runtime = {
+    modulePath: resolvedPath,
+    hash,
+    capabilities: Array.isArray(candidate.capabilities) ? candidate.capabilities.filter((item) => typeof item === "string") : [],
+    plan: typeof candidate.plan === "function" ? candidate.plan.bind(candidate) : void 0,
+    apply: typeof candidate.apply === "function" ? candidate.apply.bind(candidate) : void 0,
+    uninstall: typeof candidate.uninstall === "function" ? candidate.uninstall.bind(candidate) : void 0
+  };
+  return { ...parsed, programmatic: runtime };
+}
+async function transpileTypeScriptAdapter(modulePath, hash) {
+  const source = await readFile2(modulePath, "utf8");
+  const output = ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.ES2022,
+      target: ts.ScriptTarget.ES2022,
+      moduleResolution: ts.ModuleResolutionKind.NodeNext,
+      esModuleInterop: true,
+      sourceMap: false
+    },
+    fileName: modulePath
   });
-  if (errors.length > 0) {
-    const details = errors.map((error) => `${printParseErrorCode(error.error)} at offset ${error.offset}`).join(", ");
-    throw new Error(`Invalid adapter config ${path}: ${details}`);
+  const outPath = join(tmpdir(), `agentwheel-adapter-${hash}.mjs`);
+  await writeFile(outPath, output.outputText, "utf8");
+  return outPath;
+}
+
+// src/adapters/resolve.ts
+async function resolveAdapter(options) {
+  if (options.adapterModule) {
+    const modulePath = resolve2(options.baseDir ?? process.cwd(), options.adapterModule);
+    const adapter = await loadProgrammaticAdapter(modulePath, { allowCode: options.allowAdapterCode === true });
+    options.warn?.(`WARNING: loaded local adapter code ${adapter.programmatic?.modulePath} (${adapter.programmatic?.hash})`);
+    return adapter;
   }
-  return adapterSchema.parse(parsed);
+  if (options.adapterConfig) {
+    return loadAdapterConfig(resolve2(options.baseDir ?? process.cwd(), options.adapterConfig));
+  }
+  return getAdapter(options.adapter ?? "openclaw");
 }
 
 // src/install/apply.ts
 import { execFile } from "child_process";
-import { rm as rm3 } from "fs/promises";
+import { rm as rm2 } from "fs/promises";
 import { promisify } from "util";
 
-// src/utils/fs.ts
-import { createHash } from "crypto";
-import {
-  copyFile,
-  cp,
-  mkdir,
-  readdir,
-  readFile as readFile2,
-  rename,
-  rm,
-  stat,
-  writeFile
-} from "fs/promises";
-import { dirname, join, relative } from "path";
-async function pathExists(path) {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
+// src/install/json-merge.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+import { mkdir } from "fs/promises";
+async function mergeJsonFile(sourcePath, destPath) {
+  const source = JSON.parse(await readFile3(sourcePath, "utf8"));
+  const current = await pathExists(destPath) ? JSON.parse(await readFile3(destPath, "utf8")) : {};
+  const merged = deepMerge(current, source);
+  await mkdir(dirname(destPath), { recursive: true });
+  await writeFile2(destPath, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
 }
-async function hashPath(path) {
-  const stats = await stat(path);
-  if (stats.isFile()) {
-    const content = await readFile2(path);
-    return createHash("sha256").update("file\0").update(content).digest("hex");
-  }
-  if (!stats.isDirectory()) {
-    throw new Error(`Unsupported path kind: ${path}`);
+function deepMerge(base, incoming) {
+  if (Array.isArray(base) && Array.isArray(incoming)) {
+    return dedupeArray([...base, ...incoming]);
   }
-  const hash = createHash("sha256").update("dir\0");
-  const files = await listFiles(path);
-  for (const file of files) {
-    hash.update(relative(path, file).replaceAll("\\", "/")).update("\0");
-    hash.update(await hashPath(file)).update("\0");
+  if (isRecord(base) && isRecord(incoming)) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(incoming)) {
+      out[key] = key in out ? deepMerge(out[key], value) : value;
+    }
+    return out;
   }
-  return hash.digest("hex");
+  return incoming;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function listFiles(root) {
+function dedupeArray(values) {
+  const seen = /* @__PURE__ */ new Set();
   const out = [];
-  async function walk(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      if (entry.name === ".git" || entry.name === "node_modules") continue;
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(full);
-      } else if (entry.isFile()) {
-        out.push(full);
-      }
-    }
+  for (const value of values) {
+    const key = JSON.stringify(value);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(value);
   }
-  await walk(root);
   return out;
 }
-async function atomicCopy(source, dest, kind) {
-  await mkdir(dirname(dest), { recursive: true });
-  const temp = `${dest}.agentwheel-tmp-${process.pid}-${Date.now()}`;
-  await rm(temp, { recursive: true, force: true });
-  if (kind === "file") {
-    await copyFile(source, temp);
-  } else {
-    await cp(source, temp, { recursive: true, dereference: true });
-  }
-  await rm(dest, { recursive: true, force: true });
-  await rename(temp, dest);
-}
-async function writeJsonAtomic(path, data) {
-  await mkdir(dirname(path), { recursive: true });
-  const temp = `${path}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile(temp, `${JSON.stringify(data, null, 2)}
-`, "utf8");
-  await rename(temp, path);
-}
 
 // src/install/manifest.ts
-import { readFile as readFile3, rm as rm2 } from "fs/promises";
-import { resolve } from "path";
+import { readFile as readFile4, rm } from "fs/promises";
+import { resolve as resolve3 } from "path";
 
 // src/model/manifest.ts
 import { z as z3 } from "zod";
@@ -228,13 +273,18 @@ var manifestEntrySchema = z3.object({
   channel: z3.enum(["managed", "overlay", "addition", "override", "ejected"]).default("managed"),
   packageName: z3.string().min(1).optional(),
   semanticCommand: z3.array(z3.string()).optional(),
-  executed: z3.boolean().optional()
+  executed: z3.boolean().optional(),
+  mergeStrategy: z3.enum(["json-deep"]).optional()
 });
 var installManifestSchema = z3.object({
   version: z3.literal(1),
   adapter: z3.string().min(1),
   targetRoot: z3.string().min(1),
   generatedAt: z3.string().datetime(),
+  adapterCode: z3.object({
+    modulePath: z3.string().min(1),
+    hash: z3.string().min(16)
+  }).optional(),
   entries: z3.array(manifestEntrySchema)
 });
 var sourceLockSchema = z3.object({
@@ -276,7 +326,7 @@ function sourceLockPath(targetRoot, adapter) {
 async function readInstallManifest(targetRoot, adapter) {
   const path = installManifestPath(targetRoot, adapter);
   if (!await pathExists(path)) return void 0;
-  return installManifestSchema.parse(JSON.parse(await readFile3(path, "utf8")));
+  return installManifestSchema.parse(JSON.parse(await readFile4(path, "utf8")));
 }
 async function writeInstallManifest(manifest) {
   await writeJsonAtomic(installManifestPath(manifest.targetRoot, manifest.adapter), manifest);
@@ -287,14 +337,14 @@ async function writeSourceLock(targetRoot, adapter, lock) {
 async function readSourceLock(targetRoot, adapter) {
   const path = sourceLockPath(targetRoot, adapter);
   if (!await pathExists(path)) return void 0;
-  return sourceLockSchema.parse(JSON.parse(await readFile3(path, "utf8")));
+  return sourceLockSchema.parse(JSON.parse(await readFile4(path, "utf8")));
 }
 async function removeStateFiles(targetRoot, adapter) {
-  await rm2(installManifestPath(targetRoot, adapter), { force: true });
-  await rm2(sourceLockPath(targetRoot, adapter), { force: true });
+  await rm(installManifestPath(targetRoot, adapter), { force: true });
+  await rm(sourceLockPath(targetRoot, adapter), { force: true });
 }
 function normalizeTargetRoot(path) {
-  return resolve(path);
+  return resolve3(path);
 }
 
 // src/install/apply.ts
@@ -335,11 +385,36 @@ async function applyInstallPlan(plan, sourceLock, options = {}) {
         semanticCommand: operation.semanticCommand,
         executed: options.executePlugins === true
       });
+    } else if (operation.action === "program") {
+      if (!plan.adapterCode || !operation.desiredHash || !operation.programmaticOperation) {
+        throw new Error(`Invalid programmatic operation: ${operation.relativeDestPath}`);
+      }
+      if (operation.programmaticApply) {
+        await operation.programmaticApply(operation.programmaticOperation, {
+          targetRoot: plan.targetRoot,
+          adapterName: plan.adapter
+        });
+      }
+      entries.push({
+        path: operation.relativeDestPath,
+        artifactType: operation.artifactType,
+        artifactName: operation.artifactName,
+        kind: operation.kind,
+        hash: operation.desiredHash,
+        sourceHash: operation.desiredHash,
+        updatedAt: now,
+        channel: operation.channel,
+        packageName: operation.packageName
+      });
     } else if (operation.action === "create" || operation.action === "update") {
       if (!operation.sourcePath || !operation.desiredHash) {
         throw new Error(`Invalid operation missing source/hash: ${operation.relativeDestPath}`);
       }
-      await atomicCopy(operation.sourcePath, operation.destPath, operation.kind);
+      if (operation.mergeStrategy === "json-deep") {
+        await mergeJsonFile(operation.sourcePath, operation.destPath);
+      } else {
+        await atomicCopy(operation.sourcePath, operation.destPath, operation.kind);
+      }
       entries.push({
         path: operation.relativeDestPath,
         artifactType: operation.artifactType,
@@ -350,7 +425,8 @@ async function applyInstallPlan(plan, sourceLock, options = {}) {
         updatedAt: now,
         channel: operation.channel,
         packageName: operation.packageName,
-        semanticCommand: operation.semanticCommand
+        semanticCommand: operation.semanticCommand,
+        mergeStrategy: operation.mergeStrategy
       });
     } else if (operation.action === "skip") {
       if (!operation.desiredHash) {
@@ -361,15 +437,16 @@ async function applyInstallPlan(plan, sourceLock, options = {}) {
         artifactType: operation.artifactType,
         artifactName: operation.artifactName,
         kind: operation.kind,
-        hash: operation.desiredHash,
+        hash: operation.mergeStrategy === "json-deep" && operation.currentHash ? operation.currentHash : operation.desiredHash,
         sourceHash: operation.desiredHash,
         updatedAt: now,
         channel: operation.channel,
         packageName: operation.packageName,
-        semanticCommand: operation.semanticCommand
+        semanticCommand: operation.semanticCommand,
+        mergeStrategy: operation.mergeStrategy
       });
     } else if (operation.action === "remove") {
-      await rm3(operation.destPath, { recursive: true, force: true });
+      await rm2(operation.destPath, { recursive: true, force: true });
     }
   }
   const manifest = {
@@ -377,6 +454,7 @@ async function applyInstallPlan(plan, sourceLock, options = {}) {
     adapter: plan.adapter,
     targetRoot: plan.targetRoot,
     generatedAt: now,
+    adapterCode: plan.adapterCode,
     entries: entries.sort((a, b) => a.path.localeCompare(b.path))
   };
   await writeInstallManifest(manifest);
@@ -390,13 +468,13 @@ async function uninstall(plan, dryRun) {
   }
   if (dryRun) return;
   for (const operation of plan.operations) {
-    await rm3(operation.destPath, { recursive: true, force: true });
+    await rm2(operation.destPath, { recursive: true, force: true });
   }
   await removeStateFiles(plan.targetRoot, plan.adapter);
 }
 
 // src/install/plan.ts
-import { join as join3, relative as relative2 } from "path";
+import { join as join3, relative } from "path";
 
 // src/targets/plugins/openclaw.ts
 function openClawPluginInstallCommand(request) {
@@ -412,6 +490,23 @@ async function createInstallPlan(bundle, adapter, targetRoot, manifest) {
       desired.set(op.relativeDestPath, op);
     }
   }
+  if (adapter.programmatic?.plan) {
+    for (const op of await adapter.programmatic.plan({ targetRoot, adapterName: adapter.name })) {
+      desired.set(`programmatic/${op.name}`, {
+        action: "program",
+        artifactType: "settings",
+        artifactName: op.name,
+        kind: "file",
+        destPath: targetRoot,
+        relativeDestPath: `programmatic/${op.name}`,
+        desiredHash: adapter.programmatic.hash,
+        reason: op.reason ?? "programmatic adapter operation planned",
+        channel: "managed",
+        programmaticOperation: op,
+        programmaticApply: adapter.programmatic.apply
+      });
+    }
+  }
   const manifestByPath = new Map((manifest?.entries ?? []).map((entry) => [entry.path, entry]));
   const operations = [];
   for (const op of desired.values()) {
@@ -424,6 +519,30 @@ async function createInstallPlan(bundle, adapter, targetRoot, manifest) {
       }
       continue;
     }
+    if (op.action === "program") {
+      const existing2 = manifestByPath.get(op.relativeDestPath);
+      if (existing2 && existing2.hash === op.desiredHash) {
+        operations.push({ ...op, action: "skip", manifestHash: existing2.hash, reason: "programmatic operation already applied" });
+      } else {
+        operations.push(op);
+      }
+      continue;
+    }
+    if (op.mergeStrategy === "json-deep") {
+      const existing2 = manifestByPath.get(op.relativeDestPath);
+      const exists2 = await pathExists(op.destPath);
+      if (!exists2) {
+        operations.push({ ...op, action: "create", reason: "merge destination missing" });
+        continue;
+      }
+      const currentHash2 = await hashPath(op.destPath);
+      if (existing2 && existing2.sourceHash === op.desiredHash) {
+        operations.push({ ...op, action: "skip", currentHash: currentHash2, manifestHash: existing2.hash, reason: "merged source already up to date" });
+      } else {
+        operations.push({ ...op, action: "update", currentHash: currentHash2, manifestHash: existing2?.hash, reason: existing2 ? "merge source changed" : "merge into existing JSON" });
+      }
+      continue;
+    }
     const existing = manifestByPath.get(op.relativeDestPath);
     const exists = await pathExists(op.destPath);
     if (!exists) {
@@ -491,7 +610,10 @@ async function createInstallPlan(bundle, adapter, targetRoot, manifest) {
     adapter: adapter.name,
     targetRoot,
     operations,
-    hasBlockingChanges: operations.some((op) => op.action === "drift" || op.action === "conflict")
+    hasBlockingChanges: operations.some((op) => op.action === "drift" || op.action === "conflict"),
+    adapterCode: adapter.programmatic ? { modulePath: adapter.programmatic.modulePath, hash: adapter.programmatic.hash } : void 0,
+    programmaticApply: adapter.programmatic?.apply,
+    programmaticUninstall: adapter.programmatic?.uninstall
   };
 }
 function operationForArtifact(artifact, adapter, targetRoot) {
@@ -514,7 +636,7 @@ function operationForArtifact(artifact, adapter, targetRoot) {
       semanticCommand: openClawPluginInstallCommand({ path: sourcePath, dryRun: true })
     };
   }
-  const destPath = artifact.type === "instructions" ? join3(targetRoot, target.dest) : join3(targetRoot, target.dest, artifact.name);
+  const destPath = artifact.type === "instructions" || artifact.type === "settings" ? join3(targetRoot, target.dest) : join3(targetRoot, target.dest, artifact.name);
   return {
     action: "create",
     artifactType: artifact.type,
@@ -522,11 +644,12 @@ function operationForArtifact(artifact, adapter, targetRoot) {
     kind: artifact.kind,
     sourcePath: artifact.stagedPath ?? artifact.sourcePath,
     destPath,
-    relativeDestPath: relative2(targetRoot, destPath).replaceAll("\\", "/"),
+    relativeDestPath: relative(targetRoot, destPath).replaceAll("\\", "/"),
     desiredHash: artifact.hash,
     reason: "destination missing",
     channel: artifact.channel ?? "managed",
-    packageName: artifact.packageName
+    packageName: artifact.packageName,
+    mergeStrategy: target.merge
   };
 }
 function summarizePlan(plan) {
@@ -537,7 +660,8 @@ function summarizePlan(plan) {
     remove: 0,
     drift: 0,
     conflict: 0,
-    plugin: 0
+    plugin: 0,
+    program: 0
   };
   for (const operation of plan.operations) {
     summary[operation.action]++;
@@ -600,7 +724,8 @@ var labels = {
   remove: "REMOVE",
   drift: "DRIFT",
   conflict: "CONFLICT",
-  plugin: "PLUGIN"
+  plugin: "PLUGIN",
+  program: "PROGRAM"
 };
 var channelLabels = {
   managed: "MANAGED",
@@ -625,13 +750,13 @@ function formatPlan(plan) {
 
 // src/source/git.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdir as mkdir2, rm as rm4 } from "fs/promises";
+import { mkdir as mkdir2, rm as rm3 } from "fs/promises";
 import { homedir } from "os";
-import { basename as basename2, join as join7, resolve as resolve3 } from "path";
+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 readFile4 } from "fs/promises";
+import { readFile as readFile5 } 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";
@@ -655,7 +780,7 @@ async function findPackageManifestPath(root) {
 async function readPackageManifest(root) {
   const path = await findPackageManifestPath(root);
   if (!path) return void 0;
-  const content = await readFile4(path, "utf8");
+  const content = await readFile5(path, "utf8");
   const errors = [];
   const parsed = parse2(content, errors, { allowTrailingComma: true, disallowComments: false });
   if (errors.length > 0) {
@@ -666,12 +791,12 @@ async function readPackageManifest(root) {
 }
 
 // src/source/local.ts
-import { readdir as readdir2, stat as stat2 } from "fs/promises";
-import { basename, join as join6, resolve as resolve2 } from "path";
+import { readdir, stat as stat2 } from "fs/promises";
+import { basename, join as join6, resolve as resolve4 } from "path";
 var LocalSourceDriver = class {
   name = "local";
   async resolve(source) {
-    const resolvedPath = resolve2(source);
+    const resolvedPath = resolve4(source);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Local source not found: ${resolvedPath}`);
     }
@@ -757,7 +882,7 @@ var LocalSourceDriver = class {
         }
       }
     }
-    for (const type of ["commands", "mcp", "hooks", "plugins"]) {
+    for (const type of ["commands", "mcp", "hooks", "settings", "plugins"]) {
       const dir = join6(root, type);
       if (!await pathExists(dir)) continue;
       artifacts.push(...await listGenericArtifacts(type, dir, type, resolved.packageName));
@@ -794,7 +919,7 @@ async function firstExisting(paths) {
   return void 0;
 }
 async function sortedDirEntries(path) {
-  return (await readdir2(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  return (await readdir(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
 }
 async function listFromManifest(root, packageName) {
   const manifest = await readPackageManifest(root);
@@ -884,9 +1009,9 @@ var GitSourceDriver = class {
   }
   async fetch(resolved) {
     const parsed = parseGitSource(resolved.source);
-    await mkdir2(resolve3(resolved.resolvedPath, ".."), { recursive: true });
+    await mkdir2(resolve5(resolved.resolvedPath, ".."), { recursive: true });
     if (!await pathExists(join7(resolved.resolvedPath, ".git"))) {
-      await rm4(resolved.resolvedPath, { recursive: true, force: true });
+      await rm3(resolved.resolvedPath, { recursive: true, force: true });
       await git(["clone", "--no-tags", parsed.url, resolved.resolvedPath]);
     } else {
       await git(["-C", resolved.resolvedPath, "fetch", "--prune", "origin"]);
@@ -946,16 +1071,347 @@ function parseGitSource(source) {
   throw new Error(`Invalid git source: ${source}`);
 }
 function cachePathFor(url, cacheRoot) {
-  const root = cacheRoot ? resolve3(cacheRoot) : join7(homedir(), ".agentwheel", "cache");
-  const slug = url.replace(/^[a-z]+:\/\//i, "").replace(/\.git$/i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "");
-  return join7(root, slug || basename2(url));
+  const root = cacheRoot ? resolve5(cacheRoot) : join7(homedir(), ".agentwheel", "cache");
+  const slug2 = url.replace(/^[a-z]+:\/\//i, "").replace(/\.git$/i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "");
+  return join7(root, slug2 || basename2(url));
 }
 async function git(args) {
   return execFileAsync2("git", args, { maxBuffer: 1024 * 1024 * 10 });
 }
 
+// src/source/skillkit.ts
+import { cp, mkdir as mkdir3, readFile as readFile6, 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 * 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";
+async function artifactsFromSkillPaths(paths, packageName) {
+  const artifacts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of paths) {
+    const artifact = await artifactFromSkillPath(item, packageName);
+    if (!artifact) continue;
+    const key = `${artifact.name}:${artifact.sourcePath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    artifacts.push(artifact);
+  }
+  return artifacts.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function discoverSkillPaths(root) {
+  const paths = [];
+  await walk(root, paths);
+  return paths;
+}
+async function artifactFromSkillPath(item, packageName) {
+  const stats = await stat3(item.path);
+  if (stats.isDirectory()) {
+    const skillMd = join8(item.path, "SKILL.md");
+    if (!await pathExists(skillMd)) return void 0;
+    const name = sanitizeSkillName(item.name ?? basename3(item.path));
+    return {
+      type: "skills",
+      name,
+      sourcePath: item.path,
+      relativePath: join8("skills", name),
+      kind: "dir",
+      hash: await hashPath(item.path),
+      packageName,
+      channel: "managed"
+    };
+  }
+  if (stats.isFile() && basename3(item.path).toLowerCase() === "skill.md") {
+    const dir = dirname2(item.path);
+    const name = sanitizeSkillName(item.name ?? basename3(dir));
+    return {
+      type: "skills",
+      name,
+      sourcePath: dir,
+      relativePath: join8("skills", name),
+      kind: "dir",
+      hash: await hashPath(dir),
+      packageName,
+      channel: "managed"
+    };
+  }
+  if (stats.isFile() && extname2(item.path).toLowerCase() === ".md") {
+    const name = sanitizeSkillName(item.name ?? basename3(item.path, ".md"));
+    return {
+      type: "skills",
+      name,
+      sourcePath: item.path,
+      relativePath: join8("skills", `${name}.md`),
+      kind: "file",
+      hash: await hashPath(item.path),
+      packageName,
+      channel: "managed"
+    };
+  }
+  return void 0;
+}
+async function walk(dir, paths) {
+  if (!await pathExists(dir)) return;
+  const entries = await readdir2(dir, { withFileTypes: true });
+  if (entries.some((entry) => entry.isFile() && entry.name === "SKILL.md")) {
+    paths.push({ path: dir });
+    return;
+  }
+  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(join8(dir, entry.name), paths);
+  }
+}
+function sanitizeSkillName(name) {
+  return name.trim().replace(/\.md$/i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "skill";
+}
+
+// src/source/skillkit.ts
+var SkillKitSourceDriver = class {
+  constructor(core = defaultSkillKit) {
+    this.core = core;
+  }
+  core;
+  name = "skillkit";
+  async resolve(source, options = {}) {
+    const spec = parseSkillKitSource(source);
+    if (await pathExists(spec)) {
+      const resolvedPath = resolve6(spec);
+      return {
+        driver: this.name,
+        source,
+        resolvedPath,
+        packageName: `skillkit/${basename4(resolvedPath)}`,
+        mode: options.mode ?? "pinned",
+        sourceHash: await hashPath(resolvedPath)
+      };
+    }
+    return {
+      driver: this.name,
+      source,
+      resolvedPath: cachePathFor2(spec, options.cacheRoot),
+      packageName: `skillkit/${packageSlug(spec)}`,
+      mode: options.mode ?? "tracking",
+      requestedRef: options.ref
+    };
+  }
+  async fetch(resolved) {
+    const spec = parseSkillKitSource(resolved.source);
+    if (await pathExists(spec)) {
+      return resolved;
+    }
+    const providerSpec = normalizeProviderSource(spec);
+    const provider = this.core.detectProvider?.(providerSpec);
+    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 });
+    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"}`);
+    }
+    if (resolve6(result.path) !== resolve6(resolved.resolvedPath)) {
+      await rm4(resolved.resolvedPath, { recursive: true, force: true });
+      await cp(result.path, resolved.resolvedPath, { recursive: true, dereference: true });
+    }
+    if (result.tempRoot) {
+      await rm4(result.tempRoot, { recursive: true, force: true });
+    }
+    return {
+      ...resolved,
+      sourceHash: await hashPath(resolved.resolvedPath)
+    };
+  }
+  async list(resolved) {
+    const skills = this.discover(resolved.resolvedPath);
+    return artifactsFromSkillPaths(skills, resolved.packageName);
+  }
+  async scan(resolved) {
+    if (!this.core.SkillScanner) {
+      return { ok: false, findings: [{ level: "error", message: "SkillKit SkillScanner API unavailable" }] };
+    }
+    const scanner = new this.core.SkillScanner();
+    const findings = [];
+    for (const skill of this.discover(resolved.resolvedPath)) {
+      const scan = await scanner.scan(skill.path);
+      for (const finding of scan.findings ?? []) {
+        findings.push({
+          level: mapSeverity(finding.severity),
+          message: finding.title ?? finding.description ?? "SkillKit scanner finding",
+          path: finding.filePath
+        });
+      }
+    }
+    return { ok: !findings.some((finding) => finding.level === "error"), findings };
+  }
+  async translate(resolved) {
+    if (!this.core.translateSkill) {
+      throw new Error("SkillKit translateSkill API unavailable");
+    }
+    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" });
+      }
+    }
+    return resolved;
+  }
+  async export(resolved) {
+    return resolved;
+  }
+  discover(root) {
+    if (!this.core.discoverSkills) {
+      throw new Error("SkillKit discoverSkills API unavailable");
+    }
+    return this.core.discoverSkills(root).filter((skill) => typeof skill.path === "string").map((skill) => ({ name: skill.name, path: skill.path }));
+  }
+};
+function parseSkillKitSource(source) {
+  if (!source.startsWith("skillkit:")) {
+    throw new Error(`Invalid SkillKit source: ${source}`);
+  }
+  const spec = source.slice("skillkit:".length);
+  if (!spec) throw new Error(`Invalid SkillKit source: ${source}`);
+  return spec;
+}
+function normalizeProviderSource(spec) {
+  if (spec.startsWith("github:")) return spec.slice("github:".length);
+  if (spec.startsWith("git:https://github.com/")) return spec.slice("git:".length);
+  return spec;
+}
+function cachePathFor2(spec, cacheRoot) {
+  const root = cacheRoot ? resolve6(cacheRoot) : join9(homedir2(), ".agentwheel", "cache");
+  return join9(root, "skillkit", packageSlug(spec));
+}
+function packageSlug(spec) {
+  return spec.replace(/^[a-z]+:\/\//i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "source";
+}
+function mapSeverity(severity) {
+  if (severity === "critical" || severity === "high") return "error";
+  if (severity === "medium" || severity === "low") return "warning";
+  return "info";
+}
+
+// src/source/vercel-skills.ts
+import { stat as stat4 } from "fs/promises";
+import { basename as basename5, join as join10, resolve as resolve7 } from "path";
+var VercelSkillsSourceDriver = class {
+  name = "vercel-skills";
+  git = new GitSourceDriver();
+  async resolve(source, options = {}) {
+    const parsed = parseVercelSource(source);
+    if (parsed.kind === "local") {
+      const resolvedPath = resolve7(parsed.path);
+      if (!await pathExists(resolvedPath) || !(await stat4(resolvedPath)).isDirectory()) {
+        throw new Error(`Vercel skills local source not found: ${resolvedPath}`);
+      }
+      return {
+        driver: this.name,
+        source,
+        resolvedPath,
+        packageName: `vercel/${basename5(resolvedPath)}`,
+        mode: options.mode ?? "pinned",
+        sourceHash: await hashPath(resolvedPath)
+      };
+    }
+    const gitResolved = await this.git.resolve(parsed.gitSource, options);
+    return {
+      ...gitResolved,
+      driver: this.name,
+      source,
+      packageName: parsed.packageName
+    };
+  }
+  async fetch(resolved) {
+    const parsed = parseVercelSource(resolved.source);
+    if (parsed.kind === "local") return resolved;
+    const fetched = await this.git.fetch({
+      ...resolved,
+      driver: "git",
+      source: parsed.gitSource
+    });
+    const resolvedPath = parsed.subpath ? join10(fetched.resolvedPath, parsed.subpath) : fetched.resolvedPath;
+    if (!await pathExists(resolvedPath)) {
+      throw new Error(`Vercel skills subpath not found: ${parsed.subpath}`);
+    }
+    return {
+      ...resolved,
+      resolvedPath,
+      resolvedCommit: fetched.resolvedCommit,
+      sourceHash: await hashPath(resolvedPath)
+    };
+  }
+  async list(resolved) {
+    return artifactsFromSkillPaths(await discoverSkillPaths(resolved.resolvedPath), resolved.packageName);
+  }
+  async scan(resolved) {
+    const artifacts = await this.list(resolved);
+    return {
+      ok: artifacts.length > 0,
+      findings: artifacts.length > 0 ? [] : [{ level: "warning", message: "No SKILL.md files found", path: resolved.resolvedPath }]
+    };
+  }
+  async translate(resolved) {
+    return resolved;
+  }
+  async export(resolved) {
+    return resolved;
+  }
+};
+function parseVercelSource(source) {
+  if (!source.startsWith("vercel:")) {
+    throw new Error(`Invalid Vercel skills source: ${source}`);
+  }
+  const spec = source.slice("vercel:".length);
+  if (!spec) throw new Error(`Invalid Vercel skills source: ${source}`);
+  if (spec.startsWith(".") || spec.startsWith("/")) return { kind: "local", path: spec };
+  if (spec.startsWith("git:")) {
+    return { kind: "git", gitSource: spec, packageName: `vercel/${slug(spec)}` };
+  }
+  if (spec.startsWith("github:")) {
+    const name = spec.slice("github:".length).split("#", 1)[0];
+    return { kind: "git", gitSource: spec, packageName: `vercel/${name}` };
+  }
+  if (spec.startsWith("skills.sh/") || spec.startsWith("https://skills.sh/")) {
+    const parsed = parseSkillsSh(spec);
+    return {
+      kind: "git",
+      gitSource: `github:${parsed.owner}/${parsed.repo}${parsed.ref ? `#${parsed.ref}` : ""}`,
+      packageName: `vercel/${parsed.owner}/${parsed.repo}`,
+      subpath: parsed.skillName
+    };
+  }
+  if (/^[^/]+\/[^/]+/.test(spec)) {
+    const [repo, ref] = spec.split("#", 2);
+    const [owner, name] = repo.split("/", 2);
+    return {
+      kind: "git",
+      gitSource: `github:${owner}/${name}${ref ? `#${ref}` : ""}`,
+      packageName: `vercel/${owner}/${name}`
+    };
+  }
+  throw new Error(`Invalid Vercel skills source: ${source}`);
+}
+function parseSkillsSh(spec) {
+  const clean = spec.replace(/^https?:\/\//, "").replace(/^skills\.sh\//, "");
+  const [path, ref] = clean.split("#", 2);
+  const [owner, repo, ...rest] = path.split("/").filter(Boolean);
+  if (!owner || !repo) throw new Error(`Invalid skills.sh source: ${spec}`);
+  return { owner, repo, skillName: rest.length > 0 ? rest.join("/") : void 0, ref };
+}
+function slug(value) {
+  return value.replace(/^[a-z]+:\/\//i, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "source";
+}
+
 // src/source/index.ts
-var drivers = [new LocalSourceDriver(), new GitSourceDriver()];
+var drivers = [
+  new LocalSourceDriver(),
+  new GitSourceDriver(),
+  new SkillKitSourceDriver(),
+  new VercelSkillsSourceDriver()
+];
 function getSourceDriver(name = "local") {
   const driver = drivers.find((candidate) => candidate.name === name);
   if (!driver) {
@@ -965,13 +1421,13 @@ function getSourceDriver(name = "local") {
 }
 
 // src/staging/staging.ts
-import { cp as cp3, mkdir as mkdir4, mkdtemp } from "fs/promises";
-import { dirname as dirname3, join as join9 } from "path";
-import { tmpdir } from "os";
+import { cp as cp3, mkdir as mkdir5, mkdtemp } from "fs/promises";
+import { dirname as dirname5, join as join12 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 
 // src/staging/customize.ts
-import { cp as cp2, mkdir as mkdir3, readdir as readdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join8 } from "path";
+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";
 async function applyCustomizations(artifacts, options) {
   let next = [...artifacts];
   next = await applyReplacements(next, options, "override");
@@ -981,16 +1437,16 @@ async function applyCustomizations(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 = join8(options.workspaceRoot, ".agentwheel", "overlays", options.adapter.name, "instructions.local.md");
+  const overlayPath = join11(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 readFile5(artifact.stagedPath ?? artifact.sourcePath, "utf8");
-  const local = await readFile5(overlayPath, "utf8");
-  const composedPath = join8(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
-  await mkdir3(dirname2(composedPath), { recursive: true });
-  await writeFile2(
+  const managed = await readFile7(artifact.stagedPath ?? artifact.sourcePath, "utf8");
+  const local = await readFile7(overlayPath, "utf8");
+  const composedPath = join11(options.stageRoot, ".agentwheel-composed", "instructions", "AGENTS.md");
+  await mkdir4(dirname4(composedPath), { recursive: true });
+  await writeFile3(
     composedPath,
     [
       "<!-- BEGIN agentwheel managed: upstream -->",
@@ -1016,19 +1472,19 @@ async function applyInstructionOverlay(artifacts, options) {
   return [...artifacts.slice(0, index), updated, ...artifacts.slice(index + 1)];
 }
 async function applyAdditions(artifacts, options) {
-  const additionsRoot = join8(options.workspaceRoot, ".agentwheel", "additions");
-  const rulesRoot = join8(additionsRoot, "rules");
+  const additionsRoot = join11(options.workspaceRoot, ".agentwheel", "additions");
+  const rulesRoot = join11(additionsRoot, "rules");
   if (!await pathExists(rulesRoot)) return artifacts;
   const additions = [];
   for (const entry of await sortedDirEntries2(rulesRoot)) {
-    const full = join8(rulesRoot, entry.name);
+    const full = join11(rulesRoot, entry.name);
     if (!entry.isFile()) continue;
     additions.push({
       type: "rules",
       name: entry.name,
       sourcePath: full,
       stagedPath: full,
-      relativePath: join8("additions", "rules", entry.name),
+      relativePath: join11("additions", "rules", entry.name),
       kind: "file",
       hash: await hashPath(full),
       packageName: options.packageName,
@@ -1040,25 +1496,25 @@ async function applyAdditions(artifacts, options) {
 async function applyReplacements(artifacts, options, channel) {
   const packageName = options.packageName;
   if (!packageName) return artifacts;
-  const root = join8(options.workspaceRoot, ".agentwheel", channel === "override" ? "overrides" : "ejected", ...packageName.split("/"));
+  const root = join11(options.workspaceRoot, ".agentwheel", channel === "override" ? "overrides" : "ejected", ...packageName.split("/"));
   if (!await pathExists(root)) return artifacts;
   const byKey = new Map(artifacts.map((artifact) => [artifactKey(artifact), artifact]));
-  for (const type of ["instructions", "rules", "skills", "commands", "subagents", "mcp", "hooks", "plugins"]) {
-    const typeRoot = join8(root, type);
+  for (const type of ["instructions", "rules", "skills", "commands", "subagents", "mcp", "hooks", "settings", "plugins"]) {
+    const typeRoot = join11(root, type);
     if (!await pathExists(typeRoot)) continue;
     for (const entry of await sortedDirEntries2(typeRoot)) {
-      const full = join8(typeRoot, entry.name);
+      const full = join11(typeRoot, entry.name);
       const kind = entry.isDirectory() ? "dir" : "file";
       const existing = byKey.get(`${type}:${entry.name}`);
-      const stagedPath = join8(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
-      await mkdir3(dirname2(stagedPath), { recursive: true });
+      const stagedPath = join11(options.stageRoot, ".agentwheel-composed", channel, type, entry.name);
+      await mkdir4(dirname4(stagedPath), { recursive: true });
       await cp2(full, stagedPath, { recursive: kind === "dir", dereference: true });
       byKey.set(`${type}:${entry.name}`, {
         type,
         name: entry.name,
         sourcePath: full,
         stagedPath,
-        relativePath: existing?.relativePath ?? join8(type, entry.name),
+        relativePath: existing?.relativePath ?? join11(type, entry.name),
         kind,
         hash: await hashPath(stagedPath),
         packageName,
@@ -1079,11 +1535,11 @@ async function sortedDirEntries2(path) {
 async function stageSource(driver, source, options = {}) {
   const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(source, options))));
   const artifacts = await driver.list(resolved);
-  const root = await mkdtemp(join9(tmpdir(), "agentwheel-stage-"));
+  const root = await mkdtemp(join12(tmpdir2(), "agentwheel-stage-"));
   const stagedArtifacts = [];
   for (const artifact of artifacts) {
-    const stagedPath = join9(root, artifact.relativePath);
-    await mkdir4(dirname3(stagedPath), { recursive: true });
+    const stagedPath = join12(root, artifact.relativePath);
+    await mkdir5(dirname5(stagedPath), { recursive: true });
     await cp3(artifact.sourcePath, stagedPath, { recursive: artifact.kind === "dir", dereference: true });
     stagedArtifacts.push({
       ...artifact,
@@ -1127,29 +1583,47 @@ async function stageSource(driver, source, options = {}) {
 }
 
 // src/model/workspace.ts
-import { readFile as readFile6 } from "fs/promises";
-import { join as join10 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join13 } from "path";
 import { z as z5 } from "zod";
 var workspacePackageSchema = z5.object({
   name: z5.string().min(1),
   source: z5.string().min(1),
-  driver: z5.enum(["local", "git"]).default("local"),
+  driver: z5.enum(["local", "git", "skillkit", "vercel-skills"]).default("local"),
   adapter: z5.string().min(1).default("openclaw"),
   adapterConfig: z5.string().min(1).optional(),
+  adapterModule: z5.string().min(1).optional(),
+  adapterCodeHash: z5.string().min(16).optional(),
   mode: z5.enum(["pinned", "tracking"]).default("pinned"),
   requestedRef: z5.string().min(1).optional()
 });
+var workspaceProfileRuntimeSchema = z5.object({
+  adapter: z5.string().min(1).default("openclaw"),
+  adapterConfig: z5.string().min(1).optional(),
+  adapterModule: z5.string().min(1).optional(),
+  targetRoot: z5.string().min(1).optional(),
+  executePlugins: z5.boolean().optional()
+});
+var workspaceProfileSchema = z5.object({
+  runtimes: z5.array(workspaceProfileRuntimeSchema).min(1)
+});
+var workspaceRegistrySchema = z5.object({
+  sources: z5.array(z5.string().min(1)).optional(),
+  ttlSeconds: z5.number().int().positive().optional()
+}).default({});
 var workspaceConfigSchema = z5.object({
   schemaVersion: z5.literal(1),
-  packages: z5.array(workspacePackageSchema).default([])
+  packages: z5.array(workspacePackageSchema).default([]),
+  registry: workspaceRegistrySchema,
+  profiles: z5.record(z5.string(), workspaceProfileSchema).default({})
 });
 function workspaceConfigPath(workspaceRoot) {
-  return join10(workspaceRoot, ".agentwheel", "config.json");
+  return join13(workspaceRoot, ".agentwheel", "config.json");
 }
 async function readWorkspaceConfig(workspaceRoot) {
   const path = workspaceConfigPath(workspaceRoot);
-  if (!await pathExists(path)) return { schemaVersion: 1, packages: [] };
-  return workspaceConfigSchema.parse(JSON.parse(await readFile6(path, "utf8")));
+  if (!await pathExists(path)) return { schemaVersion: 1, packages: [], registry: {}, profiles: {} };
+  return workspaceConfigSchema.parse(JSON.parse(await readFile8(path, "utf8")));
 }
 async function writeWorkspaceConfig(workspaceRoot, config) {
   await writeJsonAtomic(workspaceConfigPath(workspaceRoot), workspaceConfigSchema.parse(config));
@@ -1158,15 +1632,15 @@ function upsertPackage(config, entry) {
   const packages = config.packages.filter((candidate) => candidate.name !== entry.name);
   packages.push(entry);
   packages.sort((a, b) => a.name.localeCompare(b.name));
-  return { schemaVersion: 1, packages };
+  return { schemaVersion: 1, packages, registry: config.registry ?? {}, profiles: config.profiles ?? {} };
 }
 
 // src/lifecycle/customization.ts
-import { appendFile, cp as cp4, mkdir as mkdir5, rm as rm5 } from "fs/promises";
-import { dirname as dirname4, join as join11 } from "path";
+import { appendFile, cp as cp4, mkdir as mkdir6, rm as rm5 } from "fs/promises";
+import { dirname as dirname6, join as join14 } from "path";
 async function remember(workspaceRoot, runtime, text) {
-  const overlayPath = join11(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
-  await mkdir5(dirname4(overlayPath), { recursive: true });
+  const overlayPath = join14(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
+  await mkdir6(dirname6(overlayPath), { recursive: true });
   await appendFile(overlayPath, `${text.trim()}
 `, "utf8");
   return { overlayPath };
@@ -1182,7 +1656,7 @@ async function ejectArtifact(workspaceRoot, item) {
   const adapter = pkg.adapterConfig ? await loadAdapterConfig(pkg.adapterConfig) : getAdapter(pkg.adapter);
   const bundle = await stageSource(driver, pkg.source, {
     adapter,
-    cacheRoot: join11(workspaceRoot, ".agentwheel", "cache"),
+    cacheRoot: join14(workspaceRoot, ".agentwheel", "cache"),
     mode: pkg.mode
   });
   try {
@@ -1190,8 +1664,8 @@ async function ejectArtifact(workspaceRoot, item) {
     if (!artifact) {
       throw new Error(`Artifact not found: ${item}`);
     }
-    const ejectedPath = join11(workspaceRoot, ".agentwheel", "ejected", ...parsed.packageName.split("/"), parsed.type, parsed.name);
-    await mkdir5(dirname4(ejectedPath), { recursive: true });
+    const ejectedPath = join14(workspaceRoot, ".agentwheel", "ejected", ...parsed.packageName.split("/"), parsed.type, parsed.name);
+    await mkdir6(dirname6(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 };
@@ -1210,6 +1684,204 @@ function parseEjectItem(item) {
   return { packageName, type, name };
 }
 
+// src/lifecycle/profile.ts
+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 stat6 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname7, join as join15, resolve as resolve8 } from "path";
+import { fileURLToPath } from "url";
+
+// src/model/registry.ts
+import { z as z6 } from "zod";
+var registryEntrySchema = z6.object({
+  name: z6.string().min(1),
+  source: z6.string().min(1),
+  type: z6.enum(["package", "skill", "plugin", "mcp", "adapter"]).default("package"),
+  description: z6.string().default(""),
+  tags: z6.array(z6.string().min(1)).default([])
+});
+var registryIndexSchema = z6.union([
+  z6.array(registryEntrySchema),
+  z6.object({
+    schemaVersion: z6.literal(1).optional(),
+    entries: z6.array(registryEntrySchema)
+  })
+]).transform((value) => Array.isArray(value) ? value : value.entries);
+var registryCacheSchema = z6.object({
+  version: z6.literal(1),
+  fetchedAt: z6.string().datetime(),
+  sources: z6.array(z6.string().min(1)),
+  entries: z6.array(registryEntrySchema)
+});
+
+// src/registry/client.ts
+var DEFAULT_REGISTRY_SOURCE = "github:NestDevLab/agentwheel-registry";
+var DEFAULT_REGISTRY_TTL_MS = 24 * 60 * 60 * 1e3;
+var RegistryClient = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.cachePath = options.cachePath ?? defaultRegistryCachePath();
+  }
+  options;
+  git = new GitSourceDriver();
+  now;
+  cachePath;
+  async getIndex(options = {}) {
+    const sources = await this.getSources();
+    const ttlMs = await this.getTtlMs();
+    const cached = await this.readCache();
+    if (!options.refresh && cached && sameSources(cached.sources, sources) && !this.isExpired(cached, ttlMs)) {
+      return { entries: cached.entries, sources: cached.sources, fetchedAt: cached.fetchedAt, fromCache: true };
+    }
+    const entries = mergeIndexes(await Promise.all(sources.map((source) => this.fetchSource(source))));
+    const fetchedAt = this.now().toISOString();
+    await writeJsonAtomic(this.cachePath, { version: 1, fetchedAt, sources, entries });
+    return { entries, sources, fetchedAt, fromCache: false };
+  }
+  async resolve(name, options = {}) {
+    const index = await this.getIndex(options);
+    return index.entries.find((entry) => entry.name === name);
+  }
+  async search(query, options = {}) {
+    const q = query.toLowerCase();
+    const index = await this.getIndex(options);
+    return index.entries.filter(
+      (entry) => entry.name.toLowerCase().includes(q) || entry.description.toLowerCase().includes(q) || entry.tags.some((tag) => tag.toLowerCase().includes(q))
+    );
+  }
+  async clearCache() {
+    await rm6(this.cachePath, { force: true });
+  }
+  async getSources() {
+    if (this.options.sources?.length) return this.options.sources;
+    if (process.env.AGENTWHEEL_REGISTRY) {
+      return process.env.AGENTWHEEL_REGISTRY.split(",").map((source) => source.trim()).filter(Boolean);
+    }
+    if (this.options.workspaceRoot) {
+      const config = await readWorkspaceConfig(this.options.workspaceRoot);
+      if (config.registry.sources?.length) return config.registry.sources;
+    }
+    return [DEFAULT_REGISTRY_SOURCE];
+  }
+  async getTtlMs() {
+    if (this.options.ttlMs !== void 0) return this.options.ttlMs;
+    if (this.options.workspaceRoot) {
+      const config = await readWorkspaceConfig(this.options.workspaceRoot);
+      if (config.registry.ttlSeconds !== void 0) return config.registry.ttlSeconds * 1e3;
+    }
+    return DEFAULT_REGISTRY_TTL_MS;
+  }
+  async readCache() {
+    if (!await pathExists(this.cachePath)) return void 0;
+    return registryCacheSchema.parse(JSON.parse(await readFile9(this.cachePath, "utf8")));
+  }
+  isExpired(cache, ttlMs) {
+    return this.now().getTime() - new Date(cache.fetchedAt).getTime() > ttlMs;
+  }
+  async fetchSource(source) {
+    const raw = await this.readSourceIndex(source);
+    return registryIndexSchema.parse(JSON.parse(raw));
+  }
+  async readSourceIndex(source) {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      const response = await fetch(source);
+      if (!response.ok) throw new Error(`Registry source failed (${response.status}): ${source}`);
+      return response.text();
+    }
+    const filePath = source.startsWith("file:") ? fileURLToPath(source) : source;
+    if (await pathExists(filePath)) {
+      const fullPath = resolve8(filePath);
+      const stats = await stat6(fullPath);
+      return readFile9(stats.isDirectory() ? join15(fullPath, "index.json") : fullPath, "utf8");
+    }
+    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join15(dirname7(this.cachePath), "registry-repos") }));
+    return readFile9(join15(resolved.resolvedPath, "index.json"), "utf8");
+  }
+};
+async function resolvePackageSource(source, workspaceRoot) {
+  const { isExplicitSource } = await import("./identify-7SEBWCNQ.js");
+  if (await isExplicitSource(source)) return { source };
+  const entry = await new RegistryClient({ workspaceRoot }).resolve(source);
+  if (!entry) {
+    throw new Error(`Registry entry not found: ${source}. Use an explicit path/git/skillkit/vercel source to bypass the registry.`);
+  }
+  return { source: entry.source, registryEntry: entry };
+}
+function mergeIndexes(indexes) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const index of indexes) {
+    for (const entry of index) {
+      if (!merged.has(entry.name)) merged.set(entry.name, entry);
+    }
+  }
+  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function defaultRegistryCachePath() {
+  return join15(homedir3(), ".agentwheel", "registry-cache.json");
+}
+function sameSources(a, b) {
+  return a.length === b.length && a.every((source, index) => source === b[index]);
+}
+
+// src/lifecycle/profile.ts
+async function syncProfile(options) {
+  const config = await readWorkspaceConfig(options.workspaceRoot);
+  const profile = config.profiles[options.profile];
+  if (!profile) {
+    throw new Error(`Unknown profile: ${options.profile}`);
+  }
+  const packages = options.source ? [await packageFromSource(options.source, options)] : config.packages;
+  if (packages.length === 0) {
+    throw new Error("Profile sync needs a source argument or configured packages.");
+  }
+  const results = [];
+  for (const pkg of packages) {
+    for (const runtime of profile.runtimes) {
+      const targetRoot = runtime.targetRoot ?? options.workspaceRoot;
+      const adapter = await resolveAdapter({
+        adapter: runtime.adapter,
+        adapterConfig: runtime.adapterConfig,
+        adapterModule: runtime.adapterModule,
+        allowAdapterCode: options.allowAdapterCode,
+        baseDir: options.workspaceRoot,
+        warn: options.warn
+      });
+      const driver = getSourceDriver(pkg.driver);
+      const bundle = await stageSource(driver, pkg.source, {
+        workspaceRoot: options.workspaceRoot,
+        adapter,
+        cacheRoot: join16(options.workspaceRoot, ".agentwheel", "cache"),
+        mode: options.mode ?? pkg.mode
+      });
+      try {
+        const plan = await createInstallPlan(bundle, adapter, targetRoot, await readInstallManifest(targetRoot, adapter.name));
+        results.push({ runtime: adapter.name, packageName: pkg.name, plan });
+        if (!options.dryRun) {
+          await applyInstallPlan(plan, bundle.sourceLock, { executePlugins: runtime.executePlugins ?? options.executePlugins });
+        }
+      } finally {
+        await rm7(bundle.root, { recursive: true, force: true });
+      }
+    }
+  }
+  return results;
+}
+async function packageFromSource(source, options) {
+  const resolved = await resolvePackageSource(source, options.workspaceRoot);
+  const driver = options.driver ?? inferSourceDriverName(resolved.source);
+  return {
+    name: resolved.registryEntry?.name ?? source,
+    source: resolved.source,
+    driver,
+    adapter: "openclaw",
+    mode: options.mode ?? "pinned"
+  };
+}
+
 // src/lifecycle/update.ts
 function shouldUpdatePackage(pkg, lock) {
   if (!lock) {
@@ -1243,41 +1915,52 @@ program.command("init").argument("[kind]", "workspace or package", "workspace").
   await writeWorkspaceConfig(root, await readWorkspaceConfig(root));
   console.log("Initialized .agentwheel/config.json.");
 });
-program.command("add").argument("<source>", "package source").option("--driver <driver>", "source driver (local or git)").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--target-root <path>", "workspace root", process.cwd()).option("--mode <mode>", "pinned or tracking", "pinned").option("--name <name>", "package alias").action(async (source, options) => {
+program.command("add").argument("<source>", "package source").option("--driver <driver>", "source driver (local, git, skillkit, or vercel-skills)").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("--target-root <path>", "workspace root", process.cwd()).option("--mode <mode>", "pinned or tracking", "pinned").option("--name <name>", "package alias").action(async (source, options) => {
   const targetRoot = normalizeTargetRoot(options.targetRoot);
-  const driverName = options.driver ?? inferDriver(source);
+  const resolvedInput = await resolvePackageSource(source, targetRoot);
+  const resolvedSource = resolvedInput.source;
+  const driverName = options.driver ?? inferSourceDriverName(resolvedSource);
   const driver = getSourceDriver(driverName);
-  const adapter = options.adapterConfig ? await loadAdapterConfig(options.adapterConfig) : getAdapter(options.adapter);
-  const bundle = await stageSource(driver, source, {
+  const adapter = await resolveAdapter({
+    adapter: options.adapter,
+    adapterConfig: options.adapterConfig,
+    adapterModule: options.adapterModule,
+    allowAdapterCode: options.allowAdapterCode,
+    baseDir: targetRoot,
+    warn: (message) => console.warn(message)
+  });
+  const bundle = await stageSource(driver, resolvedSource, {
     workspaceRoot: targetRoot,
     adapter,
-    cacheRoot: join12(targetRoot, ".agentwheel", "cache"),
+    cacheRoot: join17(targetRoot, ".agentwheel", "cache"),
     mode: options.mode
   });
-  const name = options.name ?? bundle.source.packageName ?? source;
+  const name = options.name ?? resolvedInput.registryEntry?.name ?? bundle.source.packageName ?? source;
   const entry = {
     name,
-    source,
+    source: resolvedSource,
     driver: driverName,
     adapter: adapter.name,
     adapterConfig: options.adapterConfig,
+    adapterModule: options.adapterModule,
+    adapterCodeHash: adapter.programmatic?.hash,
     mode: options.mode,
     requestedRef: bundle.source.requestedRef
   };
   await writeWorkspaceConfig(targetRoot, upsertPackage(await readWorkspaceConfig(targetRoot), entry));
-  await rm6(bundle.root, { recursive: true, force: true });
+  await rm8(bundle.root, { recursive: true, force: true });
   console.log(`Added ${name}.`);
 });
-program.command("list").argument("<source>", "local source directory").option("--driver <driver>", "source driver", "local").action(async (source, options) => {
-  const driver = getSourceDriver(options.driver);
+program.command("list").argument("<source>", "local source directory").option("--driver <driver>", "source driver").action(async (source, options) => {
+  const driver = getSourceDriver(options.driver ?? inferSourceDriverName(source));
   const resolved = await driver.resolve(source);
   const artifacts = await driver.list(resolved);
   for (const artifact of artifacts) {
     console.log(`${artifact.type}	${artifact.name}	${artifact.relativePath}`);
   }
 });
-program.command("scan").argument("<source>", "local source directory").option("--driver <driver>", "source driver", "local").action(async (source, options) => {
-  const driver = getSourceDriver(options.driver);
+program.command("scan").argument("<source>", "local source directory").option("--driver <driver>", "source driver").action(async (source, options) => {
+  const driver = getSourceDriver(options.driver ?? inferSourceDriverName(source));
   const resolved = await driver.resolve(source);
   const result = await driver.scan(resolved);
   if (result.findings.length === 0) {
@@ -1289,23 +1972,47 @@ program.command("scan").argument("<source>", "local source directory").option("-
   }
   if (!result.ok) process.exitCode = 1;
 });
-program.command("plan").argument("<source>", "source directory").option("--driver <driver>", "source driver", "local").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--target-root <path>", "runtime/project root", process.cwd()).option("--mode <mode>", "pinned or tracking").action(async (source, options) => {
+program.command("plan").argument("<source>", "source directory").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("--target-root <path>", "runtime/project root", process.cwd()).option("--mode <mode>", "pinned or tracking").action(async (source, options) => {
   const { plan, bundle } = await buildPlan(source, options);
   console.log(formatPlan(plan));
-  await rm6(bundle.root, { recursive: true, force: true });
+  await rm8(bundle.root, { recursive: true, force: true });
   if (plan.hasBlockingChanges) process.exitCode = 1;
 });
-program.command("sync").argument("<source>", "source directory").option("--driver <driver>", "source driver", "local").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--target-root <path>", "runtime/project root", process.cwd()).option("--mode <mode>", "pinned or tracking").option("--dry-run", "show plan without writing", false).option("--execute-plugins", "execute semantic plugin installs", false).action(async (source, options) => {
+program.command("sync").argument("[source]", "source directory").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter", "openclaw").option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("--target-root <path>", "runtime/project root", process.cwd()).option("--mode <mode>", "pinned or tracking").option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--execute-plugins", "execute semantic plugin installs", false).action(async (source, options) => {
+  if (options.profile) {
+    const targetRoot = normalizeTargetRoot(options.targetRoot);
+    const results = await syncProfile({
+      workspaceRoot: targetRoot,
+      profile: options.profile,
+      source,
+      driver: options.driver,
+      mode: options.mode,
+      dryRun: options.dryRun,
+      executePlugins: options.executePlugins,
+      allowAdapterCode: options.allowAdapterCode,
+      warn: (message) => console.warn(message)
+    });
+    for (const result of results) {
+      console.log(`Profile ${options.profile} / ${result.runtime} / ${result.packageName}:`);
+      console.log(formatPlan(result.plan));
+      if (result.plan.hasBlockingChanges) process.exitCode = 1;
+    }
+    if (!options.dryRun) console.log("Applied.");
+    return;
+  }
+  if (!source) {
+    throw new Error("sync requires a source unless --profile is used");
+  }
   const { plan, bundle } = await buildPlan(source, options);
   console.log(formatPlan(plan));
   if (!options.dryRun) {
     await applyInstallPlan(plan, bundle.sourceLock, { executePlugins: options.executePlugins });
     console.log("Applied.");
   }
-  await rm6(bundle.root, { recursive: true, force: true });
+  await rm8(bundle.root, { recursive: true, force: true });
   if (plan.hasBlockingChanges) process.exitCode = 1;
 });
-program.command("update").option("--target-root <path>", "workspace root", process.cwd()).option("--dry-run", "show plans without writing", false).option("--execute-plugins", "execute semantic plugin installs", false).action(async (options) => {
+program.command("update").option("--target-root <path>", "workspace root", process.cwd()).option("--dry-run", "show plans without writing", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--allow-adapter-code", "allow loading local adapter code from configured packages", false).action(async (options) => {
   const targetRoot = normalizeTargetRoot(options.targetRoot);
   const config = await readWorkspaceConfig(targetRoot);
   if (config.packages.length === 0) {
@@ -1313,7 +2020,14 @@ program.command("update").option("--target-root <path>", "workspace root", proce
     return;
   }
   for (const pkg of config.packages) {
-    const adapter = pkg.adapterConfig ? await loadAdapterConfig(pkg.adapterConfig) : getAdapter(pkg.adapter);
+    const adapter = await resolveAdapter({
+      adapter: pkg.adapter,
+      adapterConfig: pkg.adapterConfig,
+      adapterModule: pkg.adapterModule,
+      allowAdapterCode: options.allowAdapterCode,
+      baseDir: targetRoot,
+      warn: (message) => console.warn(message)
+    });
     const lock = await readSourceLock(targetRoot, adapter.name);
     const decision = shouldUpdatePackage(pkg, lock);
     if (!decision.shouldUpdate) {
@@ -1324,6 +2038,8 @@ program.command("update").option("--target-root <path>", "workspace root", proce
       driver: pkg.driver,
       adapter: pkg.adapter,
       adapterConfig: pkg.adapterConfig,
+      adapterModule: pkg.adapterModule,
+      allowAdapterCode: options.allowAdapterCode,
       targetRoot,
       mode: pkg.mode
     });
@@ -1333,10 +2049,27 @@ program.command("update").option("--target-root <path>", "workspace root", proce
       await applyInstallPlan(plan, bundle.sourceLock, { executePlugins: options.executePlugins });
       console.log(`Applied ${pkg.name}.`);
     }
-    await rm6(bundle.root, { recursive: true, force: true });
+    await rm8(bundle.root, { recursive: true, force: true });
     if (plan.hasBlockingChanges) process.exitCode = 1;
   }
 });
+program.command("registry").description("manage optional registry indexes").addCommand(
+  new Command("update").description("refresh the local registry cache").option("--target-root <path>", "workspace root", process.cwd()).action(async (options) => {
+    const client = new RegistryClient({ workspaceRoot: normalizeTargetRoot(options.targetRoot) });
+    const index = await client.getIndex({ refresh: true });
+    console.log(`Registry refreshed: ${index.entries.length} entries from ${index.sources.join(", ")}`);
+  })
+).addCommand(
+  new Command("list").description("list available registry entries").option("--target-root <path>", "workspace root", process.cwd()).action(async (options) => {
+    const client = new RegistryClient({ workspaceRoot: normalizeTargetRoot(options.targetRoot) });
+    printRegistryEntries((await client.getIndex()).entries);
+  })
+).addCommand(
+  new Command("search").description("search registry entries").argument("<query>", "search query").option("--target-root <path>", "workspace root", process.cwd()).action(async (query, options) => {
+    const client = new RegistryClient({ workspaceRoot: normalizeTargetRoot(options.targetRoot) });
+    printRegistryEntries(await client.search(query));
+  })
+);
 program.command("remember").requiredOption("--runtime <runtime>", "runtime/adapter name").option("--target-root <path>", "workspace root", process.cwd()).argument("<text>", "text to append to the local instructions overlay").action(async (text, options) => {
   const targetRoot = normalizeTargetRoot(options.targetRoot);
   const result = await remember(targetRoot, options.runtime, text);
@@ -1347,27 +2080,45 @@ program.command("eject").argument("<item>", "package/type/name").option("--targe
   const result = await ejectArtifact(targetRoot, item);
   console.log(`Ejected ${item} to ${result.ejectedPath}.`);
 });
-program.command("uninstall").option("--adapter <adapter>", "adapter", "openclaw").option("--target-root <path>", "runtime/project root", process.cwd()).option("--dry-run", "show removals without writing", false).action(async (options) => {
+program.command("uninstall").option("--adapter <adapter>", "adapter", "openclaw").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("--target-root <path>", "runtime/project root", process.cwd()).option("--dry-run", "show removals without writing", false).action(async (options) => {
   const targetRoot = normalizeTargetRoot(options.targetRoot);
-  const manifest = await readInstallManifest(targetRoot, options.adapter);
+  const programmaticAdapter = options.adapterModule ? await resolveAdapter({
+    adapter: options.adapter,
+    adapterModule: options.adapterModule,
+    allowAdapterCode: options.allowAdapterCode,
+    baseDir: targetRoot,
+    warn: (message) => console.warn(message)
+  }) : void 0;
+  const adapterName = programmaticAdapter?.name ?? options.adapter;
+  const manifest = await readInstallManifest(targetRoot, adapterName);
   if (!manifest) {
-    console.log(`No install manifest for ${options.adapter} at ${targetRoot}`);
+    console.log(`No install manifest for ${adapterName} at ${targetRoot}`);
     return;
   }
   const plan = await createUninstallPlan(manifest);
   console.log(formatPlan(plan));
   await uninstall(plan, options.dryRun);
+  if (!options.dryRun && programmaticAdapter) {
+    await programmaticAdapter.programmatic?.uninstall?.({ targetRoot, adapterName: programmaticAdapter.name });
+  }
   if (!options.dryRun) console.log("Uninstalled.");
   if (plan.hasBlockingChanges) process.exitCode = 1;
 });
 async function buildPlan(source, options) {
-  const driver = getSourceDriver(options.driver ?? inferDriver(source));
-  const adapter = options.adapterConfig ? await loadAdapterConfig(options.adapterConfig) : getAdapter(options.adapter);
+  const driver = getSourceDriver(options.driver ?? inferSourceDriverName(source));
   const targetRoot = normalizeTargetRoot(options.targetRoot);
+  const adapter = await resolveAdapter({
+    adapter: options.adapter,
+    adapterConfig: options.adapterConfig,
+    adapterModule: options.adapterModule,
+    allowAdapterCode: options.allowAdapterCode,
+    baseDir: targetRoot,
+    warn: (message) => console.warn(message)
+  });
   const bundle = await stageSource(driver, source, {
     workspaceRoot: targetRoot,
     adapter,
-    cacheRoot: join12(targetRoot, ".agentwheel", "cache"),
+    cacheRoot: join17(targetRoot, ".agentwheel", "cache"),
     mode: options.mode
   });
   const manifest = await readInstallManifest(targetRoot, adapter.name);
@@ -1375,10 +2126,10 @@ async function buildPlan(source, options) {
   return { plan, bundle };
 }
 async function initPackage(root) {
-  await mkdir6(join12(root, "instructions"), { recursive: true });
-  await mkdir6(join12(root, "rules"), { recursive: true });
-  await mkdir6(join12(root, "skills"), { recursive: true });
-  const manifestPath = join12(root, "agentwheel.json");
+  await mkdir7(join17(root, "instructions"), { recursive: true });
+  await mkdir7(join17(root, "rules"), { recursive: true });
+  await mkdir7(join17(root, "skills"), { recursive: true });
+  const manifestPath = join17(root, "agentwheel.json");
   const manifest = {
     schemaVersion: 1,
     name: "example/agentwheel-package",
@@ -1389,12 +2140,15 @@ async function initPackage(root) {
       { type: "skills", path: "skills" }
     ]
   };
-  await writeFile3(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await writeFile4(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  await writeFile3(join12(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
+  await writeFile4(join17(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
 }
-function inferDriver(source) {
-  return source.startsWith("github:") || source.startsWith("git:") ? "git" : "local";
+function printRegistryEntries(entries) {
+  for (const entry of entries) {
+    const tags = entry.tags?.length ? ` [${entry.tags.join(",")}]` : "";
+    console.log(`${entry.name}	${entry.type}	${entry.source}	${entry.description}${tags}`);
+  }
 }
 program.parseAsync().catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));