@actiondock/cli 2.0.10 → 2.0.11

package/dist/index.js

@@ -24271,6 +24271,10 @@ app.run(process.argv.slice(2)).catch((err: unknown) => {
 });
 `;
 }
+// ../core/src/catalog/action-index.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+
 // ../core/src/project/manifest.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join2, relative } from "path";
@@ -24926,11 +24930,176 @@ async function syncManifest(projectRoot, options = {}) {
     unchanged
   };
 }
+
+// ../core/src/catalog/action-index.ts
+class ActionIndex {
+  actions = new Map;
+  constructor(snapshot) {
+    this.indexSnapshot(snapshot);
+  }
+  indexSnapshot(snapshot) {
+    for (const [packageId, pkg] of snapshot.packages) {
+      const manifest = loadManifest(pkg.projectRoot);
+      if (manifest && manifest.actions) {
+        for (const [actionId, item] of Object.entries(manifest.actions)) {
+          const indexed = {
+            packageId,
+            actionId,
+            contract: {
+              id: actionId,
+              description: item.description,
+              inputSchema: item.inputSchema,
+              outputSchema: item.outputSchema,
+              uses: item.uses,
+              tags: item.tags,
+              annotations: item.annotations
+            },
+            entry: item.entry,
+            projectRoot: pkg.projectRoot
+          };
+          this.add(indexed);
+        }
+      } else {
+        const actionsDir = join3(pkg.projectRoot, pkg.config.actionsDir || "actions");
+        if (existsSync3(actionsDir)) {
+          try {
+            const files = readdirSync2(actionsDir);
+            for (const file of files) {
+              if (file.endsWith(".ts") || file.endsWith(".js")) {
+                const actionId = file.replace(/\.(ts|js)$/, "");
+                const indexed = {
+                  packageId,
+                  actionId,
+                  contract: {
+                    id: actionId
+                  },
+                  entry: join3(pkg.config.actionsDir || "actions", file),
+                  projectRoot: pkg.projectRoot
+                };
+                this.add(indexed);
+              }
+            }
+          } catch {}
+        }
+      }
+    }
+  }
+  add(action) {
+    let list = this.actions.get(action.actionId);
+    if (!list) {
+      list = [];
+      this.actions.set(action.actionId, list);
+    }
+    list.push(action);
+  }
+  list(packageId) {
+    const all = [];
+    for (const [_, list] of this.actions) {
+      for (const action of list) {
+        if (!packageId || action.packageId === packageId) {
+          all.push(action);
+        }
+      }
+    }
+    return all;
+  }
+  find(actionId, packageId) {
+    const matches = this.actions.get(actionId) || [];
+    if (packageId) {
+      return matches.filter((a) => a.packageId === packageId);
+    }
+    return matches;
+  }
+}
+// ../core/src/catalog/action-resolver.ts
+class ActionResolver {
+  snapshot;
+  index;
+  constructor(snapshot, index) {
+    this.snapshot = snapshot;
+    this.index = index || new ActionIndex(snapshot);
+  }
+  static parseRef(refStringOrObj) {
+    if (typeof refStringOrObj === "object") {
+      return refStringOrObj;
+    }
+    const str = refStringOrObj.trim();
+    if (str.includes("/")) {
+      const lastSlashIndex = str.lastIndexOf("/");
+      const packageId = str.slice(0, lastSlashIndex);
+      const actionId = str.slice(lastSlashIndex + 1);
+      if (actionId.includes(":") || actionId.includes("/") || actionId.includes("..")) {
+        throw new Error(`Invalid action identifier: '${actionId}'`);
+      }
+      return { packageId, actionId };
+    }
+    if (str.includes(":")) {
+      const parts = str.split(":");
+      throw new Error(`Legacy syntax '${str}' is deprecated. Please use '${parts.join("/")}' instead.`);
+    }
+    return { actionId: str };
+  }
+  resolve(refStringOrObj, options = {}) {
+    const ref = ActionResolver.parseRef(refStringOrObj);
+    if (ref.packageId) {
+      const matches = this.index.find(ref.actionId, ref.packageId);
+      if (matches.length === 0) {
+        throw new Error(`ACTION_NOT_FOUND: Action '${ref.actionId}' not found in package '${ref.packageId}'`);
+      }
+      const matched = matches[0];
+      const pkg = this.snapshot.packages.get(matched.packageId);
+      return {
+        resolved: {
+          packageId: matched.packageId,
+          packageInstanceId: pkg?.packageInstanceId || matched.packageId,
+          actionId: matched.actionId,
+          generationId: this.snapshot.generationId
+        },
+        action: matched
+      };
+    }
+    if (options.currentPackageId) {
+      const inCurrent = this.index.find(ref.actionId, options.currentPackageId);
+      if (inCurrent.length > 0) {
+        const matched = inCurrent[0];
+        const pkg = this.snapshot.packages.get(matched.packageId);
+        return {
+          resolved: {
+            packageId: matched.packageId,
+            packageInstanceId: pkg?.packageInstanceId || matched.packageId,
+            actionId: matched.actionId,
+            generationId: this.snapshot.generationId
+          },
+          action: matched
+        };
+      }
+    }
+    const allMatches = this.index.find(ref.actionId);
+    if (allMatches.length === 0) {
+      throw new Error(`ACTION_NOT_FOUND: Action '${ref.actionId}' not found in any linked package`);
+    }
+    if (allMatches.length > 1) {
+      const candidates = allMatches.map((m) => `${m.packageId}/${m.actionId}`).join(", ");
+      throw new Error(`AMBIGUOUS_ACTION_REF: Action '${ref.actionId}' is provided by multiple packages: ${candidates}. Please specify the package name.`);
+    }
+    const matched = allMatches[0];
+    const pkg = this.snapshot.packages.get(matched.packageId);
+    return {
+      resolved: {
+        packageId: matched.packageId,
+        packageInstanceId: pkg?.packageInstanceId || matched.packageId,
+        actionId: matched.actionId,
+        generationId: this.snapshot.generationId
+      },
+      action: matched
+    };
+  }
+}
 // ../core/src/utils/index.ts
 import { homedir as homedir2 } from "os";
 // ../sdk/src/cli.ts
-import { existsSync as existsSync3 } from "fs";
-import { delimiter, join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { delimiter, join as join4 } from "path";
 function findExecutable(command) {
   if (typeof globalThis.Bun !== "undefined" && typeof globalThis.Bun.which === "function") {
     try {
@@ -24941,7 +25110,7 @@ function findExecutable(command) {
   }
   const hasPathSep = command.includes("/") || command.includes("\\");
   if (hasPathSep) {
-    return existsSync3(command) ? command : null;
+    return existsSync4(command) ? command : null;
   }
   const pathEnv = process.env.PATH || "";
   const dirs = pathEnv.split(delimiter);
@@ -24951,8 +25120,8 @@ function findExecutable(command) {
     if (!dir)
       continue;
     for (const ext of pathext) {
-      const candidate = join3(dir, isWindows && !command.includes(".") ? command + ext : command);
-      if (existsSync3(candidate)) {
+      const candidate = join4(dir, isWindows && !command.includes(".") ? command + ext : command);
+      if (existsSync4(candidate)) {
         return candidate;
       }
     }
@@ -25002,8 +25171,8 @@ function getActionDockHome(customHome) {
   return customHome || process.env.ACTIONDOCK_HOME || homedir2();
 }
 // ../core/src/registry/registry.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename2, dirname as dirname2, join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, dirname as dirname2, join as join5, resolve as resolve3 } from "path";
 var IGNORED_SCAN_DIRS = new Set([
   "node_modules",
   ".git",
@@ -25022,7 +25191,7 @@ function discoverProjects(dir, maxDepth = 3) {
     if (currentDepth > maxDepth)
       return;
     try {
-      const entries = readdirSync2(currentDir, { withFileTypes: true });
+      const entries = readdirSync3(currentDir, { withFileTypes: true });
       const hasActiondock = entries.some((e) => e.isFile() && e.name === "actiondock.json");
       if (hasActiondock && currentDir !== resolvedDir) {
         results.push(currentDir);
@@ -25030,7 +25199,7 @@ function discoverProjects(dir, maxDepth = 3) {
       }
       for (const entry of entries) {
         if (entry.isDirectory() && !IGNORED_SCAN_DIRS.has(entry.name)) {
-          walk(join4(currentDir, entry.name), currentDepth + 1);
+          walk(join5(currentDir, entry.name), currentDepth + 1);
         }
       }
     } catch {}
@@ -25040,11 +25209,11 @@ function discoverProjects(dir, maxDepth = 3) {
 }
 function getRegistryFilePath(customHome) {
   const baseDir = getActionDockHome(customHome);
-  return join4(baseDir, ".actiondock", "registry.json");
+  return join5(baseDir, ".actiondock", "registry.json");
 }
 function loadRegistry(customHome) {
   const filePath = getRegistryFilePath(customHome);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return { version: "2.0.0", packages: {}, workspaces: {} };
   }
   try {
@@ -25070,7 +25239,7 @@ function saveRegistry(data, customHome) {
 }
 function linkPackage(targetPath = process.cwd(), customHome, options) {
   const absPath = resolve3(targetPath);
-  const directHasConfig = existsSync4(join4(absPath, "actiondock.json"));
+  const directHasConfig = existsSync5(join5(absPath, "actiondock.json"));
   if (directHasConfig && !options?.recursive) {
     const config = loadProjectConfig(absPath);
     const registry = loadRegistry(customHome);
@@ -25231,7 +25400,7 @@ function listLinkedPackages(customHome) {
   const result = { ...registry.packages };
   if (registry.workspaces) {
     for (const ws of Object.values(registry.workspaces)) {
-      if (!existsSync4(ws.path))
+      if (!existsSync5(ws.path))
         continue;
       const discovered = discoverProjects(ws.path);
       for (const root of discovered) {
@@ -25265,6 +25434,110 @@ async function projectHasAction(projectRoot, actionsDir, actionId) {
     return false;
   }
 }
+function projectHasActionSync(projectRoot, actionsDir, actionId) {
+  const manifest = loadManifest(projectRoot);
+  if (manifest?.actions && actionId in manifest.actions) {
+    return true;
+  }
+  const dir = join5(projectRoot, actionsDir || "actions");
+  if (!existsSync5(dir)) {
+    return false;
+  }
+  if (actionId.includes("..") || actionId.startsWith("/") || actionId.startsWith("\\")) {
+    return false;
+  }
+  if (existsSync5(join5(dir, `${actionId}.ts`)) || existsSync5(join5(dir, `${actionId}.js`))) {
+    return true;
+  }
+  const relFile = actionId.replace(/\./g, "/");
+  if (existsSync5(join5(dir, `${relFile}.ts`)) || existsSync5(join5(dir, `${relFile}.js`))) {
+    return true;
+  }
+  return false;
+}
+function resolveActionProjectSync(actionIdentifier, cwd = process.cwd(), customHome) {
+  const currentRoot = findProjectRoot(cwd);
+  if (currentRoot) {
+    try {
+      const config = loadProjectConfig(currentRoot);
+      if (projectHasActionSync(currentRoot, config.actionsDir, actionIdentifier)) {
+        return {
+          projectRoot: currentRoot,
+          packageId: config.id,
+          actionId: actionIdentifier
+        };
+      }
+    } catch {}
+  }
+  let targetPackage;
+  let pureActionId = actionIdentifier;
+  if (actionIdentifier.includes("/")) {
+    const slashIdx = actionIdentifier.lastIndexOf("/");
+    targetPackage = actionIdentifier.slice(0, slashIdx);
+    pureActionId = actionIdentifier.slice(slashIdx + 1);
+  } else if (actionIdentifier.includes(":")) {
+    const colonIdx = actionIdentifier.lastIndexOf(":");
+    targetPackage = actionIdentifier.slice(0, colonIdx);
+    pureActionId = actionIdentifier.slice(colonIdx + 1);
+  }
+  const linkedList = listLinkedPackages(customHome);
+  if (targetPackage) {
+    let targetRoot;
+    let targetPkgId = targetPackage;
+    const pkg = linkedList.find((p) => p.id === targetPackage || getPackageSlug(p.id) === targetPackage);
+    if (pkg && existsSync5(pkg.path)) {
+      targetRoot = pkg.path;
+      targetPkgId = pkg.id;
+    } else if (currentRoot) {
+      try {
+        const config = loadProjectConfig(currentRoot);
+        if (config.id === targetPackage || getPackageSlug(config.id) === targetPackage) {
+          targetRoot = currentRoot;
+          targetPkgId = config.id;
+        }
+      } catch {}
+    }
+    if (!targetRoot || !existsSync5(targetRoot)) {
+      throw new Error(`Linked package '${targetPackage}' not found or path no longer exists (${pkg?.path || "unregistered"}). Run 'ad link' in the package directory.`);
+    }
+    const config = loadProjectConfig(targetRoot);
+    if (!projectHasActionSync(targetRoot, config.actionsDir, pureActionId)) {
+      throw new Error(`Action '${pureActionId}' not found in package '${targetPkgId}' (${targetRoot})`);
+    }
+    return {
+      projectRoot: targetRoot,
+      packageId: targetPkgId,
+      actionId: pureActionId
+    };
+  }
+  const matches = [];
+  for (const pkg of linkedList) {
+    if (!existsSync5(pkg.path))
+      continue;
+    try {
+      const config = loadProjectConfig(pkg.path);
+      if (projectHasActionSync(pkg.path, config.actionsDir, actionIdentifier)) {
+        matches.push({ entry: pkg, actionId: actionIdentifier });
+      }
+    } catch {}
+  }
+  if (matches.length === 1) {
+    return {
+      projectRoot: matches[0].entry.path,
+      packageId: matches[0].entry.id,
+      actionId: matches[0].actionId
+    };
+  }
+  if (matches.length > 1) {
+    const pkgList = matches.map((m) => `'${m.entry.id}'`).join(", ");
+    throw new Error(`Action '${actionIdentifier}' is provided by multiple linked packages: ${pkgList}. Please specify using '<package-id>/${actionIdentifier}'.`);
+  }
+  if (currentRoot) {
+    throw new Error(`Action '${actionIdentifier}' not found in current project or any linked packages`);
+  } else {
+    throw new Error(`Action '${actionIdentifier}' not found. You are not in an ActionDock project, and no linked package provides '${actionIdentifier}'. Use 'ad link' to register your package.`);
+  }
+}
 async function resolveActionProject(actionIdentifier, cwd = process.cwd(), customHome) {
   const currentRoot = findProjectRoot(cwd);
   if (currentRoot) {
@@ -25282,11 +25555,11 @@ async function resolveActionProject(actionIdentifier, cwd = process.cwd(), custo
   let targetPackage;
   let pureActionId = actionIdentifier;
   if (actionIdentifier.includes("/")) {
-    const slashIdx = actionIdentifier.indexOf("/");
+    const slashIdx = actionIdentifier.lastIndexOf("/");
     targetPackage = actionIdentifier.slice(0, slashIdx);
     pureActionId = actionIdentifier.slice(slashIdx + 1);
   } else if (actionIdentifier.includes(":")) {
-    const colonIdx = actionIdentifier.indexOf(":");
+    const colonIdx = actionIdentifier.lastIndexOf(":");
     targetPackage = actionIdentifier.slice(0, colonIdx);
     pureActionId = actionIdentifier.slice(colonIdx + 1);
   }
@@ -25295,7 +25568,7 @@ async function resolveActionProject(actionIdentifier, cwd = process.cwd(), custo
     let targetRoot;
     let targetPkgId = targetPackage;
     const pkg = linkedList.find((p) => p.id === targetPackage || getPackageSlug(p.id) === targetPackage);
-    if (pkg && existsSync4(pkg.path)) {
+    if (pkg && existsSync5(pkg.path)) {
       targetRoot = pkg.path;
       targetPkgId = pkg.id;
     } else if (currentRoot) {
@@ -25307,7 +25580,7 @@ async function resolveActionProject(actionIdentifier, cwd = process.cwd(), custo
         }
       } catch {}
     }
-    if (!targetRoot || !existsSync4(targetRoot)) {
+    if (!targetRoot || !existsSync5(targetRoot)) {
       throw new Error(`Linked package '${targetPackage}' not found or path no longer exists (${pkg?.path || "unregistered"}). Run 'ad link' in the package directory.`);
     }
     const config = loadProjectConfig(targetRoot);
@@ -25322,7 +25595,7 @@ async function resolveActionProject(actionIdentifier, cwd = process.cwd(), custo
   }
   const matches = [];
   for (const pkg of linkedList) {
-    if (!existsSync4(pkg.path))
+    if (!existsSync5(pkg.path))
       continue;
     try {
       const config = loadProjectConfig(pkg.path);
@@ -25354,11 +25627,11 @@ function resolvePackageRoot(packageIdOrPath, cwd, customHome) {
   }
   const baseDir = cwd || process.cwd();
   const resolvedPath = resolve3(baseDir, packageIdOrPath);
-  if (existsSync4(resolvedPath)) {
+  if (existsSync5(resolvedPath)) {
     try {
       const stat = statSync2(resolvedPath);
       const targetDir = stat.isDirectory() ? resolvedPath : dirname2(resolvedPath);
-      if (existsSync4(join4(targetDir, "actiondock.json"))) {
+      if (existsSync5(join5(targetDir, "actiondock.json"))) {
         return targetDir;
       }
       const parentRoot = findProjectRoot(targetDir);
@@ -25419,7 +25692,7 @@ function resolvePlaybookProject(playbookIdentifier, cwd = process.cwd(), customH
     let targetRoot;
     let targetPkgId = targetPackage;
     const pkg = linkedList.find((p) => p.id === targetPackage || getPackageSlug(p.id) === targetPackage);
-    if (pkg && existsSync4(pkg.path)) {
+    if (pkg && existsSync5(pkg.path)) {
       targetRoot = pkg.path;
       targetPkgId = pkg.id;
     } else if (currentRoot) {
@@ -25431,7 +25704,7 @@ function resolvePlaybookProject(playbookIdentifier, cwd = process.cwd(), customH
         }
       } catch {}
     }
-    if (!targetRoot || !existsSync4(targetRoot)) {
+    if (!targetRoot || !existsSync5(targetRoot)) {
       throw new Error(`Linked package '${targetPackage}' not found or path no longer exists (${pkg?.path || "unregistered"}). Run 'ad link' in the package directory.`);
     }
     const config = loadProjectConfig(targetRoot);
@@ -25449,7 +25722,7 @@ function resolvePlaybookProject(playbookIdentifier, cwd = process.cwd(), customH
   }
   const matches = [];
   for (const pkg of linkedList) {
-    if (!existsSync4(pkg.path))
+    if (!existsSync5(pkg.path))
       continue;
     try {
       const config = loadProjectConfig(pkg.path);
@@ -25489,7 +25762,7 @@ function getRegistryStatus(customHome) {
   const seenPackageIds = new Set;
   if (registry.workspaces) {
     for (const [wsPath, wsEntry] of Object.entries(registry.workspaces)) {
-      const isWsActive = existsSync4(wsPath);
+      const isWsActive = existsSync5(wsPath);
       if (!isWsActive) {
         staleCount++;
         workspaces.push({
@@ -25534,7 +25807,7 @@ function getRegistryStatus(customHome) {
     if (seenPackageIds.has(pkgId)) {
       continue;
     }
-    const isPkgActive = existsSync4(pkgEntry.path);
+    const isPkgActive = existsSync5(pkgEntry.path);
     if (!isPkgActive) {
       staleCount++;
       packages.push({
@@ -25570,14 +25843,14 @@ function pruneRegistry(customHome) {
   const prunedPackages = [];
   if (registry.workspaces) {
     for (const [wsPath, wsEntry] of Object.entries(registry.workspaces)) {
-      if (!existsSync4(wsPath)) {
+      if (!existsSync5(wsPath)) {
         prunedWorkspaces.push(wsEntry);
         delete registry.workspaces[wsPath];
       }
     }
   }
   for (const [pkgId, pkgEntry] of Object.entries(registry.packages)) {
-    if (!existsSync4(pkgEntry.path)) {
+    if (!existsSync5(pkgEntry.path)) {
       prunedPackages.push(pkgEntry);
       delete registry.packages[pkgId];
     }
@@ -25591,14 +25864,14 @@ function pruneRegistry(customHome) {
   };
 }
 // ../core/src/doctor/doctor.ts
-import { existsSync as existsSync6, statSync as statSync3 } from "fs";
-import { join as join6, relative as relative2 } from "path";
+import { existsSync as existsSync7, statSync as statSync3 } from "fs";
+import { join as join7, relative as relative2 } from "path";
 
 // ../core/src/storage/index.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // ../core/src/storage/sqlite.ts
-import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname3 } from "path";
 
 // ../core/src/runtime/clock.ts
@@ -25742,7 +26015,7 @@ class SqliteRuntimeStorage {
     const dbPath = options.dbPath || ":memory:";
     if (dbPath !== ":memory:") {
       const dir = dirname3(dbPath);
-      if (!existsSync5(dir)) {
+      if (!existsSync6(dir)) {
         try {
           mkdirSync2(dir, { recursive: true, mode: 448 });
           chmodSync(dir, 448);
@@ -25750,7 +26023,7 @@ class SqliteRuntimeStorage {
       }
     }
     this.driver = options.driver ?? createDefaultSqliteDriver(dbPath);
-    if (dbPath !== ":memory:" && existsSync5(dbPath)) {
+    if (dbPath !== ":memory:" && existsSync6(dbPath)) {
       try {
         chmodSync(dbPath, 384);
       } catch {}
@@ -26254,12 +26527,12 @@ function resolveDatabasePath(packageId, options = {}) {
     return ":memory:";
   }
   if (options.dataDir) {
-    return join5(options.dataDir, packageId, "runtime.db");
+    return join6(options.dataDir, packageId, "runtime.db");
   }
   if (options.projectRoot) {
-    return join5(options.projectRoot, ".actiondock", "runtime.db");
+    return join6(options.projectRoot, ".actiondock", "runtime.db");
   }
-  return join5(getActionDockHome(), ".actiondock", "data", packageId, "runtime.db");
+  return join6(getActionDockHome(), ".actiondock", "data", packageId, "runtime.db");
 }
 function createStorage(packageId, options = {}) {
   const dbPath = resolveDatabasePath(packageId, options);
@@ -26275,7 +26548,7 @@ function createGlobalStorage(customHomeOrOptions, dataDirArg) {
     customHome = customHomeOrOptions;
     dataDir = dataDirArg;
   }
-  const dbPath = dataDir ? join5(dataDir, "global.db") : join5(getActionDockHome(customHome), ".actiondock", "global.db");
+  const dbPath = dataDir ? join6(dataDir, "global.db") : join6(getActionDockHome(customHome), ".actiondock", "global.db");
   return new SqliteRuntimeStorage({ dbPath, packageId: "__global__" });
 }
 
@@ -26415,7 +26688,7 @@ async function runDoctorChecks(options) {
         status: "ok",
         message: `Valid (${config.id} v${config.version})`
       });
-      const hasSdkInNodeModules = existsSync6(join6(projectRoot, "node_modules", "@actiondock", "sdk")) || existsSync6(join6(projectRoot, "node_modules", "@actiondock", "sdk", "package.json"));
+      const hasSdkInNodeModules = existsSync7(join7(projectRoot, "node_modules", "@actiondock", "sdk")) || existsSync7(join7(projectRoot, "node_modules", "@actiondock", "sdk", "package.json"));
       if (hasSdkInNodeModules) {
         checks.push({
           id: "project.sdk",
@@ -26444,7 +26717,7 @@ async function runDoctorChecks(options) {
           category: "project",
           name: "Project Database",
           status: "ok",
-          message: `Database writable at ${join6(projectRoot, ".actiondock", "runtime.db")}`
+          message: `Database writable at ${join7(projectRoot, ".actiondock", "runtime.db")}`
         });
       } catch (err) {
         checks.push({
@@ -26453,7 +26726,7 @@ async function runDoctorChecks(options) {
           name: "Project Database",
           status: "error",
           message: `Failed to write project runtime database: ${err.message}`,
-          fix: `Check write permissions for '${join6(projectRoot, ".actiondock")}'`
+          fix: `Check write permissions for '${join7(projectRoot, ".actiondock")}'`
         });
       }
       try {
@@ -26493,10 +26766,10 @@ async function runDoctorChecks(options) {
         });
       }
       try {
-        const manifestPath = join6(projectRoot, MANIFEST_FILE_NAME);
+        const manifestPath = join7(projectRoot, MANIFEST_FILE_NAME);
         const manifest = loadManifest(projectRoot);
         const actionFiles = discoverActionFiles(projectRoot, config.actionsDir || "actions");
-        if (!existsSync6(manifestPath)) {
+        if (!existsSync7(manifestPath)) {
           if (actionFiles.length > 0) {
             checks.push({
               id: "project.manifest",
@@ -26508,7 +26781,7 @@ async function runDoctorChecks(options) {
             });
           }
         } else if (manifest && manifest.actions) {
-          const missingFiles = Object.entries(manifest.actions).filter(([_, item]) => !existsSync6(join6(projectRoot, item.entry))).map(([id, item]) => `${id} (${item.entry})`);
+          const missingFiles = Object.entries(manifest.actions).filter(([_, item]) => !existsSync7(join7(projectRoot, item.entry))).map(([id, item]) => `${id} (${item.entry})`);
           const manifestEntries = new Set(Object.values(manifest.actions).map((a) => a.entry.replace(/\\/g, "/")));
           const untracked = actionFiles.map((f) => relative2(projectRoot, f).replace(/\\/g, "/")).filter((rel) => !manifestEntries.has(rel));
           if (missingFiles.length > 0) {
@@ -26739,6 +27012,7 @@ class InMemoryEventSink {
 var defaultEventSink = new InMemoryEventSink;
 
 // ../core/src/runtime/runner.ts
+import { existsSync as existsSync8 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 
 // ../core/src/schema/validator.ts
@@ -27241,12 +27515,14 @@ class ActionRunner {
   projectConfig;
   configOverrides;
   actions;
+  actionResolver;
   constructor(options) {
     this.packageId = options.packageId;
     this.storage = options.storage;
     this.projectConfig = options.projectConfig;
     this.configOverrides = options.configOverrides || {};
     this.actions = options.actions || new Map;
+    this.actionResolver = options.actionResolver;
   }
   registerAction(action) {
     this.actions.set(action.id, action);
@@ -27254,6 +27530,60 @@ class ActionRunner {
   getAction(id) {
     return this.actions.get(id);
   }
+  async resolveAction(actionOrRef) {
+    if (typeof actionOrRef === "object" && "run" in actionOrRef && typeof actionOrRef.run === "function") {
+      return actionOrRef;
+    }
+    const ref = actionOrRef;
+    const parsed = ActionResolver.parseRef(ref);
+    const targetActionId = parsed.actionId;
+    const targetPackageId = parsed.packageId;
+    if (targetPackageId && targetPackageId !== this.packageId) {
+      if (this.actions.has(`${targetPackageId}/${targetActionId}`)) {
+        return this.actions.get(`${targetPackageId}/${targetActionId}`);
+      }
+    } else {
+      if (this.actions.has(targetActionId)) {
+        return this.actions.get(targetActionId);
+      }
+      if (this.packageId && this.actions.has(`${this.packageId}/${targetActionId}`)) {
+        return this.actions.get(`${this.packageId}/${targetActionId}`);
+      }
+    }
+    if (this.actionResolver) {
+      const customResolved = await this.actionResolver(ref, this.packageId);
+      if (customResolved) {
+        if (targetPackageId && targetPackageId !== this.packageId) {
+          this.actions.set(`${targetPackageId}/${targetActionId}`, customResolved);
+        } else {
+          this.actions.set(targetActionId, customResolved);
+          if (this.packageId) {
+            this.actions.set(`${this.packageId}/${targetActionId}`, customResolved);
+          }
+        }
+        return customResolved;
+      }
+    }
+    try {
+      const identifier = targetPackageId ? `${targetPackageId}/${targetActionId}` : targetActionId;
+      const resolved = await resolveActionProject(identifier);
+      if (resolved && existsSync8(resolved.projectRoot)) {
+        const config = loadProjectConfig(resolved.projectRoot);
+        const actionsMap = await loadActions(resolved.projectRoot, config.actionsDir, {
+          autoInstall: false
+        });
+        const matched = actionsMap.get(resolved.actionId);
+        if (matched) {
+          this.actions.set(`${resolved.packageId}/${resolved.actionId}`, matched);
+          if (!targetPackageId || resolved.packageId === this.packageId) {
+            this.actions.set(resolved.actionId, matched);
+          }
+          return matched;
+        }
+      }
+    } catch {}
+    return;
+  }
   listActions() {
     return Array.from(this.actions.values());
   }
@@ -27262,27 +27592,30 @@ class ActionRunner {
     const startedAt = new Date().toISOString();
     const callStack = [...options.callStack || []];
     let action;
-    if (typeof actionOrId === "string") {
-      const found = this.actions.get(actionOrId);
-      if (!found) {
-        const error = {
-          code: "ACTION_NOT_FOUND",
-          message: `Action '${actionOrId}' not found in registry`
-        };
-        return {
-          runId,
-          result: Promise.resolve({ ok: false, runId, error }),
-          cancel: () => false
-        };
-      }
-      action = found;
-    } else {
+    let targetActionId;
+    let targetPackageId = this.packageId;
+    if (typeof actionOrId === "object" && "run" in actionOrId && typeof actionOrId.run === "function") {
       action = actionOrId;
+      targetActionId = action.id;
+    } else {
+      const parsed = ActionResolver.parseRef(actionOrId);
+      targetActionId = parsed.actionId;
+      if (parsed.packageId) {
+        targetPackageId = parsed.packageId;
+      }
+      if (parsed.packageId && parsed.packageId !== this.packageId) {
+        action = this.actions.get(`${parsed.packageId}/${targetActionId}`);
+      } else {
+        action = this.actions.get(targetActionId) || (this.packageId ? this.actions.get(`${this.packageId}/${targetActionId}`) : undefined);
+      }
     }
-    if (callStack.includes(action.id)) {
+    const isExternal = Boolean(targetPackageId && targetPackageId !== this.packageId);
+    const callKey = isExternal ? `${targetPackageId}/${targetActionId}` : targetActionId;
+    const hasCycle = isExternal ? callStack.includes(callKey) : callStack.includes(callKey) || (this.packageId ? callStack.includes(`${this.packageId}/${targetActionId}`) : false);
+    if (hasCycle) {
       const error = {
         code: "ACTION_CYCLE_DETECTED",
-        message: `Cycle detected in action invocation: ${callStack.join(" -> ")} -> ${action.id}`
+        message: `Cycle detected in action invocation: ${callStack.join(" -> ")} -> ${callKey}`
       };
       return {
         runId,
@@ -27290,8 +27623,8 @@ class ActionRunner {
         cancel: () => false
       };
     }
-    callStack.push(action.id);
-    if (action.inputSchema) {
+    callStack.push(callKey);
+    if (action?.inputSchema) {
       const val = validateSchema(action.inputSchema, input);
       if (!val.valid) {
         const error = {
@@ -27310,9 +27643,9 @@ class ActionRunner {
       id: runId,
       rootRunId: options.rootRunId || options.parentRunId || runId,
       parentRunId: options.parentRunId,
-      packageId: this.packageId,
-      packageInstanceId: options.packageInstanceId || this.packageId,
-      actionId: action.id,
+      packageId: targetPackageId,
+      packageInstanceId: options.packageInstanceId || targetPackageId,
+      actionId: targetActionId,
       generationId: options.generationId || "1",
       ownerId: options.ownerId || "local",
       status: "running",
@@ -27357,7 +27690,7 @@ class ActionRunner {
       signal: controller.signal,
       process: options.process,
       progress: options.progress,
-      logger: options.logger || new StderrLogger(action.id),
+      logger: options.logger || new StderrLogger(action?.id || targetActionId),
       onActionInvoke: async (childAction, childInput, parentRunId) => {
         const childResult = await this.execute(childAction, childInput, {
           rootRunId: initialRun.rootRunId,
@@ -27386,16 +27719,40 @@ class ActionRunner {
     });
     const executionPromise = (async () => {
       try {
+        let currentAction = action;
+        if (!currentAction) {
+          currentAction = await this.resolveAction(actionOrId);
+          if (!currentAction) {
+            const error = {
+              code: "ACTION_NOT_FOUND",
+              message: `Action '${targetActionId}' not found in registry or linked packages`
+            };
+            finalizeRun("failed", undefined, error);
+            return { ok: false, runId, error };
+          }
+          if (currentAction.inputSchema) {
+            const val = validateSchema(currentAction.inputSchema, input);
+            if (!val.valid) {
+              const error = {
+                code: "INPUT_VALIDATION_FAILED",
+                message: `Input schema validation failed for action '${currentAction.id}'`,
+                details: val.errors
+              };
+              finalizeRun("failed", undefined, error);
+              return { ok: false, runId, error };
+            }
+          }
+        }
         const rawOutput = await Promise.race([
-          Promise.resolve().then(() => action.run(input, ctx)),
+          Promise.resolve().then(() => currentAction.run(input, ctx)),
           abortPromise
         ]);
-        if (action.outputSchema) {
-          const outVal = validateSchema(action.outputSchema, rawOutput);
+        if (currentAction.outputSchema) {
+          const outVal = validateSchema(currentAction.outputSchema, rawOutput);
           if (!outVal.valid) {
             const error = {
               code: "OUTPUT_VALIDATION_FAILED",
-              message: `Output schema validation failed for action '${action.id}'`,
+              message: `Output schema validation failed for action '${currentAction.id}'`,
               details: outVal.errors
             };
             finalizeRun("failed", undefined, error);
@@ -27568,6 +27925,14 @@ ad link "<skill_root>"
 
 > \`ad link\` \u5929\u7136\u5177\u5907\u5E42\u7B49\u6027\uFF0C\u540C\u4E00 Package \u591A\u6B21\u6267\u884C\u4F1A\u76F4\u63A5\u66F4\u65B0\u8DEF\u5F84\uFF0C\u53EF\u5B89\u5168\u91CD\u590D\u8C03\u7528\u3002
 
+### \u52A8\u4F5C\u53C2\u6570\u5951\u7EA6\u6309\u9700\u8C03\u9605
+
+\u5728\u8C03\u7528\u672A\u77E5\u53C2\u6570\u7684 Action \u524D\uFF0C\u53EF\u5728\u7EC8\u7AEF\u6267\u884C\u547D\u4EE4\u6309\u9700\u67E5\u9605\u8BE5 Action \u7684\u8F93\u5165\u8F93\u51FA\u6A21\u5F0F\u4E0E\u8BE6\u7EC6\u8BF4\u660E\uFF1A
+
+\`\`\`bash
+ad action show ${pkgId}/${firstAction}
+\`\`\`
+
 ### \u6267\u884C Action
 
 \u4E3A\u907F\u514D\u591A\u6280\u80FD\u4E4B\u95F4\u7684 Action ID \u547D\u540D\u51B2\u7A81\uFF0C\u5EFA\u8BAE\u7EDF\u4E00\u4F7F\u7528\u5E26\u6709 Package \u524D\u7F00\u7684\u5B8C\u5168\u9650\u5B9A ID\u3002
@@ -27776,70 +28141,106 @@ ${binaryRelPath} state get KEY
 \`\`\`
 `;
 }
-function generateSkillJson(config, actions, binaryNameOrOptions, target = "host", playbooksList = []) {
-  let mode = "source";
-  let executable;
-  let targetPlatform = target;
-  let playbooks = playbooksList;
-  if (typeof binaryNameOrOptions === "string") {
-    mode = "standalone";
-    executable = `./bin/${binaryNameOrOptions}`;
-  } else if (binaryNameOrOptions && typeof binaryNameOrOptions === "object") {
-    mode = binaryNameOrOptions.mode || (binaryNameOrOptions.executable ? "standalone" : "source");
-    executable = binaryNameOrOptions.executable;
-    targetPlatform = binaryNameOrOptions.target || target;
-    if (binaryNameOrOptions.playbooks) {
-      playbooks = binaryNameOrOptions.playbooks;
-    }
-  }
-  const manifest = {
-    schemaVersion: "2.0.0",
-    packageId: config.id,
-    name: config.name,
-    version: config.version,
-    description: config.description,
-    mode
-  };
-  if (mode === "standalone" && executable) {
-    manifest.target = targetPlatform;
-    manifest.executable = executable;
-  }
-  manifest.actions = actions.map((a) => {
-    const item = {
-      id: a.id
-    };
-    if (a.entry) {
-      item.entry = a.entry;
-    }
-    if (a.description) {
-      item.description = a.description;
-    }
-    if (a.inputSchema !== undefined) {
-      item.inputSchema = a.inputSchema;
-    }
-    if (a.outputSchema !== undefined) {
-      item.outputSchema = a.outputSchema;
-    }
-    if (a.uses) {
-      item.uses = a.uses;
-    }
-    if (a.tags) {
-      item.tags = a.tags;
-    }
-    if (a.annotations) {
-      item.annotations = a.annotations;
+function generateCompositeSkillMd(bundleName, description, packages) {
+  const cleanName = bundleName.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+  const samplePkg = packages.find((p) => p.actions && p.actions.length > 0);
+  const sampleActionId = samplePkg ? `${samplePkg.config.id}/${samplePkg.actions[0].id}` : "sample.greet";
+  const actionSections = packages.map((pkg) => {
+    const actList = pkg.actions.map((a) => {
+      const desc = a.description ? `: ${a.description}` : "";
+      return `- \`${pkg.config.id}/${a.id}\`${desc}`;
+    }).join(`
+`);
+    return `### ${pkg.config.name} (${pkg.config.id})
+${actList || "- \u65E0\u53EF\u7528 Action"}`;
+  }).join(`
+
+`);
+  const playbookEntries = [];
+  for (const pkg of packages) {
+    for (const pb of pkg.playbooks) {
+      const relPath = `packages/${pkg.packageDir}/playbooks/${basename3(pb.filePath)}`;
+      playbookEntries.push(`- [${pb.name || pb.id}](${relPath}): ${pb.description || "\u6807\u51C6\u64CD\u4F5C\u89C4\u7A0B"}`);
     }
-    return item;
-  });
-  if (playbooks && playbooks.length > 0) {
-    manifest.playbooks = playbooks.map((p) => ({
-      id: p.id,
-      description: p.description,
-      entry: `playbooks/${basename3(p.filePath)}`
-    }));
   }
-  manifest.exportedAt = new Date().toISOString();
-  return JSON.stringify(manifest, null, 2) + `
+  const playbookSection = playbookEntries.length > 0 ? `## \u63A8\u8350\u64CD\u4F5C\u89C4\u7A0B
+
+\u6D89\u53CA\u591A\u6B65\u9AA4\u6216\u4E1A\u52A1\u6D41\u7A0B\u65F6\uFF0C\u4F18\u5148\u9075\u5FAA\u4EE5\u4E0B\u539F\u4F4D\u89C4\u7A0B\uFF1A
+
+${playbookEntries.join(`
+`)}
+
+---
+` : "";
+  return `---
+name: ${cleanName}
+description: ${description}
+---
+
+# ${bundleName} \u590D\u5408\u6280\u80FD\u5957\u4EF6
+
+${description}
+
+## ActionDock \u8FD0\u884C\u65F6\u521D\u59CB\u5316
+
+\u672C\u6280\u80FD\u4E3A **ActionDock \u590D\u5408\u5DE5\u4F5C\u533A\u6280\u80FD\u5305**\uFF0C\u805A\u5408\u4E86\u591A\u4E2A\u529F\u80FD\u5305\u3002\u667A\u80FD\u4F53\u5728\u521D\u6B21\u8C03\u7528\u6216\u521D\u59CB\u5316\u65F6\uFF0C\u5728\u5F53\u524D\u6280\u80FD\u6839\u76EE\u5F55\u6267\u884C\u6CE8\u518C\u547D\u4EE4\uFF1A
+
+\`\`\`bash
+ad link "<skill_root>"
+\`\`\`
+
+> \`ad link\` \u4F1A\u81EA\u52A8\u8BC6\u522B\u5E76\u6CE8\u518C\u5DE5\u4F5C\u533A\u4E0B\u7684\u6240\u6709\u5B50\u5305\uFF0C\u4F7F\u5176\u4E2D\u7684 Action \u968F\u65F6\u53EF\u4EE5\u901A\u8FC7\u5B8C\u5168\u9650\u5B9A\u6807\u8BC6\u8C03\u7528\u3002
+
+## \u52A8\u4F5C\u53C2\u6570\u5951\u7EA6\u6309\u9700\u8C03\u9605
+
+\u4E3A\u8282\u7701\u4E0A\u4E0B\u6587\u5F00\u9500\uFF0C\u5404 Action \u7684\u8BE6\u7EC6\u53C2\u6570\u7ED3\u6784\u4E0D\u9759\u6001\u5185\u5D4C\u5728\u8BF4\u660E\u4E66\u4E2D\u3002\u5728\u8C03\u7528\u672A\u77E5\u53C2\u6570\u7684 Action \u524D\uFF0C\u53EF\u5728\u7EC8\u7AEF\u6267\u884C\u547D\u4EE4\u67E5\u9605\u8F93\u5165\u8F93\u51FA\u7EA6\u675F\uFF1A
+
+\`\`\`bash
+ad action show ${sampleActionId}
+\`\`\`
+
+## \u53EF\u7528 Action \u5DE5\u5177\u6E05\u5355
+
+${actionSections}
+
+---
+
+${playbookSection}
+## \u6807\u51C6\u8C03\u7528\u547D\u4EE4
+
+\u63A8\u8350\u4F7F\u7528\u53C2\u6570\u6587\u4EF6\u4F20\u9012\u5185\u5BB9\uFF0C\u675C\u7EDD\u7EC8\u7AEF\u5F15\u53F7\u8F6C\u4E49\u95EE\u9898\uFF1A
+
+\`\`\`bash
+cat << 'EOF' > /tmp/input.json
+{
+  "param": "value"
+}
+EOF
+ad run ${sampleActionId} --input-file /tmp/input.json
+\`\`\`
+
+### \u7ED3\u6784\u5316\u54CD\u5E94\u89E3\u6790
+
+\u6240\u6709 Action \u6267\u884C\u7ED3\u679C\u5747\u5728 \`stdout\` \u8F93\u51FA\u6807\u51C6\u683C\u5F0F\u7684 JSON \u4FE1\u5C01\uFF1A
+
+\`\`\`json
+// \u6267\u884C\u6210\u529F\u54CD\u5E94 (ok \u4E3A true)
+{
+  "ok": true,
+  "runId": "01J...",
+  "data": { ... }
+}
+
+// \u6267\u884C\u5931\u8D25\u54CD\u5E94 (ok \u4E3A false)
+{
+  "ok": false,
+  "runId": "01J...",
+  "error": {
+    "code": "ACTION_EXECUTION_FAILED",
+    "message": "\u9519\u8BEF\u8BE6\u7EC6\u63CF\u8FF0\u4FE1\u606F"
+  }
+}
+\`\`\`
 `;
 }
 // ../core/src/filter/intent.ts
@@ -27939,8 +28340,8 @@ function filterByIntent(items, intent, extractors, fallback = true) {
   return filterWithFallbackInfo(items, intent, extractors, fallback).items;
 }
 // ../core/src/profile/manager.ts
-import { chmodSync as chmodSync2, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, join as join7 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
 var PROFILE_NAME_REGEX = /^[a-zA-Z0-9_\-\.]+$/;
 var DEFAULT_PROFILES_CONFIG = {
   currentProfile: "local",
@@ -27960,11 +28361,11 @@ function normalizeServerUrl(url) {
 }
 function getProfilesFilePath(customHome) {
   const baseDir = getActionDockHome(customHome);
-  return join7(baseDir, ".actiondock", "profiles.json");
+  return join8(baseDir, ".actiondock", "profiles.json");
 }
 function loadProfiles(customHome) {
   const filePath = getProfilesFilePath(customHome);
-  if (!existsSync7(filePath)) {
+  if (!existsSync9(filePath)) {
     return structuredClone(DEFAULT_PROFILES_CONFIG);
   }
   try {
@@ -28457,11 +28858,11 @@ async function deleteRemoteConfig(serverUrl, key, token, packageId) {
   });
 }
 // ../core/src/project/init.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename4, join as join8, resolve as resolve4 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename4, join as join9, resolve as resolve4 } from "path";
 function initProject(targetDir, options = {}) {
   const root = resolve4(targetDir);
-  if (!existsSync8(root)) {
+  if (!existsSync10(root)) {
     mkdirSync4(root, { recursive: true });
   }
   const dirName = basename4(root);
@@ -28482,7 +28883,7 @@ function initProject(targetDir, options = {}) {
       }
     }
   };
-  writeFileSync4(join8(root, "actiondock.json"), JSON.stringify(actiondockJson, null, 2) + `
+  writeFileSync4(join9(root, "actiondock.json"), JSON.stringify(actiondockJson, null, 2) + `
 `);
   const manifestJson = {
     schemaVersion: 1,
@@ -28514,7 +28915,7 @@ function initProject(targetDir, options = {}) {
     },
     assets: []
   };
-  writeFileSync4(join8(root, "actiondock.manifest.json"), JSON.stringify(manifestJson, null, 2) + `
+  writeFileSync4(join9(root, "actiondock.manifest.json"), JSON.stringify(manifestJson, null, 2) + `
 `);
   const packageJson = {
     name: id,
@@ -28528,16 +28929,16 @@ function initProject(targetDir, options = {}) {
       node: ">=22.12.0"
     },
     dependencies: {
-      "@actiondock/sdk": "^2.0.10"
+      "@actiondock/sdk": "^2.0.11"
     },
     devDependencies: {
-      "@actiondock/testing": "^2.0.10",
+      "@actiondock/testing": "^2.0.11",
       "@types/node": "^22.12.0",
       tsx: "^4.19.0",
       typescript: "^5.7.0"
     }
   };
-  writeFileSync4(join8(root, "package.json"), JSON.stringify(packageJson, null, 2) + `
+  writeFileSync4(join9(root, "package.json"), JSON.stringify(packageJson, null, 2) + `
 `);
   const tsconfigJson = {
     compilerOptions: {
@@ -28549,7 +28950,7 @@ function initProject(targetDir, options = {}) {
       types: ["node"]
     }
   };
-  writeFileSync4(join8(root, "tsconfig.json"), JSON.stringify(tsconfigJson, null, 2) + `
+  writeFileSync4(join9(root, "tsconfig.json"), JSON.stringify(tsconfigJson, null, 2) + `
 `);
   const gitignore = `.actiondock/
 node_modules/
@@ -28558,8 +28959,8 @@ build/
 *.log
 .env
 `;
-  writeFileSync4(join8(root, ".gitignore"), gitignore);
-  const actionsDir = join8(root, "actions");
+  writeFileSync4(join9(root, ".gitignore"), gitignore);
+  const actionsDir = join9(root, "actions");
   mkdirSync4(actionsDir, { recursive: true });
   const sampleAction = `import { defineAction } from "@actiondock/sdk";
 
@@ -28602,8 +29003,8 @@ export default defineAction({
   },
 });
 `;
-  writeFileSync4(join8(actionsDir, "greet.ts"), sampleAction);
-  const playbooksDir = join8(root, "playbooks");
+  writeFileSync4(join9(actionsDir, "greet.ts"), sampleAction);
+  const playbooksDir = join9(root, "playbooks");
   mkdirSync4(playbooksDir, { recursive: true });
   const samplePlaybook = `---
 id: greet-user
@@ -28617,8 +29018,8 @@ actions:
 - Call \`sample.greet\` with the user's name.
 - Confirm the returned greeting message.
 `;
-  writeFileSync4(join8(playbooksDir, "greet-user.md"), samplePlaybook);
-  const testsDir = join8(root, "tests");
+  writeFileSync4(join9(playbooksDir, "greet-user.md"), samplePlaybook);
+  const testsDir = join9(root, "tests");
   mkdirSync4(testsDir, { recursive: true });
   const sampleTest = `import { describe, it } from "node:test";
 import assert from "node:assert/strict";
@@ -28641,7 +29042,7 @@ describe("greet action", () => {
   });
 });
 `;
-  writeFileSync4(join8(testsDir, "greet.test.ts"), sampleTest);
+  writeFileSync4(join9(testsDir, "greet.test.ts"), sampleTest);
 }
 // ../core/src/runtime/execution-manager.ts
 class ExecutionManager {
@@ -28865,7 +29266,7 @@ class ServerRuntimeRegistry {
   }
 }
 // ../core/src/server/routes/common.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 function jsonResponse(data, status = 200, corsHeaders = {}) {
   return new Response(JSON.stringify(data, null, 2), {
     status,
@@ -28929,7 +29330,7 @@ function findRunAcrossStorages(runId, runtimeRegistry, projectRoot, customHome)
   try {
     const linked = listLinkedPackages(customHome);
     for (const pkg of linked) {
-      if (!existsSync9(pkg.path))
+      if (!existsSync11(pkg.path))
         continue;
       const storage = runtimeRegistry.getStorage(pkg.id, pkg.path);
       const run = storage.getRun(runId);
@@ -28966,7 +29367,7 @@ async function handleHealthRoute(ctx) {
   return jsonResponse(healthData, 200, corsHeaders);
 }
 // ../core/src/server/routes/info.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 async function handleInfoRoute(ctx) {
   const { req, url, pathname, corsHeaders, projectRoot, customHome, options } = ctx;
   if (pathname !== "/api/v1/info" || req.method !== "GET") {
@@ -29011,7 +29412,7 @@ async function handleInfoRoute(ctx) {
     } else {
       const linked = listLinkedPackages(customHome);
       for (const pkg of linked) {
-        if (!existsSync10(pkg.path))
+        if (!existsSync12(pkg.path))
           continue;
         try {
           const config = loadProjectConfig(pkg.path);
@@ -29140,7 +29541,7 @@ async function handleDoctorRoute(ctx) {
 }
 // ../core/src/server/routes/actions.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 async function handleActionsRoutes(ctx) {
   const { req, url, pathname, corsHeaders, projectRoot, customHome, runtimeRegistry, options } = ctx;
   if (pathname === "/api/v1/actions" && req.method === "GET") {
@@ -29161,7 +29562,7 @@ async function handleActionsRoutes(ctx) {
       for (const pkg of linked) {
         if (projectRoot && pkg.path === projectRoot)
           continue;
-        if (!existsSync11(pkg.path))
+        if (!existsSync13(pkg.path))
           continue;
         try {
           const config = loadProjectConfig(pkg.path);
@@ -29308,7 +29709,7 @@ async function handleActionsRoutes(ctx) {
   return null;
 }
 // ../core/src/server/routes/playbooks.ts
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 async function handlePlaybooksRoutes(ctx) {
   const { req, url, pathname, corsHeaders, projectRoot, customHome } = ctx;
   if (pathname === "/api/v1/playbooks" && req.method === "GET") {
@@ -29325,7 +29726,7 @@ async function handlePlaybooksRoutes(ctx) {
       for (const pkg of linked) {
         if (projectRoot && pkg.path === projectRoot)
           continue;
-        if (!existsSync12(pkg.path))
+        if (!existsSync14(pkg.path))
           continue;
         roots.push({ root: pkg.path, packageId: pkg.id });
       }
@@ -29374,7 +29775,7 @@ async function handlePlaybooksRoutes(ctx) {
   return null;
 }
 // ../core/src/server/routes/runs.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 async function handleRunsRoutes(ctx) {
   const { req, url, pathname, corsHeaders, projectRoot, customHome, runtimeRegistry, options } = ctx;
   if (pathname === "/api/v1/runs" && req.method === "GET") {
@@ -29400,7 +29801,7 @@ async function handleRunsRoutes(ctx) {
       for (const pkg of linked) {
         if (projectRoot && pkg.path === projectRoot)
           continue;
-        if (!existsSync13(pkg.path))
+        if (!existsSync15(pkg.path))
           continue;
         candidateStorages.push({
           packageId: pkg.id,
@@ -29451,7 +29852,7 @@ async function handleRunsRoutes(ctx) {
       for (const pkg of linked) {
         if (projectRoot && pkg.path === projectRoot)
           continue;
-        if (!existsSync13(pkg.path))
+        if (!existsSync15(pkg.path))
           continue;
         if (packageId && pkg.id !== packageId)
           continue;
@@ -52305,7 +52706,7 @@ function toMcpSchema(schema) {
   return fromJsonSchema2(schema);
 }
 // ../mcp/src/adapter.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { resolve as resolve6 } from "path";
 function isPlainObject3(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -52389,7 +52790,7 @@ async function createActionDockMcpServer(options = {}) {
   if (options.all) {
     const linked = listLinkedPackages(options.customHome);
     for (const pkg of linked) {
-      if (existsSync14(pkg.path)) {
+      if (existsSync16(pkg.path)) {
         resolvedRoots.add(resolve6(pkg.path));
       }
     }
@@ -52400,7 +52801,7 @@ async function createActionDockMcpServer(options = {}) {
   }
   for (const pkgId of targetPackages) {
     const root = resolvePackageRoot(pkgId, undefined, options.customHome);
-    if (!root || !existsSync14(root)) {
+    if (!root || !existsSync16(root)) {
       throw new Error(`Package '${pkgId}' not found in registry`);
     }
     resolvedRoots.add(resolve6(root));
@@ -53488,9 +53889,9 @@ class NodeHttpServer {
 }
 
 // ../runtime-node/src/module-loader.ts
-import { existsSync as existsSync15, statSync as statSync4 } from "fs";
+import { existsSync as existsSync17, statSync as statSync4 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname5, isAbsolute, join as join9, resolve as resolve7 } from "path";
+import { dirname as dirname5, isAbsolute, join as join10, resolve as resolve7 } from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
 var cjsRequire2 = createRequire2(import.meta.url);
 var CANDIDATE_EXTENSIONS = [
@@ -53533,7 +53934,7 @@ class TsxModuleLoader {
     if (parentPath) {
       try {
         const p = parentPath.startsWith("file://") ? fileURLToPath(parentPath) : parentPath;
-        if (existsSync15(p)) {
+        if (existsSync17(p)) {
           const stat = statSync4(p);
           baseDir = stat.isDirectory() ? resolve7(p) : dirname5(resolve7(p));
         } else {
@@ -53546,7 +53947,7 @@ class TsxModuleLoader {
     const candidateBasePath = isAbsolute(target) ? target : resolve7(baseDir, target);
     for (const ext of CANDIDATE_EXTENSIONS) {
       const fullPath = ext ? `${candidateBasePath}${ext}` : candidateBasePath;
-      if (existsSync15(fullPath)) {
+      if (existsSync17(fullPath)) {
         try {
           if (statSync4(fullPath).isFile()) {
             return fullPath;
@@ -53554,12 +53955,12 @@ class TsxModuleLoader {
         } catch {}
       }
     }
-    if (existsSync15(candidateBasePath)) {
+    if (existsSync17(candidateBasePath)) {
       try {
         if (statSync4(candidateBasePath).isDirectory()) {
           for (const indexName of INDEX_CANDIDATES) {
-            const indexFilePath = join9(candidateBasePath, indexName);
-            if (existsSync15(indexFilePath) && statSync4(indexFilePath).isFile()) {
+            const indexFilePath = join10(candidateBasePath, indexName);
+            if (existsSync17(indexFilePath) && statSync4(indexFilePath).isFile()) {
               return indexFilePath;
             }
           }
@@ -53577,7 +53978,7 @@ class TsxModuleLoader {
   }
   async load(specifier, parentPath) {
     const resolvedPath = this.resolve(specifier, parentPath);
-    const parentUrl = parentPath ? parentPath.startsWith("file://") ? parentPath : pathToFileURL2(resolve7(parentPath)).href : pathToFileURL2(join9(process.cwd(), "index.js")).href;
+    const parentUrl = parentPath ? parentPath.startsWith("file://") ? parentPath : pathToFileURL2(resolve7(parentPath)).href : pathToFileURL2(join10(process.cwd(), "index.js")).href;
     const isBun = typeof globalThis.Bun !== "undefined";
     if (isBun) {
       try {
@@ -60617,8 +61018,8 @@ function setupNodeRuntime() {
 }
 
 // src/commands/action/create.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join10, resolve as resolve8 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11, resolve as resolve8 } from "path";
 function registerActionCreateCommand(actionCmd) {
   actionCmd.command("create <id>").alias("new").description("Scaffold a new Action definition file").option("-d, --desc <description>", "Action description").option("-f, --file <filePath>", "Target file path relative to actions dir").action(async (id, options) => {
     const root = findProjectRoot();
@@ -60628,13 +61029,13 @@ function registerActionCreateCommand(actionCmd) {
     try {
       const config = loadProjectConfig(root);
       const actionsDir = resolve8(root, config.actionsDir || "actions");
-      if (!existsSync16(actionsDir)) {
+      if (!existsSync18(actionsDir)) {
         mkdirSync5(actionsDir, { recursive: true });
       }
       const cleanName = getPackageSlug(id);
       const targetRelFile = options.file || `${cleanName}.ts`;
       const targetFullFile = resolve8(actionsDir, targetRelFile);
-      if (existsSync16(targetFullFile)) {
+      if (existsSync18(targetFullFile)) {
         throw new ExecutionError(`Target action file already exists at ${targetFullFile}`);
       }
       const desc = options.desc || `Action ${id}`;
@@ -60691,7 +61092,7 @@ export default defineAction<Input, Output>({
       const manifest = loadManifest(root) || { schemaVersion: 1, actions: {}, assets: [] };
       manifest.actions = manifest.actions || {};
       manifest.actions[id] = {
-        entry: join10(config.actionsDir || "actions", targetRelFile),
+        entry: join11(config.actionsDir || "actions", targetRelFile),
         description: desc,
         inputSchema: {
           type: "object",
@@ -60728,7 +61129,7 @@ To run this action:`);
 }
 
 // src/commands/action/list.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 function registerActionListCommand(actionCmd) {
   actionCmd.command("list [patterns...]").description("List actions in current project, linked packages, or remote profile").option("-i, --intent <pattern>", "Regex or fuzzy intent filter; falls back to full list when no match").option("-P, --package <id>", "Target package ID or path").option("-p, --profile <name>", "Execute or query against a specific profile").option("-s, --server <url>", "Remote server URL").option("-t, --token <token>", "Auth token for remote server").option("--fallback", "Enable fallback to full list when no items match intent").option("--no-fallback", "Disable fallback to full list when no items match intent").option("--json", "Output as JSON").option("--envelope", "Wrap JSON output in standard envelope").action(async (patterns, rawOptions, cmd) => {
     try {
@@ -60827,7 +61228,7 @@ Run 'ad link' inside an Action package to register it.`
       }
       const aggregated = [];
       for (const pkg of linkedList) {
-        if (!existsSync17(pkg.path))
+        if (!existsSync19(pkg.path))
           continue;
         try {
           const config = loadProjectConfig(pkg.path);
@@ -61329,13 +61730,13 @@ class CompilerError extends BuilderError {
   }
 }
 // ../builder/src/build.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync8 } from "fs";
-import { join as join12, resolve as resolve11 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync8 } from "fs";
+import { join as join13, resolve as resolve11 } from "path";
 
 // ../builder/src/compiler.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { createHash } from "crypto";
-import { existsSync as existsSync18, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
 import { basename as basename5, dirname as dirname6, resolve as resolve9 } from "path";
 var SUPPORTED_TARGETS = new Set([
   "bun",
@@ -61400,7 +61801,7 @@ class BunCompiler {
       });
     }
     const resolvedEntry = resolve9(options.entrypoint);
-    if (!existsSync18(resolvedEntry)) {
+    if (!existsSync20(resolvedEntry)) {
       throw new CompilerValidationError(`Entrypoint file not found: ${options.entrypoint}`, { code: "ENTRYPOINT_NOT_FOUND" });
     }
     if (!options.outfile) {
@@ -61473,13 +61874,13 @@ class BunCompiler {
       throw normalizeCompilerError(rawStderr, rawStdout, proc.status ?? 1, options.target);
     }
     let actualExecutablePath = resolvedOutfile;
-    if (!existsSync18(actualExecutablePath) && isWindowsTarget) {
+    if (!existsSync20(actualExecutablePath) && isWindowsTarget) {
       const withExe = `${resolvedOutfile}.exe`;
-      if (existsSync18(withExe)) {
+      if (existsSync20(withExe)) {
         actualExecutablePath = withExe;
       }
     }
-    if (!existsSync18(actualExecutablePath)) {
+    if (!existsSync20(actualExecutablePath)) {
       throw new CompilerError(`Compiler completed with exit code 0 but output executable not found at ${resolvedOutfile}`, {
         code: "OUTPUT_NOT_FOUND",
         exitCode: 0,
@@ -61541,15 +61942,15 @@ class BunCompiler {
 }
 
 // ../builder/src/planner.ts
-import { existsSync as existsSync19, readdirSync as readdirSync3, readFileSync as readFileSync9, statSync as statSync7 } from "fs";
-import { basename as basename6, join as join11, relative as relative3, resolve as resolve10 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync7 } from "fs";
+import { basename as basename6, dirname as dirname7, isAbsolute as isAbsolute2, join as join12, relative as relative3, resolve as resolve10 } from "path";
 function walkDirectory(dir) {
-  if (!existsSync19(dir))
+  if (!existsSync21(dir))
     return [];
   const results = [];
-  const entries = readdirSync3(dir);
+  const entries = readdirSync4(dir);
   for (const entry of entries) {
-    const fullPath = join11(dir, entry);
+    const fullPath = join12(dir, entry);
     const stat = statSync7(fullPath);
     if (stat.isDirectory()) {
       results.push(...walkDirectory(fullPath));
@@ -61559,6 +61960,136 @@ function walkDirectory(dir) {
   }
   return results;
 }
+function isIgnoredModulePath(relPath) {
+  const normalized = relPath.replace(/\\/g, "/");
+  return normalized.startsWith("node_modules/") || normalized.includes("/node_modules/") || normalized.startsWith(".git/") || normalized.startsWith("dist/") || normalized.startsWith(".actiondock/") || normalized.endsWith(".test.ts") || normalized.endsWith(".test.js") || normalized.endsWith(".test.tsx") || normalized.endsWith(".test.jsx") || normalized.endsWith(".spec.ts") || normalized.endsWith(".spec.js") || normalized.endsWith(".spec.tsx") || normalized.endsWith(".spec.jsx") || normalized.endsWith(".d.ts");
+}
+function extractRelativeImports(source) {
+  const stripped = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const specifiers = new Set;
+  const fromRegex = /\bfrom\s*["'`]([^"'`]+)["'`]/g;
+  let match;
+  while ((match = fromRegex.exec(stripped)) !== null) {
+    const spec = match[1].trim();
+    if (spec.startsWith("./") || spec.startsWith("../")) {
+      specifiers.add(spec);
+    }
+  }
+  const importRegex = /\bimport\s*(?:\(\s*)?["'`]([^"'`]+)["'`]/g;
+  while ((match = importRegex.exec(stripped)) !== null) {
+    const spec = match[1].trim();
+    if (spec.startsWith("./") || spec.startsWith("../")) {
+      specifiers.add(spec);
+    }
+  }
+  const requireRegex = /\brequire\s*\(\s*["'`]([^"'`]+)["'`]/g;
+  while ((match = requireRegex.exec(stripped)) !== null) {
+    const spec = match[1].trim();
+    if (spec.startsWith("./") || spec.startsWith("../")) {
+      specifiers.add(spec);
+    }
+  }
+  return Array.from(specifiers);
+}
+var CANDIDATE_EXTENSIONS2 = [
+  "",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".json"
+];
+function resolveLocalModulePath(baseDir, specifier) {
+  const candidate = resolve10(baseDir, specifier);
+  if (existsSync21(candidate)) {
+    try {
+      if (statSync7(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {}
+  }
+  if (candidate.endsWith(".js")) {
+    const tsPath = candidate.slice(0, -3) + ".ts";
+    if (existsSync21(tsPath))
+      return tsPath;
+    const tsxPath = candidate.slice(0, -3) + ".tsx";
+    if (existsSync21(tsxPath))
+      return tsxPath;
+  } else if (candidate.endsWith(".mjs")) {
+    const mtsPath = candidate.slice(0, -4) + ".mts";
+    if (existsSync21(mtsPath))
+      return mtsPath;
+  } else if (candidate.endsWith(".cjs")) {
+    const ctsPath = candidate.slice(0, -4) + ".cts";
+    if (existsSync21(ctsPath))
+      return ctsPath;
+  }
+  for (const ext of CANDIDATE_EXTENSIONS2) {
+    if (!ext)
+      continue;
+    const withExt = candidate + ext;
+    if (existsSync21(withExt)) {
+      try {
+        if (statSync7(withExt).isFile()) {
+          return withExt;
+        }
+      } catch {}
+    }
+  }
+  if (existsSync21(candidate)) {
+    try {
+      if (statSync7(candidate).isDirectory()) {
+        for (const ext of [".ts", ".tsx", ".js", ".mjs", ".json"]) {
+          const indexFile = join12(candidate, `index${ext}`);
+          if (existsSync21(indexFile)) {
+            return indexFile;
+          }
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+function traceLocalModuleDependencies(entryFiles, projectRoot) {
+  const visited = new Set;
+  const modules = new Set;
+  const queue = [...entryFiles];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const relToRoot = relative3(projectRoot, current);
+    if (relToRoot.startsWith("..") || isAbsolute2(relToRoot)) {
+      continue;
+    }
+    let content = "";
+    try {
+      content = readFileSync9(current, "utf-8");
+    } catch {
+      continue;
+    }
+    const specifiers = extractRelativeImports(content);
+    const dir = dirname7(current);
+    for (const spec of specifiers) {
+      const resolved = resolveLocalModulePath(dir, spec);
+      if (resolved) {
+        const rel = relative3(projectRoot, resolved);
+        if (!rel.startsWith("..") && !isAbsolute2(rel) && !isIgnoredModulePath(rel)) {
+          modules.add(resolved);
+          if (!visited.has(resolved)) {
+            queue.push(resolved);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(modules);
+}
 function parsePlaybookFile(filePath) {
   try {
     const content = readFileSync9(filePath, "utf-8");
@@ -61584,8 +62115,8 @@ function parsePlaybookFile(filePath) {
 }
 function loadProjectPlaybooks(projectRoot, playbooksDir = "playbooks") {
   const map = new Map;
-  const dir = join11(projectRoot, playbooksDir);
-  if (!existsSync19(dir))
+  const dir = join12(projectRoot, playbooksDir);
+  if (!existsSync21(dir))
     return map;
   const files = walkDirectory(dir).filter((f) => f.endsWith(".md"));
   for (const file of files) {
@@ -61597,9 +62128,9 @@ function loadProjectPlaybooks(projectRoot, playbooksDir = "playbooks") {
   return map;
 }
 function generateStaticManifest(projectRoot, actionsDir = "actions") {
-  const dir = join11(projectRoot, actionsDir);
+  const dir = join12(projectRoot, actionsDir);
   const actions = {};
-  if (existsSync19(dir)) {
+  if (existsSync21(dir)) {
     const files = walkDirectory(dir).filter((f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.endsWith(".d.ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts"));
     for (const file of files) {
       const relPath = relative3(projectRoot, file);
@@ -61637,8 +62168,8 @@ function generateStaticManifest(projectRoot, actionsDir = "actions") {
   };
 }
 function extractExternalDependencies(projectRoot) {
-  const pkgPath = join11(projectRoot, "package.json");
-  if (!existsSync19(pkgPath))
+  const pkgPath = join12(projectRoot, "package.json");
+  if (!existsSync21(pkgPath))
     return [];
   try {
     const raw = readFileSync9(pkgPath, "utf-8");
@@ -61730,14 +62261,34 @@ class BuildPlanner {
     }
     const resolvedActionIds = new Set;
     const queue = Array.from(initialActionIds);
+    const externalActionRoots = new Map;
+    const externalActionEntries = new Map;
     while (queue.length > 0) {
       const currentId = queue.shift();
       if (resolvedActionIds.has(currentId)) {
         continue;
       }
-      const entry = manifest.actions[currentId];
+      let entry = manifest.actions[currentId];
+      let entryRoot = root;
       if (!entry) {
-        throw new PlannerError(`Action '${currentId}' referenced in dependency closure (uses) was not found in manifest`, "MISSING_DEPENDENCY");
+        try {
+          const resolvedExternal = resolveActionProjectSync(currentId, root);
+          if (resolvedExternal && existsSync21(resolvedExternal.projectRoot)) {
+            const externalManifest = loadManifest(resolvedExternal.projectRoot);
+            const externalEntry = externalManifest?.actions?.[resolvedExternal.actionId];
+            if (externalEntry) {
+              entry = externalEntry;
+              entryRoot = resolvedExternal.projectRoot;
+            }
+          }
+        } catch {}
+      }
+      if (!entry) {
+        throw new PlannerError(`Action '${currentId}' referenced in dependency closure (uses) was not found in manifest or linked packages`, "MISSING_DEPENDENCY");
+      }
+      if (entryRoot !== root) {
+        externalActionRoots.set(currentId, entryRoot);
+        externalActionEntries.set(currentId, entry);
       }
       resolvedActionIds.add(currentId);
       if (entry.uses && Array.isArray(entry.uses)) {
@@ -61757,9 +62308,13 @@ class BuildPlanner {
     }
     const actionDependencies = [];
     for (const actId of resolvedActionIds) {
-      const entry = manifest.actions[actId];
-      const resolvedPath = resolve10(root, entry.entry);
-      if (!existsSync19(resolvedPath)) {
+      const entry = manifest.actions[actId] || externalActionEntries.get(actId);
+      const entryRoot = externalActionRoots.get(actId) || root;
+      if (!entry) {
+        throw new PlannerError(`Action '${actId}' entry not found`, "ENTRY_FILE_NOT_FOUND");
+      }
+      const resolvedPath = resolve10(entryRoot, entry.entry);
+      if (!existsSync21(resolvedPath)) {
         throw new PlannerError(`Action '${actId}' entry file not found on disk: ${entry.entry}`, "ENTRY_FILE_NOT_FOUND");
       }
       actionDependencies.push({
@@ -61776,6 +62331,50 @@ class BuildPlanner {
     }
     const modulesAndAssets = [];
     const assetPathSet = new Set;
+    const modulePathSet = new Set;
+    const actionPathSet = new Set(actionDependencies.map((a) => a.resolvedPath));
+    const rootActionsMap = new Map;
+    for (const act of actionDependencies) {
+      const actRoot = externalActionRoots.get(act.id) || root;
+      if (!rootActionsMap.has(actRoot)) {
+        rootActionsMap.set(actRoot, []);
+      }
+      rootActionsMap.get(actRoot).push(act.resolvedPath);
+    }
+    for (const [actRoot, files] of rootActionsMap) {
+      const tracedModulePaths = traceLocalModuleDependencies(files, actRoot);
+      for (const modPath of tracedModulePaths) {
+        if (!actionPathSet.has(modPath)) {
+          const rel = relative3(actRoot, modPath).replace(/\\/g, "/");
+          if (!modulePathSet.has(rel) && !isIgnoredModulePath(rel)) {
+            modulePathSet.add(rel);
+            modulesAndAssets.push({
+              path: rel,
+              resolvedPath: modPath,
+              type: "module"
+            });
+          }
+        }
+      }
+    }
+    const isSelective = Boolean(options?.actions && options.actions.length > 0) || Boolean(options?.playbooks && options.playbooks.length > 0);
+    if (!isSelective) {
+      const defaultLibDir = join12(root, "lib");
+      if (existsSync21(defaultLibDir)) {
+        const libFiles = walkDirectory(defaultLibDir);
+        for (const file of libFiles) {
+          const rel = relative3(root, file).replace(/\\/g, "/");
+          if (!isIgnoredModulePath(rel) && !actionPathSet.has(file) && !modulePathSet.has(rel)) {
+            modulePathSet.add(rel);
+            modulesAndAssets.push({
+              path: rel,
+              resolvedPath: file,
+              type: "module"
+            });
+          }
+        }
+      }
+    }
     if (manifest.assets && Array.isArray(manifest.assets)) {
       for (const assetRel of manifest.assets) {
         if (!assetPathSet.has(assetRel)) {
@@ -61788,8 +62387,8 @@ class BuildPlanner {
         }
       }
     }
-    const defaultAssetsDir = join11(root, "assets");
-    if (existsSync19(defaultAssetsDir)) {
+    const defaultAssetsDir = join12(root, "assets");
+    if (existsSync21(defaultAssetsDir)) {
       const assetFiles = walkDirectory(defaultAssetsDir);
       for (const file of assetFiles) {
         const rel = relative3(root, file);
@@ -61811,16 +62410,16 @@ class BuildPlanner {
         type: "playbook"
       });
     }
-    const configPath = join11(root, "actiondock.json");
-    if (existsSync19(configPath)) {
+    const configPath = join12(root, "actiondock.json");
+    if (existsSync21(configPath)) {
       modulesAndAssets.push({
         path: "actiondock.json",
         resolvedPath: configPath,
         type: "config"
       });
     }
-    const manifestPath = join11(root, "actiondock.manifest.json");
-    if (existsSync19(manifestPath)) {
+    const manifestPath = join12(root, "actiondock.manifest.json");
+    if (existsSync21(manifestPath)) {
       modulesAndAssets.push({
         path: "actiondock.manifest.json",
         resolvedPath: manifestPath,
@@ -61868,14 +62467,14 @@ async function buildProject(options) {
   if (plan.actions.length === 0) {
     throw new BuilderError("No actions resolved for standalone compilation");
   }
-  const buildDir = join12(root, ".actiondock", ".build");
+  const buildDir = join13(root, ".actiondock", ".build");
   mkdirSync7(buildDir, { recursive: true });
   const entryCode = generateStandaloneEntrypoint(plan.packageId, plan.version, plan.description, plan.actions.map((a) => ({ id: a.id, filePath: a.resolvedPath })), plan.configDefs);
   const entryFileName = `entry-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.ts`;
-  const entryPath = join12(buildDir, entryFileName);
+  const entryPath = join13(buildDir, entryFileName);
   writeFileSync8(entryPath, entryCode, "utf-8");
   const binaryName = getPackageSlug(plan.packageId);
-  const defaultOutfile = join12(root, "dist", binaryName);
+  const defaultOutfile = join13(root, "dist", binaryName);
   const outfile = resolve11(options.outfile || defaultOutfile);
   try {
     const result = await BunCompiler.compile({
@@ -61898,23 +62497,23 @@ async function buildProject(options) {
       actions: plan.actions.map((a) => a.id)
     };
   } finally {
-    if (existsSync20(entryPath)) {
+    if (existsSync22(entryPath)) {
       rmSync(entryPath, { force: true });
     }
   }
 }
 // ../builder/src/exporter.ts
-import { copyFileSync, existsSync as existsSync21, mkdirSync as mkdirSync8, readFileSync as readFileSync11, readdirSync as readdirSync5, rmSync as rmSync2, statSync as statSync9, writeFileSync as writeFileSync10 } from "fs";
-import { basename as basename8, dirname as dirname9, join as join14, relative as relative5, resolve as resolve12 } from "path";
+import { copyFileSync, existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync11, readdirSync as readdirSync6, rmSync as rmSync2, statSync as statSync9, writeFileSync as writeFileSync10 } from "fs";
+import { basename as basename8, dirname as dirname9, join as join15, relative as relative5, resolve as resolve12 } from "path";
 
 // ../builder/src/archive.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync8, writeFileSync as writeFileSync9 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync10, statSync as statSync8, writeFileSync as writeFileSync9 } from "fs";
 import { deflateRawSync, gzipSync } from "zlib";
-import { basename as basename7, join as join13, relative as relative4, sep } from "path";
+import { basename as basename7, join as join14, relative as relative4, sep } from "path";
 function collectEntries(dir, baseDir = dir) {
   const entries = [];
-  for (const name of readdirSync4(dir).sort()) {
-    const fullPath = join13(dir, name);
+  for (const name of readdirSync5(dir).sort()) {
+    const fullPath = join14(dir, name);
     const stat = statSync8(fullPath);
     if (stat.isDirectory()) {
       entries.push({ relPath: relative4(baseDir, fullPath).split(sep).join("/"), isDir: true });
@@ -61959,9 +62558,9 @@ function createZipArchive(dir, outPath) {
   for (const entry of entries) {
     const name = `${rootName}/${entry.relPath}${entry.isDir ? "/" : ""}`;
     const nameBuf = Buffer.from(name, "utf8");
-    const stat = statSync8(join13(dir, entry.relPath));
+    const stat = statSync8(join14(dir, entry.relPath));
     const { date, time } = dosDateTime(stat.mtimeMs);
-    const content = entry.isDir ? Buffer.alloc(0) : readFileSync10(join13(dir, entry.relPath));
+    const content = entry.isDir ? Buffer.alloc(0) : readFileSync10(join14(dir, entry.relPath));
     let method = 0;
     let payload = content;
     if (!entry.isDir && content.length > 0) {
@@ -62067,7 +62666,7 @@ function createTarGzArchive(dir, outPath) {
   const chunks = [];
   for (const entry of entries) {
     const path = `${rootName}/${entry.relPath}`;
-    const fullPath = join13(dir, entry.relPath);
+    const fullPath = join14(dir, entry.relPath);
     const stat = statSync8(fullPath);
     const content = entry.isDir ? Buffer.alloc(0) : readFileSync10(fullPath);
     chunks.push(tarHeader(path, content.length, Math.floor(stat.mtimeMs / 1000), entry.isDir));
@@ -62081,12 +62680,12 @@ function createTarGzArchive(dir, outPath) {
 
 // ../builder/src/exporter.ts
 function scanRelativeFiles(dir, baseDir = dir) {
-  if (!existsSync21(dir))
+  if (!existsSync23(dir))
     return [];
   const results = [];
-  const entries = readdirSync5(dir);
+  const entries = readdirSync6(dir);
   for (const entry of entries) {
-    const fullPath = join14(dir, entry);
+    const fullPath = join15(dir, entry);
     const stat = statSync9(fullPath);
     if (stat.isDirectory()) {
       results.push(...scanRelativeFiles(fullPath, baseDir));
@@ -62100,8 +62699,8 @@ function createArchive(skillDir, format) {
   const parentDir = dirname9(skillDir);
   const folderName = basename8(skillDir);
   const archiveName = `${folderName}.${format === "tar.gz" ? "tar.gz" : "zip"}`;
-  const archivePath = join14(parentDir, archiveName);
-  if (existsSync21(archivePath)) {
+  const archivePath = join15(parentDir, archiveName);
+  if (existsSync23(archivePath)) {
     rmSync2(archivePath, { force: true });
   }
   try {
@@ -62115,6 +62714,74 @@ function createArchive(skillDir, format) {
   }
   return archivePath;
 }
+function findExistingSingleSkillMd(projectRoot, explicitPath, pkgSlug) {
+  if (explicitPath && existsSync23(explicitPath)) {
+    try {
+      if (statSync9(explicitPath).isFile())
+        return resolve12(explicitPath);
+    } catch {}
+  }
+  const candidates = [
+    join15(projectRoot, "SKILL.md"),
+    join15(projectRoot, "skill.md"),
+    join15(projectRoot, "skills", "SKILL.md"),
+    join15(projectRoot, "skills", "skill.md")
+  ];
+  if (pkgSlug) {
+    candidates.push(join15(projectRoot, "skills", pkgSlug, "SKILL.md"), join15(projectRoot, "skills", pkgSlug, "skill.md"));
+  }
+  for (const candidate of candidates) {
+    if (existsSync23(candidate)) {
+      try {
+        if (statSync9(candidate).isFile())
+          return resolve12(candidate);
+      } catch {}
+    }
+  }
+  return;
+}
+function findExistingCompositeSkillMd(options) {
+  if (options.skillMdPath && existsSync23(options.skillMdPath)) {
+    try {
+      if (statSync9(options.skillMdPath).isFile())
+        return resolve12(options.skillMdPath);
+    } catch {}
+  }
+  const bundleSlug = getPackageSlug(options.bundleName);
+  const searchDirs = new Set;
+  if (options.workspaceRoot && existsSync23(options.workspaceRoot)) {
+    searchDirs.add(resolve12(options.workspaceRoot));
+  }
+  searchDirs.add(process.cwd());
+  for (const root of options.projectRoots) {
+    const absRoot = resolve12(root);
+    const parentDir = dirname9(absRoot);
+    searchDirs.add(parentDir);
+    searchDirs.add(dirname9(parentDir));
+  }
+  const candidateRelativePaths = [
+    join15("skills", options.bundleName, "SKILL.md"),
+    join15("skills", bundleSlug, "SKILL.md"),
+    join15("skills", "SKILL.md"),
+    "SKILL.md",
+    join15("skills", options.bundleName, "skill.md"),
+    join15("skills", bundleSlug, "skill.md"),
+    join15("skills", "skill.md"),
+    "skill.md"
+  ];
+  for (const dir of searchDirs) {
+    for (const rel of candidateRelativePaths) {
+      const fullPath = join15(dir, rel);
+      if (existsSync23(fullPath)) {
+        try {
+          if (statSync9(fullPath).isFile())
+            return fullPath;
+        } catch {}
+      }
+    }
+  }
+  return;
+}
 
 class SkillExporter {
   async export(options) {
@@ -62132,10 +62799,10 @@ class SkillExporter {
     const pkgSlug = getPackageSlug(plan.packageId);
     const targetSuffix = mode === "standalone" && target !== "host" && target !== "bun" ? `-${target}` : "";
     const defaultFolderName = `${pkgSlug}-skill${targetSuffix}`;
-    const defaultSkillDir = join14(root, "dist", defaultFolderName);
+    const defaultSkillDir = join15(root, "dist", defaultFolderName);
     const skillDir = resolve12(options.outDir || defaultSkillDir);
     mkdirSync8(skillDir, { recursive: true });
-    const playbooksDestDir = join14(skillDir, "playbooks");
+    const playbooksDestDir = join15(skillDir, "playbooks");
     if (plan.playbooks.length > 0) {
       mkdirSync8(playbooksDestDir, { recursive: true });
     }
@@ -62148,14 +62815,19 @@ class SkillExporter {
       playbooksDir: "playbooks",
       config: plan.configDefs
     };
+    let usedExistingSkillMd;
     if (mode === "source") {
-      const skillMd = generateSourceSkillMd(configForTemplates, plan.actions, plan.playbooks);
-      writeFileSync10(join14(skillDir, "SKILL.md"), skillMd, "utf-8");
-      const skillJsonContent = generateSkillJson(configForTemplates, plan.actions, {
-        mode: "source",
-        playbooks: plan.playbooks
-      });
-      writeFileSync10(join14(skillDir, "actiondock.skill.json"), skillJsonContent, "utf-8");
+      const existingSkill = !options.skipSkillMd ? findExistingSingleSkillMd(root, options.skillMdPath, pkgSlug) : undefined;
+      if (existingSkill) {
+        usedExistingSkillMd = existingSkill;
+        const destSkillMd = join15(skillDir, "SKILL.md");
+        if (resolve12(existingSkill) !== resolve12(destSkillMd)) {
+          copyFileSync(existingSkill, destSkillMd);
+        }
+      } else if (!options.skipSkillMd) {
+        const skillMd = generateSourceSkillMd(configForTemplates, plan.actions, plan.playbooks);
+        writeFileSync10(join15(skillDir, "SKILL.md"), skillMd, "utf-8");
+      }
       const manifestActions = {};
       for (const a of plan.actions) {
         manifestActions[a.id] = {
@@ -62167,13 +62839,19 @@ class SkillExporter {
           tags: a.tags,
           annotations: a.annotations
         };
+        if (a.id.includes("/")) {
+          const shortId = a.id.slice(a.id.lastIndexOf("/") + 1);
+          if (!manifestActions[shortId]) {
+            manifestActions[shortId] = manifestActions[a.id];
+          }
+        }
       }
       const exportedManifest = {
         schemaVersion: 1,
         actions: manifestActions,
         assets: plan.assets
       };
-      writeFileSync10(join14(skillDir, "actiondock.manifest.json"), JSON.stringify(exportedManifest, null, 2) + `
+      writeFileSync10(join15(skillDir, "actiondock.manifest.json"), JSON.stringify(exportedManifest, null, 2) + `
 `, "utf-8");
       const exportedConfig = {
         id: plan.packageId,
@@ -62184,11 +62862,11 @@ class SkillExporter {
         playbooksDir: "playbooks",
         config: plan.configDefs
       };
-      writeFileSync10(join14(skillDir, "actiondock.json"), JSON.stringify(exportedConfig, null, 2) + `
+      writeFileSync10(join15(skillDir, "actiondock.json"), JSON.stringify(exportedConfig, null, 2) + `
 `, "utf-8");
-      const projectPkgPath = join14(root, "package.json");
+      const projectPkgPath = join15(root, "package.json");
       let exportedPkg;
-      if (existsSync21(projectPkgPath)) {
+      if (existsSync23(projectPkgPath)) {
         try {
           const raw = readFileSync11(projectPkgPath, "utf-8");
           const parsed = JSON.parse(raw);
@@ -62220,42 +62898,42 @@ class SkillExporter {
           dependencies: { "@actiondock/sdk": "^2.0.0" }
         };
       }
-      writeFileSync10(join14(skillDir, "package.json"), JSON.stringify(exportedPkg, null, 2) + `
+      writeFileSync10(join15(skillDir, "package.json"), JSON.stringify(exportedPkg, null, 2) + `
 `, "utf-8");
-      const tsconfigPath = join14(root, "tsconfig.json");
-      if (existsSync21(tsconfigPath)) {
-        copyFileSync(tsconfigPath, join14(skillDir, "tsconfig.json"));
+      const tsconfigPath = join15(root, "tsconfig.json");
+      if (existsSync23(tsconfigPath)) {
+        copyFileSync(tsconfigPath, join15(skillDir, "tsconfig.json"));
       }
       for (const act of plan.actions) {
-        if (existsSync21(act.resolvedPath)) {
-          const destFile = join14(skillDir, act.entry);
+        if (existsSync23(act.resolvedPath)) {
+          const destFile = join15(skillDir, act.entry);
           mkdirSync8(dirname9(destFile), { recursive: true });
           copyFileSync(act.resolvedPath, destFile);
         }
       }
       for (const dep of plan.dependencies.modulesAndAssets) {
-        if (dep.type === "asset" && existsSync21(dep.resolvedPath)) {
-          const destAsset = join14(skillDir, dep.path);
+        if ((dep.type === "asset" || dep.type === "module") && existsSync23(dep.resolvedPath)) {
+          const destAsset = join15(skillDir, dep.path);
           mkdirSync8(dirname9(destAsset), { recursive: true });
           copyFileSync(dep.resolvedPath, destAsset);
         }
       }
       for (const pb of plan.playbooks) {
-        if (existsSync21(pb.filePath)) {
-          const destPb = join14(playbooksDestDir, basename8(pb.filePath));
+        if (existsSync23(pb.filePath)) {
+          const destPb = join15(playbooksDestDir, basename8(pb.filePath));
           copyFileSync(pb.filePath, destPb);
         }
       }
     } else {
-      const binDir = join14(skillDir, "bin");
+      const binDir = join15(skillDir, "bin");
       mkdirSync8(binDir, { recursive: true });
       const binaryName = pkgSlug;
-      const binaryPath = join14(binDir, binaryName);
-      const buildDir = join14(root, ".actiondock", ".build");
+      const binaryPath = join15(binDir, binaryName);
+      const buildDir = join15(root, ".actiondock", ".build");
       mkdirSync8(buildDir, { recursive: true });
       const entryCode = generateStandaloneEntrypoint(plan.packageId, plan.version, plan.description, plan.actions.map((a) => ({ id: a.id, filePath: a.resolvedPath })), plan.configDefs);
       const entryFileName = `entry-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.ts`;
-      const entryPath = join14(buildDir, entryFileName);
+      const entryPath = join15(buildDir, entryFileName);
       writeFileSync10(entryPath, entryCode, "utf-8");
       let compileRes;
       try {
@@ -62271,29 +62949,31 @@ class SkillExporter {
           actions: plan.actions.map((a) => a.id)
         });
       } finally {
-        if (existsSync21(entryPath)) {
+        if (existsSync23(entryPath)) {
           rmSync2(entryPath, { force: true });
         }
       }
       const actualBinaryName = basename8(compileRes.executablePath);
-      const skillMd = generateStandaloneSkillMd(configForTemplates, plan.actions, plan.playbooks, `./bin/${actualBinaryName}`);
-      writeFileSync10(join14(skillDir, "SKILL.md"), skillMd, "utf-8");
-      const skillJsonContent = generateSkillJson(configForTemplates, plan.actions, {
-        mode: "standalone",
-        executable: `./bin/${actualBinaryName}`,
-        target,
-        playbooks: plan.playbooks
-      });
-      writeFileSync10(join14(skillDir, "actiondock.skill.json"), skillJsonContent, "utf-8");
+      const existingSkill = !options.skipSkillMd ? findExistingSingleSkillMd(root, options.skillMdPath, pkgSlug) : undefined;
+      if (existingSkill) {
+        usedExistingSkillMd = existingSkill;
+        const destSkillMd = join15(skillDir, "SKILL.md");
+        if (resolve12(existingSkill) !== resolve12(destSkillMd)) {
+          copyFileSync(existingSkill, destSkillMd);
+        }
+      } else if (!options.skipSkillMd) {
+        const skillMd = generateStandaloneSkillMd(configForTemplates, plan.actions, plan.playbooks, `./bin/${actualBinaryName}`);
+        writeFileSync10(join15(skillDir, "SKILL.md"), skillMd, "utf-8");
+      }
       for (const pb of plan.playbooks) {
-        if (existsSync21(pb.filePath)) {
-          const destPb = join14(playbooksDestDir, basename8(pb.filePath));
+        if (existsSync23(pb.filePath)) {
+          const destPb = join15(playbooksDestDir, basename8(pb.filePath));
           copyFileSync(pb.filePath, destPb);
         }
       }
       for (const dep of plan.dependencies.modulesAndAssets) {
-        if (dep.type === "asset" && existsSync21(dep.resolvedPath)) {
-          const destAsset = join14(skillDir, dep.path);
+        if (dep.type === "asset" && existsSync23(dep.resolvedPath)) {
+          const destAsset = join15(skillDir, dep.path);
           mkdirSync8(dirname9(destAsset), { recursive: true });
           copyFileSync(dep.resolvedPath, destAsset);
         }
@@ -62321,9 +63001,134 @@ class SkillExporter {
       playbooksCount: plan.playbooks.length,
       actions: plan.actions.map((a) => a.id),
       playbooks: plan.playbooks.map((p) => p.id),
-      files
+      files,
+      usedExistingSkillMd
+    };
+  }
+  async exportBatch(options) {
+    if (!options.projectRoots || options.projectRoots.length === 0) {
+      throw new BuilderError("No project roots provided for batch skill export.");
+    }
+    const results = [];
+    const baseOutDir = resolve12(options.outDir || join15(process.cwd(), "dist", "skills"));
+    mkdirSync8(baseOutDir, { recursive: true });
+    const usedDirNames = new Set;
+    for (const projectRoot of options.projectRoots) {
+      const config = loadProjectConfig(projectRoot);
+      let pkgSlug = getPackageSlug(config.id);
+      if (usedDirNames.has(pkgSlug)) {
+        pkgSlug = config.id.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/^-+|-+$/g, "");
+      }
+      usedDirNames.add(pkgSlug);
+      const pkgOutDir = join15(baseOutDir, `${pkgSlug}-skill`);
+      const res = await this.export({
+        ...options,
+        projectRoot,
+        outDir: pkgOutDir
+      });
+      results.push(res);
+    }
+    const totalActions = results.reduce((sum, r) => sum + r.actionsCount, 0);
+    const totalPlaybooks = results.reduce((sum, r) => sum + r.playbooksCount, 0);
+    return {
+      results,
+      outDir: baseOutDir,
+      totalActions,
+      totalPlaybooks
+    };
+  }
+  static async exportBatch(options) {
+    const exporter = new SkillExporter;
+    return exporter.exportBatch(options);
+  }
+  async exportComposite(options) {
+    if (!options.projectRoots || options.projectRoots.length === 0) {
+      throw new BuilderError("No project roots provided for composite skill export.");
+    }
+    if (!options.bundleName || !options.bundleName.trim()) {
+      throw new BuilderError("bundleName is required for composite skill export.");
+    }
+    const bundleSlug = getPackageSlug(options.bundleName);
+    const defaultSkillDir = join15(process.cwd(), "dist", `${bundleSlug}-skill`);
+    const skillDir = resolve12(options.outDir || defaultSkillDir);
+    mkdirSync8(skillDir, { recursive: true });
+    const packagesDestDir = join15(skillDir, "packages");
+    mkdirSync8(packagesDestDir, { recursive: true });
+    const packageInfos = [];
+    const packageSummaries = [];
+    const usedDirNames = new Set;
+    for (const projectRoot of options.projectRoots) {
+      const config = loadProjectConfig(projectRoot);
+      let pkgSlug = getPackageSlug(config.id);
+      if (usedDirNames.has(pkgSlug)) {
+        pkgSlug = config.id.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/^-+|-+$/g, "");
+      }
+      usedDirNames.add(pkgSlug);
+      const destPkgDir = join15(packagesDestDir, pkgSlug);
+      const singleExport = await this.export({
+        projectRoot,
+        outDir: destPkgDir,
+        archive: false,
+        skipSkillMd: true
+      });
+      const manifest = loadManifest(destPkgDir) || loadManifest(projectRoot);
+      const playbooks = loadPlaybooks(projectRoot, config.playbooksDir);
+      const actionEntries = singleExport.actions.map((actId) => ({
+        id: actId,
+        description: manifest?.actions?.[actId]?.description
+      }));
+      packageInfos.push({
+        config,
+        actions: actionEntries,
+        playbooks: Array.from(playbooks.values()),
+        packageDir: pkgSlug
+      });
+      packageSummaries.push({
+        packageId: config.id,
+        actions: singleExport.actions,
+        playbooks: singleExport.playbooks
+      });
+    }
+    const existingSkillPath = findExistingCompositeSkillMd(options);
+    if (existingSkillPath) {
+      const destSkillMdPath = join15(skillDir, "SKILL.md");
+      if (resolve12(existingSkillPath) !== resolve12(destSkillMdPath)) {
+        copyFileSync(existingSkillPath, destSkillMdPath);
+      }
+    } else {
+      const description = options.description || `ActionDock \u590D\u5408\u6280\u80FD\u5957\u4EF6\uFF0C\u805A\u5408 ${packageInfos.map((p) => p.config.name).join("\u3001")}`;
+      const compositeSkillMd = generateCompositeSkillMd(options.bundleName, description, packageInfos);
+      writeFileSync10(join15(skillDir, "SKILL.md"), compositeSkillMd, "utf-8");
+    }
+    let archivePath;
+    if (options.archive) {
+      let format = "zip";
+      if (options.archiveFormat === "tar.gz" || options.archive === "tar.gz") {
+        format = "tar.gz";
+      } else if (options.archiveFormat === "zip" || options.archive === "zip") {
+        format = "zip";
+      }
+      archivePath = createArchive(skillDir, format);
+    }
+    const files = scanRelativeFiles(skillDir);
+    const totalActions = packageSummaries.reduce((sum, p) => sum + p.actions.length, 0);
+    const totalPlaybooks = packageSummaries.reduce((sum, p) => sum + p.playbooks.length, 0);
+    return {
+      bundleName: options.bundleName,
+      skillDir,
+      archivePath,
+      packagesCount: packageInfos.length,
+      actionsCount: totalActions,
+      playbooksCount: totalPlaybooks,
+      packages: packageSummaries,
+      files,
+      usedExistingSkillMd: existingSkillPath
     };
   }
+  static async exportComposite(options) {
+    const exporter = new SkillExporter;
+    return exporter.exportComposite(options);
+  }
   static async export(options) {
     const exporter = new SkillExporter;
     return exporter.export(options);
@@ -62332,6 +63137,12 @@ class SkillExporter {
 async function exportSkill(options) {
   return SkillExporter.export(options);
 }
+async function exportSkillBatch(options) {
+  return SkillExporter.exportBatch(options);
+}
+async function exportCompositeSkill(options) {
+  return SkillExporter.exportComposite(options);
+}
 // src/commands/build.ts
 function registerBuildCommand(program) {
   program.command("build").description("Build project actions into a single standalone executable").option("-P, --package <id>", "Target package ID or path").option("-t, --target <target>", "Target compilation platform (e.g. bun, linux-x64, darwin-arm64, windows-x64)").option("-o, --out <path>", "Output executable path").option("-a, --actions <actions...>", "Only build specific action(s) into the standalone binary").option("-m, --minify", "Minify bundled JavaScript (default: true)", true).option("--no-minify", "Disable JavaScript minification").option("--bytecode", "Compile JavaScript to bytecode for faster startup (default: true)", true).option("--no-bytecode", "Disable bytecode compilation").action(async (options) => {
@@ -62847,19 +63658,109 @@ function registerDoctorCommand(program) {
 }
 
 // src/commands/export.ts
+import { existsSync as existsSync24 } from "fs";
+import { basename as basename9 } from "path";
+function parseListOption2(val, prev = []) {
+  const parts = val.split(",").map((s) => s.trim()).filter(Boolean);
+  return [...prev, ...parts];
+}
 function registerExportCommand(program) {
   const exportCmd = program.command("export").description("Export project artifacts");
-  exportCmd.command("skill").description("Export Skill directory for AI Agents (default: source skill; use -s/--standalone for pre-built standalone binary)").option("-P, --package <id>", "Target package ID or path").option("-s, --standalone", "Export pre-compiled standalone binary skill (for environments without ActionDock runtime)").option("-t, --target <target>", "Target compilation platform for standalone mode (e.g. host, linux-x64, darwin-arm64, windows-x64)").option("-o, --out <path>", "Output skill directory").option("-p, --playbook <playbooks...>", "Only export specific playbook(s) and their dependent actions (Playbook-driven minimal export)").option("-a, --actions <actions...>", "Only export specific action(s)").option("-m, --minify", "Minify bundled JavaScript in standalone mode (default: true)", true).option("--no-minify", "Disable JavaScript minification in standalone mode").option("--bytecode", "Compile JavaScript to bytecode in standalone mode (default: true)", true).option("--no-bytecode", "Disable bytecode compilation in standalone mode").option("-z, --archive", "Create a .zip archive of the exported skill").action(async (options) => {
-    const root = options.package ? resolvePackageRoot(options.package) : findProjectRoot();
-    if (!root) {
-      if (options.package) {
-        throw new ExecutionError(`Package '${options.package}' not found in linked packages or path`);
+  exportCmd.command("skill").description("Export Skill directory for AI Agents (default: source skill; use -s/--standalone for pre-built standalone binary)").option("-P, --package <id...>", "Target package ID(s) or path(s) (can be specified multiple times or comma-separated)", parseListOption2, []).option("--workspace", "Export all packages discovered in current workspace").option("--all", "Export all linked packages from global registry").option("--bundle [name]", "Export multiple packages as a unified composite Skill bundle (defaults to workspace directory name if omitted)").option("-s, --standalone", "Export pre-compiled standalone binary skill (for environments without ActionDock runtime)").option("-t, --target <target>", "Target compilation platform for standalone mode (e.g. host, linux-x64, darwin-arm64, windows-x64)").option("-o, --out <path>", "Output skill directory").option("-p, --playbook <playbooks...>", "Only export specific playbook(s) and their dependent actions (Playbook-driven minimal export)").option("-a, --actions <actions...>", "Only export specific action(s)").option("-m, --minify", "Minify bundled JavaScript in standalone mode (default: true)", true).option("--no-minify", "Disable JavaScript minification in standalone mode").option("--bytecode", "Compile JavaScript to bytecode in standalone mode (default: true)", true).option("--no-bytecode", "Disable bytecode compilation in standalone mode").option("-z, --archive", "Create a .zip archive of the exported skill").option("--skill-md <path>", "Use specified existing SKILL.md file instead of auto-generating").action(async (options) => {
+    const isStandalone = Boolean(options.standalone);
+    if (options.bundle && isStandalone) {
+      throw new ExecutionError("Composite Skill export (--bundle) currently only supports source mode. Please remove --standalone to export as a composite workspace Skill.");
+    }
+    const sourceCount = (options.all ? 1 : 0) + (options.workspace ? 1 : 0) + (options.package && options.package.length > 0 ? 1 : 0);
+    if (sourceCount > 1) {
+      throw new ExecutionError("Options -P/--package, --workspace, and --all are mutually exclusive. Please specify only one package selection mode.");
+    }
+    let roots = [];
+    if (options.all) {
+      const linked = listLinkedPackages();
+      roots = linked.map((p) => p.path).filter((p) => existsSync24(p));
+      if (roots.length === 0) {
+        throw new ExecutionError("No linked packages found in global registry.");
+      }
+    } else if (options.workspace) {
+      const cwd = process.cwd();
+      const discovered = discoverProjects(cwd);
+      roots = discovered.length > 0 ? discovered : findProjectRoot(cwd) ? [findProjectRoot(cwd)] : [];
+      if (roots.length === 0) {
+        throw new ExecutionError(`No ActionDock packages found in workspace '${cwd}'.
+Make sure child directories contain actiondock.json.`);
+      }
+    } else if (options.package && options.package.length > 0) {
+      for (const pkgIdOrPath of options.package) {
+        const root = resolvePackageRoot(pkgIdOrPath);
+        if (!root) {
+          throw new ExecutionError(`Package '${pkgIdOrPath}' not found in linked packages or path`);
+        }
+        if (!roots.includes(root)) {
+          roots.push(root);
+        }
+      }
+    } else {
+      const root = findProjectRoot();
+      if (root) {
+        roots.push(root);
+      } else {
+        throw new ExecutionError(`Not in an ActionDock project (actiondock.json not found).
+Please specify -P, --package <id>, --workspace, --all, or cd into a project directory.`);
       }
-      throw new ExecutionError(`Not in an ActionDock project (actiondock.json not found).
-Please specify -P, --package <id> or cd into a project directory.`);
     }
-    const isStandalone = Boolean(options.standalone);
+    if (roots.length > 1 && (options.actions || options.playbook)) {
+      throw new ExecutionError("Filtering options (--actions, --playbook) can only be used when exporting a single package.");
+    }
     try {
+      if (options.bundle !== undefined) {
+        const bundleName = typeof options.bundle === "string" && options.bundle.trim() ? options.bundle.trim() : basename9(process.cwd());
+        console.log(`Exporting composite Skill bundle '${bundleName}' (${roots.length} package${roots.length > 1 ? "s" : ""})...`);
+        const result = await exportCompositeSkill({
+          bundleName,
+          projectRoots: roots,
+          outDir: options.out,
+          archive: options.archive,
+          workspaceRoot: options.workspace ? process.cwd() : undefined,
+          skillMdPath: options.skillMd
+        });
+        console.log(`[OK] Successfully exported Composite Skill: ${result.bundleName}`);
+        console.log(`  Packages:   ${result.packagesCount}`);
+        console.log(`  Actions:    ${result.actionsCount}`);
+        console.log(`  Playbooks:  ${result.playbooksCount}`);
+        console.log(`  Skill Dir:  ${result.skillDir}`);
+        if (result.usedExistingSkillMd) {
+          console.log(`  SKILL.md:   Reused existing file from ${result.usedExistingSkillMd}`);
+        }
+        if (result.archivePath) {
+          console.log(`  Archive:    ${result.archivePath}`);
+        }
+        return;
+      }
+      if (roots.length > 1) {
+        console.log(`Batch exporting ${roots.length} Skill packages...`);
+        const batchRes = await exportSkillBatch({
+          projectRoots: roots,
+          mode: isStandalone ? "standalone" : "source",
+          standalone: isStandalone,
+          target: options.target,
+          outDir: options.out,
+          archive: options.archive,
+          playbooks: options.playbook,
+          actions: options.actions,
+          minify: options.minify,
+          bytecode: options.bytecode,
+          skillMdPath: options.skillMd
+        });
+        console.log(`[OK] Successfully batch exported ${batchRes.results.length} Skill packages to: ${batchRes.outDir}`);
+        for (const res of batchRes.results) {
+          console.log(`  - ${res.packageId} (v${res.version}): ${res.actionsCount} actions, ${res.playbooksCount} playbooks -> ${res.skillDir}`);
+        }
+        console.log(`  Total Actions:   ${batchRes.totalActions}`);
+        console.log(`  Total Playbooks: ${batchRes.totalPlaybooks}`);
+        return;
+      }
+      const root = roots[0];
       console.log(`Exporting ${isStandalone ? "standalone binary" : "source"} Skill artifact...`);
       const result = await exportSkill({
         projectRoot: root,
@@ -62871,13 +63772,17 @@ Please specify -P, --package <id> or cd into a project directory.`);
         playbooks: options.playbook,
         actions: options.actions,
         minify: options.minify,
-        bytecode: options.bytecode
+        bytecode: options.bytecode,
+        skillMdPath: options.skillMd
       });
       console.log(`[OK] Successfully exported ${result.mode === "standalone" ? "Standalone" : "Source"} Skill: ${result.packageId} (v${result.version})`);
       console.log(`  Mode:       ${result.mode}${result.mode === "standalone" ? ` (target: ${result.target})` : ""}`);
       console.log(`  Actions:    ${result.actionsCount}`);
       console.log(`  Playbooks:  ${result.playbooksCount}`);
       console.log(`  Skill Dir:  ${result.skillDir}`);
+      if (result.usedExistingSkillMd) {
+        console.log(`  SKILL.md:   Reused existing file from ${result.usedExistingSkillMd}`);
+      }
       if (result.archivePath) {
         console.log(`  Archive:    ${result.archivePath}`);
       }
@@ -62888,7 +63793,7 @@ Please specify -P, --package <id> or cd into a project directory.`);
 }
 
 // src/commands/info.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 async function getProjectDetailInfo(root) {
   const config = loadProjectConfig(root);
   const manifest = loadManifest(root);
@@ -63164,7 +64069,7 @@ Declared Config Keys:`);
         } catch {}
       }
       for (const pkg of linkedList) {
-        if (!existsSync22(pkg.path))
+        if (!existsSync25(pkg.path))
           continue;
         if (seenPaths.has(pkg.path))
           continue;
@@ -63354,12 +64259,12 @@ function registerLinkCommands(program) {
 
 // src/commands/mcp.ts
 import { resolve as resolve13 } from "path";
-function parseListOption2(val, prev = []) {
+function parseListOption3(val, prev = []) {
   const parts = val.split(",").map((s) => s.trim()).filter(Boolean);
   return [...prev, ...parts];
 }
 function registerMcpCommands2(program) {
-  const mcpCommand = program.command("mcp").description("Model Context Protocol (MCP) server for ActionDock Actions (STDIO default)").option("-d, --dir <path>", "Project root directory or directories (can be specified multiple times or comma-separated)", parseListOption2, []).option("--package <package-id>", "Specific linked package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption2, []).option("--all", "Serve all linked packages from global registry").option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)").action(async (options) => {
+  const mcpCommand = program.command("mcp").description("Model Context Protocol (MCP) server for ActionDock Actions (STDIO default)").option("-d, --dir <path>", "Project root directory or directories (can be specified multiple times or comma-separated)", parseListOption3, []).option("--package <package-id>", "Specific linked package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption3, []).option("--all", "Serve all linked packages from global registry").option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)").action(async (options) => {
     let timeoutMs;
     if (options.timeout) {
       try {
@@ -63382,7 +64287,7 @@ function registerMcpCommands2(program) {
       throw new ExecutionError(`Failed to start MCP STDIO server: ${err.message}`);
     }
   });
-  mcpCommand.command("serve").description("Start the ActionDock MCP server over HTTP transport").option("-p, --port <port>", "Port to listen on (default: 5178)", "5178").option("-H, --host <host>", "Host address to bind to (default: 127.0.0.1)", "127.0.0.1").option("-t, --token <token>", "Authentication token for securing the endpoint (or set ACTIONDOCK_TOKEN)").option("--token-env <env>", "Environment variable name containing the authentication token").option("--allow-insecure-no-auth", "Allow non-loopback host binding without authentication token (INSECURE)").option("--cors-origin <origin>", "Allowed CORS origin (can be specified multiple times)", (val, prev = []) => [...prev, val], []).option("--max-body <size>", "Maximum allowed JSON request body size (e.g. 1mb, 500kb)", "1mb").option("-d, --dir <path>", "Project root directory or directories (can be specified multiple times or comma-separated)", parseListOption2, []).option("--package <package-id>", "Specific linked package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption2, []).option("--all", "Serve all linked packages from global registry").option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)").action(async (options) => {
+  mcpCommand.command("serve").description("Start the ActionDock MCP server over HTTP transport").option("-p, --port <port>", "Port to listen on (default: 5178)", "5178").option("-H, --host <host>", "Host address to bind to (default: 127.0.0.1)", "127.0.0.1").option("-t, --token <token>", "Authentication token for securing the endpoint (or set ACTIONDOCK_TOKEN)").option("--token-env <env>", "Environment variable name containing the authentication token").option("--allow-insecure-no-auth", "Allow non-loopback host binding without authentication token (INSECURE)").option("--cors-origin <origin>", "Allowed CORS origin (can be specified multiple times)", (val, prev = []) => [...prev, val], []).option("--max-body <size>", "Maximum allowed JSON request body size (e.g. 1mb, 500kb)", "1mb").option("-d, --dir <path>", "Project root directory or directories (can be specified multiple times or comma-separated)", parseListOption3, []).option("--package <package-id>", "Specific linked package ID(s) to serve (can be specified multiple times or comma-separated)", parseListOption3, []).option("--all", "Serve all linked packages from global registry").option("--timeout <duration>", "Execution timeout (e.g. 30s, 5m, 500ms)").action(async (options) => {
     const port = parseInt(options.port, 10) || 5178;
     const host = options.host || "127.0.0.1";
     const token = options.token || (options.tokenEnv ? process.env[options.tokenEnv] : undefined) || process.env.ACTIONDOCK_TOKEN;
@@ -63477,7 +64382,7 @@ Stopping MCP HTTP server...`);
 }
 
 // src/commands/playbook.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname10, resolve as resolve14 } from "path";
 function registerPlaybookCommands2(program) {
   const pbCmd = program.command("playbook").description("Manage task Playbooks (Task SOPs for AI Agents)");
@@ -63589,7 +64494,7 @@ Run 'ad link' inside an Action package to register it.`
       }
       const aggregated = [];
       for (const pkg of linkedList) {
-        if (!existsSync23(pkg.path))
+        if (!existsSync26(pkg.path))
           continue;
         try {
           const config = loadProjectConfig(pkg.path);
@@ -63670,13 +64575,13 @@ Run 'ad link' inside an Action package to register it.`
     try {
       const config = loadProjectConfig(root);
       const pbDir = resolve14(root, config.playbooksDir || "playbooks");
-      if (!existsSync23(pbDir)) {
+      if (!existsSync26(pbDir)) {
         mkdirSync9(pbDir, { recursive: true });
       }
       const cleanName = id.replace(/[^a-zA-Z0-9-_]/g, "-");
       const targetRelFile = options.file || `${cleanName}.md`;
       const targetFullFile = resolve14(pbDir, targetRelFile);
-      if (existsSync23(targetFullFile)) {
+      if (existsSync26(targetFullFile)) {
         throw new ExecutionError(`File '${targetFullFile}' already exists`);
       }
       mkdirSync9(dirname10(targetFullFile), { recursive: true });
@@ -63824,7 +64729,7 @@ This playbook provides task execution guidance for AI Agents.
           throw new ArgumentError("Not in an ActionDock project, and no packages linked.");
         }
         for (const pkg of linkedList) {
-          if (!existsSync23(pkg.path))
+          if (!existsSync26(pkg.path))
             continue;
           try {
             const config = loadProjectConfig(pkg.path);
@@ -64113,7 +65018,7 @@ Use 'ad profile use <name>' to switch or 'ad run <action> --profile <name>' to e
 }
 
 // src/commands/runs.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 function printRunRecord(run) {
   console.log(`Run:          ${run.id}`);
   console.log(`Action:       ${run.actionId}`);
@@ -64220,7 +65125,7 @@ function registerRunsCommands2(program) {
       }
       let allRecords = [];
       for (const pkg of linkedList) {
-        if (!existsSync24(pkg.path))
+        if (!existsSync27(pkg.path))
           continue;
         try {
           const projConfig = loadProjectConfig(pkg.path);
@@ -64326,7 +65231,7 @@ function registerRunsCommands2(program) {
         if (!foundRun) {
           const linkedList = listLinkedPackages();
           for (const pkg of linkedList) {
-            if (!existsSync24(pkg.path))
+            if (!existsSync27(pkg.path))
               continue;
             try {
               const projConfig = loadProjectConfig(pkg.path);
@@ -64533,7 +65438,7 @@ Stopping ActionDock server...`);
 }
 
 // src/commands/state.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 function getTargetRoot2(packageOption, keyHint) {
   let targetPackage = packageOption;
   let effectiveKey = keyHint || "";
@@ -64641,7 +65546,7 @@ function registerStateCommands2(program) {
       }
       const aggregated = [];
       for (const pkg of linkedList) {
-        if (!existsSync25(pkg.path))
+        if (!existsSync28(pkg.path))
           continue;
         try {
           const projConfig = loadProjectConfig(pkg.path);
@@ -64940,16 +65845,16 @@ function registerStateCommands2(program) {
 
 // src/commands/test.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync12 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 function registerTestCommand(program) {
   program.command("test [pattern]").description("Run project tests using configured test runner (node:test or bun test)").action((pattern) => {
     const root = findProjectRoot();
     const cwd = root || process.cwd();
-    const pkgJsonPath = join15(cwd, "package.json");
+    const pkgJsonPath = join16(cwd, "package.json");
     let testCmd = "npm";
     let testArgs = ["test"];
-    if (existsSync26(pkgJsonPath)) {
+    if (existsSync29(pkgJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync12(pkgJsonPath, "utf-8"));
         if (pkg.scripts?.test?.includes("bun test") && typeof globalThis.Bun !== "undefined") {
@@ -64993,7 +65898,7 @@ function applyCommonOptions(cmd) {
 }
 function createCliProgram() {
   const program = new Command2;
-  program.name("ad").description("ActionDock (ad) 2.0 - Toolchain for building and shipping standalone AI Agent Actions & Skills").version("2.0.10", "-v, --version");
+  program.name("ad").description("ActionDock (ad) 2.0 - Toolchain for building and shipping standalone AI Agent Actions & Skills").version("2.0.11", "-v, --version");
   program.option("-V", "output the version number");
   program.on("option:V", () => {
     program._outputConfiguration.writeOut(`${program.version()}