@lark-apaas/miaoda-cli 0.1.30 → 0.1.31-alpha.1f31c36

package/README.md

@@ -55,7 +55,7 @@ miaoda file ls --output json
 
 `miaoda registry` 提供 shadcn 式的「组件 registry」：把 SDK 文件**拷进**当前项目（copy-in），而非作为依赖安装。registry 是独立 npm 包，按运行时分发（design-html / html → buildless runtime → `@lark-apaas/coding-registry-buildless`）。
 
-前置：当前目录（或 `--dir`）已走过 `miaoda app init`，且 `.spark/meta.json` 的 `stack` 有对应 registry 包（当前支持 `design-html` / `html`）；其余 stack 执行时报 `REGISTRY_STACK_UNSUPPORTED` 并提示支持列表。
+前置：当前工作目录已走过 `miaoda app init`，且 `.spark/meta.json` 的 `stack` 有对应 registry 包（当前支持 `design-html` / `html`）；其余 stack 执行时报 `REGISTRY_STACK_UNSUPPORTED` 并提示支持列表。meta 一律从 cwd 读取，不随 `--dir` 走。
 
 ```bash
 # 列出可用 SDK 条目（输出各文件 USAGE 注释块原文，便于 Agent 直接读用法）
@@ -76,7 +76,7 @@ miaoda registry add deck-slide --overwrite         # 目标已存在时覆盖（
 - **拍平落地**：所有文件**拍平**到项目根（`scripts/deck-slide.js` → 项目 `deck-slide.js`，不保留子目录）；闭包内同名 basename 撞车时后者覆盖前者。
 - **skip-by-disk**：项目已有同名（拍平后的 basename）文件默认跳过，`--overwrite` 才覆盖；不写任何安装记账文件，项目文件树即状态。
 - **add 回执带 usage**：`add` 结果的 `entries` 只列**你请求的条目**（不含被 `Depends` 传递拉进来的依赖——依赖照常落地在 `added`/`skipped`，但那是"管道"），逐条给出 `usage`（USAGE 块原文）与 `dependsOn`，Agent `add` 完即可直接读用法，无需再 `registry list`。请求的条目即使已存在被跳过也回带 usage（`status` 标 `added`/`skipped`，据此判断磁盘上是 registry 版还是你改过的旧版）。`--json` 结构为 `{registryVersion, added, skipped, dryRun, entries}`；pretty（默认）输出 `registry@<ver>` + `added:`/`skipped:` 逗号列表 + 各请求条目的 USAGE 块，稳定 label、无 JSON 数组、无截断，对 Agent 与人同样可读。
-- `--version <ver>` 指定 registry 包版本或 dist-tag（缺省 `latest`），`--dir <path>` 指定项目目录（缺省当前目录）。
+- `--version <ver>` 指定 registry 包版本或 dist-tag（缺省 `latest`）；`add` 的 `--dir <path>` 指定 copy-in 落地目录（缺省当前目录），不影响 `.spark/meta.json` 读取。
 
 ## 全局参数
 

package/dist/cli/commands/deploy/modern.js

@@ -72,7 +72,7 @@ JSON 输出（stdout）
     }));
     const patchCmd = deployCmd
         .command('patch')
-        .description('design-html 增量发布：按文件 create/update/delete，.html 增删时同步 routes.json')
+        .description('design-html 增量发布：按文件 create/update/delete，.html 变动时同步 routes.json')
         .option('--create <relpath>', '新增文件（可重复）', shared_1.collectRepeatedOption, [])
         .option('--update <relpath>', '覆盖已有文件（可重复）', shared_1.collectRepeatedOption, [])
         .option('--delete <relpath>', '删除文件（可重复）', shared_1.collectRepeatedOption, [])
@@ -80,10 +80,11 @@ JSON 输出（stdout）
         .addHelpText('after', `
 --dir 为项目目录（与 deploy 同名参数，默认当前目录）。
 仅支持 design-html（design_local_deploy）。路径为工程根相对路径（= 服务端 latest 下 key），
-禁绝对路径与 ".."。--create/--update 的本地文件必须存在。.html 被新增/删除（路由集合变化）
-时自动重算并随包更新 routes.json；纯 --update 现有 .html 只改内容，不动 routes.json。
-routes.json 每项为 {path, file}：path 为相对路径（不含 base 前缀，由消费侧拼接），file 为
-对应源文件（如 / → index.html）。
+禁绝对路径与 ".."。--create/--update 的本地文件必须存在。改动里含任意 .html（增 / 改 / 删）
+时自动重算并随包更新 routes.json；纯非 .html 改动不动 routes.json。
+routes.json 每项为 {path, file, name?}：path 为相对路径（不含 base 前缀，由消费侧拼接），
+file 为对应源文件（如 / → index.html），name 为该 HTML 的 <title> 文本（方案名，可缺省，
+缺省时由消费侧 fallback 到 path）。
 
 JSON 输出
   {"data": {"upsertCount": <n>, "deleteCount": <n>, "actionsSent": <n>, "routesRegenerated": <bool>}}

package/dist/cli/commands/registry/index.js

@@ -33,8 +33,9 @@ function registerRegistryCommands(program) {
   - add 落地：拍平到项目根（包根 scripts/x.js → 项目 x.js）；同名 basename 撞车时后者覆盖前者
 
 前置
-  当前目录（或 --dir）已走过 'miaoda app init'，且 .spark/meta.json 的 stack 有对应
+  当前工作目录已走过 'miaoda app init'，且 .spark/meta.json 的 stack 有对应
   registry 包（当前支持 design-html / html）；其余 stack 执行时报 REGISTRY_STACK_UNSUPPORTED
+  meta 一律从 cwd 读取，add 的 --dir 只影响 copy-in 落地目录
 `);
     registerRegistryList(registryCmd);
     registerRegistryAdd(registryCmd);
@@ -43,7 +44,6 @@ function registerRegistryList(parent) {
     const cmd = parent
         .command('list')
         .description('列出 registry 可用 SDK 条目，输出各文件的 USAGE 块原文')
-        .option('--dir <path>', '项目目录，默认当前目录', '.')
         .option('--version <ver>', 'registry 包版本或 dist-tag，缺省 latest')
         .addHelpText('after', `
 输出
@@ -59,7 +59,6 @@ JSON 输出
 `);
     cmd.action((0, shared_1.withHelp)(cmd, async (rawOpts) => {
         await (0, index_1.handleRegistryList)({
-            dir: rawOpts.dir,
             version: rawOpts.version,
         });
     }));
@@ -69,7 +68,7 @@ function registerRegistryAdd(parent) {
         .command('add')
         .description('把一个或多个 SDK 文件 copy-in 到当前项目（拍平到项目根，含 Depends 闭包）')
         .argument('<token...>', 'name / 完整文件名 / relPath，可传多个；同名多匹配全拉，Depends 自动传递解析')
-        .option('--dir <path>', '项目目录，默认当前目录', '.')
+        .option('--dir <path>', 'copy-in 落地目录，默认当前目录（stack 一律读 cwd 的 .spark/meta.json）', '.')
         .option('--version <ver>', 'registry 包版本或 dist-tag，缺省 latest')
         .option('--overwrite', '目标文件已存在时覆盖（默认跳过以保护用户改动）', false)
         .option('--dry-run', '只报告将写 / 将跳哪些文件，不落盘', false)
@@ -77,8 +76,9 @@ function registerRegistryAdd(parent) {
 行为
   - token 寻址：name（foo）/ 完整文件名（foo.css）/ relPath（stylesheets/foo.css）任一形式
   - 多匹配全拉：token 命中多个同名条目时全部 copy-in；想只要其一就写完整文件名 / relPath
-  - 解析 USAGE 块 Depends 传递闭包，把 SDK 文件**拍平**拷到项目根
-    （包根 scripts/deck-stage.js → 项目 deck-stage.js；同名 basename 撞车时后者覆盖前者）
+  - 解析 USAGE 块 Depends 传递闭包，把 SDK 文件**拍平**拷到落地目录（--dir，默认当前目录）
+    （包根 scripts/deck-stage.js → 落地 deck-stage.js；同名 basename 撞车时后者覆盖前者）
+  - stack 一律读当前工作目录的 .spark/meta.json，--dir 不影响 meta 读取
   - skip-by-disk：目标文件已存在默认跳过；--overwrite 才覆盖
   - 不写任何安装记账文件（项目文件树即状态）
 

package/dist/cli/commands/skills/index.js

@@ -21,11 +21,16 @@ function registerSkillsCommands(program) {
 function registerSkillsSync(parent) {
     const cmd = parent
         .command('sync')
-        .description('同步 coding-steering（latest 或指定版本）到 user app')
+        .description('同步 skills 到 user app（默认 coding-steering；带 --type 时走 sandbox-skills）')
         .option('--dir <path>', '项目目录，默认当前目录', '.')
         .option('--version <ver>', 'coding-steering 包版本或 dist-tag，缺省 latest')
         .option('--local', '走本地 dev / agent 输出形态：拷到 .agents/skills 平铺 + 创建 .claude/skills 软链。' +
         '不传时退回老形态：拷到 .agent/skills/steering/<stack>/skills/（跟沙箱端 update-skills.sh 对齐）', false)
+        .option('--type <type>', '走 sandbox 分支：miaoda | miaoda-modern | miaoda-design | openclaw。有值时忽略 --local，' +
+        '从 @lark-apaas/coding-<pkg>-sandbox-skills 拉包平铺写入，并额外同步 steering ' +
+        '到 .agent/skills/steering/<stack>/（--version 对后者仍生效）')
+        .option('--tgz-key <key>', '配合 --type 使用；老 TCC skillsUpdateTgzKey 值透传，' +
+        '从 skills_versions/all_<X>.tgz 反推出 lane 名 X，再过滤出 -alpha.<X> 版本；缺省走 @latest')
         .addHelpText('after', `
 前置要求
   当前目录（或 --dir）已走过 'miaoda app init'（.spark/meta.json 含 stack）
@@ -41,21 +46,36 @@ function registerSkillsSync(parent) {
     .agents/tech.md
     .claude/skills → ../.agents/skills（软链，让 Claude Code 识别同一份）
 
+  传 --type（沙箱链路，两部分都同步）：
+    .agent/skills/<skill>/...                        ← 业务线 skill，平铺
+    .agent/skills/steering/<stack>/skills/<skill>/   ← steering，同上面默认形态
+    （openclaw 的业务线部分落 skills/ 而非 .agent/skills/）
+
 JSON 输出
   {"data": {"stack": "...", "version": "...", "syncedSkills": [...], "techSynced": true|false,
             "claudeSkillsLink": "created|updated|noop|conflict"  // 仅 --local 时}}
 
+  传 --type 时：
+  {"data": {"mode": "sandbox", "type": "...", "packageName": "...", "version": "...",
+            "lane": "...", "syncedTop": [...], "targetDir": "...",
+            "steering": {"status": "synced|skipped|failed", ...}}}
+  steering 失败或无 stack 不影响整体成功——业务线 skill 已同步，不该因增量部分阻断
+
 示例
   $ miaoda skills sync                              # 拉 @latest
   $ miaoda skills sync --local                      # 本地 dev / agent 用
   $ miaoda skills sync --version 0.2.0              # 显式指定版本
   $ miaoda skills sync --dir ./my-app
+  # 沙箱链路（由 feida-ai 下发）：业务线 skill + steering 一次同步到位
+  $ miaoda skills sync --type miaoda-modern --tgz-key 'skills_versions/all_demo-lane.tgz'
 `);
     cmd.action((0, shared_1.withHelp)(cmd, async (rawOpts) => {
         await (0, index_1.handleSkillsSync)({
             dir: rawOpts.dir,
             version: rawOpts.version,
             local: rawOpts.local,
+            type: rawOpts.type,
+            tgzKey: rawOpts.tgzKey,
         });
     }));
 }

package/dist/cli/handlers/registry/add.js

@@ -13,7 +13,8 @@ const output_1 = require("../../../utils/output");
  * miaoda registry add <name...> [--overwrite] [--dry-run] [--dir <path>] [--version <ver>]
  *
  * 解析 USAGE 块 Depends 传递闭包，把每个条目对应的 SDK 文件从 registry 包根的 <relPath>
- * **保留相对路径**拷到项目根（--dir 指定目录的根）。
+ * **保留相对路径**拷到落地目录（--dir，默认 cwd）。stack 一律从 <cwd>/.spark/meta.json 读，
+ * 不随 --dir 走。
  * skip-by-disk：目标已存在默认跳过，--overwrite 才覆盖。不写任何安装记账文件。
  */
 async function handleRegistryAdd(opts) {
@@ -22,7 +23,7 @@ async function handleRegistryAdd(opts) {
         throw new error_1.AppError('ARGS_INVALID', 'registry add 至少需要一个条目名');
     }
     const targetDir = node_path_1.default.resolve(opts.dir ?? process.cwd());
-    const stack = (0, shared_1.resolveRegistryStack)(targetDir);
+    const stack = (0, shared_1.resolveRegistryStack)();
     const reg = (0, index_1.loadRegistry)({ stack, version: opts.version });
     try {
         const plan = (0, index_1.planAdd)({

package/dist/cli/handlers/registry/list.js

@@ -1,17 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleRegistryList = handleRegistryList;
-const node_path_1 = __importDefault(require("node:path"));
 const index_1 = require("../../../services/registry/index");
 const shared_1 = require("./shared");
 const output_1 = require("../../../utils/output");
 /**
- * miaoda registry list [--dir <path>] [--version <ver>]
+ * miaoda registry list [--version <ver>]
  *
- * 从 .spark/meta.json 读 stack → runtime → 包名，拉对应 registry 包，从包根递归扫含 USAGE 块的 SDK 文件。
+ * 从 <cwd>/.spark/meta.json 读 stack → runtime → 包名，拉对应 registry 包，从包根递归扫含 USAGE 块的 SDK 文件。
  *
  * - 默认（pretty）：输出各条目 USAGE 块原文，带文件名分隔，给 Agent 直接读注释。
  * - --json：输出 [{name, file, usage(原文字符串), dependsOn[]}]，usage 保持原文不解析成字段。
@@ -19,8 +15,7 @@ const output_1 = require("../../../utils/output");
  */
 async function handleRegistryList(opts) {
     await Promise.resolve();
-    const targetDir = node_path_1.default.resolve(opts.dir ?? process.cwd());
-    const stack = (0, shared_1.resolveRegistryStack)(targetDir);
+    const stack = (0, shared_1.resolveRegistryStack)();
     const reg = (0, index_1.loadRegistry)({ stack, version: opts.version });
     try {
         if ((0, output_1.isJsonMode)()) {

package/dist/cli/handlers/registry/shared.js

@@ -5,16 +5,20 @@ const spark_meta_1 = require("../../../utils/spark-meta");
 const index_1 = require("../../../services/registry/index");
 const error_1 = require("../../../utils/error");
 /**
- * 从 <targetDir>/.spark/meta.json 读 stack，校验该 stack 有组件 registry。
+ * 从 <cwd>/.spark/meta.json 读 stack，校验该 stack 有组件 registry。
+ * meta 只与当前工作目录相关（CLI 必须在 user app 根目录下运行），不随 --dir 走——
+ * --dir 只影响 add 的 copy-in 落地目录。
  * 缺 stack → 提示先 init；stack 无 registry（无对应 runtime / runtime 无 registry 包）→ 提示支持哪些 stack。
  *
  * 这里只做「stack 是否在支持列表」的早校验给用户友好提示；包名的两跳解析
  * （stack → runtime → 包）由 loadRegistry/resolveRegistryPackage 负责。
  */
-function resolveRegistryStack(targetDir) {
-    const meta = (0, spark_meta_1.readSparkMeta)(targetDir);
+function resolveRegistryStack() {
+    const meta = (0, spark_meta_1.readSparkMeta)(process.cwd());
     if (meta.stack === undefined || meta.stack === '') {
-        throw new error_1.AppError('REGISTRY_META_INCOMPLETE', '.spark/meta.json missing stack — run `miaoda app init` first');
+        throw new error_1.AppError('REGISTRY_META_INCOMPLETE', '.spark/meta.json missing stack — run `miaoda app init` first', {
+            next_actions: ['meta 一律读当前工作目录（不随 --dir），请 cd 到 user app 根目录后重试'],
+        });
     }
     if (!index_1.REGISTRY_SUPPORTED_STACKS.includes(meta.stack)) {
         throw new error_1.AppError('REGISTRY_STACK_UNSUPPORTED', `stack "${meta.stack}" 没有组件 registry`, {

package/dist/cli/handlers/skills/sync.js

@@ -6,9 +6,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleSkillsSync = handleSkillsSync;
 const node_path_1 = __importDefault(require("node:path"));
 const coding_steering_1 = require("../../../utils/coding-steering");
+const sandbox_skills_1 = require("../../../utils/sandbox-skills");
+const file_ops_1 = require("../../../utils/file-ops");
 const spark_meta_1 = require("../../../utils/spark-meta");
 const error_1 = require("../../../utils/error");
 const output_1 = require("../../../utils/output");
+/**
+ * sandbox 分支下补同步 steering（`.agent/skills/steering/<stack>/`）。
+ *
+ * **绝不抛错**，因为它在 sandbox 链路里是「附加项」而非门禁：
+ *   - 无 `.spark/meta.json` / 无 stack → skipped。对齐老 cp-skills.sh 的
+ *     `[ -n "$STACK" ] && [ "$STACK" != "null" ]` 判断（无 stack 就跳过 steering）。
+ *   - 拉包 / 写盘失败 → failed，但仍让整条 sync 算成功。
+ *
+ * 为什么不能抛：feida-ai 侧 TCC 可配 `allowFailure: false`，一抛就阻断 agent 启动。
+ * 平铺业务线 skill 已经同步好了，不该因为 steering 这个增量部分让用户开不了会话。
+ */
+function syncSteeringForSandbox(params) {
+    let stack;
+    try {
+        const meta = (0, spark_meta_1.readSparkMeta)(params.targetDir);
+        if (meta.stack === undefined || meta.stack === '' || meta.stack === 'null') {
+            return { status: 'skipped', reason: '.spark/meta.json missing stack' };
+        }
+        stack = meta.stack;
+    }
+    catch (err) {
+        return { status: 'skipped', reason: `read .spark/meta.json failed: ${err.message}` };
+    }
+    // 版本口径与下方本地分支保持一致：--version > BOE 的 dist-tag dev > latest
+    const isBoe = process.env.FORCE_FRAMEWORK_ENVIRONMENT === 'boe';
+    const effectiveVersion = params.version ?? (isBoe ? 'dev' : undefined);
+    try {
+        const r = (0, coding_steering_1.syncCodingSteering)({
+            stack,
+            targetDir: params.targetDir,
+            version: effectiveVersion,
+            // 必须显式传 mode，不能落到 inferMode()：它靠 env MIAODA_DEP_CACHE_DIR 嗅探，
+            // 而 mode 决定读包内哪个 layer（sandbox→`skills/`，local→`skills_local/`）。
+            // `--type` 分支本身就是沙箱语义，嗅探失手会去读不存在的 skills_local/、
+            // 静默同步 0 个 skill。
+            mode: 'sandbox',
+            // 同理固定 nested：落 .agent/skills/steering/<stack>/，与老链路一致
+            outputLayout: 'nested',
+        });
+        return {
+            status: 'synced',
+            stack,
+            version: r.version,
+            syncedSkills: r.syncedSkills,
+            techSynced: r.techSynced,
+        };
+    }
+    catch (err) {
+        return { status: 'failed', reason: err.message };
+    }
+}
 /**
  * miaoda skills sync [--dir <path>] [--version <ver>]
  *
@@ -26,6 +79,57 @@ const output_1 = require("../../../utils/output");
 async function handleSkillsSync(opts) {
     await Promise.resolve();
     const targetDir = node_path_1.default.resolve(opts.dir ?? process.cwd());
+    // --type 走 sandbox-skills 分支（迁仓后沙箱内由 feida-ai 直接下发调用）。
+    //
+    // 这条分支必须**同时**同步两部分，缺一不可 —— 线上老链路 update-skills.sh 也是两步
+    // （自己 rsync 平铺，再于第 230 行调不带 --type 的 `miaoda skills sync` 写 steering）：
+    //   ① syncSandboxSkills：平铺业务线 skill，rsync 式对齐（保 .keep/.config/steering）
+    //   ② steering：`.agent/skills/steering/<stack>/`，按 .spark/meta.json 的 stack 过滤
+    //   ③ lockDirReadonly：锁只读收尾（update-skills.sh:241），仅沙箱侧路径
+    //
+    // 历史 bug：早期这里 ① 完就 return，steering 既不同步、又被当时的整目录清空删掉，
+    // 沙箱少掉整批技术栈 skill（BOE 实测 scanAllSkills 从 59 掉到 34）。
+    //
+    // `.keep` 语义（update-skills.sh:149）：目标目录挂了 .keep 表示「我手改过，别覆盖」，
+    // ① 会跳过并回报 skippedByKeepFile，此时 ② 也必须跳过 —— 否则 steering 仍被覆写，
+    // 冻结只冻结了一半。
+    if (opts.type !== undefined && opts.type !== '') {
+        const { type, tgzKey } = (0, sandbox_skills_1.validateSandboxSyncOpts)({ type: opts.type, tgzKey: opts.tgzKey });
+        const result = (0, sandbox_skills_1.syncSandboxSkills)({ type, tgzKey, targetDir });
+        const steering = result.skippedByKeepFile
+            ? { status: 'skipped', reason: '.keep file found, sync frozen' }
+            : syncSteeringForSandbox({ targetDir, version: opts.version });
+        // ③ 收尾锁只读（update-skills.sh:241 的 chmod -R a=rX）。必须在 ①② 全部写完之后，
+        //    锁上就写不进去了。`.keep` 冻结时不锁 —— 老链路那条路径是 exit 0 直接走、
+        //    末尾的 chmod 压根不执行，保持一致。
+        //
+        // **只锁沙箱侧**：这里的 result.targetDir 只会是 `.agent/skills` 或 `skills`
+        //   （见 sandbox-skills 的 skillsRoot），都是平台下发的资产根。本地 `--local` 走
+        //   flat layout 输出到 `.agents/`，压根不经过本分支，权限不会被碰。
+        //
+        // 回退风险由解锁侧兜：权限是持久化在磁盘的，代码能回退、磁盘状态不会。所以
+        //   file-ops 的 unlockDirForWrite 在**两处写入前**都调用了（syncSandboxSkills 的
+        //   写入前 + syncCodingSteering 的 nested 分支写入前），任一入口都不会因为
+        //   上一轮的锁而 EACCES。改动这里之前先确认那两处解锁还在。
+        const lockedReadonly = result.skippedByKeepFile ? false : (0, file_ops_1.lockDirReadonly)(result.targetDir);
+        (0, output_1.emit)({
+            data: {
+                mode: 'sandbox',
+                type,
+                packageName: result.packageName,
+                version: result.version,
+                lane: result.lane,
+                syncedTop: result.syncedTop,
+                deleted: result.deleted,
+                skippedByKeepFile: result.skippedByKeepFile,
+                lockedReadonly,
+                targetDir: result.targetDir,
+                steering,
+            },
+        });
+        return;
+    }
+    // 原有 coding-steering 同步逻辑（本地 dev / miaoda app init 用）
     const meta = (0, spark_meta_1.readSparkMeta)(targetDir);
     if (meta.stack === undefined || meta.stack === '') {
         throw new error_1.AppError('SKILLS_META_INCOMPLETE', '.spark/meta.json missing stack — run `miaoda app init` first');

package/dist/services/deploy/modern/patch/actions.js

@@ -36,8 +36,10 @@ function isHtml(rel) {
 /**
  * 把 changeset 组成 TosFileAction[]：
  *   - create/update 读本地文件、自动编码；delete 仅 FilePath。
- *   - .html 被 create / delete（路由集合变化）时，追加重算 routes.json 的 UPDATE action；
- *     纯 update 现有 .html 只改内容、不改路由集合，不重算 routes.json。
+ *   - 任一 .html 被 create / update / delete 时，追加重算 routes.json 的 UPDATE action。
+ *     update 也算：routes.json 的 name 取自 HTML 的 `<title>`，改方案名就是一次纯 update，
+ *     只按 create/delete 判定会让改名永远进不了 routes.json。
+ *   - 纯非 .html 改动（js / css / 图片）不动 routes.json。
  */
 function buildTosActions(projectDir, cs) {
     const actions = [];
@@ -48,8 +50,8 @@ function buildTosActions(projectDir, cs) {
     for (const rel of cs.deletes) {
         actions.push({ actionType: index_1.TosActionType.DELETE, filePath: normalizeRel(rel) });
     }
-    const routeSetChanged = [...cs.creates, ...cs.deletes].some(isHtml);
-    if (routeSetChanged) {
+    const routesMayChange = [...cs.creates, ...cs.updates, ...cs.deletes].some(isHtml);
+    if (routesMayChange) {
         actions.push({
             actionType: index_1.TosActionType.UPDATE,
             filePath: 'routes.json',

package/dist/services/deploy/modern/patch/html-title.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTitle = extractTitle;
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * 读 `<title>` 时的扫描窗口上限（字节）。title 规范上在 `<head>` 里、正常紧贴文档开头，
+ * 64KB 足以覆盖 head 里塞了内联 style / script 的情况，同时给大 HTML 兜住 IO 上限
+ * （generateRoutes 会遍历工程内所有 .html，不能整文件读）。
+ */
+const HEAD_SCAN_BYTES = 64 * 1024;
+const TITLE_RE = /<title[^>]*>([^<]*)<\/title>/i;
+const HEAD_CLOSE_RE = /<\/head\s*>/i;
+const COMMENT_RE = /<!--[\s\S]*?-->/g;
+const ENTITY_RE = /&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi;
+/** HTML 里可能出现在 title 文本中的命名实体。未列出的原样保留，不做全量实体表。 */
+const NAMED_ENTITIES = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+};
+/** 把 title 文本里的实体还原成明文——name 是给前端直接当文本渲染的，不该带 `&amp;`。 */
+function decodeEntities(s) {
+    return s.replace(ENTITY_RE, (matched, body) => {
+        if (!body.startsWith('#')) {
+            return NAMED_ENTITIES[body.toLowerCase()] ?? matched;
+        }
+        const code = /^#x/i.test(body) ? parseInt(body.slice(2), 16) : parseInt(body.slice(1), 10);
+        if (!Number.isInteger(code) || code <= 0 || code > 0x10ffff)
+            return matched;
+        return String.fromCodePoint(code);
+    });
+}
+/** 只读文件头部 HEAD_SCAN_BYTES 字节。尾部可能截断多字节字符，对 title 提取无影响。 */
+function readHead(absPath) {
+    const fd = node_fs_1.default.openSync(absPath, 'r');
+    try {
+        const buf = Buffer.alloc(HEAD_SCAN_BYTES);
+        const bytes = node_fs_1.default.readSync(fd, buf, 0, HEAD_SCAN_BYTES, 0);
+        return buf.subarray(0, bytes).toString('utf-8');
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+    }
+}
+/**
+ * 取 HTML 的 `<title>` 文本作为该页面的方案名。
+ *
+ * - 扫描范围截到第一个 `</head>`：body 里的 `<title>` 不算——内联 SVG 图标的 a11y
+ *   `<title>` 很常见，抓到就会把图标描述当成方案名。找不到 `</head>` 时退回整个窗口。
+ * - 先剔 HTML 注释，避免抓到被注释掉的 title。
+ * - 实体还原 + 空白折叠 + trim；空 title / 无 title / 读失败一律返回 undefined，
+ *   由消费侧 fallback 到 path（旧应用没有 title 时保持显示页面地址）。
+ */
+function extractTitle(absPath) {
+    let head;
+    try {
+        head = readHead(absPath);
+    }
+    catch {
+        return undefined;
+    }
+    const headClose = HEAD_CLOSE_RE.exec(head)?.index ?? -1;
+    const scope = (headClose >= 0 ? head.slice(0, headClose) : head).replace(COMMENT_RE, '');
+    const raw = TITLE_RE.exec(scope)?.[1];
+    if (raw === undefined)
+        return undefined;
+    const text = decodeEntities(raw).replace(/\s+/g, ' ').trim();
+    return text === '' ? undefined : text;
+}

package/dist/services/deploy/modern/patch/index.js

@@ -11,7 +11,7 @@ const actions_1 = require("./actions");
 var actions_2 = require("./actions");
 Object.defineProperty(exports, "buildTosActions", { enumerable: true, get: function () { return actions_2.buildTosActions; } });
 /**
- * design-html 增量发布：读本地文件组 TosFileAction（create/delete .html 时带重算的
+ * design-html 增量发布：读本地文件组 TosFileAction（改动含 .html 时带重算的
  * routes.json），调后端 applyTosDiff 应用到 latest。scope 限 design_local_deploy。
  */
 async function patchDesignDeploy(opts) {

package/dist/services/deploy/modern/patch/routes.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRoutes = generateRoutes;
+const node_path_1 = __importDefault(require("node:path"));
+const html_title_1 = require("./html-title");
 const source_scan_1 = require("./source-scan");
 /**
  * .html → route path 推导（相对路径，不带 base 前缀）。rel 为 posix 相对路径。
@@ -16,8 +21,9 @@ function toRoute(rel) {
 }
 /**
  * 扫描 projectDir 下所有 .html（套 source-scan 的 EXCLUDES），生成 routes.json 文本（含尾换行）。
- * 每项为 { path, file }：path 为相对路径（不带 CLIENT_BASE_PATH 前缀，由消费侧拼接），
- * file 为该路由对应的原始 .html 源文件。按 path 排序、同 path 取字典序靠前的 file 去重。
+ * 每项为 { path, file, name? }：path 为相对路径（不带 CLIENT_BASE_PATH 前缀，由消费侧拼接），
+ * file 为该路由对应的原始 .html 源文件，name 为该文件 `<title>` 解析出的方案名（可缺省）。
+ * 按 path 排序、同 path 取字典序靠前的 file 去重。
  * 零 html 时输出空数组——不伪造解析不到文件的根路由。
  */
 function generateRoutes(projectDir) {
@@ -27,7 +33,11 @@ function generateRoutes(projectDir) {
         if (!byPath.has(entry.path))
             byPath.set(entry.path, entry);
     }
-    const routes = [...byPath.values()];
+    // title 只读去重后胜出的 file：同 path 多源（foo.html / foo/index.html）时不做无用 IO。
+    const routes = [...byPath.values()].map((entry) => {
+        const name = (0, html_title_1.extractTitle)(node_path_1.default.join(projectDir, entry.file));
+        return name === undefined ? entry : { ...entry, name };
+    });
     return JSON.stringify(routes, null, 2) + '\n';
 }
 function byPathThenFile(a, b) {

package/dist/utils/coding-steering.js

@@ -63,6 +63,16 @@ function syncCodingSteering(opts) {
                 dstSkillsDir: node_path_1.default.join(opts.targetDir, '.agent', 'skills', 'steering', opts.stack, 'skills'),
                 dstTechPath: node_path_1.default.join(opts.targetDir, '.agent', 'skills', 'steering', opts.stack, 'tech.md'),
             };
+        // **本函数不碰任何权限位**——解锁是调用方的事：
+        //   - 老链路：`update-skills.sh:162` 在跑一切之前统一 `chmod -R u+w "$TARGET_DIR"`
+        //   - 新链路（`skills sync --type X`）：同一次调用里 syncSandboxSkills 已经递归解锁过
+        //     整个 skills 根，本函数紧随其后执行，目录必然可写
+        //   - 本地 dev / `app init`：目录从来不会被锁
+        //
+        // 曾在这里加过「解锁 + 写完还原」，两个理由下掉：steering 子树的所有权明确归 CLI
+        // （老脚本 :179/:208 写明 `steering/ 子树由 miaoda CLI 独占，update.sh 不写不删`），
+        // 锁它没收益；而权限逻辑散在写入方会跟收尾的 lockDirReadonly 形成隐式耦合，
+        // 范围一旦不对称就会出「跑一次 skills sync 把整个 skills 目录解封」这种事。
         node_fs_1.default.mkdirSync(dstSkillsDir, { recursive: true });
         let techSynced = false;
         const techSrc = node_path_1.default.join(stackDir, 'tech.md');

package/dist/utils/file-ops.js

@@ -5,6 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeLineFromFile = removeLineFromFile;
 exports.removeLineFromContent = removeLineFromContent;
+exports.unlockDirForWrite = unlockDirForWrite;
+exports.lockDirReadonly = lockDirReadonly;
+exports.forceRemove = forceRemove;
+const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const logger_1 = require("./logger");
@@ -43,3 +47,80 @@ function removeLineFromContent(content, pattern) {
         changed: filtered.length !== lines.length,
     };
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// 目录权限：沙箱 skill 目录被刻意锁成只读，写入前须解锁、写完须锁回。
+//
+// 背景：老 update-skills.sh 同步末尾 `chmod -R a=rX "$TARGET_DIR"`（:241）把
+// skills 锁成只读——skills 是平台下发的资产，不该被用户/agent 手改；下一轮同步
+// 开头再 `chmod -R u+w`（:162）统一解锁。目录 owner 是沙箱当前用户，虽无写位但
+// 有权改权限，所以不需要 sudo（沙箱容器带 no_new_privileges，sudo 本就被禁）。
+//
+// **解锁只做在「整棵树的接管者」那一层**：新链路里就是 syncSandboxSkills（它重写
+// 整个平铺层），对齐老脚本 :162 那一次统一解锁。写 steering 的 syncCodingSteering
+// 不碰权限 —— 它跑在同一次调用里、紧随 syncSandboxSkills 之后，目录已经可写；
+// 各写入方各自 chmod 会与收尾的 lockDirReadonly 形成隐式耦合，范围一旦不对称就会
+// 出「跑一次 skills sync 把整个 skills 目录解封」这种事。
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 解锁目录使其可写（`chmod -R u+w`）。
+ *
+ * 写入被只读锁保护的目录前必须调用，否则 `fs.cpSync` / `fs.rmSync` 报 EACCES。
+ * 只加 owner 写位、不动 g/o，与老链路一致。目录不存在直接返回 false（调用方
+ * 通常紧接着 mkdir）。失败只 debug 不抛：解锁是尽力而为，真写不进去让后续
+ * 写操作自己报错，错误信息更具体。
+ */
+function unlockDirForWrite(dir) {
+    if (!node_fs_1.default.existsSync(dir))
+        return false;
+    try {
+        (0, node_child_process_1.execFileSync)('chmod', ['-R', 'u+w', dir], { stdio: ['ignore', 'ignore', 'pipe'] });
+        return true;
+    }
+    catch (err) {
+        (0, logger_1.debug)(`file-ops: chmod -R u+w ${dir} failed: ${err.message}`);
+        return false;
+    }
+}
+/**
+ * 把目录锁成只读（`chmod -R a=rX`），对齐 update-skills.sh:241。
+ *
+ * `a=rX`：所有人只读；`X` 是大写，只给目录和「原本已有执行位」的文件加 x，
+ * 不会把 SKILL.md 变成可执行。会连 owner 写位一并清掉，所以下一轮写入前必须
+ * {@link unlockDirForWrite}。
+ *
+ * **调用时机必须是全部写入完成之后**——锁上就写不进去了。
+ */
+function lockDirReadonly(dir) {
+    if (!node_fs_1.default.existsSync(dir))
+        return false;
+    try {
+        (0, node_child_process_1.execFileSync)('chmod', ['-R', 'a=rX', dir], { stdio: ['ignore', 'ignore', 'pipe'] });
+        return true;
+    }
+    catch (err) {
+        (0, logger_1.debug)(`file-ops: chmod -R a=rX ${dir} failed: ${err.message}`);
+        return false;
+    }
+}
+/**
+ * 强制删除文件或目录，三层兜底：`chmod -R u+w` → `rm -rf` → `fs.rmSync`。
+ *
+ * 为什么不能直接 `fs.rmSync`：删条目需要**父目录**写权限，而 skill 目录常处于
+ * 只读锁下；另外老 update.sh 曾以 root 跑过，可能留下异主文件（如 root-owned 的
+ * `.last-update`），`rmSync{force:true}` 只忽略 ENOENT、遇 EACCES 仍抛。
+ * shell `rm -rf` 对异主文件 / 怪符号链接比 rmSync 宽容，故作主档。
+ */
+function forceRemove(target) {
+    if (!node_fs_1.default.existsSync(target))
+        return;
+    unlockDirForWrite(target);
+    try {
+        (0, node_child_process_1.execFileSync)('rm', ['-rf', target], { stdio: ['ignore', 'ignore', 'pipe'] });
+        if (!node_fs_1.default.existsSync(target))
+            return;
+    }
+    catch (err) {
+        (0, logger_1.debug)(`file-ops: rm -rf ${target} failed: ${err.message}`);
+    }
+    node_fs_1.default.rmSync(target, { recursive: true, force: true });
+}

package/dist/utils/npm-pack.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickLaneVersion = pickLaneVersion;
 exports.fetchNpmPackage = fetchNpmPackage;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -11,6 +12,38 @@ const node_path_1 = __importDefault(require("node:path"));
 const error_1 = require("./error");
 const logger_1 = require("./logger");
 const DEFAULT_REGISTRY = 'https://registry.npmmirror.com/';
+/**
+ * 从 `npm view <pkg> versions --json` 里过滤出后缀 `-alpha.<X>` 的版本。
+ *
+ * 用于 sandbox-skills 新姿势（2026-08 迁离 lane-<X> dist-tag 之后）：
+ * publish-sandbox-skills.sh 每次发的版本号 = `<base>-alpha.<LANE>-<YYYYMMDDHHMMSS>`，
+ * TCC 里的 X = `<LANE>-<TIMESTAMP>` 全局唯一。反推侧过滤 versions 数组即可精确命中。
+ *
+ * **不 throw 是硬要求**（消费方 fallback @latest 依赖返回 null 判定）：
+ *   - `npm view` 网络挂、包不存在、metadata 解析失败 → 返回 null
+ *   - 无版本匹配 → 返回 null
+ *   - 多版本匹配（理论上不该发生，因 timestamp 精度到秒）→ 字符串排序取最大（timestamp 最大）
+ */
+function pickLaneVersion(packageName, X, registry) {
+    const reg = registry ?? process.env.MIAODA_NPM_REGISTRY ?? DEFAULT_REGISTRY;
+    const suffix = `-alpha.${X}`;
+    try {
+        const stdout = (0, node_child_process_1.execFileSync)('npm', ['view', packageName, 'versions', '--json', '--registry', reg], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const versions = JSON.parse(stdout);
+        if (!Array.isArray(versions))
+            return null;
+        const matched = versions.filter((v) => typeof v === 'string' && v.endsWith(suffix));
+        if (matched.length === 0)
+            return null;
+        // 通常唯一命中（X 含 timestamp 到秒）；多命中时字符串排序取最大（timestamp 更晚）
+        matched.sort();
+        return matched[matched.length - 1] ?? null;
+    }
+    catch (err) {
+        (0, logger_1.debug)(`pickLaneVersion(${packageName}, X=${X}) failed: ${err.message}`);
+        return null;
+    }
+}
 /**
  * `npm pack <pkg>@<ver> --registry <r>` + `tar -xzf`，解到临时目录。
  * extractDir 是包内容根（含 package.json）。使用完必须 cleanup()。

package/dist/utils/sandbox-skills.js

@@ -0,0 +1,271 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLaneFromTgzKey = extractLaneFromTgzKey;
+exports.syncSandboxSkills = syncSandboxSkills;
+exports.validateSandboxSyncOpts = validateSandboxSyncOpts;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const npm_pack_1 = require("../utils/npm-pack");
+const error_1 = require("../utils/error");
+const logger_1 = require("../utils/logger");
+const file_ops_1 = require("../utils/file-ops");
+const PACKAGE_BY_TYPE = {
+    miaoda: '@lark-apaas/coding-miaoda-sandbox-skills',
+    'miaoda-modern': '@lark-apaas/coding-miaoda-sandbox-skills',
+    'miaoda-design': '@lark-apaas/coding-miaoda-sandbox-skills',
+    openclaw: '@lark-apaas/coding-openclaw-sandbox-skills',
+};
+/**
+ * 目标根目录下**永不删除**的控制文件（对齐 `update-skills.sh` 的删除白名单）：
+ *   - `.keep`        沙箱级「冻结 skills」开关，存在即整体跳过同步（见 {@link syncSandboxSkills}）
+ *   - `.config`      沙箱级 tgzKey 覆盖，feida-ai 的 `enableConfigFileOverride` 读它
+ *                    （`getKeepFileTgzKey` → `.agent/skills/.config`），删了会让版本钉死失效
+ *   - `.last-update` 同步时间戳，feida-ai freshness 检查读它；每轮末尾会重写，列进来只是语义完备
+ */
+const PRESERVED_ENTRIES = new Set(['.keep', '.config', '.last-update']);
+/** `.keep` 存在时整体跳过同步的标记文件名，语义同 `update-skills.sh:149`。 */
+const KEEP_FILE = '.keep';
+/**
+ * rsync 式对齐：删掉目标里「源包已不提供」的顶层条目，对齐 `update-skills.sh:196-218`。
+ *
+ * 与整目录清空的区别（后者是本函数取代的旧实现）：
+ *   - 保住 {@link PRESERVED_ENTRIES} 里的控制文件
+ *   - 保住 `steering/` 子树 —— 它由 handler 层的 syncCodingSteering 独占管理
+ *     （`update-skills.sh:207` 平铺型分支同样明确「归 miaoda CLI 管，update.sh 不删不覆盖」）
+ *
+ * 只处理顶层：源包内容本身就是「一个 skill 一个顶层目录」，逐文件比对没有额外收益。
+ */
+function pruneStaleEntries(skillsRoot, sourceTopEntries) {
+    if (!node_fs_1.default.existsSync(skillsRoot))
+        return [];
+    const deleted = [];
+    for (const entry of node_fs_1.default.readdirSync(skillsRoot)) {
+        if (PRESERVED_ENTRIES.has(entry) || entry === 'steering')
+            continue;
+        if (sourceTopEntries.has(entry))
+            continue;
+        const target = node_path_1.default.join(skillsRoot, entry);
+        try {
+            // forceRemove 的 chmod→rm -rf→rmSync 三层兜底对文件同样适用：
+            // 老 update.sh 以 root 跑过、且会 chmod -R 锁只读，直接 rmSync 会 EACCES
+            (0, file_ops_1.forceRemove)(target);
+            deleted.push(entry);
+        }
+        catch (err) {
+            (0, logger_1.debug)(`sandbox-skills: prune ${entry} failed: ${err.message}`);
+        }
+    }
+    return deleted;
+}
+// 合并包内的业务线子目录（miaoda / miaoda-modern / miaoda-design）；shared 单独处理。
+const BUSINESS_LINE_BY_TYPE = {
+    miaoda: 'miaoda',
+    'miaoda-modern': 'miaoda-modern',
+    'miaoda-design': 'miaoda-design',
+    openclaw: null, // openclaw 独立包，直接展平
+};
+/**
+ * 从 TCC skillsUpdateTgzKey 反推 lane 名。
+ *   skills_versions/all_feat-xxx.tgz  → feat-xxx
+ *   skills_versions/all_feat_xxx.tgz  → feat-xxx  (_ sanitize → -)
+ *   skills_versions/all_latest.tgz    → null（走 @latest）
+ *   任何 all_<X>.tgz                  → <X> 里 _ 全部转 -
+ *
+ * **宽进严出**：正则允许 `_` 匹配（兼容老 miaoda-skills 时代 TOS key 含 `_` 的存量 TCC
+ * 命名），但返回时 sanitize 成 `-` —— 对齐 publish-sandbox-skills.sh 侧只发 `-` 版
+ * lane 的现实（npm SemVer pre-release 只允许 `[A-Za-z0-9-]`，不允许 `_`）。
+ * 存量 TCC 里如果有 `all_feat_xxx.tgz` 这种命名，反推出 `feat-xxx` 后能正确命中
+ * npm 上实际发出的 `@lane-feat-xxx` 包，而不是静默 fallback 到 @latest。
+ *
+ * 用 nullable 而不是空字符串 —— 让调用方能判断"没 lane 就走 latest"。
+ */
+function extractLaneFromTgzKey(tgzKey) {
+    if (tgzKey === undefined || tgzKey === '') {
+        return null;
+    }
+    const match = /(?:^|\/)all_([A-Za-z0-9][A-Za-z0-9_-]*)\.tgz$/.exec(tgzKey);
+    if (match === null) {
+        return null;
+    }
+    const lane = match[1].replace(/_/g, '-');
+    if (lane === 'latest') {
+        return null;
+    }
+    return lane;
+}
+/**
+ * 主流程：按 type 拉包 + sync 到目标目录。
+ *
+ * sync 策略：**rsync 式对齐**，逐条对应线上真实跑的 `update-skills.sh`（不是
+ * `cp-skills.sh`——那个脚本线上不执行，日志里的 `copied/skipped/deleted` 出自前者）：
+ *   1. 目标目录有 `.keep` → 整体跳过（`update-skills.sh:149`）
+ *   2. 覆盖式写入源包提供的顶层条目
+ *   3. 删掉源包已不提供的顶层条目（{@link pruneStaleEntries}），但保住
+ *      {@link PRESERVED_ENTRIES} 与 `steering/`
+ *
+ * 不用整目录清空：那会删掉 `.config`（沙箱级 tgzKey 覆盖）、`.keep`（冻结开关）
+ * 和 handler 层刚写的 `steering/`，而老链路对这三者都有保护。
+ */
+function syncSandboxSkills(opts) {
+    const targetDir = node_path_1.default.resolve(opts.targetDir ?? process.cwd());
+    const packageName = PACKAGE_BY_TYPE[opts.type];
+    const businessLine = BUSINESS_LINE_BY_TYPE[opts.type];
+    const lane = extractLaneFromTgzKey(opts.tgzKey);
+    // ---- lane 拉包 ----
+    // 新姿势（2026-08 迁离 lane-<X> dist-tag 之后）：
+    //   TCC 里的 X（比如 `feat-migrate-skills-from-miaoda-skills-20260805143512`）
+    //   包含 branch + timestamp，`pickLaneVersion` 走 `npm view <pkg> versions --json`
+    //   过滤 `endsWith('-alpha.' + X)`（因 X 含 timestamp 全局唯一，唯一命中或 0 命中）。
+    //   0 命中 → fallback @latest（对齐旧 TCC 值找不到、灰度切换期间的兜底语义）。
+    //   `pickLaneVersion` 内部对 `npm view` 报错 / 无匹配都返回 null，绝不 throw ——
+    //   目标就是"不挂掉"。
+    let fetched;
+    const laneVersion = lane === null ? null : (0, npm_pack_1.pickLaneVersion)(packageName, lane, opts.registry);
+    if (lane !== null && laneVersion === null) {
+        (0, logger_1.debug)(`sandbox-skills: no npm version matched -alpha.${lane}, fallback to @latest ` +
+            `(TCC 里的 X 可能是老 lane dist-tag 命名 / 已 unpublish / npm view 挂 / 网络断)`);
+    }
+    const primaryVersion = laneVersion ?? 'latest';
+    try {
+        (0, logger_1.debug)(`sandbox-skills: fetching ${packageName}@${primaryVersion}`);
+        fetched = (0, npm_pack_1.fetchNpmPackage)({
+            packageName,
+            version: primaryVersion,
+            registry: opts.registry,
+        });
+    }
+    catch (err) {
+        if (primaryVersion === 'latest') {
+            throw err;
+        }
+        (0, logger_1.debug)(`sandbox-skills: pack ${primaryVersion} failed, fallback to @latest (err: ${err.message})`);
+        fetched = (0, npm_pack_1.fetchNpmPackage)({
+            packageName,
+            version: 'latest',
+            registry: opts.registry,
+        });
+    }
+    try {
+        // 计算 skill 目标根目录：
+        //   - openclaw → <targetDir>/skills/（跟老 cp-skills.sh 的 openclaw 分支对齐，落 $WORKSPACE_DIR/agent/skills）
+        //   - 其它 →     <targetDir>/.agent/skills/
+        const skillsRoot = opts.type === 'openclaw'
+            ? node_path_1.default.join(targetDir, 'skills')
+            : node_path_1.default.join(targetDir, '.agent', 'skills');
+        // `.keep` 短路：对齐 update-skills.sh:149-152，沙箱侧放了这个文件即表示
+        // 「我手改过 skills，别覆盖我」，整体跳过同步（含 steering —— 调用方看到
+        // skipped 就不该再往下写）。
+        if (node_fs_1.default.existsSync(node_path_1.default.join(skillsRoot, KEEP_FILE))) {
+            (0, logger_1.debug)(`sandbox-skills: ${KEEP_FILE} found in ${skillsRoot}, skip sync`);
+            return {
+                packageName,
+                version: fetched.version,
+                lane,
+                syncedTop: [],
+                deleted: [],
+                skippedByKeepFile: true,
+                targetDir: skillsRoot,
+            };
+        }
+        // 写入前解锁，对齐 update-skills.sh:160-165：
+        //   上一轮同步末尾会 chmod -R a=rX 锁只读（见 file-ops 的 lockDirReadonly），
+        //   不先解锁，下面 fs.cpSync 覆盖已存在的 skill 目录必 EACCES。
+        // 只加 u+w（不动 g/o），与老链路一致；owner 是沙箱当前用户，无需 sudo。
+        (0, file_ops_1.unlockDirForWrite)(skillsRoot);
+        node_fs_1.default.mkdirSync(skillsRoot, { recursive: true });
+        const syncedTop = [];
+        // 源包提供的全部顶层条目 —— prune 的保留集。与 syncedTop 分开维护：syncedTop 是
+        // 「本轮实际写入」，用于对外汇报；prune 只能依据「源包提供了什么」来判断 stale，
+        // 两者一旦哪天再次分叉（比如某分支又加了跳过写入的条件），拿 syncedTop 当保留集
+        // 就会把没重写的条目误判成 stale 删掉、下一轮再写回来，反复抖动。
+        const sourceTop = new Set();
+        if (businessLine !== null) {
+            // 合并包 miaoda/miaoda-modern/miaoda-design：cp <extractDir>/<business-line>/* 到 target
+            const sourceDir = node_path_1.default.join(fetched.extractDir, businessLine);
+            if (node_fs_1.default.existsSync(sourceDir)) {
+                for (const entry of node_fs_1.default.readdirSync(sourceDir)) {
+                    const from = node_path_1.default.join(sourceDir, entry);
+                    const to = node_path_1.default.join(skillsRoot, entry);
+                    sourceTop.add(entry);
+                    node_fs_1.default.cpSync(from, to, { recursive: true });
+                    syncedTop.push(entry);
+                }
+            }
+            else {
+                (0, logger_1.debug)(`sandbox-skills: source dir ${sourceDir} not found in package (skipped)`);
+            }
+            // shared：合并包内 shared/* 到 target。**无条件覆盖**，逐字对齐老 build.sh:42-52 ——
+            // 那里业务线先 `cp -r`（:33-34）、shared 后 `cp -r`（:47），后写覆盖前写，
+            // 即同名时 **shared 赢**。当前包里两边无同名交集，但语义得跟老链路一致。
+            //
+            // 早期这里写成「`fs.existsSync(to)` 就 continue」，有两个问题：
+            //   1. 同名优先级反了（变成业务线赢）；
+            //   2. 更严重 —— existsSync 分不清「本轮业务线刚写的」和「上一轮 shared 自己写的」，
+            //      于是 shared skill 首次落盘后就永久冻结，包里再更新也同步不到已有沙箱
+            //      （沙箱磁盘跨会话保留，每次 update-skills 都会命中 existsSync）。
+            const sharedDir = node_path_1.default.join(fetched.extractDir, 'shared');
+            if (node_fs_1.default.existsSync(sharedDir)) {
+                for (const entry of node_fs_1.default.readdirSync(sharedDir)) {
+                    const from = node_path_1.default.join(sharedDir, entry);
+                    const to = node_path_1.default.join(skillsRoot, entry);
+                    sourceTop.add(entry);
+                    node_fs_1.default.cpSync(from, to, { recursive: true });
+                    syncedTop.push(entry);
+                }
+            }
+        }
+        else {
+            // openclaw 独立包：直接把包内所有 skill 目录（除 package.json 等元文件外）平铺到 skillsRoot
+            for (const entry of node_fs_1.default.readdirSync(fetched.extractDir)) {
+                if (entry === 'package.json' || entry === 'README.md' || entry === 'LICENSE')
+                    continue;
+                const from = node_path_1.default.join(fetched.extractDir, entry);
+                const stat = node_fs_1.default.statSync(from);
+                if (!stat.isDirectory())
+                    continue;
+                const to = node_path_1.default.join(skillsRoot, entry);
+                sourceTop.add(entry);
+                node_fs_1.default.cpSync(from, to, { recursive: true });
+                syncedTop.push(entry);
+            }
+        }
+        // rsync 式收尾：删掉源包已不提供的顶层条目（对齐 update-skills.sh 的 deleted）。
+        // 保留集用 sourceTop（源包提供的全部）而非 syncedTop（本轮实际写入的）——原因见
+        // sourceTop 声明处的注释：否则 shared skill 会被反复删了又写。
+        const deleted = pruneStaleEntries(skillsRoot, sourceTop);
+        // 写 .last-update 时间戳（对齐老 update-skills.sh；供 feida-ai freshness 检查用）
+        const lastUpdatePath = node_path_1.default.join(skillsRoot, '.last-update');
+        node_fs_1.default.writeFileSync(lastUpdatePath, String(Date.now()));
+        return {
+            packageName,
+            version: fetched.version,
+            lane,
+            deleted,
+            skippedByKeepFile: false,
+            syncedTop,
+            targetDir: skillsRoot,
+        };
+    }
+    finally {
+        fetched.cleanup();
+    }
+}
+/**
+ * 参数校验：type 白名单 + tgzKey 格式（避免非法值透传到 npm 包名）。
+ */
+function validateSandboxSyncOpts(opts) {
+    const validTypes = ['miaoda', 'miaoda-modern', 'miaoda-design', 'openclaw'];
+    if (opts.type === undefined || !validTypes.includes(opts.type)) {
+        throw new error_1.AppError('SKILLS_INVALID_TYPE', `--type must be one of: ${validTypes.join(', ')} (got: ${opts.type ?? 'undefined'})`);
+    }
+    if (opts.tgzKey !== undefined && opts.tgzKey !== '') {
+        // 校验 tgz key 大致格式（前缀 skills_versions/ + all_ + 允许字符 + .tgz）；避免非法值影响 lane 反推
+        if (!/^[A-Za-z0-9/_\-.]+\.tgz$/.test(opts.tgzKey)) {
+            throw new error_1.AppError('SKILLS_INVALID_TGZ_KEY', `--tgz-key value looks invalid: ${opts.tgzKey}`);
+        }
+    }
+    return { type: opts.type, tgzKey: opts.tgzKey };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/miaoda-cli",
-  "version": "0.1.30",
+  "version": "0.1.31-alpha.1f31c36",
   "description": "Miaoda 平台命令行工具，面向 Agent 调用",
   "type": "commonjs",
   "bin": {