@yottameta/yotta-skills 0.23.1 → 0.23.3

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## v0.23.3 (2026-10-01)
+
+- 安装器卫生批次：`install.sh` 统一（未知参数报错 exit 2、`--help` / `--version`、残留清理白名单）；`skills.json` 清单 pin 同步 27 项。
+
+## v0.23.2 (2026-10-01)
+
+- 修复家族安装管线嵌套载荷丢失：复制原语的顶层跳过名单（`package.json` / `bin` / `node_modules` / `.git`）此前按条目名逐层生效，会把技能包内嵌套的同名载荷（如元造 `template/package.json`、`template/bin/install.js`）一并跳过——家族安装 / 更新元造后，其脚手架自检会失败（缺必需文件）。现改为仅顶层生效，与元造 0.1.3 的安装器修复对齐。
+- 新增 `lib/copy-tree.js`（单一复制原语）与回归测试：顶层同名跳过、嵌套同名保留、缓存类（`__pycache__` / `.pytest_cache` / `.mypy_cache` / `*.pyc` / `*.pyo`）任意层级清理；家族管线集成回归同步补齐。
+- 清单同步：`skills.json` / `references/skill-list.md` 更新元造 0.1.4、元案 0.1.1。
+
 ## v0.23.1 (2026-10-01)
 
 - 文档：环境变量表补齐 `YOTTA_SKILLS_REGISTRY_FILE` / `YOTTA_SKILLS_USAGE_FILE` / `YOTTA_PROVIDER_HOME` 三项，并新增「隔离环境：三个状态文件成组导出」小节（bash / PowerShell 示例）——测试、CI 与多 agent 场景需三件成组导出，避免读写宿主真实状态。

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: yotta-skills
-version: 0.23.1
+version: 0.23.3
 description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点 + 运行时 hook 适配。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；M1 记忆裁决层：usage enable/mark 本地结构化记录 + decide-memory / MCP decide_memory 输出 promote / hold / demote 只读建议（需授权 provider；只建议不删除、不自动写元忆）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么组合使用（安装与调用均由用户确认后执行）」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录（默认 --pin 锁死清单精确版本）；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工只建议跑本地 --reindex；更新检查走手动 --check 或后台 --check --scheduled）；运行时适配层：hook capabilities / evaluate / bind / unbind 按宿主能力矩阵执行六个统一事件并留证降级，元信 before_install 已接入安装管线；自包含零依赖，不依赖任何元技能；MCP 按需加载且需用户确认后写入配置（可选：list_installed_skills/describe_skill/reindex/route_request/decide_memory，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / usage 使用记录 / decide-memory 记忆裁决 / install / update / update --check（只读检查）/ update --check --scheduled（后台周检）/ update --auto（家族自动更新）/ hook 适配 / --inventory / --reindex / --dry-run 预览 / --pin（默认）/ --range。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、路由或判断该用哪些技能、判断哪些技能值得长期记忆、查看或记录技能使用信号、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、评估宿主 hook 能力、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/检查更新/自动更新/hook 适配/该用哪个技能/路由技能/记忆裁决/技能该不该记住/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + M1 记忆裁决只读建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index + hook 适配」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能、不静默写宿主配置或全局记忆、不自动删除技能或记忆；家族安装先自举或调用元信装前门禁，DO NOT INSTALL 阻断，非元阁家族包不自动安装。
 license: MIT
 metadata:

package/bin/yotta-skills.js

@@ -42,9 +42,10 @@ const m1FeaturesLib = require('../lib/m1-features');
 const routeFeaturesLib = require('../lib/route-features');
 const routeDynamicLib = require('../lib/route-dynamic');
 const { createInstaller, isSafeTarEntry } = require('../lib/install-pipeline');
+const { COPY_SKIP, copyDir } = require('../lib/copy-tree');
 
 const PKG_ROOT = path.join(__dirname, '..');
-let VERSION = '0.23.1';
+let VERSION = '0.23.3';
 try { VERSION = require(path.join(PKG_ROOT, 'package.json')).version; } catch (_) { /* keep fallback */ }
 
 function loadManifest() {
@@ -513,24 +514,7 @@ async function runUpdateAuto(opts, dest) {
   return { code: failed2 > 0 ? autoExitCode : 0 };
 }
 
-function shouldSkip(name, isFile) {
-  if (name === '__pycache__' || name === '.pytest_cache' || name === '.mypy_cache') return true;
-  if (isFile && (name.endsWith('.pyc') || name.endsWith('.pyo'))) return true;
-  return false;
-}
-function copyDir(src, dst, skip) {
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    if (skip.has(entry.name) || shouldSkip(entry.name, entry.isFile())) continue;
-    const s = path.join(src, entry.name);
-    const d = path.join(dst, entry.name);
-    if (entry.isDirectory()) {
-      fs.mkdirSync(d, { recursive: true });
-      copyDir(s, d, skip);
-    } else if (entry.isFile()) {
-      fs.copyFileSync(s, d);
-    }
-  }
-}
+// 复制原语（顶层跳过口径 / 缓存清理）统一在 lib/copy-tree.js，此处不再保留第二份实现。
 
 function resolveTargetDir(opts) {
   if (opts.dir) return path.resolve(opts.dir);
@@ -659,8 +643,6 @@ function extractTarball(tarball, extractDir) {
   return { pkgDir };
 }
 
-const COPY_SKIP = new Set(['package.json', 'bin', 'node_modules', '.git', '__pycache__']);
-
 function ensureGate(context) {
   const { skill, extracted, dest, opts } = context;
   const current = findVerifyEngine(dest, opts);
@@ -716,7 +698,7 @@ function ensureGate(context) {
 const installOne = createInstaller({
   runNpmPack,
   extractTarball,
-  copyDir: (src, dst) => copyDir(src, dst, COPY_SKIP),
+  copyDir: (src, dst) => copyDir(src, dst, COPY_SKIP, true),
   readInstalledVersion,
   ensureGate,
   scanTarget,

package/install.sh

@@ -1,31 +1,30 @@
 #!/usr/bin/env bash
-# yotta-skills（元阁）多智能体安装脚本（YottaSkills）
-# 用途：把「元阁安装器技能」本身装进智能体/目录（它自带 SKILL.md，让代理能调用元阁）。
-# 注意：这**不是**把 27 个 yotta-* 技能一并装齐——装全家需再跑
-#       `node bin/yotta-skills.js install --agent <name>`（或 --dir <path>）。
+# yotta-skills 多智能体安装脚本（YottaSkills）
 # 用法:
-#   bash install.sh --agent <name>  # 把安装器技能装到智能体默认用户级目录
+#   bash install.sh --agent <name>  # 按智能体默认用户级目录安装
 #   bash install.sh --dir <path>    # 装到指定目录（用户改过目录的智能体）
 #   bash install.sh -g              # 装到全部已知智能体用户级目录
-#   bash install.sh                  # 检测并安装到已存在的项目级目录
+#   bash install.sh                 # 检测并安装到已存在的项目级目录
 #   bash install.sh --list          # 列出智能体 -> 默认目录
+#   bash install.sh --dry-run       # 只显示将写入的目标，不写文件
+#   bash install.sh --version       # 显示版本
+#   bash install.sh --help          # 显示帮助
+# 退出码: 0 成功 / 1 安装失败 / 2 用法错误 / 4 目标错误
 set -euo pipefail
 
 SKILL_NAME="yotta-skills"
 SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+_IS_WINDOWS=0
 case "$(uname -s)" in
   MINGW*|MSYS*)
     SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -W)"
+    _IS_WINDOWS=1
     ;;
+  CYGWIN*) _IS_WINDOWS=1 ;;
 esac
 
 # 智能体 -> 用户级默认目录（--agent 装到第一个）
 # .agents/skills 并非通用目录：OpenCode / Cursor / Cline / Amp / Kimi / Gemini CLI / GitHub Copilot 读取。
-# 判断当前环境：Windows Git Bash 用 %USERPROFILE%，Unix 用 ~
-_IS_WINDOWS=0
-case "$(uname -s)" in
-  MINGW*|MSYS*|CYGWIN*) _IS_WINDOWS=1 ;;
-esac
 dirs_for() {
   case "$1" in
     claude)     echo ".claude/skills" ;;
@@ -63,46 +62,153 @@ resolve_user() {
   esac
 }
 
-install_to() {
-  local base="$1"
-  local dest
-  local item
-  case "$base" in
-    ""|"/") echo "安装失败：拒绝不安全的目标目录：'$base'" >&2; return 1 ;;
-  esac
-  if [ -L "$base" ]; then
-    echo "安装失败：目标目录是符号链接，拒绝跟随：$base" >&2; return 1
+skill_version() {
+  local pkg="$SOURCE_DIR/package.json" v=""
+  [ -f "$pkg" ] || return 0
+  if command -v awk >/dev/null 2>&1; then
+    v="$(awk -F'"' '{for (i=1;i<=NF;i++) if ($i=="version") {print $(i+2); exit}}' "$pkg" 2>/dev/null || true)"
   fi
-  mkdir -p "$base"
-  dest="$base/$SKILL_NAME"
-  if [ -L "$dest" ]; then
-    echo "安装失败：技能目录是符号链接，拒绝跟随：$dest" >&2; return 1
+  if [ -z "$v" ]; then
+    v="$(sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$pkg" 2>/dev/null | head -n 1 || true)"
   fi
-  if [ -e "$dest" ] && [ ! -d "$dest" ]; then
-    echo "安装失败：技能路径已存在且不是目录：$dest" >&2; return 1
+  printf '%s' "$v"
+}
+
+usage() {
+  echo "$SKILL_NAME 安装脚本（YottaSkills）"
+  echo ""
+  echo "用法:"
+  echo "  bash install.sh --agent <name>   按智能体默认用户级目录安装（推荐）"
+  echo "  bash install.sh --dir <path>     装到指定目录（用户改了目录的智能体）"
+  echo "  bash install.sh -g               安装到全部已知智能体用户级目录"
+  echo "  bash install.sh                  安装到检测到的项目级目录"
+  echo ""
+  echo "参数:"
+  echo "  --agent <name>  智能体键名，见 --list"
+  echo "  --dir <path>    自定义技能目录"
+  echo "  -g, --global    安装到全部已知用户级目录"
+  echo "  --list, -l      列出支持的智能体目录"
+  echo "  --dry-run       只显示将写入的目标，不写文件"
+  echo "  --version, -v   显示版本"
+  echo "  --help, -h      显示帮助"
+  echo "  --yes, -y       兼容参数（-g 不再强制要求）"
+  echo ""
+  echo "退出码: 0 成功 / 1 安装失败 / 2 用法错误 / 4 目标错误"
+}
+
+resolve_path() {
+  # 与 SOURCE_DIR 同一风格（Windows Git Bash 用 pwd -W），供路径包含判断使用
+  local p="$1"
+  if [ "$_IS_WINDOWS" = "1" ]; then
+    (cd "$p" 2>/dev/null && pwd -W)
+  else
+    (cd "$p" 2>/dev/null && pwd -P)
+  fi
+}
+
+assert_safe_target() {
+  local dest="$1" src_real dest_real parent
+  src_real="$(resolve_path "$SOURCE_DIR")" || return 0
+  if [ -d "$dest" ]; then
+    dest_real="$(resolve_path "$dest")" || return 0
+  else
+    parent="$(dirname "$dest")"
+    dest_real="$(resolve_path "$parent")" || return 0
+    dest_real="$dest_real/$(basename "$dest")"
   fi
-  mkdir -p "$dest"
+  case "$dest_real" in
+    "$src_real"|"$src_real"/*)
+      echo "安装失败：目标目录不能在技能源目录内（防止自装自毁）" >&2
+      return 1
+      ;;
+  esac
+  return 0
+}
 
-  # 只安装技能本体与运行时需要的 MCP/清单资产；只清副本内的固定子路径。
-  for item in .git .github .gitignore .npmignore bin lib test package.json package-lock.json install.sh; do
-    if [ -e "$dest/$item" ] && [ ! -L "$dest/$item" ]; then
-      rm -rf -- "$dest/$item"
+# 清理旧版安装残留（fail-closed 白名单）：仅在目标目录已存在且含 SKILL.md 时触发；
+# 只删顶层开发项 + 任意层级缓存；不整目录删除、不跟随符号链接。
+DEV_SKIP="package.json package-lock.json bin lib test .github .git .gitignore .npmignore .gitattributes .yotta .tmp install.sh node_modules"
+clean_residue() {
+  local dest="$1" name p
+  [ -d "$dest" ] || return 0
+  [ -f "$dest/SKILL.md" ] || return 0
+  for name in $DEV_SKIP; do
+    p="$dest/$name"
+    [ -L "$p" ] && continue
+    if [ -e "$p" ]; then
+      rm -rf -- "$p"
+      echo "已清理残留: $name"
     fi
   done
-  for item in SKILL.md skill-manifest.json references scripts assets skills.json scan-policy.json LICENSE NOTICE README.md README.zh-CN.md CHANGELOG.md USER_GUIDE.md; do
-    if [ -e "$SOURCE_DIR/$item" ]; then
-      cp -RP "$SOURCE_DIR/$item" "$dest/"
+  find "$dest" -type d \( -name '__pycache__' -o -name '.pytest_cache' -o -name '.mypy_cache' \) -prune -exec rm -rf -- {} + 2>/dev/null || true
+  find "$dest" -type f \( -name '*.pyc' -o -name '*.pyo' \) -delete 2>/dev/null || true
+}
+
+# 复制技能本体：顶层跳过开发件与运行时不相关目录（嵌套同名保留）；
+# 任意层级跳过缓存（__pycache__ / .pytest_cache / .mypy_cache / *.pyc / *.pyo）。
+copy_tree() {
+  local src="$1" dst="$2" top="$3" entry base
+  mkdir -p "$dst"
+  for entry in "$src"/* "$src"/.[!.]* "$src"/..?*; do
+    [ -e "$entry" ] || [ -L "$entry" ] || continue
+    base="$(basename "$entry")"
+    case "$base" in
+      __pycache__|.pytest_cache|.mypy_cache) continue ;;
+    esac
+    if [ "$top" = "1" ]; then
+      case " $DEV_SKIP " in
+        *" $base "*) continue ;;
+      esac
+    fi
+    if [ -d "$entry" ] && [ ! -L "$entry" ]; then
+      copy_tree "$entry" "$dst/$base" 0 || return 1
+    else
+      case "$base" in
+        *.pyc|*.pyo) continue ;;
+      esac
+      cp -RP "$entry" "$dst/$base" || return 1
     fi
   done
-  find "$dest" -type d -name '__pycache__' -prune -exec rm -rf {} + 2>/dev/null || true
-  find "$dest" -type f -name '*.pyc' -delete 2>/dev/null || true
+}
+
+install_to() {
+  local base="$1" dry="$2" dest
+  dest="$base/$SKILL_NAME"
+  if [ -L "$base" ]; then
+    echo "安装失败：目标目录是符号链接，拒绝跟随：$base" >&2
+    return 1
+  fi
+  if [ -e "$base" ] && [ ! -d "$base" ]; then
+    echo "安装失败：目标路径已存在且不是目录：$base" >&2
+    return 1
+  fi
+  if [ -L "$dest" ]; then
+    echo "安装失败：技能目录是符号链接，拒绝跟随：$dest" >&2
+    return 1
+  fi
+  if [ -e "$dest" ] && [ ! -d "$dest" ]; then
+    echo "安装失败：技能路径已存在且不是目录：$dest" >&2
+    return 1
+  fi
+  assert_safe_target "$dest" || return 1
+  if [ "$dry" = "1" ]; then
+    echo "[dry-run] 将安装到 -> $dest"
+    return 0
+  fi
+  clean_residue "$dest"
+  mkdir -p "$dest" || return 1
+  copy_tree "$SOURCE_DIR" "$dest" 1 || return 1
+  if [ ! -f "$dest/SKILL.md" ]; then
+    echo "安装失败：结果缺少 SKILL.md" >&2
+    return 1
+  fi
   echo "installed -> $dest"
 }
 
 list() {
   echo "智能体 -> 默认技能目录（--agent <name> 装到第一个，用户级）:"
+  local a dirs first
   for a in claude cursor codex gemini goose amp opencode windsurf workbuddy kiro trae trae-cn qwen comate codebuddy kimi agents; do
-    local dirs first
     dirs="$(dirs_for "$a")"
     first="${dirs%% *}"
     case "$first" in
@@ -121,49 +227,101 @@ list() {
 }
 
 main() {
-  local agent="" dir="" global=0 show_list=0 assume_yes=0
+  local agent="" dir="" global=0 show_list=0 show_help=0 show_version=0 dry=0
   while [ $# -gt 0 ]; do
     case "$1" in
-      --agent) shift; agent="${1:-}" ;;
-      --dir)   shift; dir="${1:-}" ;;
-      -g|--global) global=1 ;;
-      -y|--yes) assume_yes=1 ;;
+      --help|-h) show_help=1 ;;
+      --version|-v) show_version=1 ;;
       --list|-l) show_list=1 ;;
+      -g|--global) global=1 ;;
+      --dry-run) dry=1 ;;
+      --yes|-y) : ;;
+      --agent)
+        shift
+        if [ $# -eq 0 ] || [ -z "${1:-}" ]; then
+          echo "用法错误: --agent 需要一个非空名称" >&2
+          exit 2
+        fi
+        agent="$1"
+        ;;
+      --dir)
+        shift
+        if [ $# -eq 0 ] || [ -z "${1:-}" ]; then
+          echo "用法错误: --dir 需要一个非空路径" >&2
+          exit 2
+        fi
+        dir="$1"
+        ;;
       *) echo "未知参数: $1" >&2; exit 2 ;;
     esac
     shift
   done
 
-  if [ "$show_list" = "1" ]; then list; return; fi
-  if [ -n "$dir" ]; then install_to "$dir"; echo "完成。"; return; fi
+  if [ "$show_help" = "1" ]; then usage; return 0; fi
+  if [ "$show_version" = "1" ]; then
+    local v
+    v="$(skill_version)"
+    if [ -z "$v" ]; then
+      echo "$SKILL_NAME 版本未知（未找到 package.json）" >&2
+      exit 1
+    fi
+    echo "$SKILL_NAME v$v"
+    return 0
+  fi
+  if [ "$show_list" = "1" ]; then list; return 0; fi
+
+  local selected=0
+  [ -n "$dir" ] && selected=$((selected + 1))
+  [ -n "$agent" ] && selected=$((selected + 1))
+  [ "$global" = "1" ] && selected=$((selected + 1))
+  if [ "$selected" -gt 1 ]; then
+    echo "用法错误: --dir / --agent / -g 只能选一个" >&2
+    exit 2
+  fi
+
+  if [ -n "$dir" ]; then
+    install_to "$dir" "$dry" || exit 1
+    [ "$dry" = "1" ] || echo "完成。"
+    return 0
+  fi
   if [ -n "$agent" ]; then
     local dirs first
     if ! dirs="$(dirs_for "$agent")"; then
-      echo "未收录智能体: $agent。请用 --dir <路径> 指定技能目录。" >&2; exit 2
+      echo "未收录智能体: $agent。可用 --list 查看，或 --dir <路径> 指定。" >&2
+      exit 2
     fi
     first="${dirs%% *}"
-    install_to "$(resolve_user "$first")"; echo "完成。"; return
+    install_to "$(resolve_user "$first")" "$dry" || exit 1
+    [ "$dry" = "1" ] || echo "完成。"
+    return 0
   fi
   if [ "$global" = "1" ]; then
-    if [ "$assume_yes" != "1" ]; then
-      echo "批量安装到全部已知智能体目录会写入多个宿主目录，需要显式确认：请加 --yes（或用 --agent / --dir 指定单一目标）。" >&2
-      exit 2
-    fi
-    echo "安装到全部已知智能体用户级目录..."
-    local dirs rel
+    local a dirs rel seen=" "
     for a in claude cursor codex gemini goose amp opencode windsurf workbuddy kiro trae trae-cn qwen comate codebuddy kimi agents; do
-      dirs="$(dirs_for "$a")"
-      for rel in $dirs; do install_to "$(resolve_user "$rel")"; done
+      dirs="$(dirs_for "$a")" || continue
+      for rel in $dirs; do
+        case "$seen" in
+          *" $rel "*) continue ;;
+        esac
+        seen="$seen$rel "
+        install_to "$(resolve_user "$rel")" "$dry" || exit 1
+      done
     done
-    echo "完成。"; return
+    [ "$dry" = "1" ] || echo "完成。"
+    return 0
   fi
   local installed=0 d
   for d in .claude/skills .cursor/skills .codex/skills .config/goose/skills .config/agents/skills .opencode/skills .codeium/windsurf/skills .workbuddy/skills .kiro/skills .traecli/skills .gemini/skills .trae-cn/skills .qwen/skills .comate/skills .codebuddy/skills .kimi/skills .agents/skills; do
-    if [ -d "$d" ]; then install_to "$d"; installed=1; fi
+    if [ -d "$d" ]; then
+      install_to "$d" "$dry" || exit 1
+      installed=1
+    fi
   done
   if [ "$installed" = "0" ]; then
-    echo "未检测到项目级智能体目录。可用 --agent <name> / -g 装到用户级，或 --dir 指定。"
+    echo "目标错误: 未检测到项目级智能体目录。可用 --agent <name> 装到用户级，或用 --dir <路径> 指定目录。" >&2
+    exit 4
   fi
+  [ "$dry" = "1" ] || echo "完成。"
 }
 
 main "$@"

package/lib/copy-tree.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * 安装落位的复制原语（单一真源）。
+ *
+ * 口径（2026-10-01，与元造 0.1.3 的安装器修复对齐）：
+ * - 顶层开发文件 / 目录（package.json / bin / node_modules / .git）只在**安装包顶层**跳过；
+ *   技能包内嵌套的同名载荷（如 template/package.json、template/bin/install.js）必须保留。
+ * - 缓存 / 编译产物（__pycache__ / .pytest_cache / .mypy_cache / *.pyc / *.pyo）任意层级都跳过。
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COPY_SKIP = new Set(['package.json', 'bin', 'node_modules', '.git']);
+
+function shouldSkipCache(name, isFile) {
+  if (name === '__pycache__' || name === '.pytest_cache' || name === '.mypy_cache') return true;
+  if (isFile && (name.endsWith('.pyc') || name.endsWith('.pyo'))) return true;
+  return false;
+}
+
+function copyDir(src, dst, skip, topLevel) {
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (topLevel && skip.has(entry.name)) continue;
+    if (shouldSkipCache(entry.name, entry.isFile())) continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(d, { recursive: true });
+      copyDir(s, d, skip, false);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+module.exports = { COPY_SKIP, shouldSkipCache, copyDir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-skills",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
   "license": "MIT",
   "keywords": [

package/references/skill-list.md

@@ -1,37 +1,37 @@
 # 全家技能清单（27 个）
 
 > 机器权威源：`skills.json`（随包分发）；本文件为人工可读副本，新技能发布后须同步更新
-> `skills.json`（登记表为内部台账，不随包分发）。清单更新日期：2026-09-27。
+> `skills.json`（登记表为内部台账，不随包分发）。清单更新日期：2026-10-01。
 
 | slug | 中文名 | npm 包 | 清单版本 | 说明 |
 |---|---|---|---|---|
-| `yotta-anti-shallow` | 元谨 | `@yottameta/yotta-anti-shallow` | 1.4.1 | 防 AI 敷衍规则引擎（深入分析/根因追溯时激活） |
-| `yotta-code-quality` | 元质 | `@yottameta/yotta-code-quality` | 0.4.1 | 结对式代码质量评审（十二类腐化风险 + 0-100 健康分） |
-| `yotta-workflow` | 元序 | `@yottameta/yotta-workflow` | 0.4.2 | 跨会话/跨项目通用工作流协议（状态就近存） |
-| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.20.0 | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
-| `yotta-learn` | 元习 | `@yottameta/yotta-learn` | 0.2.1 | 学习沉淀 CLI：错误/纠正/洞见沉淀为 .learnings/ 条目 |
-| `yotta-security-audit` | 元安 | `@yottameta/yotta-security-audit` | 0.3.0 | 安全扫描引擎：13 类检测器 + 系统安全基线 + 学生数据隐私（教育版） |
-| `yotta-vetter` | 元审 | `@yottameta/yotta-vetter` | 0.2.6 | 安全审查协议：四阶段 review + SAFE TO INSTALL 判定 |
-| `yotta-recon` | 元析 | `@yottameta/yotta-recon` | 0.1.7 | 跨智能体网络侦察：零依赖端口/服务/版本指纹探测 |
-| `yotta-guardian` | 元盾 | `@yottameta/yotta-guardian` | 0.1.7 | 跨智能体危险调用拦截护栏：确定性规则 + 可插拔意图验证 |
-| `yotta-humanize` | 元真 | `@yottameta/yotta-humanize` | 0.2.1 | 去 AI 味中文写作编辑：检测器引擎 |
-| `yotta-logs` | 元史 | `@yottameta/yotta-logs` | 0.3.2 | 跨智能体历史会话 / 记忆日志检索 |
-| `yotta-security-testing` | 元测 | `@yottameta/yotta-security-testing` | 0.3.1 | 有纪律的 AI 安全测试方法论 + Scope Guard 五道防线 |
-| `yotta-agent-hardening` | 元安全 | `@yottameta/yotta-agent-hardening` | 0.2.6 | 防御向 AI 智能体自身安全加固（配置面静态扫描三域） |
-| `yotta-skill-creator` | 元造 | `@yottameta/yotta-skill-creator` | 0.1.3 | 工坊「造」：端到端造技能脚手架 |
-| `yotta-publish-guard` | 元守 | `@yottameta/yotta-publish-guard` | 0.4.2 | 工坊「守」：发布前守门（版本四件对齐 + 三通道查重） |
-| `yotta-logwatch` | 元察 | `@yottameta/yotta-logwatch` | 0.3.0 | 安全日志分析检测引擎（攻击链识别/告警聚合） |
-| `yotta-intel` | 元情 | `@yottameta/yotta-intel` | 0.2.1 | 威胁情报 IOC 提取与规范化引擎（STIX-lite） |
-| `yotta-secret` | 元钥 | `@yottameta/yotta-secret` | 0.2.1 | 密钥 / 凭据泄露源头扫描引擎 |
-| `yotta-chain` | 元链 | `@yottameta/yotta-chain` | 0.1.4 | 供应链依赖校验引擎 |
-| `yotta-triage` | 元鉴 | `@yottameta/yotta-triage` | 0.1.3 | 恶意样本静态初筛引擎（哈希/熵/字符串/PE-ELF） |
-| `yotta-prompt` | 元引 | `@yottameta/yotta-prompt` | 0.2.3 | 意图澄清 + 生态入口（常驻注入，map 串联元阁全家） |
-| `yotta-verify` | 元信 | `@yottameta/yotta-verify` | 0.3.3 | 装前安全扫描器 + audited 徽章（prompt injection + 危险模式） |
-| `yotta-compliance` | 元规 | `@yottameta/yotta-compliance` | 0.1.0 | 本地确定性合规条款审查（PIPL + 数据出境规则包 / 证据锚点 / 框架覆盖分级） |
-| `yotta-mirror` | 元镜 | `@yottameta/yotta-mirror` | 0.1.0 | 本地确定性学情分析（知识点掌握率 / 分层与临界生 / 薄弱点诊断，学生数据不出本机） |
-| `yotta-lesson` | 元案 | `@yottameta/yotta-lesson` | 0.1.0 | 本地确定性教案骨架与覆盖校验（课标映射 / 环节时间精确分配 / 缺口检查） |
-| `yotta-item` | 元题 | `@yottameta/yotta-item` | 0.1.0 | 本地确定性组卷与试卷校验（双向细目表 / 题库选题 / 缺口检查） |
-| `yotta-school-doc` | 元公 | `@yottameta/yotta-school-doc` | 0.1.2 | 本地确定性学校公文可信起草与校验（文种规则包 / 可复算骨架 / 12 类缺口） |
+| `yotta-anti-shallow` | 元谨 | `@yottameta/yotta-anti-shallow` | 1.4.2 | 防 AI 敷衍规则引擎（深入分析/根因追溯时激活） |
+| `yotta-code-quality` | 元质 | `@yottameta/yotta-code-quality` | 0.4.2 | 结对式代码质量评审（十二类腐化风险 + 0-100 健康分） |
+| `yotta-workflow` | 元序 | `@yottameta/yotta-workflow` | 0.4.3 | 跨会话/跨项目通用工作流协议（状态就近存） |
+| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.20.1 | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
+| `yotta-learn` | 元习 | `@yottameta/yotta-learn` | 0.2.2 | 学习沉淀 CLI：错误/纠正/洞见沉淀为 .learnings/ 条目 |
+| `yotta-security-audit` | 元安 | `@yottameta/yotta-security-audit` | 0.3.1 | 安全扫描引擎：13 类检测器 + 系统安全基线 + 学生数据隐私（教育版） |
+| `yotta-vetter` | 元审 | `@yottameta/yotta-vetter` | 0.2.7 | 安全审查协议：四阶段 review + SAFE TO INSTALL 判定 |
+| `yotta-recon` | 元析 | `@yottameta/yotta-recon` | 0.1.8 | 跨智能体网络侦察：零依赖端口/服务/版本指纹探测 |
+| `yotta-guardian` | 元盾 | `@yottameta/yotta-guardian` | 0.1.8 | 跨智能体危险调用拦截护栏：确定性规则 + 可插拔意图验证 |
+| `yotta-humanize` | 元真 | `@yottameta/yotta-humanize` | 0.2.2 | 去 AI 味中文写作编辑：检测器引擎 |
+| `yotta-logs` | 元史 | `@yottameta/yotta-logs` | 0.3.3 | 跨智能体历史会话 / 记忆日志检索 |
+| `yotta-security-testing` | 元测 | `@yottameta/yotta-security-testing` | 0.3.2 | 有纪律的 AI 安全测试方法论 + Scope Guard 五道防线 |
+| `yotta-agent-hardening` | 元安全 | `@yottameta/yotta-agent-hardening` | 0.2.7 | 防御向 AI 智能体自身安全加固（配置面静态扫描三域） |
+| `yotta-skill-creator` | 元造 | `@yottameta/yotta-skill-creator` | 0.1.5 | 工坊「造」：端到端造技能脚手架 |
+| `yotta-publish-guard` | 元守 | `@yottameta/yotta-publish-guard` | 0.4.3 | 工坊「守」：发布前守门（版本四件对齐 + 三通道查重） |
+| `yotta-logwatch` | 元察 | `@yottameta/yotta-logwatch` | 0.3.1 | 安全日志分析检测引擎（攻击链识别/告警聚合） |
+| `yotta-intel` | 元情 | `@yottameta/yotta-intel` | 0.2.2 | 威胁情报 IOC 提取与规范化引擎（STIX-lite） |
+| `yotta-secret` | 元钥 | `@yottameta/yotta-secret` | 0.2.2 | 密钥 / 凭据泄露源头扫描引擎 |
+| `yotta-chain` | 元链 | `@yottameta/yotta-chain` | 0.1.5 | 供应链依赖校验引擎 |
+| `yotta-triage` | 元鉴 | `@yottameta/yotta-triage` | 0.1.4 | 恶意样本静态初筛引擎（哈希/熵/字符串/PE-ELF） |
+| `yotta-prompt` | 元引 | `@yottameta/yotta-prompt` | 0.2.4 | 意图澄清 + 生态入口（常驻注入，map 串联元阁全家） |
+| `yotta-verify` | 元信 | `@yottameta/yotta-verify` | 0.3.4 | 装前安全扫描器 + audited 徽章（prompt injection + 危险模式） |
+| `yotta-compliance` | 元规 | `@yottameta/yotta-compliance` | 0.1.1 | 本地确定性合规条款审查（PIPL + 数据出境规则包 / 证据锚点 / 框架覆盖分级） |
+| `yotta-mirror` | 元镜 | `@yottameta/yotta-mirror` | 0.1.1 | 本地确定性学情分析（知识点掌握率 / 分层与临界生 / 薄弱点诊断，学生数据不出本机） |
+| `yotta-lesson` | 元案 | `@yottameta/yotta-lesson` | 0.1.2 | 本地确定性教案骨架与覆盖校验（课标映射 / 环节时间精确分配 / 缺口检查） |
+| `yotta-item` | 元题 | `@yottameta/yotta-item` | 0.1.1 | 本地确定性组卷与试卷校验（双向细目表 / 题库选题 / 缺口检查） |
+| `yotta-school-doc` | 元公 | `@yottameta/yotta-school-doc` | 0.1.3 | 本地确定性学校公文可信起草与校验（文种规则包 / 可复算骨架 / 12 类缺口） |
 
 ## 家族分布
 

package/scan-policy.json

@@ -7,8 +7,8 @@
   ],
   "skills": {
     "yotta-anti-shallow": {
-      "version": "1.4.1",
-      "treeHash": "sha256:81fbbb00cb39ff09f8c6a35e6099228bfadcd71394cace26e5ca61d87cba5e56",
+      "version": "1.4.2",
+      "treeHash": "sha256:f27ea5f8171bb340b4b4e9bdf18ddd9f0f02e480b2d1c7f521b87e17fde6005b",
       "files": 7,
       "bytes": 220568,
       "mode": "strict",
@@ -28,10 +28,10 @@
       ]
     },
     "yotta-chain": {
-      "version": "0.1.4",
-      "treeHash": "sha256:ba455f7460fc0b0b6469d57cbd13b60c7a103fb85c0619bb5f61efcd4085f5a2",
+      "version": "0.1.5",
+      "treeHash": "sha256:916313781a095d62752ab70f31c8de7f2f68a1a175cac0aae0f0efbf105254e4",
       "files": 9,
-      "bytes": 274372,
+      "bytes": 274617,
       "mode": "strict",
       "exceptions": [
         {
@@ -59,10 +59,10 @@
       ]
     },
     "yotta-guardian": {
-      "version": "0.1.7",
-      "treeHash": "sha256:7bc0b09d06b6b6dbbb8cb29601ccdb2a41b1b9bdfd96d78af2c10ede035dce16",
+      "version": "0.1.8",
+      "treeHash": "sha256:9e88214c3f30c142f37ab031cf459f9f3a3c8899d17c2850a00a2367d1afcf58",
       "files": 13,
-      "bytes": 267260,
+      "bytes": 267505,
       "mode": "detection",
       "exceptions": [
         {
@@ -104,10 +104,10 @@
       ]
     },
     "yotta-logwatch": {
-      "version": "0.3.0",
-      "treeHash": "sha256:fbe53b95f9fb738555f2936c8285fa6857613328d0c667f73a259fb3bccfbef5",
+      "version": "0.3.1",
+      "treeHash": "sha256:cffa6e8b7cda1dd2d4846c5f545d99e67a5fa9efe02caad209c78110baa20c9f",
       "files": 13,
-      "bytes": 267453,
+      "bytes": 267698,
       "mode": "detection",
       "exceptions": [
         {
@@ -197,10 +197,10 @@
       ]
     },
     "yotta-memory": {
-      "version": "0.20.0",
-      "treeHash": "sha256:b105f6a7ab46da3cf538c45b3776570d9a82577510fda0864f52fb3a7911d7c3",
+      "version": "0.20.1",
+      "treeHash": "sha256:605b49cda99c787cd45c22309d65d4f935111fe4bbd8938bf3a1f0e80072db00",
       "files": 18,
-      "bytes": 1176014,
+      "bytes": 1183380,
       "mode": "strict",
       "exceptions": [
         {
@@ -313,10 +313,10 @@
       ]
     },
     "yotta-recon": {
-      "version": "0.1.7",
-      "treeHash": "sha256:d3d04d34fe4416017b8b4304b0ce78bc1447b908f7d01747826924cde2adead2",
+      "version": "0.1.8",
+      "treeHash": "sha256:d14ec30bc41d7be925d3e6b25d5e4c3ad373d5db0f3d56da57fcfd69fdfc190e",
       "files": 11,
-      "bytes": 275665,
+      "bytes": 275910,
       "mode": "detection",
       "exceptions": [
         {
@@ -346,10 +346,10 @@
       ]
     },
     "yotta-security-audit": {
-      "version": "0.3.0",
-      "treeHash": "sha256:bffcb3573f64b11d2b78e6aa5793e6db35f1f429f9a7dc7ad2b49cd8ab25ea8c",
+      "version": "0.3.1",
+      "treeHash": "sha256:09f72de0959ff8a31e612023c2ad73b843897bb687cb353b3c3b89c3df0bf374",
       "files": 15,
-      "bytes": 355942,
+      "bytes": 356187,
       "mode": "detection",
       "exceptions": [
         {
@@ -399,10 +399,10 @@
       ]
     },
     "yotta-triage": {
-      "version": "0.1.3",
-      "treeHash": "sha256:f1dabde26bf05cf9b36cc28ebe5522ba3af558a6824306bd4a85ad583684df5c",
+      "version": "0.1.4",
+      "treeHash": "sha256:d52fdc61de486235b0396ccdb9fdad5adb4933f7539e6c7c3aa38b3006ea8ce8",
       "files": 10,
-      "bytes": 233925,
+      "bytes": 234170,
       "mode": "detection",
       "exceptions": [
         {
@@ -468,10 +468,10 @@
       ]
     },
     "yotta-vetter": {
-      "version": "0.2.6",
-      "treeHash": "sha256:691ff78f9a7e1a46d1595d97b6a97d84e94bdcb5c159f9d743f7f0e875063382",
+      "version": "0.2.7",
+      "treeHash": "sha256:02935b4b9d146f09acb80a9219cc156523f56c626db5a8c9a139722a16a65564",
       "files": 11,
-      "bytes": 222254,
+      "bytes": 222499,
       "mode": "strict",
       "exceptions": [
         {

package/scripts/yotta-skills-mcp.py

@@ -27,7 +27,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-VERSION = "0.23.1"
+VERSION = "0.23.3"
 TOOL_NAME = "yotta-skills"
 CN_NAME = "元阁"
 MCP_PROTOCOL_MODERN = "2026-07-28"

package/skill-manifest.json

@@ -3,7 +3,7 @@
   "slug": "yotta-skills",
   "name": "元阁",
   "package": "@yottameta/yotta-skills",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "trust": "yottameta",
   "install": {
     "idempotent": true

package/skills.json

@@ -1,195 +1,195 @@
 {
   "manifestVersion": 1,
-  "updated": "2026-09-30",
+  "updated": "2026-10-01",
   "note": "清单同步要求：每次技能发布新版本后，按 YottaSkills 技能登记表更新本文件（登记表为内部台账，不随包分发）。",
   "skills": [
     {
       "slug": "yotta-anti-shallow",
       "name": "元谨",
       "pkg": "@yottameta/yotta-anti-shallow",
-      "version": "1.4.1",
+      "version": "1.4.2",
       "desc": "防 AI 敷衍规则引擎（深入分析/根因追溯时激活）"
     },
     {
       "slug": "yotta-code-quality",
       "name": "元质",
       "pkg": "@yottameta/yotta-code-quality",
-      "version": "0.4.1",
+      "version": "0.4.2",
       "desc": "结对式代码质量评审（十二类腐化风险 + 0-100 健康分）"
     },
     {
       "slug": "yotta-workflow",
       "name": "元序",
       "pkg": "@yottameta/yotta-workflow",
-      "version": "0.4.2",
+      "version": "0.4.3",
       "desc": "跨会话/跨项目通用工作流协议（状态就近存）"
     },
     {
       "slug": "yotta-memory",
       "name": "元忆",
       "pkg": "@yottameta/yotta-memory",
-      "version": "0.20.0",
+      "version": "0.20.1",
       "desc": "有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT）"
     },
     {
       "slug": "yotta-learn",
       "name": "元习",
       "pkg": "@yottameta/yotta-learn",
-      "version": "0.2.1",
+      "version": "0.2.2",
       "desc": "学习沉淀 CLI：错误/纠正/洞见沉淀为 .learnings/ 条目"
     },
     {
       "slug": "yotta-security-audit",
       "name": "元安",
       "pkg": "@yottameta/yotta-security-audit",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "desc": "安全扫描引擎：13 类检测器 + 系统安全基线 + 学生数据隐私（教育版）"
     },
     {
       "slug": "yotta-vetter",
       "name": "元审",
       "pkg": "@yottameta/yotta-vetter",
-      "version": "0.2.6",
+      "version": "0.2.7",
       "desc": "安全审查协议：四阶段 review + SAFE TO INSTALL 判定"
     },
     {
       "slug": "yotta-recon",
       "name": "元析",
       "pkg": "@yottameta/yotta-recon",
-      "version": "0.1.7",
+      "version": "0.1.8",
       "desc": "跨智能体网络侦察：零依赖端口/服务/版本指纹探测"
     },
     {
       "slug": "yotta-guardian",
       "name": "元盾",
       "pkg": "@yottameta/yotta-guardian",
-      "version": "0.1.7",
+      "version": "0.1.8",
       "desc": "跨智能体危险调用拦截护栏：确定性规则 + 可插拔意图验证"
     },
     {
       "slug": "yotta-humanize",
       "name": "元真",
       "pkg": "@yottameta/yotta-humanize",
-      "version": "0.2.1",
+      "version": "0.2.2",
       "desc": "去 AI 味中文写作编辑：检测器引擎"
     },
     {
       "slug": "yotta-logs",
       "name": "元史",
       "pkg": "@yottameta/yotta-logs",
-      "version": "0.3.2",
+      "version": "0.3.3",
       "desc": "跨智能体历史会话 / 记忆日志检索"
     },
     {
       "slug": "yotta-security-testing",
       "name": "元测",
       "pkg": "@yottameta/yotta-security-testing",
-      "version": "0.3.1",
+      "version": "0.3.2",
       "desc": "有纪律的 AI 安全测试方法论 + Scope Guard 五道防线"
     },
     {
       "slug": "yotta-agent-hardening",
       "name": "元安全",
       "pkg": "@yottameta/yotta-agent-hardening",
-      "version": "0.2.6",
+      "version": "0.2.7",
       "desc": "防御向 AI 智能体自身安全加固（配置面静态扫描三域）"
     },
     {
       "slug": "yotta-skill-creator",
       "name": "元造",
       "pkg": "@yottameta/yotta-skill-creator",
-      "version": "0.1.3",
+      "version": "0.1.5",
       "desc": "工坊「造」：端到端造技能脚手架"
     },
     {
       "slug": "yotta-publish-guard",
       "name": "元守",
       "pkg": "@yottameta/yotta-publish-guard",
-      "version": "0.4.2",
+      "version": "0.4.3",
       "desc": "工坊「守」：发布前守门（版本四件对齐 + 三通道查重）"
     },
     {
       "slug": "yotta-logwatch",
       "name": "元察",
       "pkg": "@yottameta/yotta-logwatch",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "desc": "安全日志分析检测引擎（攻击链识别/告警聚合）"
     },
     {
       "slug": "yotta-intel",
       "name": "元情",
       "pkg": "@yottameta/yotta-intel",
-      "version": "0.2.1",
+      "version": "0.2.2",
       "desc": "威胁情报 IOC 提取与规范化引擎（STIX-lite）"
     },
     {
       "slug": "yotta-secret",
       "name": "元钥",
       "pkg": "@yottameta/yotta-secret",
-      "version": "0.2.1",
+      "version": "0.2.2",
       "desc": "密钥 / 凭据泄露源头扫描引擎"
     },
     {
       "slug": "yotta-chain",
       "name": "元链",
       "pkg": "@yottameta/yotta-chain",
-      "version": "0.1.4",
+      "version": "0.1.5",
       "desc": "供应链依赖校验引擎"
     },
     {
       "slug": "yotta-triage",
       "name": "元鉴",
       "pkg": "@yottameta/yotta-triage",
-      "version": "0.1.3",
+      "version": "0.1.4",
       "desc": "恶意样本静态初筛引擎（哈希/熵/字符串/PE-ELF）"
     },
     {
       "slug": "yotta-prompt",
       "name": "元引",
       "pkg": "@yottameta/yotta-prompt",
-      "version": "0.2.3",
+      "version": "0.2.4",
       "desc": "意图澄清 + 生态入口（常驻注入，map 串联元阁全家）"
     },
     {
       "slug": "yotta-verify",
       "name": "元信",
       "pkg": "@yottameta/yotta-verify",
-      "version": "0.3.3",
+      "version": "0.3.4",
       "desc": "装前安全扫描器 + audited 徽章（prompt injection + 危险模式）"
     },
     {
       "slug": "yotta-compliance",
       "name": "元规",
       "pkg": "@yottameta/yotta-compliance",
-      "version": "0.1.0",
+      "version": "0.1.1",
       "desc": "本地确定性合规条款审查（PIPL + 数据出境规则包 / 证据锚点 / 框架覆盖分级）"
     },
     {
       "slug": "yotta-mirror",
       "name": "元镜",
       "pkg": "@yottameta/yotta-mirror",
-      "version": "0.1.0",
+      "version": "0.1.1",
       "desc": "本地确定性学情分析（知识点掌握率 / 分层与临界生 / 薄弱点诊断，学生数据不出本机）"
     },
     {
       "slug": "yotta-lesson",
       "name": "元案",
       "pkg": "@yottameta/yotta-lesson",
-      "version": "0.1.0",
+      "version": "0.1.2",
       "desc": "本地确定性教案骨架与覆盖校验（课标映射 / 环节时间精确分配 / 缺口检查）"
     },
     {
       "slug": "yotta-item",
       "name": "元题",
       "pkg": "@yottameta/yotta-item",
-      "version": "0.1.0",
+      "version": "0.1.1",
       "desc": "本地确定性组卷与试卷校验（双向细目表 / 题库选题 / 缺口检查）"
     },
     {
       "slug": "yotta-school-doc",
       "name": "元公",
       "pkg": "@yottameta/yotta-school-doc",
-      "version": "0.1.2",
+      "version": "0.1.3",
       "desc": "本地确定性学校公文可信起草与校验（文种规则包 / 可复算骨架 / 12 类缺口）"
     }
   ]