@haaaiawd/loom 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+## 1.2.0 — 2026-07-31
+
+### Added
+
+- External Acquisition Gate：Capability Graph 只声明 `acquisition_mode`，Forge 按当前
+  Intent 信号派生 Search Plan，并实际通过 Skill registry、网络、官方文档或研究资料获取信息。
+- revision-scoped Expertise Pack 与 `loom expertise init|get|validate`，以来源、检索证据和
+  Capability Capsules 形成类似 Skill 的项目化核心信息组，但不复制或内置第三方内容。
+- `guide`、Forge/Keeper activation、`verify pass`、`intent done` 与 `doctor` 的外部能力
+  获取强门；passed 记录绑定当前 Pack 内容摘要，Keeper 必须独立重开关键来源。
+
+### Compatibility
+
+- 中低影响 capability 默认为 `adaptive`；高影响 capability 未显式豁免时，以及任意 capability
+  显式声明 `external_required` 时启用持久化强门。
+- `project_only` 保留内部协议与机械任务路径，但必须说明 `acquisition_rationale`。
+
+## 1.1.0 — 2026-07-30
+
+### Added
+
+- Capability Graph、Capability Brief 与 coverage/compile 命令，将项目问题面、能力缺口、
+  风险和证据显式回链到 Intent。
+- provenance-backed Capability Graph Proposal 工作流，由 Architect 裁决新发现对 Graph、
+  Intent、acceptance 或版本边界的影响。
+- 版本化 Asset Library，校验来源、作者、许可、本地哈希、批准状态与 evidence 双向引用。
+- Authorship System：第五种认知职能 Author、Identity Compiler、可选 Atelier Path，以及
+  `loom atelier init|get|validate`。
+- Atelier Record 的 `intent_revision`、`stance_revision`、候选、修正、基线与选择证据校验。
+- Keeper/Quality Proof 的 Atelier 闭合门；`doctor`、`guide` 与 `intent done` 可识别缺失、
+  过期或未绑定的创作证据。
+
+### Compatibility
+
+- 旧 Intent 缺少 `quality_strategy` 时等价于 `adaptive`，不会创建 Atelier Record。
+- Atelier 是按需深路径，不增加角色、Intent 状态或验证维度。
+- 旧项目缺少 Capability Graph 时保留兼容诊断，可在后续架构修订中迁移。

package/EXTERNAL_ACQUISITION_DESIGN.md

@@ -0,0 +1,143 @@
+# External Acquisition Gate — 来源化能力网络设计
+
+> 状态：Implemented  
+> 目标：阻止 AI 在专业能力不足时闭门生成，并把真实外部检索编译成当前 Intent 可使用、可追溯、会随 revision 失效的核心信息组。
+
+## 1. 问题
+
+LOOM 已经能识别任务需要哪些能力，但“识别能力”不等于“获得能力”。如果 Forge 只根据模型已有知识临时生成一段设计原则，它仍可能做出结构正确、审美普通的结果，并把自洽误当成专业。
+
+本设计把能力链拆成四个不同事实：
+
+1. Capability Graph：项目为什么需要某项能力。
+2. Search Plan：本轮要用什么问题和关键词去外部寻找。
+3. Expertise Pack：实际打开来源后，哪些规则、工作流、判断门和失败模式可用于本 Intent。
+4. Quality Proof：这些判断是否真的让结果胜过基线。
+
+Graph 不保存网站、Skill 名称或固定关键词；Pack 不复制第三方 Skill 或网页正文。
+
+## 2. 核心不变量
+
+- AI 可以生成检索计划，不能把自己生成的内容登记为外部专业知识。
+- `external_required` 能力必须实际使用 Skill registry、网络、官方文档或研究资料。
+- 搜索结果标题、未打开的摘要、模型记忆和“行业通常如此”都不是来源。
+- 每个 Capability Capsule 必须直接引用至少一个已打开、可回查的外部来源。
+- Pack 绑定 `intent_revision`；Intent 修订后旧 Pack 自动失效。
+- Forge 可以使用 Pack；Keeper 不继承 Forge 的结论，必须重新打开关键来源。
+- 来源化不等于正确。CLI 证明结构与追溯，Keeper 证明来源是否真的支持判断。
+
+## 3. 触发模型
+
+Capability 节点可选：
+
+```json
+{
+  "acquisition_mode": "adaptive | external_required | project_only",
+  "acquisition_rationale": "project_only 时必填"
+}
+```
+
+有效模式按以下顺序计算：
+
+1. Graph 显式声明的模式优先。
+2. 未声明时，高影响 capability 自动提升为 `external_required`。
+3. 中低影响 capability 默认为 `adaptive`。
+
+`project_only` 只适合未公开内部协议、纯机械迁移等外部知识不会改变做法的任务，必须说明理由。外部交付依赖与只读研究访问是两件事：允许检索资料，不等于允许把外部服务写进产品架构。
+
+## 4. 运行流程
+
+```text
+Capability Graph
+  → compile acquisition requirement
+  → derive Search Plan from project signals
+  → perform real external retrieval
+  → synthesize Capability Capsules
+  → validate Expertise Pack
+  → Author / Atelier / implementation
+  → independent Keeper source check
+  → passed record binds current Pack
+```
+
+搜索词由 Forge 根据以下信号动态派生：
+
+- capability question 与 Brief；
+- Intent narrative、quality contract 和 creative scope；
+- 当前媒介、宿主、技术与许可约束；
+- 基线中已经观察到的具体缺口；
+- Authorial Stance 尚未解决的机制问题。
+
+关键词属于本轮工作证据，不回写 Graph。这样 LOOM 不会把“网页设计等于某几个灵感站”固化成框架偏见。
+
+## 5. Expertise Pack
+
+位置：
+
+```text
+.loom/vN/10_EXPERTISE_PACKS/<intent-id>.json
+```
+
+Pack 包含：
+
+- `search_plan`：决策问题、项目信号、派生查询、约束和停止条件；
+- `sources`：类型、权威层级、HTTPS 定位、获取时间、选择理由和已打开证据；
+- `capsules`：专业问题、适用时机、规则、工作流、判断门、失败模式、验证信号和来源引用；
+- `required_capability_refs` 与 `intent_revision`；
+- `status: draft | ready | blocked`。
+
+Capability Capsule 是“类似 Skill 的核心信息组”，但它有三个刻意限制：
+
+1. 只服务当前 Intent，不假装是通用知识；
+2. 只保存项目化综合，不复制来源内容；
+3. 未经多个真实任务和 Quality Proof 支持，不自动晋升为 Skill 或 Doctrine。
+
+## 6. Author 与自我更正
+
+外部获取发生在 Author/Atelier 之前。Authorial Stance 必须建立在已经来源化的机制和项目事实之上，而不是用人格、风格词或模型偏好代替研究。
+
+自我更正分三层：
+
+- Capsule 解释错误、来源不支持规则：修正 Pack，重新验证；如果已 passed，必须由 Keeper 重验。
+- 当前构图、措辞、动效或候选选择失效：写入 Atelier `corrections[]`，递增 `stance_revision`。
+- 出现新的用户结果、约束、风险或能力缺口：提交 Capability Graph proposal，由 Architect 裁决。
+
+Author 不能修改 Graph 后继续自证，也不能用一次局部修正把任务长期知识化。
+
+## 7. 强门与验证
+
+以下入口共同阻止绕过：
+
+- `loom guide`：优先引导创建或补齐 Pack；
+- `loom activate forge --intent <id>`：Pack 未 ready 时显示 OPEN 门，只允许勘察、基线和检索；
+- `loom expertise validate <id>`：检查 revision、真实外部来源、直接引用和 Capsule 完整性；
+- `loom verify pass`：强门未闭合时拒绝 passed，并把当前 Pack 的内容摘要绑定到验证记录；
+- `loom intent done`：拒绝未绑定、内容摘要变化或已经过期的 Pack；
+- `loom doctor`：报告缺失、失效和 passed 绑定漂移；
+- Keeper Context Pack：只给出证据入口，不注入 Forge 的 Capsule 结论。
+
+## 8. 搜索预算与停止条件
+
+LOOM 不规定固定网站数量，也不鼓励无限浏览。每个 Search Plan 必须写停止条件。通常在以下条件同时成立时停止：
+
+- 每个 required capability 都有直接来源化 Capsule；
+- 来源足以回答当前决策问题，而不只是提供视觉相似物；
+- 已能写出可执行的判断门、失败模式和验证信号；
+- 新来源只重复已有机制，不再改变候选或验证方法。
+
+如果来源互相冲突、关键资料不可访问或许可不清，Pack 应进入 `blocked`，而不是让模型补齐空白。
+
+## 9. 与现有系统的去重
+
+- Capability Brief 负责“项目问题与获取边界”；Pack 负责“本轮实际获得了什么”。二者不重复。
+- Authorship 负责“基于材料做什么独特选择”；Pack 负责“选择前有哪些可信材料”。二者不重复。
+- Atelier Record 保存候选与修正；Pack 保存外部能力证据。二者不合并。
+- Quality Proof 证明结果提升；Pack 只证明专业判断有来源。来源不能替代结果。
+- Doctrine 保存长期项目判断；Pack 默认短命。未经重复外部结果支持，不进入 Doctrine。
+
+## 10. 非目标
+
+- 不在 LOOM 仓库内安装、镜像或维护第三方 Skill。
+- 不建立固定网站白名单或 UI 专用关键词表。
+- 不声称只要检索就能突破基础模型的所有智能边界。
+- 不用来源数量、星标或流行度替代任务适配性。
+- 不让 CLI 自动编造 Capsule；CLI 只建模、校验、编译和阻断。

package/README.md

@@ -15,8 +15,9 @@ LOOM 是一个**哲学驱动的 Agent 质量框架**，核心理念：
 LOOM 的核心机制：
 1. **Project Doctrine** 从项目事实中形成长期判断，而不是套用规范模板
 2. **Intent + Contract** 同时定义可靠完成的底线与可选的质量上限
-3. **Expertise Compiler** 为当前任务临时组装领域、品味、批评与验证能力
+3. **Expertise Compiler** 为当前任务临时组装领域、品味、作者、批评与验证能力
 4. **Quality Arena + Quality Proof** 用机制不同的候选和独立证据支撑质量提升
+5. **Authorship + Atelier** 在真正需要创作判断时形成作者命题、媒介原型与可审计选择
 
 ---
 
@@ -27,7 +28,10 @@ LOOM 的核心机制：
 | **哲学** | 项目的价值观和工程原则——为什么存在、什么不做、冲突时谁优先。由 Weaver 从真实思想体系织造，不是模板填空 |
 | **Intent** | 一个意图单元——不是"做什么"（任务），是"为什么做"（意图）。每个 Intent 有验收契约，Keeper 据此判定实现是否忠实 |
 | **Intent Map** | 所有 Intent 的依赖图（JSON）。Architect 绘制，定义拓扑序和依赖关系 |
-| **Expertise Pack** | Forge 针对当前任务临时编译的专业认知，不成为永久规则 |
+| **Capability Graph** | 在 Intent 前展开项目问题面、能力缺口、风险和证据；高影响节点必须路由，并回链到 Intent |
+| **Expertise Pack** | Forge 通过真实外部检索为当前 Intent 编译的来源化核心信息组；绑定 revision，不成为永久规则 |
+| **Authorial Stance** | 针对单个 Intent 编译的创作命题、选择、拒绝项、媒介语法和验证视角，不是 Persona 扮演 |
+| **Atelier Path** | 可选创作深路径：冻结基线、形成机制不同候选、比较或保留原版，并把证据写入唯一 Atelier Record |
 | **Quality Arena** | 以基线和机制不同候选进行探索、比较、实现与观察 |
 | **Quality Proof** | Keeper 独立验证完成与质量声明，证据不足时不允许宣称提升 |
 | **Intent Loop** | 选择 → 编译专业能力 → 实现/比较 → 独立证明 → 闭合或回流 |
@@ -58,9 +62,22 @@ Keeper 验证（基础四维；有质量契约时增加 quality_achievement，
 
 ---
 
-## 快速开始
-
-### 步骤 0：诊断当前阶段
+## 快速开始
+
+### 安装
+
+```bash
+npm install --global @haaaiawd/loom
+loom --version
+```
+
+也可以不做全局安装，直接运行：
+
+```bash
+npx @haaaiawd/loom --help
+```
+
+### 步骤 0：诊断当前阶段
 
 ```bash
 loom guide
@@ -119,9 +136,9 @@ loom activate architect
 ```
 
 **输入**：愿景文档 + 哲学文档
-**Architect 会做什么**：设计系统边界 → 绘制 Intent Map → 定义完成契约、按需的质量契约与专业能力需求
-**产出**：`.loom/v1/02_ARCHITECTURE.md` + `.loom/v1/04_INTENT_MAP.json`
-**怎么判断合格**：完成契约可观察，质量契约可比较，依赖无环，每个 Intent 有叙事引用
+**Architect 会做什么**：先展开 Capability Graph → 设计系统边界 → 绘制 Intent Map → 定义完成契约、按需的质量契约与专业能力需求
+**产出**：`.loom/v1/07_CAPABILITY_GRAPH.json` + `07_CAPABILITY_BRIEFS/` + `.loom/v1/02_ARCHITECTURE.md` + `.loom/v1/04_INTENT_MAP.json`
+**怎么判断合格**：高影响图谱节点都有路由、Intent 都可回链到图谱，完成契约可观察，质量契约可比较，依赖无环
 **下一步**：进入 Intent Loop
 
 ### 步骤 5：进入 Intent Loop
@@ -134,6 +151,10 @@ loom intent update INT-001 --status in_progress
 # Forge 编译专业能力并实现
 loom activate forge --intent INT-001
 
+# 仅当 Architect 为该 Intent 声明 quality_strategy=atelier
+loom atelier init INT-001
+loom atelier validate INT-001
+
 # Keeper 独立形成 Quality Proof
 loom activate keeper --intent INT-001
 loom verify contract INT-001  # 查看验收契约
@@ -189,7 +210,7 @@ Agent 在用户说"看看进度 / 打开 preview / 看全局"时，先跑 `loom
 | `loom preview status` | 检查 `loom-preview.html` 是否存在、是否新鲜 |
 | `loom preview --regen` | 输出提示词，让 Agent 重写 HTML 预览 |
 | `loom preview --stale` | 强行打开过期预览 |
-| `loom help <topic>` | 分层指南（workflow\|concepts\|loop\|version\|patch\|doctor\|preview） |
+| `loom help <topic>` | 分层指南（含 workflow、concepts、loop、capability、atelier、version、patch、doctor、preview） |
 | `loom version list` | 列出所有版本（* 标记当前） |
 | `loom version new` | 创建新版本 + 自动切换（Major 升级） |
 | `loom version use <v>` | 切换当前版本 |
@@ -205,6 +226,11 @@ Agent 在用户说"看看进度 / 打开 preview / 看全局"时，先跑 `loom
 | `loom intent revise <id> --reason <text>` | 创建修订 draft 并报告反向依赖 |
 | `loom intent draft <id>` | 查看 draft |
 | `loom intent finalize <id> [--review <ids> --unaffected <ids>]` | 校验 draft 并原子更新官方 Map/topo_order；修订时必须分类全部下游影响 |
+| `loom capability graph\|frontier\|get\|coverage\|compile` | 查看能力图谱、未路由前沿、覆盖缺口和当前 Intent 的能力编译输入 |
+| `loom capability proposal list\|get\|submit\|decide\|close` | 以 provenance 提交新发现，并由 Architect 裁决和闭合 |
+| `loom asset import\|list\|search\|get\|validate` | 管理带来源、许可、哈希、批准状态与 evidence 回链的本地素材 |
+| `loom expertise init\|get\|validate <id>` | 创建和校验 revision-scoped Search Plan、外部来源与 Capability Capsules |
+| `loom atelier init\|get\|validate <id>` | 为显式 Atelier Intent 创建、读取和校验创作记录 |
 | `loom intent deprecate <id> --reason <text>` | 只读评估当前版本弃用影响；加 `--confirm` 并完整分类依赖方后原子写入 |
 | `loom intent narrative <id>` | Intent 意图叙事 |
 | `loom intent trace <id>` | Intent 完整追溯链（依赖+验证+哲学+叙事） |
@@ -241,27 +267,34 @@ LOOM/
 │   ├── INTENT_LOOP.md           Loop 控制流 + Intent Map + Verification 底线
 │   └── PHILOSOPHY_WEAVER.md     哲学织造器规范
 │
-├── dimensions/                  哲学维度库（Weaver 的弹药库）
-│   ├── SEARCH_METHODOLOGY.md    检索方法论（怎么找到优质思想）
-│   ├── universal/               通用层：产品/工程/协作（按需填充）
+├── dimensions/                  哲学维度库（Weaver 的弹药库）
+│   ├── SEARCH_METHODOLOGY.md    检索方法论（怎么找到优质思想）
+│   ├── AUTHORSHIP.md             Atelier 启用时加载的作者性方法
+│   ├── universal/               通用层：产品/工程/协作（按需填充）
 │   ├── domain/                  领域层：UX/游戏/后端/AI（按需填充）
 │   └── crosscutting/            交叉层：性能/安全/心理学/增长（按需填充）
 │
 ├── roles/                       角色原型定义
 │   ├── visionary.md             远见者——定义愿景，织造意图叙事
-│   ├── architect.md             建筑师——设计系统，绘制 Intent Map
+│   ├── architect.md             建筑师——展开图谱，设计系统，绘制 Intent Map
 │   ├── forge.md                 锻造师——在哲学约束下自主实现
 │   └── keeper.md                守护者——验证意图忠实度
 │
 ├── cli/                         CLI 传感器层（Agent 通过 CLI 访问磁盘数据）
-│   ├── bin/loom.js              命令入口
-│   ├── src/                     核心库（intent-map / philosophy / verify）
-│   └── test/                    端到端测试
+│   ├── bin/loom.js              命令入口
+│   ├── src/                     核心库（intent-map / capability / atelier / verify）
+│   ├── help/                    Agent 可直接读取的工作流指南
+│   └── test/                    端到端测试
 │
 └── templates/                   项目级起点骨架
     ├── PHILOSOPHY_TEMPLATE.md   哲学文档起点
     ├── VISION_TEMPLATE.md       愿景文档起点
-    └── INTENT_MAP_TEMPLATE.json Intent Map 起点
+    ├── INTENT_MAP_TEMPLATE.json Intent Map 起点
+    ├── CAPABILITY_GRAPH_TEMPLATE.json Capability Graph 起点
+    ├── CAPABILITY_BRIEF_TEMPLATE.md   Capability Brief 起点
+    ├── ASSET_LIBRARY_MANIFEST_TEMPLATE.json Asset Library 起点
+    ├── EXPERTISE_PACK_TEMPLATE.json   外部能力获取记录起点
+    └── ATELIER_RECORD_TEMPLATE.json   Atelier Record 起点
 ```
 
 ### 文档导航
@@ -279,8 +312,11 @@ LOOM/
 | Forge 做什么 | `roles/forge.md` |
 | Keeper 做什么 | `roles/keeper.md` |
 | 哲学文档长什么样 | `templates/PHILOSOPHY_TEMPLATE.md` |
-| 愿景文档长什么样 | `templates/VISION_TEMPLATE.md` |
-| Intent Map 长什么样 | `templates/INTENT_MAP_TEMPLATE.json` |
+| 愿景文档长什么样 | `templates/VISION_TEMPLATE.md` |
+| Capability Graph 与 Brief 长什么样 | `cli/help/capability.md`、`templates/CAPABILITY_GRAPH_TEMPLATE.json` |
+| 为什么必须外部检索、Expertise Pack 怎么闭合 | `cli/help/expertise.md`、`EXTERNAL_ACQUISITION_DESIGN.md` |
+| Author 与 Atelier 怎么工作 | `cli/help/atelier.md`、`dimensions/AUTHORSHIP.md` |
+| Intent Map 长什么样 | `templates/INTENT_MAP_TEMPLATE.json` |
 | 怎么搜索高质量参考 | `dimensions/SEARCH_METHODOLOGY.md` |
 
 ---
@@ -295,8 +331,9 @@ LOOM/
 **Agent 生成的**（每个项目跑出来的，厚而灵活）：
 - 哲学文档体系（Weaver 决定要几个、多详细）
 - 愿景文档（带意图叙事）
-- 架构文档（根据哲学决定结构）
-- Intent Map（意图依赖图，JSON）
+- 架构文档（根据哲学决定结构）
+- Capability Graph 与按需生成的 Capability Brief
+- Intent Map（意图依赖图，JSON）
 - 验证契约和验证记录
 
 **我们的规范是元规范**——规范"怎么生成规范"，不直接规范"规范长什么样"。
@@ -308,7 +345,7 @@ LOOM/
 | 角色 | 原型 | 职责 | 激活时机 |
 |---|---|---|---|
 | **Visionary** 远见者 | 产品联合创始人 | 定义愿景，织造意图叙事 | 项目启动 |
-| **Architect** 建筑师 | 系统建筑师 | 设计系统，绘制 Intent Map | Visionary 完成后 |
+| **Architect** 建筑师 | 系统建筑师 | 展开 Capability Graph，设计系统，绘制 Intent Map | Visionary 完成后 |
 | **Forge** 锻造师 | 高级工程师 | 在哲学约束下自主实现 | Intent Loop 实现阶段 |
 | **Keeper** 守护者 | 独立验证者（独立激活） | 从磁盘事实验证意图与质量主张 | Intent Loop 验证阶段 |
 
@@ -360,11 +397,13 @@ Agent 在项目中生成的文档结构：
     ├── 01_VISION.md               Visionary 产出（带意图叙事）
     ├── 02_ARCHITECTURE.md         Architect 产出
     ├── 03_DECISIONS/              架构决策记录
-    ├── 04_INTENT_MAP.json         意图依赖图（DAG）
+    ├── 04_INTENT_MAP.json         意图依赖图（DAG）
     ├── 05_VERIFICATION.md         每个 Intent 的验证契约
     ├── 06_CHANGELOG.json          Patch 变更记录（唯一权威来源）
     ├── 06_CHANGELOG.md            确定性生成的只读投影
-    └── verifications/             Keeper 的验证记录
+    ├── 07_CAPABILITY_GRAPH.json   问题面、能力缺口、风险、证据与 Intent 回链
+    ├── 07_CAPABILITY_BRIEFS/      按需生成的项目化能力 Brief
+    └── verifications/             Keeper 的验证记录
         ├── INT-001.json
         ├── INT-001.md
         └── ...
@@ -393,11 +432,12 @@ Agent 通过 **CLI 访问** JSON，不直接读文件——省 token、更高效
 2. Visionary 定义愿景
    → 基于哲学写愿景 → 每个意图带意图叙事 → 识别需要的哲学维度
 
-3. Architect 设计系统
-   → 基于愿景设计结构 → 绘制 Intent Map → 定义验证契约
+3. Architect 先展开 Capability Graph，再设计系统
+   → 基于愿景检查问题面、能力缺口、风险与证据 → 路由高影响节点 → 绘制 Intent Map → 定义验证契约
 
 4. LOOM Quality Engine
-   → Forge 编译 Expertise Pack → Quality Arena 实现/比较 → Keeper 形成 Quality Proof
+   → Forge 编译 Expertise Pack → 按需编译 Authorial Stance / 进入 Atelier
+   → Quality Arena 实现/比较 → Keeper 形成 Quality Proof
    → 循环直到所有 Intent 闭合
 ```
 
@@ -407,11 +447,12 @@ Agent 通过 **CLI 访问** JSON，不直接读文件——省 token、更高效
 
 - [x] `meta/` 元规范（4 个文件）
 - [x] `roles/` 角色原型（4 个角色）
-- [x] `templates/` 起点骨架（3 个模板）
+- [x] `templates/` 起点骨架
 - [x] `README.md` 系统总览
 - [x] `dimensions/SEARCH_METHODOLOGY.md` 检索方法论
-- [x] `cli/` CLI 访问层（118 个测试全过）
-- [ ] `dimensions/` 维度文件（按需填充，Weaver 可自主判断）
+- [x] `cli/` CLI 访问层（Capability Graph / Proposal / Asset Library / Atelier / Quality Proof）
+- [x] `dimensions/AUTHORSHIP.md` 按需创作方法
+- [ ] 继续通过真实项目校准专业维度与 Atelier 的质量增益
 
 ---
 

package/cli/bin/loom.js

@@ -2,7 +2,7 @@
 // loom — LOOM 框架的 CLI 传感器层
 // Agent 通过这个 CLI 访问 Intent Map / 哲学 / 验证记录，不直接读文件。
 
-import { argv, cwd, exit } from 'node:process';
+import { argv, cwd, env, exit } from 'node:process';
 import { resolve, join, dirname } from 'node:path';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -24,6 +24,11 @@ import { generatePreviewPrompt, getPreviewStatus } from '../src/preview.js';
 import { getPatch, listPatches, recordPatch, validatePatches } from '../src/patch.js';
 import { addIntentDraft, finalizeIntentDraft, getIntentDraft, reviseIntentDraft } from '../src/intent-draft.js';
 import { resolveIntentRef } from '../src/shared/intent-ref.js';
+import { compileCapabilityInputs, getCapabilityCoverage, getCapabilityFrontier, getCapabilityGraphProjection, getCapabilityNode } from '../src/capability-graph.js';
+import { getAsset, importAsset, listAssets, recoverAssetImportTransaction, searchAssets, validateAssetLibrary } from '../src/asset-library.js';
+import { closeCapabilityProposal, decideCapabilityProposal, getCapabilityProposal, listCapabilityProposals, submitCapabilityProposal } from '../src/capability-proposals.js';
+import { getAtelierRecord, initAtelierRecord, validateAtelierRecord } from '../src/atelier.js';
+import { assertExpertiseReady, getExpertisePack, initExpertisePack, validateExpertisePack } from '../src/expertise-pack.js';
 
 // ─── 路径解析 ──────────────────────────────────────────
 // findLoomRoot / findVersionDir / readCurrentPointer 已提取到 shared/paths.js
@@ -58,15 +63,148 @@ const [cmd, sub, ...rest] = argv.slice(2);
 
 try {
   switch (cmd) {
-    case '--version':
+    case '--version':
     case '-v': {
       // 从根 package.json 读版本号（cli/bin -> cli -> LOOM root）
       const pkgPath = resolve(__dirname, '..', '..', 'package.json');
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
       console.log(`loom ${pkg.version}`);
-      break;
-    }
-
+      break;
+    }
+
+    case 'capability': {
+      const versionDir = findVersionDir();
+      switch (sub) {
+        case 'graph':
+          output(getCapabilityGraphProjection(versionDir));
+          break;
+        case 'frontier':
+          output(getCapabilityFrontier(versionDir));
+          break;
+        case 'get': {
+          const id = rest[0];
+          if (!id) die('用法: loom capability get <node-id>');
+          output(getCapabilityNode(versionDir, id));
+          break;
+        }
+        case 'coverage':
+          output(getCapabilityCoverage(versionDir));
+          break;
+        case 'compile': {
+          const intentId = rest[0];
+          if (!intentId) die('用法: loom capability compile <intent-id>');
+          output(compileCapabilityInputs(versionDir, intentId));
+          break;
+        }
+        case 'proposal': {
+          const action = rest[0];
+          if (action === 'list') output(listCapabilityProposals(versionDir));
+          else if (action === 'get') {
+            if (!rest[1]) die('用法: loom capability proposal get <CGP-ID>');
+            output(getCapabilityProposal(versionDir, rest[1]));
+          } else if (action === 'submit') {
+            const fileIndex = argv.indexOf('--json-file');
+            const path = fileIndex === -1 ? null : argv[fileIndex + 1];
+            if (!path) die('用法: loom capability proposal submit --json-file <proposal.json>');
+            output(submitCapabilityProposal(versionDir, JSON.parse(readFileSync(path, 'utf-8'))));
+          } else if (action === 'decide') {
+            const rationaleIndex = argv.indexOf('--rationale');
+            if (!rest[1] || !rest[2] || rationaleIndex === -1 || !argv[rationaleIndex + 1]) die('用法: loom capability proposal decide <CGP-ID> <decision> --rationale <text>');
+            output(decideCapabilityProposal(versionDir, rest[1], rest[2], argv[rationaleIndex + 1]));
+          } else if (action === 'close') {
+            const resolutionIndex = argv.indexOf('--resolution-file');
+            if (!rest[1] || resolutionIndex === -1 || !argv[resolutionIndex + 1]) die('用法: loom capability proposal close <CGP-ID> --resolution-file <resolution.json>');
+            output(closeCapabilityProposal(versionDir, rest[1], JSON.parse(readFileSync(argv[resolutionIndex + 1], 'utf-8'))));
+          } else die('用法: loom capability proposal [list|get|submit|decide|close]');
+          break;
+        }
+        default:
+          die(`未知 capability 子命令: ${sub}\n用法: loom capability [graph|frontier|get|coverage|compile|proposal]`);
+      }
+      break;
+    }
+
+    case 'asset': {
+      const versionDir = findVersionDir();
+      switch (sub) {
+        case 'import': {
+          const filePath = rest[0];
+          const option = (name) => {
+            const index = argv.indexOf(name);
+            return index === -1 ? undefined : argv[index + 1];
+          };
+          if (!filePath || filePath.startsWith('--')) die('用法: loom asset import <本地文件> --tags <标签,...> --source <来源> --author <作者> --license <许可> --approval approved [--kind image] [--evidence <节点,...>]');
+          output(importAsset(versionDir, filePath, {
+            tags: option('--tags'), source: option('--source'), author: option('--author'), license: option('--license'),
+            approval: option('--approval'), kind: option('--kind'), evidenceRefs: option('--evidence'),
+            failureInjection: env.NODE_ENV === 'test' && option('--test-fail-after') === 'manifest' ? 'after_manifest'
+              : env.NODE_ENV === 'test' && option('--test-fail-after') === 'crash-manifest' ? 'crash_after_manifest' : undefined,
+          }));
+          break;
+        }
+        case 'list': output(listAssets(versionDir)); break;
+        case 'search': {
+          const query = rest[0];
+          if (!query) die('用法: loom asset search <查询>');
+          output(searchAssets(versionDir, query));
+          break;
+        }
+        case 'get': {
+          const id = rest[0];
+          if (!id) die('用法: loom asset get <asset-id>');
+          output(getAsset(versionDir, id));
+          break;
+        }
+        case 'validate': {
+          const recovery = recoverAssetImportTransaction(versionDir);
+          output({ valid: true, assets: Object.keys(validateAssetLibrary(versionDir).assets).length, recovered_transaction: recovery.recovered ? recovery : null });
+          break;
+        }
+        default: die(`未知 asset 子命令: ${sub}\n用法: loom asset [import|list|search|get|validate]`);
+      }
+      break;
+    }
+
+    case 'atelier': {
+      const versionDir = findVersionDir();
+      const intentId = rest[0];
+      if (!intentId) die(`用法: loom atelier ${sub || '<init|get|validate>'} <intent-id>`);
+      switch (sub) {
+        case 'init':
+          output(initAtelierRecord(versionDir, intentId));
+          break;
+        case 'get':
+          output(getAtelierRecord(versionDir, intentId));
+          break;
+        case 'validate':
+          output(validateAtelierRecord(versionDir, intentId));
+          break;
+        default:
+          die(`未知 atelier 子命令: ${sub}\n用法: loom atelier [init|get|validate] <intent-id>`);
+      }
+      break;
+    }
+
+    case 'expertise': {
+      const versionDir = findVersionDir();
+      const intentId = rest[0];
+      if (!intentId) die(`用法: loom expertise ${sub || '<init|get|validate>'} <intent-id>`);
+      switch (sub) {
+        case 'init':
+          output(initExpertisePack(versionDir, intentId));
+          break;
+        case 'get':
+          output(getExpertisePack(versionDir, intentId));
+          break;
+        case 'validate':
+          output(validateExpertisePack(versionDir, intentId));
+          break;
+        default:
+          die(`未知 expertise 子命令: ${sub}\n用法: loom expertise [init|get|validate] <intent-id>`);
+      }
+      break;
+    }
+
     case 'intent': {
       const versionDir = findVersionDir();
       switch (sub) {
@@ -227,7 +365,26 @@ try {
           if (!isVerificationCurrent(intent, latest)) {
             die(`${id} 最新 passed 验证不属于当前 Intent revision ${intent.revision ?? 1}。先重新验证。`);
           }
-          const currentStatus = intent.status;
+          const expertise = assertExpertiseReady(versionDir, id);
+          if (expertise && (latest.expertise?.record_ref !== `10_EXPERTISE_PACKS/${id}.json`
+            || latest.expertise?.intent_revision !== expertise.intent_revision
+            || latest.expertise?.source_count !== expertise.source_count
+            || latest.expertise?.capsule_count !== expertise.capsule_count
+            || latest.expertise?.pack_digest !== expertise.pack_digest)) {
+            die(`${id} 最新 passed 未绑定当前 Expertise Pack。请在新的 Keeper task 中重新打开来源并验证。`);
+          }
+          if (intent.quality_strategy === 'atelier') {
+            const atelier = validateAtelierRecord(versionDir, id);
+            if (!['selected', 'baseline_retained'].includes(atelier.status)) {
+              die(`${id} 的 Atelier Record 尚未完成选择（当前: ${atelier.status}）`);
+            }
+            if (latest.atelier?.record_ref !== `09_ATELIER/${id}.json`
+              || latest.atelier?.stance_revision !== atelier.stance_revision
+              || latest.atelier?.status !== atelier.status) {
+              die(`${id} 最新 passed 未绑定当前 Atelier Record 与 stance_revision。请在新的 Keeper task 中重新验证。`);
+            }
+          }
+          const currentStatus = intent.status;
           if (currentStatus === 'completed') {
             console.log(`${id} 已经是 completed，无需操作`);
             break;
@@ -796,7 +953,19 @@ To Human:
   loom patch list               列出当前版本的 Patch
   loom patch get <id>           返回指定 Patch
   loom patch validate           校验 Patch ledger 和 Markdown 投影
-
+
+  loom capability graph         输出 Capability Graph 的 Mermaid 投影与摘要
+  loom capability frontier      列出尚未路由的高影响节点
+  loom capability get <id>      返回节点、关系、Brief 与 Intent 回链
+  loom capability coverage      检查图谱覆盖、Brief 和 Intent 回链
+  loom capability compile <id>  只读显示会进入该 Intent 的能力输入
+  loom expertise init <id>      创建当前 Intent 的外部能力获取记录
+  loom expertise get <id>       返回并校验当前 Expertise Pack
+  loom expertise validate <id>  校验检索、来源、Capsule 与 revision
+  loom atelier init <id>        为 atelier Intent 创建唯一创作记录
+  loom atelier get <id>         返回并校验当前 Atelier Record
+  loom atelier validate <id>    校验 Record、revision、候选与证据引用
+
   loom intent next              返回下一个可执行 Intent
   loom intent add --title <text> [--depends-on <ids>]  创建新增 draft
   loom intent revise <id> --reason <text>  创建修订 draft 并报告反向依赖

package/cli/help/asset.md

@@ -0,0 +1,36 @@
+# Asset Library Protocol
+
+Asset Library is the versioned, local-first source of truth for project materials. It stores asset bytes under `.loom/vN/08_ASSET_LIBRARY/files/` and metadata in `manifest.json`. A remote URL, successful download, or HTTP 200 is never proof that an asset is renderable in the target host.
+
+## Import
+
+```bash
+loom asset import ./approved-image.png \
+  --kind image \
+  --tags "庆祝,表情,项目名" \
+  --source "用户自有素材包" \
+  --author "作者或权利人" \
+  --license "授权说明或许可证" \
+  --approval approved
+```
+
+Import copies an explicitly named ordinary local file, computes SHA-256, derives a stable `ASSET-...` ID, and rejects symbolic links, destination/path escape, duplicate bytes, missing provenance, and unapproved assets. It does not fetch remote material.
+
+## Recoverable import transaction
+
+An evidence-linked import changes three files: the copied bytes, `manifest.json`, and `07_CAPABILITY_GRAPH.json`. Filesystems do not provide one atomic operation across those files, so Loom does not claim that they do. It first prevalidates the complete candidate, then writes same-directory temporary files and a recovery journal (flushed where the filesystem supports it). If an import errors, Loom rolls back to the recorded pre-import state; if the process is interrupted, the next `loom asset validate`, import, or library read recovers the journal before using the library. `loom asset validate` reports a recovered transaction in its JSON output.
+
+## Discover and verify
+
+```bash
+loom asset list
+loom asset search 表情
+loom asset get ASSET-<hash-prefix>
+loom asset validate
+```
+
+Tags are Unicode strings, so Chinese search works without a separate tokenizer for the small local library. Search returns only active `approval: approved` assets; `asset list` remains the audit view. Only approved assets may be used by Forge.
+
+## Evidence links
+
+When importing with `--evidence`, Loom validates the complete prospective manifest and Graph first, then writes both the asset's `evidence_refs` and the evidence node's `asset_refs` as one recoverable transaction. `loom asset validate` checks this reciprocal link plus hashes and provenance. This records bytes and traceability; Keeper must still check the real target host renders the result.