@heihei0299/matt-skills 2.0.2 → 2.1.0

package/.agents/skills/tdd-implement/scripts/scan-sensitive.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Deterministic staged-diff secret scan for the tdd-implement deliver gate.
+# Only ADDED lines are inspected: removing a leaked secret must never be blocked.
+# Match contents are never echoed, so detected credentials do not leak into agent/log output.
+# FAIL: structured assignments and private-key blocks.
+# WARN: bare keywords that may legitimately appear in documentation.
+set -euo pipefail
+
+if [[ $# -gt 1 || ( $# -eq 1 && "$1" != "--staged-only" ) ]]; then
+  echo "usage: $0 [--staged-only]" >&2
+  exit 2
+fi
+
+fail_patterns='(api[_-]?key|secret|token|passwd|password)[[:space:]]*[=:][[:space:]]*[^[:space:]]{8,}|BEGIN (RSA|OPENSSH|EC|DSA) PRIVATE KEY'
+warn_patterns='(api[_-]?key|secret|token|passwd|password|\.env)'
+
+# Strip diff metadata and deletions. The scanner cares only about content that the
+# commit would introduce, not secrets that the commit is removing.
+added_lines=$(
+  git diff --cached --unified=0 --no-color \
+    | awk '/^\+\+\+ / { next } /^\+/ { print substr($0, 2) }'
+)
+
+fail=0
+
+if grep -qiE "$fail_patterns" <<< "$added_lines"; then
+  echo "❌ Possible structured secret found in ADDED staged content — remove or redact it before committing." >&2
+  fail=1
+else
+  echo "✅ No structured secrets in added staged content."
+fi
+
+if grep -qiE "$warn_patterns" <<< "$added_lines"; then
+  echo "⚠  Sensitive keyword found in ADDED staged content — inspect the staged diff manually." >&2
+fi
+
+exit "$fail"

package/README.md

@@ -1,6 +1,6 @@
 # matt-skills
 
-mattpocock/skills（`skills/engineering` + `skills/productivity`）的配置仓库：工作区内容镜像为 `template/` 模板快照，以 npm 包 `@heihei0299/matt-skills` 分发，目标仓库一条命令即完成初始化。
+mattpocock/skills（`skills/engineering` + `skills/productivity`）的配置仓库：工作区维护完整 skill 集合，其中一部分 proprietary skill 只供本仓库使用；`template/` 只包含可分发内容，以 npm 包 `@heihei0299/matt-skills` 分发，目标仓库一条命令即完成初始化。
 
 ## 模板结构
 
@@ -8,7 +8,7 @@ mattpocock/skills（`skills/engineering` + `skills/productivity`）的配置仓
 template/
 ├── AGENTS.md         项目级全局配置（行为路由 + 分文件指针）
 ├── .agents/
-│   └── skills/       33 个技能（上游 26 + 独有 6：ci-guard、tdd-implement、grill-to-spec、diagnose-fix、commit-check、scaffold-functional-test；另含 show-me）单一源；模板全量 33，默认安装编程相关 26（engineering 18 + 独有所需 1 + 核心独有 4，见 config/engineering.json 与 config/required.json），--all 展开全量
+│   └── skills/       workspace 的完整 skill 单一源；template 只携带可分发 skill，默认安装 programming 范围，--all 展开全部可分发 skill
 ├── .pi/              pi-agent 项目配置
 │   ├── skills/       空占位（项目自定义技能，含 .gitkeep + README.md）
 │   ├── prompts/      issue-audit 命令（prompt template）
@@ -17,39 +17,60 @@ template/
 └── .opencode/        opencode 项目配置
     ├── skills/       空占位（项目自定义技能，含 .gitkeep + README.md）
     ├── agents/       issue-audit 子代理定义
-│    ├── commands/     issue-audit + 10 个显式触发技能命令（grill-to-spec/wayfinder/to-spec/to-tickets/triage/improve-codebase-architecture/teach/handoff/writing-for-agents/commit-check）
+    ├── commands/     issue-audit + 可分发的显式触发技能命令（grill-to-spec/wayfinder/to-spec/to-tickets/triage/improve-codebase-architecture/teach/handoff/writing-for-agents）
     ├── docs/agents/  5 个分文件（运行时纪律 / 技能设计 / issue tracker / triage labels / domain）
     ├── CONTEXT.md    术语表
     ├── package.json  插件依赖清单
     └── .gitignore
 ```
 
+## 独有 skill 分发边界
+
+本仓库维护 7 个独有（proprietary）skill：
+
+### 可分发的 5 个
+
+- `tdd-implement`
+- `diagnose-fix`
+- `grill-to-spec`
+- `scaffold-functional-test`
+- `show-me`
+
+默认 programming 范围中的 4 个独有 skill 是 `tdd-implement`、`diagnose-fix`、`grill-to-spec`、`show-me`；`scaffold-functional-test` 可分发但默认可选。
+
+### 仓库内部的 2 个
+
+- `ci-guard`
+- `commit-check`
+
+`ci-guard` 和 `commit-check` 只服务 matt-skills 仓库自身，不会通过 `list`、`install`、`init`、`sync`、`--all` 或 global install 分发到用户项目。workspace 保留完整集合，template 只包含可分发集合。
+
 ## 初始化
 
 在目标仓库根目录执行一条命令：
 
 ```sh
-npx @heihei0299/matt-skills init              # 默认编程相关 26（engineering 18 + 独有所需 4 + 核心独有 4），--all 展开全量 33
-npx @heihei0299/matt-skills init --all       # 安装全量 33（含 productivity）
+npx @heihei0299/matt-skills init              # 默认 programming 范围
+npx @heihei0299/matt-skills init --all       # 安装全部可分发 skill（含 productivity）
 ```
 
-`init` 默认只在目标没有 `AGENTS.md` 时初始化；已有项目默认跳过以保护定制，显式 `init --all` 会刷新模板并安装/覆盖全量 33 个 skill。模板全量 33，默认仅安装默认范围 26（engineering 18 + 独有所需 4 + 核心独有 4，见 config/engineering.json 与 config/required.json），无需二次拉取上游。
+`init` 默认只在目标没有 `AGENTS.md` 时初始化；已有项目默认跳过以保护定制，显式 `init --all` 会刷新模板并安装/覆盖全部可分发 skill。模板已经包含可分发内容，无需二次拉取上游；repo-local skill 不会进入目标项目。
 
-选项：`--dest <path>` 指定目标目录（默认当前目录）；`--all` 包含非编程技能（productivity，默认编程 26：engineering 18 + 独有所需 4 + 核心独有 4）；已有目标使用 `init --all` 刷新，普通 `init` 跳过。
+选项：`--dest <path>` 指定目标目录（默认当前目录）；`--all` 包含全部可分发的非默认 skill（包括 productivity 和 optional proprietary）；已有目标使用 `init --all` 刷新，普通 `init` 跳过。
 **增量同步（已有项目）**：已有项目更新到最新模板与技能：
 
 ```sh
-npx @heihei0299/matt-skills sync                                 # 默认安全增量：AGENTS.md 有定制则跳过，默认技能 26 rm+cp（不删多余）
-npx @heihei0299/matt-skills sync --all                           # 仅更新同名技能内容（存在则覆盖，不存在则新增）并更新 AGENTS.md（不跳过定制），不删多余
-npx @heihei0299/matt-skills sync --dry-run --json                # 预演：只比对不写盘（默认范围，--all 全量可透传）
+npx @heihei0299/matt-skills sync                                 # 默认安全增量：同步默认 programming skill（不删多余）
+npx @heihei0299/matt-skills sync --all                           # 同步全部可分发 skill（不删多余）
+npx @heihei0299/matt-skills sync --dry-run --json                # 预演：只比对不写盘（默认范围，--all 可透传）
 npx @heihei0299/matt-skills sync --dest <path> --upstream <url> --ref <ref> --json  # 选项可组合
 ```
 
-`sync` 专为已有项目设计，两档语义：`--dry-run` 仅对比不写盘（默认范围 engineering + 独有所需，`--all` 展开全量同名集合，打印“上游 HEAD / 本地非独有 vs 上游 / 新增/更新/删除/一致”表，`--json` 可解析，有差异 `exit 1`）；默认安全增量写盘（`AGENTS.md` 若含 `tdd-implement` 则跳过，`.agents/skills` 按默认范围 26 `rm+cp` 覆盖但不删多余，`template/.opencode/.pi` 增量 `add/update`，旧镜像 `.pi/skills` + `.opencode/skills` 中残留共享技能自动清理但保留项目自定义）；`--all` 仅更新同名技能内容（存在则覆盖，不存在则新增）并更新 `AGENTS.md`（不跳过定制），不删多余。`--dest`、`--upstream`、`--ref`、`--json`、`--all`、`--dry-run` 可透传。
-目标仓库会话即自动加载共享技能（`.agents/skills/` 单一源，默认编程 26，`--all` 全量 33）与项目级全局配置（行为路由表、分文件约定）；项目自定义技能可按需放入 `.pi/skills/` 或 `.opencode/skills/`（按 harness 自动发现）；`issue-audit` 以子代理 + 命令形式分发（`.opencode/agents/`、`.opencode/commands/`）；10 个显式触发技能注册为 opencode 命令（`.opencode/commands/`，`/命令名` 触发）。
-**pi-agent 用户**：初始化命令完全相同。pi 从 `.agents/skills/` 自动发现全部共享技能，无需额外指向；`.pi/skills/` 仅用于项目自定义。首次在目标仓库交互启动时 pi 会询问项目信任，用 `/trust` 保存即可。
+`sync` 专为已有项目设计，两档语义：写盘模式下默认同步默认 programming 范围，`--all` 同步全部可分发 skill；`--dry-run` 仅对比上游、不写盘，默认比较 engineering + required 的上游部分，`--all` 比较全量上游范围，打印“上游 HEAD / 本地非独有 vs 上游 / 新增/更新/删除/一致”表，`--json` 可解析，有差异 `exit 1`。上游 dry-run/check 不比较 proprietary，因为它们不属于上游；默认安全增量写盘不删多余，模板配置增量更新，旧镜像中的共享 skill 自动清理但保留项目自定义。repo-local skill 永远不新增、不覆盖、不删除，发现历史副本时只提示保留。`--dest`、`--upstream`、`--ref`、`--json`、`--all`、`--dry-run` 可透传。
+目标仓库会话即自动加载可分发共享技能（`.agents/skills/` 单一源）与项目级全局配置（行为路由表、分文件约定）；项目自定义技能可按需放入 `.pi/skills/` 或 `.opencode/skills/`（按 harness 自动发现）；`issue-audit` 以子代理 + 命令形式分发（`.opencode/agents/`、`.opencode/commands/`）；可分发的显式触发技能注册为 opencode 命令（`.opencode/commands/`，`/命令名` 触发）。
+**pi-agent 用户**：初始化命令完全相同。pi 从 `.agents/skills/` 自动发现全部可分发共享技能，无需额外指向；`.pi/skills/` 仅用于项目自定义。首次在目标仓库交互启动时 pi 会询问项目信任，用 `/trust` 保存即可。
 
-**手动方式（备选）**：无 npx 环境时，将 `template/` 整个文件夹复制到目标仓库根目录即可（已含全量技能）：
+**手动方式（备选）**：无 npx 环境时，将 `template/` 整个文件夹复制到目标仓库根目录即可（已含全部可分发 skill）：
 
 ```sh
 cp -r template/. /path/to/target/
@@ -67,9 +88,9 @@ git clone --depth 1 https://github.com/mattpocock/skills.git /tmp/mattpocock-ski
 
 | 工作区 | 模板 |
 |--------|------|
-| `.agents/skills/`（全部 33 个：上游 26 + 独有 7：ci-guard、tdd-implement、grill-to-spec、diagnose-fix、commit-check、scaffold-functional-test、show-me） | `template/.agents/skills/`（全量快照，单一源） |
+| `.agents/skills/`（workspace 完整 skill 集合：upstream + proprietary） | `template/.agents/skills/`（仅可分发 skill） |
 | `.agents/skills/` 的 harness 占位说明 | `template/.pi/skills/.gitkeep` + `README.md`、`template/.opencode/skills/.gitkeep` + `README.md`（空目录占位，供项目自定义） |
-│   │   ├── commands/     issue-audit + 10 个显式触发技能命令（grill-to-spec/wayfinder/to-spec/to-tickets/triage/improve-codebase-architecture/teach/handoff/writing-for-agents/commit-check）
+│   │   ├── commands/     issue-audit + 可分发的显式触发技能命令（grill-to-spec/wayfinder/to-spec/to-tickets/triage/improve-codebase-architecture/teach/handoff/writing-for-agents）
 | `.pi/prompts/issue-audit.md`（pi 命令：opencode 版适配，去 subagent frontmatter） | `template/.pi/prompts/issue-audit.md` |
 | `AGENTS.md` | `template/AGENTS.md`（引用映射为 `.opencode/` 路径） |
 | `CONTEXT.md` | `template/.opencode/CONTEXT.md` + `template/.pi/CONTEXT.md` |
@@ -78,7 +99,7 @@ git clone --depth 1 https://github.com/mattpocock/skills.git /tmp/mattpocock-ski
 共享技能统一在 `.agents/skills` 单一源，不再双份镜像到 `.opencode/skills` / `.pi/skills`。
 `test/template-sync.test.js` 守护同步（含路径映射），漏同步测试即红。
 
-新增技能前先查上游 `mattpocock/skills` 是否已存在；仅上游没有的技能才作为独有技能落在本仓库（当前独有：ci-guard、tdd-implement、grill-to-spec、diagnose-fix、commit-check、scaffold-functional-test），上游技能通过 `scripts/sync-upstream.js` 同步到 `.agents/skills` 后随模板分发。
+新增技能前先查上游 `mattpocock/skills` 是否已存在；仅上游没有的技能才作为 proprietary skill 落在本仓库。Proprietary skill 再分为 distributable 和 repo-local：后者只服务本仓库，不进入 template 或任何用户安装路径。上游技能通过 `scripts/sync-upstream.js` 同步到 `.agents/skills` 后，只有可分发内容会进入模板。
 
 ## harness 支持
 
@@ -119,13 +140,13 @@ CODEX_E2E=1 npm run codex:smoke             # 显式运行真实 smoke test
 
 - **全局**：`~/.pi/agent/skills/`、`~/.agents/skills/`（用户级技能，自动发现）；配置在 `~/.pi/agent/settings.json`
 - **项目**：
-  - `.agents/skills/` — 共享技能单一源（默认编程 26，`--all` 全量 32，自动发现）
+  - `.agents/skills/` — 可分发共享技能单一源（默认 programming，`--all` 全部可分发，自动发现）
   - `.pi/skills/` — 项目自定义技能（pi 标准结构，自动发现，仅放项目本地技能）
   - `.pi/prompts/` — pi 命令（prompt template）自动发现，如 `issue-audit.md` → `/issue-audit`
   - `.pi/settings.json` — 已简化为空对象（历史指向 `.opencode/skills` 已移除，共享技能走 `.agents/skills`）
 ### opencode
 
-- **项目**：`.agents/skills/`（共享技能单一源，默认编程 26，`--all` 全量 33）、`.opencode/skills/`（项目自定义技能）、`.opencode/agents/`（子代理）、`.opencode/commands/`（命令：issue-audit + 10 个显式触发技能，`/命令名` 触发）、`.opencode/docs/`（文档）
+- **项目**：`.agents/skills/`（可分发共享技能单一源，默认 programming，`--all` 全部可分发）、`.opencode/skills/`（项目自定义技能）、`.opencode/agents/`（子代理）、`.opencode/commands/`（命令：issue-audit + 可分发显式触发技能，`/命令名` 触发）、`.opencode/docs/`（文档）
 
 同一份技能（Agent Skills 标准）与 `AGENTS.md` 行为路由在两种 harness 下均可加载：pi 与 codex/claude 从 `.agents/skills/` 自动发现；opencode 按本模板约定同样优先读取 `.agents/skills/`（`.opencode/skills/` 仅用于项目自定义）。
 
@@ -134,23 +155,23 @@ CODEX_E2E=1 npm run codex:smoke             # 显式运行真实 smoke test
 仓库内提供安装管理 CLI（`bin/cli.js`，依赖 `prompts`，见 `package.json`），同时作为 npm 包 `@heihei0299/matt-skills` 分发（`npx @heihei0299/matt-skills <command>`）：
 
 ```sh
-node bin/cli.js init [--dest <dir>] [--all]                               # 初始化项目：template 全量 33，默认编程 26
+node bin/cli.js init [--dest <dir>] [--all]                               # 初始化项目：默认 programming 或全部可分发 skill
 node bin/cli.js sync [--all] [--dry-run] [--dest <path>] [--upstream <url>] [--ref <ref>] [--json]  # 同步已有项目到最新（默认编程，--all 仅同名 upsert + AGENTS.md）
 node bin/cli.js list [--json] [--all]                                            # 列出技能（默认编程）
 node bin/cli.js install [选项]                                                 # 把技能复制到目标工具目录（交互式选择，默认编程）
 node bin/cli.js check [--json] [--all] [--upstream <url>] [--ref <ref>]          # 只读检查上游技能是否最新（等价 sync --dry-run，默认范围）
 ```
 
-`init` 选项：`--dest <path>` 指定目标目录（默认当前目录）；`--all` 包含非编程（productivity，默认编程 26：engineering 18 + 独有所需 1 + 核心独有 4），见「初始化」。
-`sync` 选项：`--all` 仅更新同名技能内容（存在则覆盖，不存在则新增）并更新 `AGENTS.md`（不跳过定制），不删多余；`--dry-run` 预演（只比对不写盘，`--json` 可解析，有差异 `exit 1`）；`--all` 展开同名全量；`--dest <path>` 目标目录；`--upstream <url>` 上游地址；`--ref <ref>` 上游分支；`--json` JSON 输出；默认即安全增量（`AGENTS.md` 有定制则跳过）。
-`check` 选项：`--json`、`--all`（默认范围：engineering + 独有所需）、`--upstream <url>`、`--ref <ref>`（等价 `sync --dry-run`）。
+`init` 选项：`--dest <path>` 指定目标目录（默认当前目录）；`--all` 包含全部可分发 skill，见「初始化」。
+`sync` 选项：写盘时 `--all` 更新全部可分发同名技能内容（存在则覆盖，不存在则新增）并更新 `AGENTS.md`（不跳过定制），不删多余；默认写盘只同步默认 programming；`--dry-run` 只比对上游、不写盘（默认 engineering + required 上游范围，`--all` 为全量上游范围，`--json` 可解析，有差异 `exit 1`）；`--dest <path>` 目标目录；`--upstream <url>` 上游地址；`--ref <ref>` 上游分支；`--json` JSON 输出；默认安全增量会保留目标定制。
+`check` 选项：`--json`、`--all`（默认只比较 engineering + required 上游范围；proprietary 不参与上游 compare）、`--upstream <url>`、`--ref <ref>`（等价 `sync --dry-run`）。
 
 `install` 选项：
 
 - `--dest <dir>`：复制到指定目录（覆盖工具映射）
 - `--tools <t1,t2>`：指定工具，项目级已统一 `codex/pi/opencode/claude → .agents/skills`（共享技能单一源，`.pi/skills`/`.opencode/skills` 仅用于项目自定义）
 - `--global`：安装到全局目录（`~/.codex/skills`、`~/.pi/agent/skills`、`~/.config/opencode/skills`、`~/.claude/skills`）；`--project` 回到项目级
-- `--all`：安装全部技能（默认编程 26，`--all` 33，交互勾选时仅列默认范围）；`--force`：覆盖已存在的技能
+- `--all`：安装全部可分发 skill（交互勾选时默认只列 programming 范围）；`--force`：覆盖已存在的技能
 
 
 ### 上游同步（自动更新）
@@ -160,14 +181,14 @@ node bin/cli.js check [--json] [--all] [--upstream <url>] [--ref <ref>]
 - **本地 CLI**：`matt-skills sync` 两档——`--dry-run` 只读比对（有差异 `exit 1`，`--json` 可解析）、默认安全增量与 `sync --all` 仅同名 upsert + `AGENTS.md`；`matt-skills check [--json] [--upstream <url>] [--ref <ref>]` 为只读别名（等价 `sync --dry-run`）；`matt-skills update` 已合并到 `sync`（执行提示 `update 已合并到 sync` 且 `exit 1`）
 ```sh
 npx @heihei0299/matt-skills sync --dry-run --json              # 预演只读检查，JSON 输出：{ head, counts, result: { added, updated, renamed, removed, same } }
-npx @heihei0299/matt-skills sync                               # 默认安全增量（AGENTS.md 定制跳过，默认技能 26）
+npx @heihei0299/matt-skills sync                               # 默认安全增量（AGENTS.md 定制跳过，默认 programming）
 npx @heihei0299/matt-skills sync --all                         # 仅同名 upsert + AGENTS.md
 npx @heihei0299/matt-skills check --json             # 等价 sync --dry-run
 node scripts/sync-upstream.js --check               # 等价底层脚本（CLI sync/check 的实现）
 node scripts/sync-upstream.js --apply --dry-run
 ```
 
-实现细节：`scripts/sync-upstream.js` 为单一事实源（CLI 与 Actions 共用），以 `config/proprietary.json` 为独有白名单 + `config/engineering.json` 为编程白名单 + `config/required.json` 为独有所需白名单（当前仅 grilling：grill-to-spec 经 grill-with-docs 所需，属 productivity 但默认同步；其余 productivity 默认不装，`--all` 展开），上游通过 `git clone --depth 1 https://github.com/mattpocock/skills.git` 获取，比对 `SKILL.md` 的 sha256，自动处理新增/更新/重命名/删除；Actions 提 PR 后需人工合入，合入后按“发布”节打 `v*` 标签即发布（自动 patch 发版可在后续扩展为 PR 合入后自动 bump）。
+实现细节：`scripts/sync-upstream.js` 为单一事实源（CLI 与 Actions 共用），以 proprietary 分类契约排除本仓库独有 skill，以 `config/engineering.json` 为编程白名单，以 `config/required.json` 为独有所需白名单；上游通过 `git clone --depth 1 https://github.com/mattpocock/skills.git` 获取，比对 `SKILL.md` 的 sha256，自动处理新增/更新/重命名/删除。上游同步只维护 workspace，模板生成时再按 distributable 边界投影。
 上游重命名映射：`RENAMES = { "writing-great-skills": "writing-for-agents" }`，Actions/CLI 均会删除旧目录并复制新目录。
 ## 发布
 
@@ -200,7 +221,7 @@ npm publish
 
 ```sh
 npm test                          # 全量测试
-npm run build:template            # 从单源生成 template/.agents/skills（全量 33 技能）+ 空占位
+npm run build:template            # 从 workspace 生成仅含可分发 skill 的 template + 空占位
 ```
 
 交互模式依赖 `prompts`（见 `package.json`）；测试见 `test/cli.test.js`、`test/cli-init.test.js`、`test/template-sync.test.js`。

package/bin/cli.js

@@ -4,11 +4,17 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import prompts from 'prompts';
+import {
+  PROPRIETARY_SKILLS,
+  isDefaultProgrammingSkill,
+  isDistributableProprietarySkill,
+  isDistributableSkill,
+  isRepoLocalSkill,
+  REPO_LOCAL_SKILLS,
+} from './skill-boundaries.js';
 
 const SKILLS_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '.agents', 'skills');
 const TEMPLATE_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'template');
-const PROPRIETARY_SKILLS = new Set(['ci-guard', 'tdd-implement', 'grill-to-spec', 'diagnose-fix', 'commit-check', 'scaffold-functional-test', 'show-me']);
-const PROPRIETARY_DEFAULT = new Set(['tdd-implement', 'diagnose-fix', 'commit-check', 'grill-to-spec', 'show-me']); // 默认仅装核心 4 + show-me，--all 才装全部 7
 const ENGINEERING_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'config', 'engineering.json');
 const REQUIRED_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'config', 'required.json');
 let ENGINEERING_SKILLS = null;
@@ -34,10 +40,10 @@ async function loadRequiredSkills() {
   return REQUIRED_SKILLS;
 }
 function isProgrammingSkill(name, engineering, required) {
-  return PROPRIETARY_DEFAULT.has(name) || engineering.has(name) || (required && required.has(name));
+  return isDefaultProgrammingSkill(name, engineering, required);
 }
 function isProgrammingAll(name, engineering) {
-  return PROPRIETARY_SKILLS.has(name) || engineering.has(name);
+  return isDistributableProprietarySkill(name) || engineering.has(name);
 }
 process.stdout.on('error', (err) => {
   if (err.code === 'EPIPE') process.exit(0);
@@ -64,9 +70,9 @@ Usage:
 
 Init options:
   --dest <path>   Target directory (default: current directory)
-  --all           Include non-programming skills (productivity) and optional proprietary; default only core programming (engineering 18 + required 4 + default proprietary 4 → 26)
+  --all           Include all distributable skills; default only default programming skills
   --help, -h      Show this help
-提示：已有 AGENTS.md 时普通 init 跳过；显式 init --all 刷新模板并覆盖全量 skills。
+提示：已有 AGENTS.md 时普通 init 跳过；显式 init --all 刷新模板并覆盖全量可分发 skills。
 
 提示：matt-skills --help 查看全量
 `;
@@ -82,7 +88,7 @@ Sync options:
   --dest <path>   Target directory (default: current directory)
   --help, -h      Show this help
 
-说明：默认不带 --all 仅增量同步默认技能（26）且 AGENTS.md 有定制则跳过；--all 时对同名技能 upsert 并强制更新 AGENTS.md。
+说明：默认不带 --all 仅增量同步默认 programming skill 且 AGENTS.md 有定制则跳过；--all 时同步全部可分发 skill 并强制更新 AGENTS.md。
 
 提示：matt-skills --help 查看全量
 `;
@@ -93,7 +99,7 @@ Usage:
   matt-skills list [--all] [--json]
 
 List options:
-  --all           List all skills (default only core programming 26)
+  --all           List all distributable skills (default only default programming skills)
   --json          Output as JSON
   --help, -h      Show this help
 
@@ -106,7 +112,7 @@ Usage:
   matt-skills check [--all] [--json] [--upstream <url>] [--ref <ref>]
 
 Check options:
-  --all           Include non-programming and optional proprietary; default only core programming (26: engineering 18 + required 4 + default proprietary 4)
+  --all           Include the full upstream comparison scope; default engineering + required upstream skills (proprietary excluded)
   --json          Output as JSON
   --upstream <url> Upstream repo URL (default: https://github.com/mattpocock/skills.git)
   --ref <ref>     Upstream ref (default: HEAD)
@@ -122,7 +128,7 @@ Usage:
 
 Install options:
   --tools <a,b>   Install for the given tools (codex, pi, opencode, claude); skips tool selection — 共享技能统一指向 .agents/skills，.pi/skills/.opencode/skills 仅用于项目自定义
-  --all           Install all skills (default only core programming 26); skips skill selection
+  --all           Install all distributable skills (default only default programming); skips skill selection
   --force         Overwrite existing skills
   --global        Install to the user's global skill directories
   --project       Install to project skill directories (default)
@@ -161,6 +167,7 @@ async function listSkills({ onlyProgramming = false } = {}) {
     if (!entry.isDirectory()) continue;
     if (entry.name.endsWith('.bak')) continue;
     if (entry.name === 'skill-creator') continue;
+    if (isRepoLocalSkill(entry.name)) continue;
     if (onlyProgramming && !isProgrammingSkill(entry.name, engineering, required)) continue;
     let content;
     try {
@@ -182,6 +189,13 @@ async function pathExists(p) {
     return false;
   }
 }
+
+function shouldCopyTemplatePath(src) {
+  const relative = path.relative(TEMPLATE_DIR, src);
+  const parts = relative.split(path.sep);
+  return !(parts[0] === '.agents' && parts[1] === 'skills' && isRepoLocalSkill(parts[2]));
+}
+
 const TOOLS = ['codex', 'pi', 'opencode', 'claude'];
 
 // 统一源：共享技能全部在 .agents/skills，harness 的 .pi/skills/.opencode/skills 仅用于项目自定义
@@ -262,6 +276,12 @@ async function installCommand({ dest, all, force, tools, global }) {
     process.stdout.write('未选择任何技能，未安装任何技能\n');
     return;
   }
+  const knownDistributable = new Set(skills.map((skill) => skill.name));
+  for (const name of selected) {
+    if (!isDistributableSkill(name, knownDistributable)) {
+      throw new Error(`${name} is repository-local or unavailable and cannot be distributed`);
+    }
+  }
   for (const { tool, dir } of targets) {
     let installed = 0;
     let skipped = 0;
@@ -287,7 +307,11 @@ async function initCommand({ dest, all }) {
   if (await pathExists(marker) && !all) {
     process.stdout.write('模板已存在（AGENTS.md），跳过\n');
   } else {
-    await cp(TEMPLATE_DIR, target, { recursive: true, force: true });
+    await cp(TEMPLATE_DIR, target, {
+      recursive: true,
+      force: true,
+      filter: shouldCopyTemplatePath,
+    });
     process.stdout.write('模板：已复制（AGENTS.md、.agents/skills、.opencode/、.pi/）\n');
     // 默认范围（engineering + 独有所需 + 默认独有），--all 才保留其余 productivity
     if (onlyProgramming && path.resolve(target) !== path.resolve(path.join(path.dirname(fileURLToPath(import.meta.url)), '..'))) {
@@ -311,7 +335,7 @@ async function initCommand({ dest, all }) {
   let installed = 0;
   try {
     const entries = await readdir(skillsDir, { withFileTypes: true });
-    installed = entries.filter((e) => e.isDirectory() && !e.name.endsWith('.bak') && e.name !== '.git' && e.name !== 'skill-creator').length;
+    installed = entries.filter((e) => e.isDirectory() && !e.name.endsWith('.bak') && e.name !== '.git' && e.name !== 'skill-creator' && !isRepoLocalSkill(e.name)).length;
   } catch {}
   const allSkillsFull = await listSkills({ onlyProgramming: false });
   const engineeringForStats = await loadEngineeringSkills();
@@ -322,12 +346,12 @@ async function initCommand({ dest, all }) {
   const displayTotal = onlyProgramming ? programmingCount : allSkillsFull.length;
   const displayUpstream = onlyProgramming ? upstreamProg : upstreamFull;
   if (path.resolve(skillsDir) === path.resolve(SKILLS_DIR)) {
-    process.stdout.write(`技能：已装 ${installed}、跳过 0（全量 ${allSkillsFull.length}，含上游 ${upstreamFull}；编程 ${programmingCount}，含上游 ${upstreamProg}）\n`);
+    process.stdout.write(`技能：已装 ${installed}、跳过 0（可分发 ${allSkillsFull.length}，含上游 ${upstreamFull}；默认编程 ${programmingCount}，含上游 ${upstreamProg}）\n`);
   } else {
     if (onlyProgramming) {
-      process.stdout.write(`技能：已装 ${installed}（编程 ${displayTotal}，含上游 ${displayUpstream}；全量 ${allSkillsFull.length}，含上游 ${upstreamFull}）\n`);
+      process.stdout.write(`技能：已装 ${installed}（默认编程 ${displayTotal}，含上游 ${displayUpstream}；可分发 ${allSkillsFull.length}，含上游 ${upstreamFull}）\n`);
     } else {
-      process.stdout.write(`技能：已装 ${installed}（全量 ${displayTotal}，含上游 ${displayUpstream}）\n`);
+      process.stdout.write(`技能：已装 ${installed}（可分发 ${displayTotal}，含上游 ${displayUpstream}）\n`);
     }
   }
   process.stdout.write(`目标路径：${target}\n`);
@@ -340,7 +364,7 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
     if (json) {
       process.stdout.write(JSON.stringify({ head: cmp.head, counts: cmp.counts, result: cmp.result, onlyProgramming }, null, 2) + '\n');
     } else {
-      const modeHint = onlyProgramming ? '（默认：engineering + 独有所需）' : '（全量）';
+      const modeHint = onlyProgramming ? '（默认：engineering + 独有所需）' : '（全量上游）';
       const lines = [];
       lines.push(`上游 HEAD: ${cmp.head}`);
       lines.push(`本地非独有: ${cmp.counts.local}  上游: ${cmp.counts.upstream} ${modeHint}`);
@@ -368,7 +392,11 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
   // 模板同步：默认模式下过滤 skills，仅同步默认子集
   async function copyTemplateFiltered() {
     if (!onlyProgramming) {
-      await cp(TEMPLATE_DIR, target, { recursive: true, force: true });
+      await cp(TEMPLATE_DIR, target, {
+        recursive: true,
+        force: true,
+        filter: shouldCopyTemplatePath,
+      });
       return;
     }
     // 默认范围：分别复制非 skills 部分，skills 由后续 allSkills 循环处理
@@ -391,7 +419,11 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
   if (!(await pathExists(marker))) {
     process.stdout.write('未检测到现有项目（AGENTS.md 不存在），将执行全新初始化\n');
     if (onlyProgramming) await copyTemplateFiltered();
-    else await cp(TEMPLATE_DIR, target, { recursive: true, force: true });
+    else await cp(TEMPLATE_DIR, target, {
+      recursive: true,
+      force: true,
+      filter: shouldCopyTemplatePath,
+    });
     process.stdout.write('模板：已复制（AGENTS.md、.agents/skills、.opencode/、.pi/）\n');
   } else {
     process.stdout.write('同步：检测到现有项目，将增量更新\n');
@@ -416,21 +448,30 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
           }
         } catch {}
       } else {
-        await cp(path.join(TEMPLATE_DIR, '.agents'), path.join(target, '.agents'), { recursive: true, force: true });
+        await cp(path.join(TEMPLATE_DIR, '.agents'), path.join(target, '.agents'), {
+          recursive: true,
+          force: true,
+          filter: shouldCopyTemplatePath,
+        });
         await cp(path.join(TEMPLATE_DIR, '.opencode'), path.join(target, '.opencode'), { recursive: true, force: true });
         await cp(path.join(TEMPLATE_DIR, '.pi'), path.join(target, '.pi'), { recursive: true, force: true });
       }
       process.stdout.write('模板：已同步（AGENTS.md 跳过，已含定制）\n');
     } else {
       if (onlyProgramming) await copyTemplateFiltered();
-      else await cp(TEMPLATE_DIR, target, { recursive: true, force: true });
+      else await cp(TEMPLATE_DIR, target, {
+        recursive: true,
+        force: true,
+        filter: shouldCopyTemplatePath,
+      });
       process.stdout.write('模板：已同步（AGENTS.md、.agents/skills、.opencode/、.pi/）\n');
     }
   }
-  // 技能同步：--all 仅更新同名技能内容，存在则覆盖，不存在则新增，并更新 AGENTS.md（由上一步已处理）；默认范围 26，--all 时按全量同名集合处理，不删多余
+  // 技能同步：--all 仅更新同名可分发技能内容，存在则覆盖，不存在则新增，并更新 AGENTS.md（由上一步已处理）；默认范围为默认 programming，不删多余
   const entries = await readdir(SKILLS_DIR, { withFileTypes: true });
   const allNames = entries.filter((e) => e.isDirectory() && !e.name.endsWith('.bak') && e.name !== 'skill-creator' && e.name !== '.git').map((e) => e.name);
   let allSkills = allNames.sort();
+  allSkills = allSkills.filter((name) => !isRepoLocalSkill(name));
   if (onlyProgramming) {
     const engineering = await loadEngineeringSkills();
     const required = await loadRequiredSkills();
@@ -438,6 +479,23 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
   }
   const skillsDir = path.join(target, '.agents', 'skills');
   await mkdir(skillsDir, { recursive: true });
+  const preservedRepoLocal = [];
+  const preserveLocations = [
+    {
+      dir: skillsDir,
+      label: '.agents/skills',
+      isWorkspaceSource: path.resolve(skillsDir) === path.resolve(SKILLS_DIR),
+    },
+    { dir: path.join(target, '.pi', 'skills'), label: '.pi/skills', isWorkspaceSource: false },
+    { dir: path.join(target, '.opencode', 'skills'), label: '.opencode/skills', isWorkspaceSource: false },
+  ];
+  for (const name of REPO_LOCAL_SKILLS) {
+    for (const location of preserveLocations) {
+      if (!location.isWorkspaceSource && await pathExists(path.join(location.dir, name))) {
+        preservedRepoLocal.push(`${location.label}/${name}`);
+      }
+    }
+  }
   let installed = 0;
   let updated = 0;
   for (const name of allSkills) {
@@ -468,7 +526,7 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
       if (!e.isDirectory()) continue;
       if (e.name === '.git' || e.name.endsWith('.bak')) continue;
       if (e.name === '.gitkeep' || e.name === 'README.md') continue;
-      if (allSkills.includes(e.name) || PROPRIETARY_SKILLS.has(e.name)) {
+      if (allSkills.includes(e.name)) {
         await rm(path.join(dir, e.name), { recursive: true, force: true });
       }
     }
@@ -484,7 +542,10 @@ async function syncCommand({ dest, all, dryRun, json, upstreamUrl, ref }) {
       }
     }
   } catch {}
-  const modeLabel = onlyProgramming ? '编程' : '全量';
+  if (preservedRepoLocal.length) {
+    process.stdout.write(`迁移提示：${preservedRepoLocal.join(', ')} 已不再分发，现有副本已保留\n`);
+  }
+  const modeLabel = onlyProgramming ? '默认编程' : '全部可分发';
   process.stdout.write(`技能：新增 ${installed}、更新 ${updated}（${modeLabel} ${allSkills.length}）\n`);
   process.stdout.write(`目标路径：${target}\n`);
 }
@@ -584,7 +645,7 @@ async function checkCommand(args) {
   } else {
     const lines = [];
     lines.push(`上游 HEAD: ${cmp.head}`);
-    const modeHint = onlyProgramming ? '（默认：engineering + 独有所需）' : '（全量）';
+    const modeHint = onlyProgramming ? '（默认：engineering + 独有所需）' : '（全量上游）';
     lines.push(`本地非独有: ${cmp.counts.local}  上游: ${cmp.counts.upstream} ${modeHint}`);
     lines.push('');
     const totalDiff = cmp.result.added.length + cmp.result.updated.length + cmp.result.removed.length + cmp.result.renamed.length;

package/bin/skill-boundaries.js

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const CONFIG_PATH = path.join(ROOT, 'config', 'proprietary.json');
+const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+
+function toUniqueSet(value, key) {
+  if (!Array.isArray(value) || new Set(value).size !== value.length) {
+    throw new Error(`invalid proprietary classification: ${key} must be a unique array`);
+  }
+  return new Set(value);
+}
+
+export const PROPRIETARY_SKILLS = toUniqueSet(config.all, 'all');
+export const DISTRIBUTABLE_PROPRIETARY_SKILLS = toUniqueSet(config.distributable, 'distributable');
+export const REPO_LOCAL_SKILLS = toUniqueSet(config.repoLocal, 'repoLocal');
+export const DEFAULT_PROPRIETARY_SKILLS = toUniqueSet(config.default, 'default');
+
+const classified = new Set([...DISTRIBUTABLE_PROPRIETARY_SKILLS, ...REPO_LOCAL_SKILLS]);
+const missing = [...PROPRIETARY_SKILLS].filter((name) => !classified.has(name));
+const extra = [...classified].filter((name) => !PROPRIETARY_SKILLS.has(name));
+const overlap = [...DISTRIBUTABLE_PROPRIETARY_SKILLS].filter((name) => REPO_LOCAL_SKILLS.has(name));
+const invalidDefaults = [...DEFAULT_PROPRIETARY_SKILLS].filter((name) => !DISTRIBUTABLE_PROPRIETARY_SKILLS.has(name));
+if (missing.length || extra.length || overlap.length || invalidDefaults.length) {
+  throw new Error(
+    `invalid proprietary classification: missing=${missing.join(',')} extra=${extra.join(',')} ` +
+    `overlap=${overlap.join(',')} defaults=${invalidDefaults.join(',')}`,
+  );
+}
+
+export function isProprietarySkill(name) {
+  return PROPRIETARY_SKILLS.has(name);
+}
+
+export function isDistributableProprietarySkill(name) {
+  return DISTRIBUTABLE_PROPRIETARY_SKILLS.has(name);
+}
+
+export function isRepoLocalSkill(name) {
+  return REPO_LOCAL_SKILLS.has(name);
+}
+
+export function isDefaultProprietarySkill(name) {
+  return DEFAULT_PROPRIETARY_SKILLS.has(name);
+}
+
+export function isDefaultProgrammingSkill(name, engineering, required) {
+  return (
+    DEFAULT_PROPRIETARY_SKILLS.has(name) ||
+    engineering.has(name) ||
+    (required && required.has(name))
+  );
+}
+
+export function isDistributableSkill(name, knownNames) {
+  if (!knownNames) return isDistributableProprietarySkill(name);
+  const known = knownNames instanceof Set ? knownNames : new Set(knownNames);
+  return known.has(name) && !REPO_LOCAL_SKILLS.has(name);
+}

package/config/proprietary.json

@@ -1,9 +1,28 @@
-[
-  "ci-guard",
-  "tdd-implement",
-  "grill-to-spec",
-  "diagnose-fix",
-  "commit-check",
-  "scaffold-functional-test",
-  "show-me"
-]
+{
+  "all": [
+    "ci-guard",
+    "tdd-implement",
+    "grill-to-spec",
+    "diagnose-fix",
+    "commit-check",
+    "scaffold-functional-test",
+    "show-me"
+  ],
+  "distributable": [
+    "tdd-implement",
+    "diagnose-fix",
+    "grill-to-spec",
+    "scaffold-functional-test",
+    "show-me"
+  ],
+  "repoLocal": [
+    "ci-guard",
+    "commit-check"
+  ],
+  "default": [
+    "tdd-implement",
+    "diagnose-fix",
+    "grill-to-spec",
+    "show-me"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heihei0299/matt-skills",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Agent skills + 项目配置模板：一条命令初始化 opencode / pi-agent 项目（含 mattpocock/skills 上游技能）",
   "type": "module",
   "bin": {