@actiondock/cli 2.14.0 → 2.16.0

package/dist/commands/config/delete.js

@@ -1,6 +1,8 @@
-import { ArgumentError } from "../../errors.js";
+import { loadProjectConfig, } from "@actiondock/core";
+import { resolvePackageRoot, } from "@actiondock/core/registry";
+import { ArgumentError, packageNotFoundError } from "../../errors.js";
 import { writeStdout } from "../../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveTargetPackageScope, withService, } from "../../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, withService } from "../../utils/index.js";
 /**
  * 注册 config delete 子命令：删除配置项。
  *
@@ -20,22 +22,31 @@ export function registerConfigDeleteCommand(configCmd, context) {
         if (!key) {
             throw new ArgumentError("Configuration key is required");
         }
-        const scope = resolveTargetPackageScope(options, context);
+        const root = resolvePackageRoot(options.package);
         await withService(options, context, async (service, resolved) => {
             if (resolved.type === "remote") {
-                await service.management?.config.delete(scope.packageId, key);
+                await service.management?.config.delete(options.package || "", key);
                 writeStdout(`[OK] Configuration '${key}' deleted from remote server`, context);
                 return;
             }
-            if (options.global || (!scope.root && !options.package)) {
+            if (options.global) {
                 await service.management?.config.delete("global", key);
                 writeStdout(`[OK] Global configuration '${key}' deleted`, context);
                 return;
             }
-            await service.management?.config.delete(scope.packageId, key);
-            writeStdout(`[OK] Configuration '${key}' deleted for package '${scope.packageId}'`, context);
+            if (!root) {
+                if (options.package) {
+                    throw packageNotFoundError(options.package);
+                }
+                await service.management?.config.delete("global", key);
+                writeStdout(`[OK] Global configuration '${key}' deleted`, context);
+                return;
+            }
+            const projConfig = loadProjectConfig(root);
+            await service.management?.config.delete(projConfig.id, key);
+            writeStdout(`[OK] Configuration '${key}' deleted for package '${projConfig.id}'`, context);
         }, 
         // 按实际查询范围打开存储：显式包寻址结果作为本地根目录传递
-        { localRoot: scope.root });
+        { localRoot: root || undefined });
     });
 }

package/dist/commands/config/env.js

@@ -2,7 +2,7 @@ import { resolveEnvValue } from "@actiondock/core";
 import { fetchRemoteConfigEnv } from "@actiondock/core/profile";
 import { isSecretConfigKey, } from "@actiondock/core/project";
 import { renderConfigEnv, renderResult } from "../../renderer.js";
-import { applyTargetOptions, assertNotCompositeSkill, getEffectiveOptions, requirePackageRoot, resolveTargetFromOptions, } from "../../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, requirePackageRoot, resolveTargetFromOptions } from "../../utils/index.js";
 /**
  * 注册 config env 子命令：诊断环境变量对声明配置的满足率。
  *
@@ -18,7 +18,7 @@ export function registerConfigEnvCommand(configCmd, context) {
         .action(async (identifier, rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
         const targetPkg = identifier || options.package;
-        // 1. 目标拓扑解析（远端服务分支完全隔离本地文件系统）
+        // 远端服务分支直接查询远端配置环境诊断接口
         const target = resolveTargetFromOptions(options, context);
         if (target.type === "remote") {
             const res = await fetchRemoteConfigEnv(target.serverUrl, target.token, targetPkg, {
@@ -37,7 +37,6 @@ export function registerConfigEnvCommand(configCmd, context) {
             return;
         }
         // 本地项目分支
-        assertNotCompositeSkill(targetPkg);
         const { root, projConfig } = requirePackageRoot(targetPkg, {
             loadConfig: true,
             hint: "Usage: ad config env [package-id] or cd into a project directory.",

package/dist/commands/config/get.js

@@ -1,10 +1,11 @@
 import { fetchRemoteConfig, } from "@actiondock/core/profile";
 import { isSecretConfigKey, maskSecretValue, } from "@actiondock/core/project";
 import { loadProjectConfig, } from "@actiondock/core";
-import { ArgumentError } from "../../errors.js";
+import { resolvePackageRoot, } from "@actiondock/core/registry";
+import { ArgumentError, packageNotFoundError } from "../../errors.js";
 import { renderResult } from "../../renderer.js";
 import { resolveMergedConfigEntry } from "../../services/config-merge.js";
-import { applyTargetOptions, getEffectiveOptions, resolveTargetPackageScope, withService, } from "../../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, resolveTargetFromOptions, withService, } from "../../utils/index.js";
 /**
  * 注册 config get 子命令：查询指定配置键的生效值。
  *
@@ -26,11 +27,12 @@ export function registerConfigGetCommand(configCmd, context) {
             throw new ArgumentError("Configuration key is required");
         }
         const reveal = Boolean(options.reveal || options.showSecrets);
-        const scope = resolveTargetPackageScope(options, context);
-        if (scope.isRemote) {
-            const res = await fetchRemoteConfig(scope.resolved.serverUrl, scope.resolved.token, scope.packageId, {
+        // 远端服务分支不经过 Target 门面，直接查询远端配置接口
+        const target = resolveTargetFromOptions(options, context);
+        if (target.type === "remote") {
+            const res = await fetchRemoteConfig(target.serverUrl, target.token, options.package, {
                 allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                insecure: scope.resolved.insecure,
+                insecure: target.insecure,
             });
             const val = res.values?.[key];
             const isSecret = isSecretConfigKey(key, res.declared?.[key]);
@@ -48,8 +50,13 @@ export function registerConfigGetCommand(configCmd, context) {
             });
             return;
         }
+        // 本地分支
+        const root = resolvePackageRoot(options.package);
         await withService(options, context, async (service) => {
-            if (options.global || !scope.root) {
+            if (options.global || !root) {
+                if (!options.global && options.package && !root) {
+                    throw packageNotFoundError(options.package);
+                }
                 const confView = await service.management?.config.get("global", key);
                 const val = confView?.value;
                 const isSecret = confView?.secret ?? isSecretConfigKey(key);
@@ -67,10 +74,10 @@ export function registerConfigGetCommand(configCmd, context) {
                 });
                 return;
             }
-            const projConfig = scope.projConfig || loadProjectConfig(scope.root);
+            const projConfig = loadProjectConfig(root);
             const declaredItem = projConfig.config?.[key];
             // 合并优先级链单一事实源：项目包级 > 全局持久化 > 环境变量 > 声明默认值
-            const { value: displayValue, source, secret: isSecret } = await resolveMergedConfigEntry(key, scope.packageId, declaredItem, service, reveal);
+            const { value: displayValue, source, secret: isSecret } = await resolveMergedConfigEntry(key, projConfig.id, declaredItem, service, reveal);
             const payload = {
                 key,
                 value: displayValue,
@@ -84,6 +91,6 @@ export function registerConfigGetCommand(configCmd, context) {
             });
         }, 
         // 按实际查询范围打开存储：显式包寻址结果作为本地根目录传递
-        { localRoot: scope.root });
+        { localRoot: root || undefined });
     });
 }

package/dist/commands/config/list.js

@@ -1,9 +1,10 @@
 import { fetchRemoteConfig, } from "@actiondock/core/profile";
 import { loadProjectConfig, } from "@actiondock/core";
 import { filterWithFallbackInfo, isSecretConfigKey, maskSecretValue, } from "@actiondock/core/project";
+import { packageNotFoundError } from "../../errors.js";
 import { renderConfigList, renderResult } from "../../renderer.js";
 import { buildMergedConfigEntries } from "../../services/config-merge.js";
-import { applyTargetOptions, getEffectiveOptions, remoteTargetLabel, resolveFallbackStrategy, resolveIntent, resolveTargetPackageScope, withService, } from "../../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, remoteTargetLabel, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../../utils/index.js";
 /**
  * 构造单条配置项的展示视图（含掩码决策，reveal 为假且为敏感键时打码）。
  * 掩码决策收敛于命令层，renderer 仅负责值的字符串格式化。
@@ -41,24 +42,29 @@ export function registerConfigListCommand(configCmd, context) {
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const { shouldFallback } = resolveFallbackStrategy(options);
         const reveal = Boolean(options.reveal || options.showSecrets);
-        const scope = resolveTargetPackageScope(options, context);
-        if (scope.isRemote) {
-            const res = await fetchRemoteConfig(scope.resolved.serverUrl, scope.resolved.token, scope.packageId, {
+        // 远端服务分支不经过 Target 门面，直接查询远端配置接口
+        const remoteTargetInfo = resolveTargetFromOptions(options, context);
+        if (remoteTargetInfo.type === "remote") {
+            const res = await fetchRemoteConfig(remoteTargetInfo.serverUrl, remoteTargetInfo.token, options.package, {
                 allowInsecureHttp: Boolean(options.allowInsecureHttp),
-                insecure: scope.resolved.insecure,
+                insecure: remoteTargetInfo.insecure,
             });
             const entries = Object.entries(res.values || {}).map(([k, v]) => toDisplayEntry(k, v, "remote", isSecretConfigKey(k, res.declared?.[k]), reveal, res.declared?.[k]?.description || ""));
             renderResult(entries, {
                 json: options.json,
-                humanFormatter: () => renderConfigList(entries, remoteTargetLabel(scope.resolved), false, effectiveIntent),
+                humanFormatter: () => renderConfigList(entries, remoteTargetLabel(remoteTargetInfo), false, effectiveIntent),
                 context,
             });
             return;
         }
         // 本地分支（通过 Service 门面统一访问）：显式包寻址结果作为本地根目录传递（仅 local 分支求值）
         await withService(options, context, async (service) => {
+            const root = resolveLocalPackageRoot(options.package) || undefined;
             // 全局作用域分支：显式 --global 或无工程回退时仅列举全局配置
-            if (options.global || !scope.root) {
+            if (options.global || !root) {
+                if (!options.global && options.package) {
+                    throw packageNotFoundError(options.package);
+                }
                 const all = (await service.management?.config.list("global")) ?? [];
                 const entries = all.map((item) => toDisplayEntry(item.key, item.value, "global", item.secret || isSecretConfigKey(item.key), reveal));
                 const filterRes = filterWithFallbackInfo(entries, effectiveIntent, [(c) => c.key, (c) => c.value], shouldFallback);
@@ -69,9 +75,9 @@ export function registerConfigListCommand(configCmd, context) {
                 });
                 return;
             }
-            const projConfig = scope.projConfig || loadProjectConfig(scope.root);
+            const projConfig = loadProjectConfig(root);
             // 跨作用域合并视图单一事实源：项目包级 > 全局持久化 > 环境变量 > 声明默认值
-            const merged = await buildMergedConfigEntries(scope.root, service, reveal);
+            const merged = await buildMergedConfigEntries(root, service, reveal);
             const filterRes = filterWithFallbackInfo(merged, effectiveIntent, [(c) => c.key, (c) => c.value, (c) => c.description, (c) => c.source], shouldFallback);
             renderResult(filterRes.items, {
                 json: options.json,
@@ -79,7 +85,7 @@ export function registerConfigListCommand(configCmd, context) {
                 context,
             });
         }, {
-            localRoot: scope.root,
+            localRoot: () => resolveLocalPackageRoot(options.package) || undefined,
         });
     });
 }

package/dist/commands/config/schema.js

@@ -2,7 +2,7 @@ import { isSecretConfigKey, } from "@actiondock/core/project";
 import { notInProjectError } from "../../errors.js";
 import { renderConfigSchema, renderResult } from "../../renderer.js";
 import { buildMergedConfigEntries } from "../../services/config-merge.js";
-import { applyTargetOptions, assertNotCompositeSkill, getEffectiveOptions, requirePackageRoot, withService, } from "../../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, requirePackageRoot, withService } from "../../utils/index.js";
 /**
  * 注册 config schema 子命令：检查声明配置的解析状态。
  *
@@ -25,18 +25,17 @@ export function registerConfigSchemaCommand(configCmd, context) {
         .option("--json", "Output as JSON")
         .action(async (identifier, rawOptions, cmd) => {
         const options = getEffectiveOptions(rawOptions, cmd);
-        // 远端目标显式拒绝：schema 状态推导依赖本地工程声明与环境变量解析，
-        // 远端作用域无法获得等价视图，静默落到本地会误导调用方
-        if (options.profile || options.server) {
-            throw notInProjectError("'ad config schema' only supports local projects. Remote targets are not supported for schema inspection.");
-        }
         const targetPkg = identifier || options.package;
-        assertNotCompositeSkill(targetPkg);
         const { root, projConfig } = requirePackageRoot(targetPkg, {
             loadConfig: true,
             hint: "Usage: ad config schema [package-id] or cd into a project directory.",
         });
         const declared = projConfig.config || {};
+        // 远端目标显式拒绝：schema 状态推导依赖本地工程声明与环境变量解析，
+        // 远端作用域无法获得等价视图，静默落到本地会误导调用方
+        if (options.profile || options.server) {
+            throw notInProjectError("'ad config schema' only supports local projects. Remote targets are not supported for schema inspection.");
+        }
         // 跨作用域合并视图单一事实源：与 config list 共享同一条优先级链
         await withService(options, context, async (service) => {
             const merged = await buildMergedConfigEntries(root, service, true);

package/dist/commands/config/set.js

@@ -1,7 +1,9 @@
 import { isSecretConfigKey, } from "@actiondock/core/project";
-import { ArgumentError } from "../../errors.js";
+import { loadProjectConfig, } from "@actiondock/core";
+import { resolvePackageRoot, } from "@actiondock/core/registry";
+import { ArgumentError, packageNotFoundError } from "../../errors.js";
 import { writeStdout } from "../../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveTargetPackageScope, withService, } from "../../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, withService } from "../../utils/index.js";
 import { resolveConfigValueInput } from "../../prompt.js";
 /**
  * 注册 config set 子命令：写入配置值（支持标准输入与安全提示）。
@@ -22,8 +24,22 @@ export function registerConfigSetCommand(configCmd, context) {
         if (!key) {
             throw new ArgumentError("Configuration key is required");
         }
-        const scope = resolveTargetPackageScope(options, context);
-        const declaredDef = scope.projConfig?.config?.[key];
+        let root = null;
+        let projConfig = null;
+        let declaredDef;
+        if (!options.global && !options.profile && !options.server) {
+            root = resolvePackageRoot(options.package);
+            if (root) {
+                try {
+                    projConfig = loadProjectConfig(root);
+                    declaredDef = projConfig.config?.[key];
+                }
+                catch (err) {
+                    // 清单损坏时必须让错误可见：静默忽略会导致写入错误的作用域
+                    throw err;
+                }
+            }
+        }
         const isSecret = isSecretConfigKey(key, declaredDef);
         let effectiveValueStr = rawVal;
         if (effectiveValueStr === undefined || options.stdin) {
@@ -44,21 +60,27 @@ export function registerConfigSetCommand(configCmd, context) {
         // 目标解析与写入（远端分支直接写远端作用域，本地分支按全局/项目作用域写入）
         await withService(options, context, async (service, resolved) => {
             if (resolved.type === "remote") {
-                await service.management?.config.set(scope.packageId, key, parsedVal);
+                await service.management?.config.set(options.package || "", key, parsedVal);
                 writeStdout(`[OK] Configuration '${key}' updated on remote server`, context);
                 return;
             }
-            if (options.global || (!scope.root && !options.package)) {
+            if (options.global) {
+                await service.management?.config.set("global", key, parsedVal);
+                writeStdout(`[OK] Global configuration '${key}' updated`, context);
+                return;
+            }
+            if (!root) {
+                if (options.package) {
+                    throw packageNotFoundError(options.package);
+                }
                 await service.management?.config.set("global", key, parsedVal);
-                writeStdout(!scope.root && !options.package
-                    ? `[OK] Global configuration '${key}' updated (no project in current directory)`
-                    : `[OK] Global configuration '${key}' updated`, context);
+                writeStdout(`[OK] Global configuration '${key}' updated (no project in current directory)`, context);
                 return;
             }
-            await service.management?.config.set(scope.packageId, key, parsedVal);
-            writeStdout(`[OK] Configuration '${key}' updated for package '${scope.packageId}'`, context);
+            await service.management?.config.set(projConfig.id, key, parsedVal);
+            writeStdout(`[OK] Configuration '${key}' updated for package '${projConfig.id}'`, context);
         }, 
         // 按实际查询范围打开存储：显式包寻址结果作为本地根目录传递
-        { localRoot: scope.root });
+        { localRoot: root || undefined });
     });
 }

package/dist/commands/describe.js

@@ -1,8 +1,8 @@
 import { ACTION_NOT_FOUND, PACKAGE_NOT_FOUND, NOT_FOUND, } from "@actiondock/core";
 import { buildActionDescribePayload, } from "@actiondock/core/project";
-import { ArgumentError, ExecutionError } from "../errors.js";
+import { ArgumentError, ExecutionError, packageNotFoundError } from "../errors.js";
 import { formatActionDetail, renderResult } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveCommandTarget, withService, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, resolveLocalPackageRoot, withService, } from "../utils/index.js";
 /**
  * 挂载 describe 子命令至指定 Commander 节点。
  *
@@ -22,9 +22,12 @@ export function attachDescribeCommand(parent, context) {
         if (!id) {
             throw new ArgumentError("Action ID is required for describe");
         }
-        // 目标拓扑与动作引用解析（远端目标完全隔离本地文件系统）
-        const target = resolveCommandTarget(options, context);
-        const targetRef = target.resolveActionRef(id);
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw packageNotFoundError(options.package);
+        }
+        const targetRef = id;
         // 通过 Service 门面统一查询 Action 规范
         await withService(options, context, async (service) => {
             let spec;
@@ -47,7 +50,7 @@ export function attachDescribeCommand(parent, context) {
                 humanFormatter: () => formatActionDetail(payload),
                 context,
             });
-        }, { localRoot: target.targetPackageRoot, scanLinkedPackages: !target.localSkill });
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true });
     });
 }
 /**

package/dist/commands/list.js

@@ -1,6 +1,7 @@
 import { filterWithFallbackInfo, } from "@actiondock/core/project";
+import { packageNotFoundError } from "../errors.js";
 import { renderActionList, renderResult } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, remoteTargetSuffix, resolveCommandTarget, resolveFallbackStrategy, resolveIntent, withService, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, remoteTargetSuffix, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, withService, } from "../utils/index.js";
 /**
  * 挂载 list 子命令至指定 Commander 节点。
  *
@@ -22,20 +23,22 @@ export function attachListCommand(parent, context) {
         const options = getEffectiveOptions(rawOptions, cmd);
         const effectiveIntent = resolveIntent(options.intent, patterns);
         const { isMachine, shouldFallback } = resolveFallbackStrategy(options);
-        // 目标拓扑与动作引用解析（远端目标完全隔离本地文件系统）
-        const target = resolveCommandTarget(options, context);
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw packageNotFoundError(options.package);
+        }
         // 通过 Service 门面统一获取 Action 列表
         await withService(options, context, async (service, resolved) => {
             let rawSummaries = await service.discovery.listActions();
-            // 若指定了包 ID（非本地技能目录），则按包归属精确过滤（本地与远端统一生效）：
+            // 若指定了目标包但本地未过滤，则按包归属精确过滤：
             // 仅保留全限定名命中目标包前缀、或 packageId 归属目标包的条目；
             // 无法归属到目标包的无前缀短 id 条目不放行，避免他包短 id 混入
-            if (options.package && !target.localSkill) {
+            if (options.package && !options.profile && !options.server) {
                 const targetPkg = options.package;
                 rawSummaries = rawSummaries.filter((s) => {
-                    const pkgId = s.packageId;
-                    if (pkgId) {
-                        return (pkgId === targetPkg ||
+                    if (s.packageId) {
+                        return (s.packageId === targetPkg ||
                             s.id === targetPkg ||
                             s.id.startsWith(`${targetPkg}/`));
                     }
@@ -43,17 +46,14 @@ export function attachListCommand(parent, context) {
                     return s.id === targetPkg || s.id.startsWith(`${targetPkg}/`);
                 });
             }
-            const isCompositeSkill = target.localSkill?.type === "composite";
             const rawList = rawSummaries.map((s) => {
                 let id = s.id;
-                // 复合技能保持完全限定 ID，不剥离包名前缀
-                if (!isCompositeSkill && (target.targetPackageRoot || options.package)) {
-                    const targetPkg = target.localSkill ? target.localSkill.packages[0].packageId : options.package;
-                    const pkgId = targetPkg || s.packageId;
+                if (targetPackageRoot || options.package) {
+                    const pkgId = s.packageId || options.package;
                     if (pkgId && id.startsWith(`${pkgId}/`)) {
                         id = id.slice(pkgId.length + 1);
                     }
-                    else if (target.targetPackageRoot && id.includes("/")) {
+                    else if (targetPackageRoot && id.includes("/")) {
                         id = id.slice(id.indexOf("/") + 1);
                     }
                 }
@@ -80,7 +80,7 @@ export function attachListCommand(parent, context) {
             }
             const title = resolved.type === "remote"
                 ? `Actions ${remoteTargetSuffix(resolved)}`
-                : target.targetPackageRoot
+                : targetPackageRoot
                     ? `Actions in ${options.package || "current project"}`
                     : "Available Actions";
             renderResult(filterRes.items, {
@@ -88,7 +88,7 @@ export function attachListCommand(parent, context) {
                 humanFormatter: () => renderActionList(filterRes.items, title, filterRes.isFallback, effectiveIntent),
                 context,
             });
-        }, { localRoot: target.targetPackageRoot, scanLinkedPackages: !target.localSkill });
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true });
     });
 }
 /**

package/dist/commands/run.js

@@ -1,8 +1,9 @@
 import { validateActionInputValue, mapInputValidationFailure, } from "@actiondock/core/project";
+import { resolveTarget, } from "@actiondock/core/profile";
 import { ACTION_NOT_FOUND, NOT_FOUND, resolveExecutionHint, } from "@actiondock/core";
-import { ArgumentError, ExecutionError, SigintError } from "../errors.js";
+import { ArgumentError, ExecutionError, SigintError, packageNotFoundError } from "../errors.js";
 import { extractTextFieldPayload, resolveActionDefaultTextField, writeStderr, writeStdout, } from "../renderer.js";
-import { applyTargetOptions, getEffectiveOptions, resolveActionInput, resolveCommandTarget, resolveTimeoutMs, withService, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, resolveActionInput, resolveLocalPackageRoot, resolveTimeoutMs, withService, } from "../utils/index.js";
 /**
  * 以原始纯文本形式渲染 Action 执行终态结果（默认纯文本模式）。
  *
@@ -110,13 +111,25 @@ export async function executeAction(id, options, context, flatArgs, control) {
         }
     }
     try {
-        // 目标拓扑与动作引用解析（远端目标完全隔离本地文件系统）
-        const target = resolveCommandTarget(options, context);
         // 异步执行仅支持远端目标，本地模式直接拒绝
-        if (!target.isRemote && options.async) {
+        const resolvedTopology = resolveTarget({
+            profile: options.profile,
+            server: options.server,
+            token: options.token,
+            insecure: options.insecure,
+        }, context?.customHome);
+        if (resolvedTopology.type === "local" && options.async) {
             throw new ExecutionError("Async execution requires a long-running ActionDock server.\nUse --profile, --server, or start 'ad serve'.");
         }
-        const targetRef = target.resolveActionRef(id);
+        // 目标拓扑解析（仅 local 分支需要包寻址）
+        const targetPackageRoot = resolveLocalPackageRoot(options.package);
+        if (options.package && !targetPackageRoot) {
+            throw packageNotFoundError(options.package);
+        }
+        let targetRef = id;
+        if (options.package && !id.includes("/")) {
+            targetRef = `${options.package}/${id}`;
+        }
         // 通过 Service 统一执行
         await withService(options, context, async (service) => {
             const isMachine = Boolean(options.json);
@@ -192,7 +205,7 @@ export async function executeAction(id, options, context, flatArgs, control) {
                     return;
                 }
             }
-        }, { localRoot: target.targetPackageRoot || undefined, scanLinkedPackages: !target.localSkill, ownDataDir: true });
+        }, { localRoot: targetPackageRoot || undefined, scanLinkedPackages: true, ownDataDir: true });
     }
     catch (err) {
         // sigint 取消源、中断链路特征错误码或 SigintError 本身，均统一归并为 SigintError

package/dist/commands/state.js

@@ -1,11 +1,11 @@
 import { decodeStateKey, } from "@actiondock/sdk";
-import { loadProjectConfig, inspectLocalPackageDirectory, } from "@actiondock/core";
+import { loadProjectConfig, } from "@actiondock/core";
 import { filterWithFallbackInfo, } from "@actiondock/core/project";
 import { listLinkedPackages, } from "@actiondock/core/registry";
 import { existsSync } from "node:fs";
 import { ArgumentError, ExecutionError, NO_PROJECT_NO_LINKED_MESSAGE } from "../errors.js";
 import { renderResult, renderStateList, writeStderr, writeStdout } from "../renderer.js";
-import { applyTargetOptions, assertNotCompositeSkill, getEffectiveOptions, getTargetRoot, remoteTargetLabel, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../utils/index.js";
+import { applyTargetOptions, getEffectiveOptions, getTargetRoot, remoteTargetLabel, requirePackageRoot, resolveFallbackStrategy, resolveIntent, resolveLocalPackageRoot, resolveTargetFromOptions, withService, } from "../utils/index.js";
 /**
  * 统一预解码状态键寻址（get、set、delete 共享的单一事实源）。
  *
@@ -57,22 +57,6 @@ function resolveStateScope(resolved, options, rawKey) {
             localRoot: undefined,
         };
     }
-    assertNotCompositeSkill(options.package);
-    // 本地单包技能目录优先处理
-    if (options.package) {
-        const localSkill = inspectLocalPackageDirectory(options.package);
-        if (localSkill?.type === "single") {
-            const pkg = localSkill.packages[0];
-            return {
-                packageId: pkg.packageId,
-                scopeSuffix: `in package '${pkg.packageId}'`,
-                deleteSuffix: `from package '${pkg.packageId}'`,
-                effectiveKey: rawKey || "",
-                projConfig: pkg.projectConfig,
-                localRoot: pkg.packageRoot,
-            };
-        }
-    }
     // 本地项目模式：getTargetRoot 会从键中剥离 pkg/ 前缀，寻址基于解耦后的裸键
     const { root, key: effectiveKey } = getTargetRoot(options.package, rawKey);
     const projConfig = loadProjectConfig(root);
@@ -191,7 +175,6 @@ export function registerStateCommands(program, context) {
                 return;
             }
             // 本地工程与链接包模式：按目标根目录决策输出范围
-            assertNotCompositeSkill(options.package);
             const targetRoot = options.package
                 ? requirePackageRoot(options.package).root
                 : resolveLocalPackageRoot();

package/dist/utils/target.d.ts

@@ -1,4 +1,4 @@
-import { loadProjectConfig, type ActionDockService, type LocalSkillDirectory } from "@actiondock/core";
+import { type ActionDockService } from "@actiondock/core";
 import { type ResolvedTarget } from "@actiondock/core/profile";
 import type { Command } from "commander";
 import type { CliContext } from "../types.js";
@@ -33,68 +33,14 @@ export interface TargetResolutionOptions {
 /**
  * 目标拓扑解析单一入口：从命令选项视图解析远端/本地目标拓扑信息。
  *
- * 显式路径与包标识符分类规则：
- * - 显式路径形态（以 .、/、~ 开头或包含非 scoped 分隔符）：
- *   严格作为本地技能或包目录解析；禁止与显式远端选项（--server 或非 local 的 --profile）组合，违规抛出 ArgumentError；
- *   不受隐式 Profile 或 ACTIONDOCK_SERVER_URL 环境变量改变目标，本地执行优先；
- *   若本地目录不存在或不合法，抛出 packageNotFoundError；
- * - 纯词法包标识符（如 pkg.a、@scope/pkg）：
- *   若存在远端目标（显式 --server、非 local profile 或默认远端环境），严格作为远端包标识解析，绝不因本地 cwd 存在同名目录而劫持为本地执行；
- *   若无远端目标，正常按本地目标解析。
+ * 收拢全部解析字段（profile/server/token/insecure/allowInsecureHttp），
+ * 消除命令间逐字段内联复制导致的漂移（如漏传 allowInsecureHttp）。
  *
  * @param options 命令选项视图（支持直接传入 Commander 解析后的 options 对象）
  * @param context CLI 上下文
  * @returns 解析后的目标拓扑信息（仅信息解析，不创建 Service 实例）
  */
 export declare function resolveTargetFromOptions(options: TargetResolutionOptions, context?: CliContext): ResolvedTarget;
-/**
- * 命令目标与动作引用解析结果。
- */
-export interface CommandTargetResolution {
-    /** 目标拓扑信息 */
-    resolved: ResolvedTarget;
-    /** 是否为远端目标 */
-    isRemote: boolean;
-    /** 本地封闭技能目录视图（非本地技能目录时为 null） */
-    localSkill: LocalSkillDirectory | null;
-    /** 本地包根目录路径（远端分支为 undefined，未找到为 undefined） */
-    targetPackageRoot?: string;
-    /** 统一计算目标 Action 引用的辅助函数 */
-    resolveActionRef: (actionId: string) => string;
-}
-/**
- * 统一解析 CLI 命令的目标拓扑与包作用域（run, describe, list 等命令的单一事实源）。
- *
- * 保证：
- * - 优先判定目标拓扑；
- * - 远端目标（remote）完全隔离：不执行任何本地目录探测、清单加载或包根寻址；
- * - 远端目标动作引用保持原始词法包 ID 拼接（${options.package}/${actionId}），绝不被本地同名目录或清单 ID 篡改；
- * - 本地目标按本地封闭技能目录或工程包严格解析，不存在时透明抛出 packageNotFoundError。
- */
-export declare function resolveCommandTarget(options: TargetResolutionOptions, context?: CliContext): CommandTargetResolution;
-/**
- * 配置与状态管理目标作用域。
- */
-export interface TargetPackageScope {
-    /** 解析后的目标拓扑 */
-    resolved: ResolvedTarget;
-    /** 是否为远端目标 */
-    isRemote: boolean;
-    /** 目标包标识（远端为 options.package 原值，本地为工程配置 id 或 "global"） */
-    packageId: string;
-    /** 本地工程根目录（远端分支为 undefined） */
-    root?: string;
-    /** 本地工程配置（远端分支为 undefined） */
-    projConfig?: ReturnType<typeof loadProjectConfig>;
-}
-/**
- * 校验并拒绝复合技能目录用于配置或状态管理命令（单一事实源）。
- */
-export declare function assertNotCompositeSkill(packageOption?: string): void;
-/**
- * 统一解析配置与状态命令的目标作用域（支持单包技能目录、本地工程、远端服务与 --profile local）。
- */
-export declare function resolveTargetPackageScope(options: TargetResolutionOptions, context?: CliContext): TargetPackageScope;
 /**
  * 高阶服务执行辅助：统一封装「目标解析 → Service 创建 → 业务回调 → try/finally close」样板。
  *

package/dist/utils/target.js

@@ -1,7 +1,7 @@
-import { connectActionDock, createActionDock, createNodePlatform, findProjectRoot, inspectLocalPackageDirectory, isExplicitPath, loadProjectConfig, } from "@actiondock/core";
+import { connectActionDock, createActionDock, createNodePlatform, findProjectRoot, } from "@actiondock/core";
 import { resolvePackageRoot, } from "@actiondock/core/registry";
 import { resolveTarget, } from "@actiondock/core/profile";
-import { ArgumentError, packageNotFoundError } from "../errors.js";
+import { ArgumentError } from "../errors.js";
 /**
  * 统一为 Commander 命令节点挂载目标环境解析相关选项（单一事实源）。
  * 包括：-p/--profile, -s/--server, -t/--token, -k/--insecure, --allow-insecure-http。
@@ -20,36 +20,14 @@ export function applyTargetOptions(command) {
 /**
  * 目标拓扑解析单一入口：从命令选项视图解析远端/本地目标拓扑信息。
  *
- * 显式路径与包标识符分类规则：
- * - 显式路径形态（以 .、/、~ 开头或包含非 scoped 分隔符）：
- *   严格作为本地技能或包目录解析；禁止与显式远端选项（--server 或非 local 的 --profile）组合，违规抛出 ArgumentError；
- *   不受隐式 Profile 或 ACTIONDOCK_SERVER_URL 环境变量改变目标，本地执行优先；
- *   若本地目录不存在或不合法，抛出 packageNotFoundError；
- * - 纯词法包标识符（如 pkg.a、@scope/pkg）：
- *   若存在远端目标（显式 --server、非 local profile 或默认远端环境），严格作为远端包标识解析，绝不因本地 cwd 存在同名目录而劫持为本地执行；
- *   若无远端目标，正常按本地目标解析。
+ * 收拢全部解析字段（profile/server/token/insecure/allowInsecureHttp），
+ * 消除命令间逐字段内联复制导致的漂移（如漏传 allowInsecureHttp）。
  *
  * @param options 命令选项视图（支持直接传入 Commander 解析后的 options 对象）
  * @param context CLI 上下文
  * @returns 解析后的目标拓扑信息（仅信息解析，不创建 Service 实例）
  */
 export function resolveTargetFromOptions(options, context) {
-    const isExplicit = options.package ? isExplicitPath(options.package) : false;
-    if (isExplicit) {
-        const hasExplicitServer = Boolean(options.server && options.server.trim());
-        const hasExplicitProfile = Boolean(options.profile && options.profile.trim() && options.profile.trim() !== "local");
-        if (hasExplicitServer || hasExplicitProfile) {
-            throw new ArgumentError("Cannot combine local package/skill directory with remote target options (--server or --profile). Specify a package ID for remote targets, or remove remote target options for local directory execution.");
-        }
-        const localSkill = inspectLocalPackageDirectory(options.package);
-        if (!localSkill) {
-            throw packageNotFoundError(options.package);
-        }
-        return {
-            type: "local",
-            profileName: "local",
-        };
-    }
     return resolveTarget({
         profile: options.profile,
         server: options.server,
@@ -58,143 +36,6 @@ export function resolveTargetFromOptions(options, context) {
         allowInsecureHttp: options.allowInsecureHttp,
     }, context?.customHome);
 }
-/**
- * 统一解析 CLI 命令的目标拓扑与包作用域（run, describe, list 等命令的单一事实源）。
- *
- * 保证：
- * - 优先判定目标拓扑；
- * - 远端目标（remote）完全隔离：不执行任何本地目录探测、清单加载或包根寻址；
- * - 远端目标动作引用保持原始词法包 ID 拼接（${options.package}/${actionId}），绝不被本地同名目录或清单 ID 篡改；
- * - 本地目标按本地封闭技能目录或工程包严格解析，不存在时透明抛出 packageNotFoundError。
- */
-export function resolveCommandTarget(options, context) {
-    const resolved = resolveTargetFromOptions(options, context);
-    if (resolved.type === "remote") {
-        return {
-            resolved,
-            isRemote: true,
-            localSkill: null,
-            targetPackageRoot: undefined,
-            resolveActionRef: (actionId) => {
-                if (options.package && !actionId.includes("/")) {
-                    return `${options.package}/${actionId}`;
-                }
-                return actionId;
-            },
-        };
-    }
-    // 本地分支
-    const localSkill = options.package ? inspectLocalPackageDirectory(options.package) : null;
-    const targetPackageRoot = localSkill
-        ? localSkill.root
-        : options.package
-            ? resolveLocalPackageRoot(options.package)
-            : findProjectRoot();
-    if (options.package && !targetPackageRoot) {
-        throw packageNotFoundError(options.package);
-    }
-    return {
-        resolved,
-        isRemote: false,
-        localSkill,
-        targetPackageRoot: targetPackageRoot || undefined,
-        resolveActionRef: (actionId) => {
-            if (!options.package)
-                return actionId;
-            if (localSkill) {
-                if (localSkill.type === "single" && !actionId.includes("/")) {
-                    return `${localSkill.packages[0].packageId}/${actionId}`;
-                }
-                // 复合技能短名不拼目录名，保持 actionId 供 Host resolveAction 裁决唯一匹配或多包歧义
-                return actionId;
-            }
-            if (!actionId.includes("/")) {
-                return `${options.package}/${actionId}`;
-            }
-            return actionId;
-        },
-    };
-}
-/**
- * 校验并拒绝复合技能目录用于配置或状态管理命令（单一事实源）。
- */
-export function assertNotCompositeSkill(packageOption) {
-    if (!packageOption)
-        return;
-    const localSkill = inspectLocalPackageDirectory(packageOption);
-    if (localSkill?.type === "composite") {
-        throw new ArgumentError("Multi-package entries do not support config/state management; configure actions using --config and --data-dir.");
-    }
-}
-/**
- * 统一解析配置与状态命令的目标作用域（支持单包技能目录、本地工程、远端服务与 --profile local）。
- */
-export function resolveTargetPackageScope(options, context) {
-    // 1. 目标拓扑解析
-    const resolved = resolveTargetFromOptions(options, context);
-    // 2. 远端分支：直接消费 options.package，不触碰本地文件系统
-    if (resolved.type === "remote") {
-        return {
-            resolved,
-            isRemote: true,
-            packageId: options.package || "",
-            root: undefined,
-            projConfig: undefined,
-        };
-    }
-    // 3. 复合技能目录守卫（单一事实源）仅在本地分支生效
-    assertNotCompositeSkill(options.package);
-    // 4. 本地分支：统一解析单包目录、工程包或全局作用域
-    if (options.package) {
-        const localSkill = inspectLocalPackageDirectory(options.package);
-        if (localSkill?.type === "single") {
-            const pkg = localSkill.packages[0];
-            return {
-                resolved,
-                isRemote: false,
-                packageId: pkg.packageId,
-                root: pkg.packageRoot,
-                projConfig: pkg.projectConfig,
-            };
-        }
-        const root = resolveLocalPackageRoot(options.package);
-        if (!root) {
-            throw packageNotFoundError(options.package);
-        }
-        const projConfig = loadProjectConfig(root);
-        return {
-            resolved,
-            isRemote: false,
-            packageId: projConfig.id,
-            root,
-            projConfig,
-        };
-    }
-    // 未指定 -P：当前目录工程探测
-    const root = findProjectRoot();
-    if (root) {
-        try {
-            const projConfig = loadProjectConfig(root);
-            return {
-                resolved,
-                isRemote: false,
-                packageId: projConfig.id,
-                root,
-                projConfig,
-            };
-        }
-        catch {
-            // 当前目录配置损坏时仍允许全局操作
-        }
-    }
-    return {
-        resolved,
-        isRemote: false,
-        packageId: "global",
-        root: undefined,
-        projConfig: undefined,
-    };
-}
 /**
  * 高阶服务执行辅助：统一封装「目标解析 → Service 创建 → 业务回调 → try/finally close」样板。
  *
@@ -215,13 +56,10 @@ export async function withService(options, context, fn, localOptions) {
     if (localOptions?.requireRemote && resolved.type === "local") {
         throw new ArgumentError("'ad runs cancel' is only supported for remote execution targets. Use --profile <name> or --server <url>.");
     }
-    const localSkill = resolved.type === "local" && options.package
-        ? inspectLocalPackageDirectory(options.package)
-        : null;
     // localRoot 仅在 local 分支求值，避免远端模式下触发包寻址副作用
-    const localRoot = resolved.type === "local" && !localSkill
+    const localRoot = resolved.type === "local"
         ? (typeof localOptions?.localRoot === "function" ? localOptions.localRoot() : localOptions?.localRoot) ??
-            (options.package ? resolveLocalPackageRoot(options.package) : findProjectRoot()) ??
+            findProjectRoot() ??
             undefined
         : undefined;
     const recoverOrphans = localOptions?.recoverOrphans ?? (localOptions?.ownDataDir === true);
@@ -232,38 +70,20 @@ export async function withService(options, context, fn, localOptions) {
             insecure: resolved.insecure,
             allowInsecureHttp: resolved.allowInsecureHttp ?? options.allowInsecureHttp,
         })
-        : localSkill
-            ? await createActionDock({
-                type: "local",
-                packages: localSkill.packages.map((pkg) => ({
-                    packageRoot: pkg.packageRoot,
-                    projectConfig: pkg.projectConfig,
-                    dataDir: options.dataDir || context?.dataDir,
-                })),
-                customHome: context?.customHome,
-                dataDir: options.dataDir || context?.dataDir,
-                platform: createNodePlatform({
-                    customHome: context?.customHome,
-                    dataDir: options.dataDir || context?.dataDir,
-                }),
-                autoLoadCurrentProject: false,
-                scanLinkedPackages: false,
-                recoverOrphans,
-            })
-            : await createActionDock({
-                type: "local",
-                projectRoot: localRoot,
+        : await createActionDock({
+            type: "local",
+            projectRoot: localRoot,
+            customHome: context?.customHome,
+            dataDir: options.dataDir || context?.dataDir,
+            platform: createNodePlatform({
                 customHome: context?.customHome,
                 dataDir: options.dataDir || context?.dataDir,
-                platform: createNodePlatform({
-                    customHome: context?.customHome,
-                    dataDir: options.dataDir || context?.dataDir,
-                }),
-                ...(localOptions?.scanLinkedPackages !== undefined
-                    ? { scanLinkedPackages: localOptions.scanLinkedPackages }
-                    : undefined),
-                recoverOrphans,
-            });
+            }),
+            ...(localOptions?.scanLinkedPackages !== undefined
+                ? { scanLinkedPackages: localOptions.scanLinkedPackages }
+                : undefined),
+            recoverOrphans,
+        });
     try {
         await fn(service, resolved);
     }
@@ -277,10 +97,6 @@ export async function withService(options, context, fn, localOptions) {
  */
 export function resolveLocalPackageRoot(pkgId) {
     if (pkgId) {
-        const localSkill = inspectLocalPackageDirectory(pkgId);
-        if (localSkill) {
-            return localSkill.root;
-        }
         return resolvePackageRoot(pkgId);
     }
     return findProjectRoot();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/cli",
-  "version": "2.14.0",
+  "version": "2.16.0",
   "description": "ActionDock CLI facade for developing, testing, building, and exporting standalone Agent Actions and Skills",
   "type": "module",
   "bin": {
@@ -34,10 +34,10 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/builder": "^2.14.0",
-    "@actiondock/core": "^2.14.0",
-    "@actiondock/mcp": "^2.14.0",
-    "@actiondock/sdk": "^2.14.0",
+    "@actiondock/builder": "^2.16.0",
+    "@actiondock/core": "^2.16.0",
+    "@actiondock/mcp": "^2.16.0",
+    "@actiondock/sdk": "^2.16.0",
     "commander": "^13.1.0",
     "selfsigned": "^5.5.0"
   },