@haaaiawd/loom 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # 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

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

@@ -29,7 +29,7 @@ LOOM 的核心机制：
 | **Intent** | 一个意图单元——不是"做什么"（任务），是"为什么做"（意图）。每个 Intent 有验收契约，Keeper 据此判定实现是否忠实 |
 | **Intent Map** | 所有 Intent 的依赖图（JSON）。Architect 绘制，定义拓扑序和依赖关系 |
 | **Capability Graph** | 在 Intent 前展开项目问题面、能力缺口、风险和证据；高影响节点必须路由，并回链到 Intent |
-| **Expertise Pack** | Forge 针对当前任务临时编译的专业认知，不成为永久规则 |
+| **Expertise Pack** | Forge 通过真实外部检索为当前 Intent 编译的来源化核心信息组；绑定 revision，不成为永久规则 |
 | **Authorial Stance** | 针对单个 Intent 编译的创作命题、选择、拒绝项、媒介语法和验证视角，不是 Persona 扮演 |
 | **Atelier Path** | 可选创作深路径：冻结基线、形成机制不同候选、比较或保留原版，并把证据写入唯一 Atelier Record |
 | **Quality Arena** | 以基线和机制不同候选进行探索、比较、实现与观察 |
@@ -229,6 +229,7 @@ Agent 在用户说"看看进度 / 打开 preview / 看全局"时，先跑 `loom
 | `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 意图叙事 |
@@ -292,6 +293,7 @@ LOOM/
     ├── 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 起点
 ```
 
@@ -312,6 +314,7 @@ LOOM/
 | 哲学文档长什么样 | `templates/PHILOSOPHY_TEMPLATE.md` |
 | 愿景文档长什么样 | `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` |

package/cli/bin/loom.js

@@ -28,6 +28,7 @@ import { compileCapabilityInputs, getCapabilityCoverage, getCapabilityFrontier,
 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
@@ -184,6 +185,26 @@ try {
       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) {
@@ -344,6 +365,14 @@ try {
           if (!isVerificationCurrent(intent, latest)) {
             die(`${id} 最新 passed 验证不属于当前 Intent revision ${intent.revision ?? 1}。先重新验证。`);
           }
+          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)) {
@@ -930,6 +959,9 @@ To Human:
   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、候选与证据引用

package/cli/help/capability.md

@@ -66,3 +66,8 @@ Visionary 给出 outcome、角色、非目标与项目事实。Architect 用项
 `loom capability compile <intent-id>` 只读显示会进入当前 Intent 的图谱节点与 Brief。Forge 激活
 Intent 时会获得同一份输入；发现新依赖、风险或能力缺口时必须回流 Architect 更新 Graph，不能静默
 扩展实现。Keeper 以图谱回链检查高影响问题是否真的被兑现。
+
+Capability 节点可选声明 `acquisition_mode: adaptive | external_required | project_only`。
+`project_only` 必须附 `acquisition_rationale`。未声明时，高影响 capability 自动提升为
+`external_required`。Graph 只保存获取必要性，不保存网站、Skill 名称或
+搜索词；Forge 在本轮 Expertise Pack 中按项目信号派生查询并记录真实来源。

package/cli/help/concepts.md

@@ -54,7 +54,10 @@ Forge 针对当前 Intent 临时组装一个 Expertise Pack。先由 Capability
 6. 如何验证专业质量。
 
 能力名称只表示“可发现”；只有真实加载并转化为任务判断的内容才算进入 Expertise Pack。
-Pack 仅服务当前任务，不成为长期 Doctrine。
+当 External Acquisition Gate 为 required 时，Forge 只能自行派生 Search Plan，内容必须来自
+实际打开的 Skill、网络、官方文档或研究资料；Pack 写入当前 Intent revision 的
+`10_EXPERTISE_PACKS`，每个 Capability Capsule 都直接回链来源。Pack 仅服务当前任务，不成为
+长期 Doctrine。
 
 ## Quality Arena
 

package/cli/help/expertise.md

@@ -0,0 +1,51 @@
+# External Acquisition 与 Expertise Pack
+
+LOOM 把“知道任务需要某项能力”和“真正获得了这项能力”分开。Capability Graph 只决定是否
+需要外部获取；Forge 在当前 Intent 中派生查询、实际检索，再把有来源的核心信息编译成
+Capability Capsules。
+
+```bash
+loom capability compile <intent-id>
+loom expertise init <intent-id>
+# 编辑 .loom/vN/10_EXPERTISE_PACKS/<intent-id>.json，并实际执行检索
+loom expertise validate <intent-id>
+loom activate forge --intent <intent-id>
+```
+
+## 什么时候强制
+
+- capability 显式声明 `acquisition_mode: external_required`；
+- 或高影响 capability 没有显式声明其他模式。
+
+中低影响任务默认为 `adaptive`。高影响任务只有在 Architect 明确写 `adaptive` 时才按证据
+决定是否检索；仅依赖未公开内部协议、外部知识不会改变做法的机械任务可以用 `project_only`，
+但必须写 `acquisition_rationale`。
+
+## Search Plan
+
+Forge 根据 capability question、Capability Brief、Intent narrative、质量契约、creative
+scope、媒介约束和基线缺口派生查询。关键词是运行时证据，不写回 Graph。
+
+必须实际使用 Skill registry、网络、官方文档或研究资料。模型自行生成的原则、没有打开的
+搜索摘要和只看标题的结果都不能登记为来源。每个计划必须写停止条件，避免无边界浏览。
+
+## Capability Capsule
+
+每个 required capability 至少有一个 Capsule，包含：
+
+- 专业问题与适用时机；
+- 规则和工作流；
+- 决策门与失败模式；
+- 可观察验证信号；
+- 至少一个直接外部来源引用。
+
+Pack 只保存项目化综合和定位信息，不复制第三方 Skill 或网页正文，也不会自动变成 Doctrine
+或通用 Skill。Intent revision 改变后，旧 Pack 自动失效。
+
+## Keeper
+
+CLI 能检查 Pack 当前、来源可定位、Capsule 直接引用外部资料，但不能仅凭 JSON 判断来源是否
+真的支持结论。Keeper 必须在独立 task 中重新打开至少一个关键来源，核对规则与判断门，并让
+`loom verify pass` 将当前 Pack 的内容摘要绑定进验证记录；之后 Pack 内容发生变化必须重验。
+
+更多设计边界见 `EXTERNAL_ACQUISITION_DESIGN.md`。

package/cli/help/loop.md

@@ -28,8 +28,10 @@ Forge 先形成任务级 Expertise Pack：
 - 已实际加载的技能、资料、工具及其用途。
 - Critic 视角与验证方法。
 
-Pack 是临时认知配置，不写成新的长期规范。明显任务可以很短；高质量任务应足以解释为什么
-某个专业手法适合这个项目。
+Pack 是任务级认知配置，不写成新的长期规范。External Acquisition Gate required 时，Pack
+必须落盘到 `10_EXPERTISE_PACKS/<intent-id>.json`：Search Plan 可由 AI 派生，但 Capsule 内容
+必须来自实际打开的外部来源，并写出判断门、失败模式和验证信号。明显的机械任务可以保持
+`adaptive`；高质量任务必须足以解释为什么某个专业手法适合这个项目。
 
 ## 3. Quality Arena
 

package/cli/help/workflow.md

@@ -64,6 +64,16 @@ loom activate keeper --intent <id>
 Forge 编译 Expertise Pack，在 Quality Arena 中实现与比较。
 Keeper 从当前磁盘事实和契约独立验证，不继承 Forge 的解释。
 
+当 `loom capability compile <id>` 报告 `acquisition.required=true` 时，先运行：
+
+```bash
+loom expertise init <id>
+# 实际执行 find skill / web / official docs / research 检索并填写 Pack
+loom expertise validate <id>
+```
+
+门未闭合时不能写入 passed。Keeper 会重新打开关键来源，passed 记录绑定当前 Pack。
+
 无质量契约时，四个基础维度通过即可闭合。存在质量契约时，额外验证
 `quality_achievement`；声明相对提升时，在该维度中链接 Quality Proof：
 

package/cli/src/activate.js

@@ -10,6 +10,7 @@ import { getVerificationContract } from './verify.js';
 import { extractMdSection } from './shared/md-utils.js';
 import { compileCapabilityInputs } from './capability-graph.js';
 import { getAtelierRecord } from './atelier.js';
+import { formatExpertisePackForPrompt, getExpertisePack, getExpertisePackState } from './expertise-pack.js';
 
 const VALID_ROLES = ['weaver', 'visionary', 'architect', 'forge', 'keeper'];
 
@@ -262,8 +263,9 @@ function compileExpertiseInputs(role, versionDir, objective) {
     `- quality_strategy: ${qualityStrategy}`,
     '- Skill、工具和资产名称只代表可发现入口；实际检查并加载后才进入 Expertise Pack。',
   ];
+  let compiled = null;
   if (versionDir && objective.intent) {
-    const compiled = compileCapabilityInputs(versionDir, objective.intent.id);
+    compiled = compileCapabilityInputs(versionDir, objective.intent.id);
     if (!compiled.available) {
       lines.push(`- Capability Graph: ${compiled.warnings.join(' ')}`);
     } else if (compiled.nodes.length === 0) {
@@ -279,6 +281,40 @@ function compileExpertiseInputs(role, versionDir, objective) {
       for (const warning of compiled.warnings) lines.push(`- Capability Graph warning: ${warning}`);
     }
   }
+  if (compiled?.acquisition?.nodes?.length) {
+    lines.push('- External acquisition modes:');
+    for (const node of compiled.acquisition.nodes) {
+      lines.push(`  - ${node.node_id}: ${node.mode}（${node.reason}）`);
+    }
+  }
+  if (versionDir && objective.intent && ['forge', 'keeper'].includes(role)) {
+    const state = getExpertisePackState(versionDir, subject.id);
+    if (state.required && !state.ready) {
+      lines.push(
+        '\n### External Acquisition Gate — OPEN',
+        `- required_capabilities: ${state.required_node_ids.join(', ')}`,
+        '- 先根据 Capability question、Authorial Stance/creative_scope、媒介约束与已观察缺口派生搜索词；搜索词属于本轮计划，不得写死进 Capability Graph。',
+        '- 必须实际使用外部 find skill、网络搜索、官方文档或研究资料获取信息。模型自行生成的常识、内部复述和未打开的搜索结果不能充当来源。',
+        `- ${state.reason === 'missing' ? `运行 \`loom expertise init ${subject.id}\`` : `修正 \`10_EXPERTISE_PACKS/${subject.id}.json\``}，记录可回查来源与 Capability Capsules，再运行 \`loom expertise validate ${subject.id}\`。`,
+        '- 门未闭合时，只能完成机械性勘察、基线冻结与检索；不得声称专业方案已形成，也不得通过验证。',
+      );
+    } else if (state.required && role === 'forge') {
+      const pack = getExpertisePack(versionDir, subject.id);
+      lines.push(
+        '\n### External Acquisition Gate — READY',
+        '- 以下内容是本 Intent revision 的来源化核心信息组。它不是永久 Doctrine，也不是复制进仓库的第三方 Skill。',
+        `\n${formatExpertisePackForPrompt(pack)}`,
+      );
+    } else if (state.required && role === 'keeper') {
+      lines.push(
+        '\n### External Acquisition Evidence — PRESENT',
+        `- record_ref: 10_EXPERTISE_PACKS/${subject.id}.json`,
+        `- required_capabilities: ${state.required_node_ids.join(', ')}`,
+        `- source_count: ${state.validation.source_count}; capsule_count: ${state.validation.capsule_count}`,
+        '- 不继承 Forge 的 Capsule 结论。重新打开至少一个关键来源，检查来源确实支持规则与判断门，并把绑定写入本轮验证记录。',
+      );
+    }
+  }
   if (role === 'keeper') {
     lines.push('- 不继承 Forge Expertise Pack；按契约独立准备验证能力。');
     if (qualityStrategy === 'atelier') {

package/cli/src/capability-graph.js

@@ -11,6 +11,7 @@ const NODE_KINDS = ['outcome', 'concern', 'capability', 'risk', 'evidence'];
 const NODE_STATUSES = ['open', 'researched', 'covered', 'deferred', 'out_of_scope'];
 const ROUTES = ['expand', 'brief', 'intent', 'defer', 'exclude', 'covered_by'];
 const RELATIONSHIPS = ['refines', 'requires', 'realizes', 'constrains', 'risks', 'validated_by', 'covered_by'];
+const ACQUISITION_MODES = ['adaptive', 'external_required', 'project_only'];
 const VERIFICATION_FIELDS = ['method', 'target', 'procedure', 'pass_criteria', 'artifact'];
 const EVIDENCE_ARTIFACT_DIRS = ['verifications', '08_ASSET_LIBRARY/files'];
 
@@ -66,6 +67,17 @@ function validateNode(id, node, allIds, errors) {
   if (node.asset_refs !== undefined && node.kind !== 'evidence') {
     errors.push(`nodes["${id}"].asset_refs 只允许写在 evidence 节点`);
   }
+  if (node.acquisition_mode !== undefined) {
+    if (node.kind !== 'capability') {
+      errors.push(`nodes["${id}"].acquisition_mode 只允许写在 capability 节点`);
+    } else if (!ACQUISITION_MODES.includes(node.acquisition_mode)) {
+      errors.push(`nodes["${id}"].acquisition_mode 非法: ${node.acquisition_mode}`);
+    }
+  }
+  if (node.acquisition_mode === 'project_only'
+    && (typeof node.acquisition_rationale !== 'string' || !node.acquisition_rationale.trim())) {
+    errors.push(`nodes["${id}"].acquisition_mode=project_only 必须声明 acquisition_rationale`);
+  }
   if (node.verification !== undefined) {
     if (node.kind !== 'evidence') {
       errors.push(`nodes["${id}"].verification 只允许写在 evidence 节点`);
@@ -131,6 +143,13 @@ export function loadCapabilityGraph(versionDir, { required = true } = {}) {
   return validateCapabilityGraph(readJsonFile(filePath, 'Capability Graph'));
 }
 
+function getEffectiveAcquisitionMode(node) {
+  if (node.kind !== 'capability') return null;
+  if (node.acquisition_mode) return node.acquisition_mode;
+  if (node.impact === 'high') return 'external_required';
+  return 'adaptive';
+}
+
 function isRouted(node) {
   return ['brief', 'intent', 'defer', 'exclude', 'covered_by'].includes(node.route);
 }
@@ -261,6 +280,19 @@ export function getCapabilityCoverage(versionDir) {
     if (node.route === 'brief' && !node.brief_ref) {
       capabilitiesWithoutPlan.push({ node_id: node.id, reason: 'route=brief 但缺少 brief_ref' });
     }
+    if (node.kind === 'capability') {
+      const linkedIntents = (node.intent_refs || [])
+        .map((intentId) => intentMap.intents[intentId])
+        .filter(Boolean);
+      const needsExternalAcquisition = linkedIntents.length > 0
+        && getEffectiveAcquisitionMode(node) === 'external_required';
+      if (needsExternalAcquisition && !node.brief_ref && node.route !== 'brief') {
+        capabilitiesWithoutPlan.push({
+          node_id: node.id,
+          reason: '外部能力获取为 required，但缺少 brief_ref 来定义专业问题与验收边界',
+        });
+      }
+    }
     if (['defer', 'exclude'].includes(node.route) && (!node.rationale || typeof node.rationale !== 'string' || node.rationale.trim() === '')) {
       routingGaps.push({ node_id: node.id, reason: `route=${node.route} 但缺少 rationale` });
     }
@@ -339,7 +371,15 @@ function collectCompilationNodes(graph, intentId) {
 
 export function compileCapabilityInputs(versionDir, intentId) {
   const graph = loadCapabilityGraph(versionDir, { required: false });
-  if (!graph) return { available: false, nodes: [], briefs: [], warnings: ['项目尚未建立 Capability Graph；使用 Intent 的 capability_needs 兼容路径。'] };
+  if (!graph) {
+    return {
+      available: false,
+      nodes: [],
+      briefs: [],
+      warnings: ['项目尚未建立 Capability Graph；使用 Intent 的 capability_needs 兼容路径。'],
+      acquisition: { required: false, required_node_ids: [], nodes: [] },
+    };
+  }
   const nodes = collectCompilationNodes(graph, intentId);
   const briefs = [];
   const warnings = [];
@@ -347,5 +387,30 @@ export function compileCapabilityInputs(versionDir, intentId) {
     if (!node.brief_ref) continue;
     try { briefs.push({ node_id: node.id, ...resolveBrief(versionDir, node.brief_ref) }); } catch (error) { warnings.push(`${node.id}: ${error.message}`); }
   }
-  return { available: true, nodes, briefs, warnings };
+  const acquisitionNodes = nodes
+    .filter((node) => node.kind === 'capability')
+    .map((node) => ({
+      node_id: node.id,
+      title: node.title,
+      mode: getEffectiveAcquisitionMode(node),
+      reason: node.acquisition_mode
+        ? 'Capability Graph 显式声明'
+        : node.impact === 'high'
+          ? '高影响能力默认需要外部来源化'
+          : '按任务证据自适应判断',
+    }));
+  const requiredNodeIds = acquisitionNodes
+    .filter((node) => node.mode === 'external_required')
+    .map((node) => node.node_id);
+  return {
+    available: true,
+    nodes,
+    briefs,
+    warnings,
+    acquisition: {
+      required: requiredNodeIds.length > 0,
+      required_node_ids: requiredNodeIds,
+      nodes: acquisitionNodes,
+    },
+  };
 }

package/cli/src/diagnostics.js

@@ -15,6 +15,7 @@ import { getCapabilityCoverage, getCapabilityGraphPath, loadCapabilityGraph } fr
 import { listCapabilityProposals } from './capability-proposals.js';
 import { getAssetManifestPath, validateAssetLibrary } from './asset-library.js';
 import { validateAtelierRecord } from './atelier.js';
+import { getExpertisePackState } from './expertise-pack.js';
 
 function readIntentMapRaw(versionDir) {
   const filePath = join(versionDir, '04_INTENT_MAP.json');
@@ -178,6 +179,8 @@ const FIX_HINTS = {
   asset_library_invalid: '修复 08_ASSET_LIBRARY/manifest.json 的来源、许可、哈希、库内路径或 evidence 双向引用，然后运行 loom asset validate。',
   atelier_record_invalid: '运行 loom atelier init {id} 创建记录，或按校验错误修正后运行 loom atelier validate {id}。',
   atelier_verification_missing: '重新运行独立 Keeper 验证，让 passed 记录绑定当前 Atelier Record 与 stance_revision。',
+  expertise_pack_invalid: '运行 loom expertise init {id}（若尚未创建）；实际执行 find skill / 网络或文档检索，补齐来源与 Capability Capsules 后运行 loom expertise validate {id}。',
+  expertise_verification_missing: '重新运行独立 Keeper 验证，让 passed 记录绑定当前 10_EXPERTISE_PACKS/{id}.json。',
 };
 
 /**
@@ -314,6 +317,33 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
         }
       }
     }
+    if (!['pending', 'blocked', 'deprecated'].includes(intent.status)) {
+      try {
+        const expertise = getExpertisePackState(versionDir, id);
+        if (expertise.required && !expertise.ready) {
+          issues.push({
+            id,
+            type: 'expertise_pack_invalid',
+            severity: intent.status === 'completed' || latest?.verdict === 'passed' ? 'high' : 'medium',
+            msg: `${id} 的外部能力获取强门尚未闭合: ${expertise.reason || 'Expertise Pack not ready'}`,
+          });
+        } else if (expertise.required && latest?.verdict === 'passed') {
+          const validation = expertise.validation;
+          if (latest.expertise?.record_ref !== `10_EXPERTISE_PACKS/${id}.json`
+            || latest.expertise?.intent_revision !== validation.intent_revision
+            || latest.expertise?.source_count !== validation.source_count
+            || latest.expertise?.capsule_count !== validation.capsule_count
+            || latest.expertise?.pack_digest !== validation.pack_digest) {
+            issues.push({
+              id,
+              type: 'expertise_verification_missing',
+              severity: 'high',
+              msg: `${id} 的最新 passed 未绑定当前 Expertise Pack、Intent revision 与来源/Capsule 计数`,
+            });
+          }
+        }
+      } catch { /* Capability Graph 的结构错误已由上方统一报告。 */ }
+    }
     if (intent.quality_strategy === 'atelier' && latest?.verdict === 'passed') {
       const atelier = atelierRecords.get(id);
       if (!atelier

package/cli/src/expertise-pack.js

@@ -0,0 +1,336 @@
+// expertise-pack.js — provenance-backed external capability acquisition for one Intent.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { getIntent } from './intent-map.js';
+import { compileCapabilityInputs } from './capability-graph.js';
+import { getLoomRoot } from './shared/paths.js';
+import { readJsonFile } from './shared/md-utils.js';
+
+const PACKS_DIR = '10_EXPERTISE_PACKS';
+const VALID_STATUS = ['draft', 'ready', 'blocked'];
+const QUERY_CHANNELS = ['skill_registry', 'web', 'official_docs', 'research', 'tool', 'asset'];
+const SOURCE_KINDS = ['skill', 'web', 'official_docs', 'research', 'tool', 'human'];
+const SOURCE_AUTHORITIES = ['official', 'primary', 'expert', 'community', 'secondary'];
+const EXTERNAL_KNOWLEDGE_KINDS = new Set(['skill', 'web', 'official_docs', 'research']);
+
+export function getExpertisePacksDir(versionDir) {
+  return join(versionDir, PACKS_DIR);
+}
+
+export function getExpertisePackPath(versionDir, intentId) {
+  return join(getExpertisePacksDir(versionDir), `${intentId}.json`);
+}
+
+function pushText(value, label, errors) {
+  if (typeof value !== 'string' || value.trim() === '') errors.push(`${label} 必须是非空字符串`);
+}
+
+function pushTextArray(value, label, errors, { min = 1 } = {}) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} 必须是字符串数组`);
+    return;
+  }
+  if (value.length < min) errors.push(`${label} 至少需要 ${min} 项`);
+  value.forEach((item, index) => pushText(item, `${label}[${index}]`, errors));
+}
+
+function isHttpsLocator(value) {
+  try {
+    return new URL(value).protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+export function getExpertiseRequirement(versionDir, intentId) {
+  const intent = getIntent(versionDir, intentId);
+  const compiled = compileCapabilityInputs(versionDir, intentId);
+  const acquisition = compiled.acquisition || {
+    required: false,
+    required_node_ids: [],
+    nodes: [],
+  };
+  return {
+    intent,
+    compiled,
+    required: acquisition.required === true,
+    required_node_ids: acquisition.required_node_ids || [],
+    acquisition_nodes: acquisition.nodes || [],
+  };
+}
+
+function validateSearchPlan(plan, strict, errors) {
+  if (!plan || typeof plan !== 'object' || Array.isArray(plan)) {
+    errors.push('search_plan 必须是对象');
+    return;
+  }
+  if (!strict) return;
+  pushText(plan.decision_question, 'search_plan.decision_question', errors);
+  pushTextArray(plan.project_signals, 'search_plan.project_signals', errors);
+  pushTextArray(plan.constraints, 'search_plan.constraints', errors);
+  pushText(plan.stop_condition, 'search_plan.stop_condition', errors);
+  if (!Array.isArray(plan.derived_queries) || plan.derived_queries.length === 0) {
+    errors.push('search_plan.derived_queries 至少需要一条运行时派生查询');
+  } else {
+    plan.derived_queries.forEach((query, index) => {
+      const prefix = `search_plan.derived_queries[${index}]`;
+      if (!query || typeof query !== 'object' || Array.isArray(query)) {
+        errors.push(`${prefix} 必须是对象`);
+        return;
+      }
+      if (!QUERY_CHANNELS.includes(query.channel)) {
+        errors.push(`${prefix}.channel 必须是 ${QUERY_CHANNELS.join('|')}`);
+      }
+      pushText(query.query, `${prefix}.query`, errors);
+      pushText(query.rationale, `${prefix}.rationale`, errors);
+    });
+  }
+}
+
+function validateSources(sources, strict, errors) {
+  const ids = new Set();
+  const valid = new Map();
+  if (!Array.isArray(sources)) {
+    errors.push('sources 必须是数组');
+    return { ids, valid, externalCount: 0 };
+  }
+  if (strict && sources.length === 0) errors.push('ready Expertise Pack 必须包含外部来源');
+  let externalCount = 0;
+  sources.forEach((source, index) => {
+    const prefix = `sources[${index}]`;
+    if (!source || typeof source !== 'object' || Array.isArray(source)) {
+      errors.push(`${prefix} 必须是对象`);
+      return;
+    }
+    pushText(source.id, `${prefix}.id`, errors);
+    if (typeof source.id === 'string') {
+      if (ids.has(source.id)) errors.push(`${prefix}.id 重复: ${source.id}`);
+      ids.add(source.id);
+    }
+    if (!SOURCE_KINDS.includes(source.kind)) {
+      errors.push(`${prefix}.kind 必须是 ${SOURCE_KINDS.join('|')}`);
+    }
+    if (!SOURCE_AUTHORITIES.includes(source.authority)) {
+      errors.push(`${prefix}.authority 必须是 ${SOURCE_AUTHORITIES.join('|')}`);
+    }
+    pushText(source.title, `${prefix}.title`, errors);
+    pushText(source.locator, `${prefix}.locator`, errors);
+    if (source.kind !== 'human' && typeof source.locator === 'string' && !isHttpsLocator(source.locator)) {
+      errors.push(`${prefix}.locator 必须是可追溯的 https URL`);
+    }
+    pushText(source.retrieved_at, `${prefix}.retrieved_at`, errors);
+    if (typeof source.retrieved_at === 'string' && Number.isNaN(Date.parse(source.retrieved_at))) {
+      errors.push(`${prefix}.retrieved_at 必须是合法日期时间`);
+    }
+    pushText(source.why_selected, `${prefix}.why_selected`, errors);
+    pushText(source.retrieval_evidence, `${prefix}.retrieval_evidence`, errors);
+    if (EXTERNAL_KNOWLEDGE_KINDS.has(source.kind)) externalCount += 1;
+    if (typeof source.id === 'string' && source.id.trim()) valid.set(source.id, source);
+  });
+  if (strict && externalCount === 0) {
+    errors.push('ready Expertise Pack 至少需要一个 skill|web|official_docs|research 外部知识来源');
+  }
+  return { ids, valid, externalCount };
+}
+
+function validateCapsules(capsules, requiredNodeIds, sourceMap, strict, errors) {
+  const covered = new Set();
+  if (!Array.isArray(capsules)) {
+    errors.push('capsules 必须是数组');
+    return covered;
+  }
+  if (strict && capsules.length === 0) errors.push('ready Expertise Pack 必须包含 Capability Capsule');
+  capsules.forEach((capsule, index) => {
+    const prefix = `capsules[${index}]`;
+    if (!capsule || typeof capsule !== 'object' || Array.isArray(capsule)) {
+      errors.push(`${prefix} 必须是对象`);
+      return;
+    }
+    pushText(capsule.capability_ref, `${prefix}.capability_ref`, errors);
+    if (typeof capsule.capability_ref === 'string') covered.add(capsule.capability_ref);
+    if (strict && requiredNodeIds.length > 0 && !requiredNodeIds.includes(capsule.capability_ref)) {
+      errors.push(`${prefix}.capability_ref 未引用当前 Intent 的外部获取能力节点: ${capsule.capability_ref}`);
+    }
+    if (!strict) return;
+    pushText(capsule.professional_problem, `${prefix}.professional_problem`, errors);
+    pushText(capsule.when_to_use, `${prefix}.when_to_use`, errors);
+    pushTextArray(capsule.rules, `${prefix}.rules`, errors);
+    pushTextArray(capsule.workflow, `${prefix}.workflow`, errors);
+    pushTextArray(capsule.decision_gates, `${prefix}.decision_gates`, errors);
+    pushTextArray(capsule.failure_modes, `${prefix}.failure_modes`, errors);
+    pushTextArray(capsule.verification_signals, `${prefix}.verification_signals`, errors);
+    if (!Array.isArray(capsule.source_refs) || capsule.source_refs.length === 0) {
+      errors.push(`${prefix}.source_refs 至少需要一个来源`);
+    } else {
+      let externalRefCount = 0;
+      capsule.source_refs.forEach((ref, refIndex) => {
+        pushText(ref, `${prefix}.source_refs[${refIndex}]`, errors);
+        if (typeof ref === 'string' && !sourceMap.has(ref)) {
+          errors.push(`${prefix}.source_refs[${refIndex}] 引用不存在的来源: ${ref}`);
+        } else if (EXTERNAL_KNOWLEDGE_KINDS.has(sourceMap.get(ref)?.kind)) {
+          externalRefCount += 1;
+        }
+      });
+      if (externalRefCount === 0) {
+        errors.push(`${prefix} 必须直接引用至少一个 skill|web|official_docs|research 外部知识来源`);
+      }
+    }
+  });
+  if (strict) {
+    for (const nodeId of requiredNodeIds) {
+      if (!covered.has(nodeId)) errors.push(`缺少外部必需能力 ${nodeId} 的 Capability Capsule`);
+    }
+  }
+  return covered;
+}
+
+export function validateExpertisePack(versionDir, intentId, pack = null, { requireReady = true } = {}) {
+  const requirement = getExpertiseRequirement(versionDir, intentId);
+  const path = getExpertisePackPath(versionDir, intentId);
+  const data = pack ?? readJsonFile(path, 'Expertise Pack');
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error('Expertise Pack 校验失败:\n  - 根节点必须是对象');
+  }
+  const errors = [];
+  if (!data._meta || typeof data._meta !== 'object' || Array.isArray(data._meta)) {
+    errors.push('_meta 必须是对象');
+  } else {
+    if (data._meta._version !== '1.0') errors.push('_meta._version 必须是 1.0');
+    if (data._meta._loom_version !== basename(versionDir)) {
+      errors.push(`_meta._loom_version 必须是 ${basename(versionDir)}`);
+    }
+  }
+  if (data.intent_id !== intentId) errors.push(`intent_id 必须是 ${intentId}`);
+  if (data.intent_revision !== (requirement.intent.revision ?? 1)) {
+    errors.push(`intent_revision=${data.intent_revision} 已过期；当前为 ${requirement.intent.revision ?? 1}`);
+  }
+  if (!Array.isArray(data.required_capability_refs)) {
+    errors.push('required_capability_refs 必须是数组');
+  } else {
+    data.required_capability_refs.forEach((ref, index) => {
+      pushText(ref, `required_capability_refs[${index}]`, errors);
+    });
+    const declared = [...new Set(data.required_capability_refs)].sort();
+    const expected = [...new Set(requirement.required_node_ids)].sort();
+    if (JSON.stringify(declared) !== JSON.stringify(expected)) {
+      errors.push(`required_capability_refs 必须精确匹配当前强门节点: ${expected.join(', ') || '无'}`);
+    }
+  }
+  if (!VALID_STATUS.includes(data.status)) errors.push(`status 必须是 ${VALID_STATUS.join('|')}`);
+  const strict = data.status === 'ready';
+  validateSearchPlan(data.search_plan, data.status === 'ready' || data.status === 'blocked', errors);
+  const sourceResult = validateSources(data.sources, strict, errors);
+  validateCapsules(data.capsules, requirement.required_node_ids, sourceResult.valid, strict, errors);
+  if (data.status === 'blocked') {
+    if (!data.blocker || typeof data.blocker !== 'object' || Array.isArray(data.blocker)) {
+      errors.push('blocked 状态必须提供 blocker 对象');
+    } else {
+      pushText(data.blocker.reason, 'blocker.reason', errors);
+      pushText(data.blocker.recovery_condition, 'blocker.recovery_condition', errors);
+    }
+  } else if (data.blocker !== null && data.blocker !== undefined) {
+    errors.push('非 blocked 状态的 blocker 必须为 null 或省略');
+  }
+  if (requireReady && requirement.required && data.status !== 'ready') {
+    errors.push(`当前 Intent 需要外部能力获取，Expertise Pack 必须为 ready（当前: ${data.status}）`);
+  }
+  if (errors.length) throw new Error(`Expertise Pack 校验失败:\n  - ${errors.join('\n  - ')}`);
+  return {
+    valid: true,
+    required: requirement.required,
+    intent_id: intentId,
+    intent_revision: data.intent_revision,
+    status: data.status,
+    required_node_ids: requirement.required_node_ids,
+    source_count: data.sources.length,
+    external_source_count: sourceResult.externalCount,
+    capsule_count: data.capsules.length,
+    pack_digest: createHash('sha256').update(JSON.stringify(data)).digest('hex'),
+    path,
+  };
+}
+
+export function getExpertisePack(versionDir, intentId) {
+  const path = getExpertisePackPath(versionDir, intentId);
+  if (!existsSync(path)) throw new Error(`Expertise Pack 不存在: ${path}`);
+  const pack = readJsonFile(path, 'Expertise Pack');
+  validateExpertisePack(versionDir, intentId, pack, { requireReady: false });
+  return pack;
+}
+
+export function initExpertisePack(versionDir, intentId) {
+  const requirement = getExpertiseRequirement(versionDir, intentId);
+  if (!requirement.required) {
+    throw new Error(`${intentId} 当前没有外部能力获取强门；只有显式 external_required 或未显式豁免的高影响 capability 才需要持久化 Expertise Pack`);
+  }
+  const path = getExpertisePackPath(versionDir, intentId);
+  if (existsSync(path)) throw new Error(`Expertise Pack 已存在，不会覆盖: ${path}`);
+  const templatePath = join(getLoomRoot(), 'templates', 'EXPERTISE_PACK_TEMPLATE.json');
+  const pack = JSON.parse(readFileSync(templatePath, 'utf-8'));
+  pack._meta._loom_version = basename(versionDir);
+  pack.intent_id = intentId;
+  pack.intent_revision = requirement.intent.revision ?? 1;
+  pack.required_capability_refs = requirement.required_node_ids;
+  mkdirSync(getExpertisePacksDir(versionDir), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(pack, null, 2)}\n`, { encoding: 'utf-8', flag: 'wx' });
+  return pack;
+}
+
+export function getExpertisePackState(versionDir, intentId) {
+  const requirement = getExpertiseRequirement(versionDir, intentId);
+  const path = getExpertisePackPath(versionDir, intentId);
+  if (!requirement.required) {
+    return { required: false, ready: true, path, required_node_ids: [] };
+  }
+  if (!existsSync(path)) {
+    return { required: true, ready: false, path, required_node_ids: requirement.required_node_ids, reason: 'missing' };
+  }
+  try {
+    const validation = validateExpertisePack(versionDir, intentId, null, { requireReady: false });
+    const ready = validation.status === 'ready';
+    const pack = ready ? null : readJsonFile(path, 'Expertise Pack');
+    const reason = ready
+      ? undefined
+      : validation.status === 'blocked'
+        ? `blocked: ${pack.blocker.reason}`
+        : `status=${validation.status}`;
+    return { required: true, ready, path, required_node_ids: requirement.required_node_ids, validation, reason };
+  } catch (error) {
+    return { required: true, ready: false, path, required_node_ids: requirement.required_node_ids, reason: error.message };
+  }
+}
+
+export function assertExpertiseReady(versionDir, intentId) {
+  const state = getExpertisePackState(versionDir, intentId);
+  if (!state.required) return null;
+  if (!state.ready) {
+    const action = state.reason === 'missing'
+      ? `先运行 loom expertise init ${intentId}，通过 find skill 与网络搜索获取外部信息，完成后运行 loom expertise validate ${intentId}`
+      : `修正 10_EXPERTISE_PACKS/${intentId}.json 后运行 loom expertise validate ${intentId}`;
+    throw new Error(`${intentId} 的外部能力获取强门尚未闭合: ${state.reason || 'Expertise Pack not ready'}\n${action}`);
+  }
+  return state.validation;
+}
+
+export function formatExpertisePackForPrompt(pack) {
+  const lines = [
+    `- decision_question: ${pack.search_plan.decision_question}`,
+    `- sources: ${pack.sources.map((source) => `${source.id} ${source.title} (${source.locator})`).join('; ')}`,
+  ];
+  for (const capsule of pack.capsules) {
+    lines.push(
+      `\n### Capability Capsule: ${capsule.capability_ref}`,
+      `- professional_problem: ${capsule.professional_problem}`,
+      `- when_to_use: ${capsule.when_to_use}`,
+      `- rules:\n${capsule.rules.map((item) => `  - ${item}`).join('\n')}`,
+      `- workflow:\n${capsule.workflow.map((item) => `  - ${item}`).join('\n')}`,
+      `- decision_gates:\n${capsule.decision_gates.map((item) => `  - ${item}`).join('\n')}`,
+      `- failure_modes:\n${capsule.failure_modes.map((item) => `  - ${item}`).join('\n')}`,
+      `- verification_signals:\n${capsule.verification_signals.map((item) => `  - ${item}`).join('\n')}`,
+      `- source_refs: ${capsule.source_refs.join(', ')}`,
+    );
+  }
+  return lines.join('\n');
+}

package/cli/src/guide.js

@@ -10,6 +10,7 @@ import { getCapabilityCoverage } from './capability-graph.js';
 import { listCapabilityProposals } from './capability-proposals.js';
 import { isAutoOn, getAutoMode, writeHeartbeat, needsHumanReview } from './auto.js';
 import { doctor } from './diagnostics.js';
+import { getExpertisePackState } from './expertise-pack.js';
 
 /**
  * 检测文件是否还是模板（未填充真实内容）。
@@ -373,6 +374,39 @@ function diagnoseStage(cwd, loomRoot, auto) {
   // 状态 5: 有 in_progress
   if (counts.in_progress > 0) {
     const inProgressIds = allIntents.filter((i) => i.status === 'in_progress').map((i) => i.id);
+    const expertiseOpen = allIntents
+      .filter((intent) => intent.status === 'in_progress')
+      .map((intent) => ({ intent, state: getExpertisePackState(versionDir, intent.id) }))
+      .find(({ state }) => state.required && !state.ready);
+    if (expertiseOpen) {
+      const missing = expertiseOpen.state.reason === 'missing';
+      const blocked = expertiseOpen.state.reason?.startsWith('blocked:');
+      return {
+        stage: 'in_loop',
+        stage_num: 5,
+        details: {
+          version: current,
+          counts,
+          in_progress_ids: inProgressIds,
+          expertise_intent: expertiseOpen.intent.id,
+          expertise_reason: expertiseOpen.state.reason,
+        },
+        auto,
+        next_action: missing
+          ? '创建搜索计划并执行外部能力获取'
+          : blocked
+            ? '解决 Expertise Pack 记录的外部获取阻塞'
+            : '补齐来源化 Expertise Pack',
+        next_command: missing
+          ? `loom expertise init ${expertiseOpen.intent.id}`
+          : blocked
+            ? `loom expertise get ${expertiseOpen.intent.id}`
+            : `loom expertise validate ${expertiseOpen.intent.id}`,
+        message: blocked
+          ? `${expertiseOpen.intent.id} 的外部能力获取已明确 blocked：${expertiseOpen.state.reason.slice('blocked: '.length)}。满足 Pack 中的 recovery_condition 后再继续；不能让模型补齐空白。`
+          : `${expertiseOpen.intent.id} 需要外部能力获取。先由任务信号派生搜索词，实际使用 find skill、网络搜索、官方文档或研究资料，再把可回查来源编译为 Capability Capsules；模型临时生成内容不能代替来源。`,
+      };
+    }
     const atelierWithoutRecord = allIntents.find((intent) => intent.status === 'in_progress'
       && intent.quality_strategy === 'atelier'
       && !existsSync(join(versionDir, '09_ATELIER', `${intent.id}.json`)));

package/cli/src/init.js

@@ -51,7 +51,8 @@ export function createVersionStructure(projectDir, version, parentVersion = null
     `.loom/${v}/07_CAPABILITY_BRIEFS`,
     `.loom/${v}/07_GRAPH_PROPOSALS`,
     `.loom/${v}/08_ASSET_LIBRARY/files`,
-  ];
+    `.loom/${v}/10_EXPERTISE_PACKS`,
+  ];
 
   for (const d of dirs) {
     const path = join(cwd, d);

package/cli/src/verify.js

@@ -8,6 +8,7 @@ import { getIntent, getEffectiveVerificationEpoch, hasLegacyIntentRevision } fro
 import { formatIntentRef, resolveIntentRef } from './shared/intent-ref.js';
 import { resolveQualityProofReference } from './shared/proof-reference.js';
 import { validateAtelierRecord } from './atelier.js';
+import { assertExpertiseReady } from './expertise-pack.js';
 
 /** 合法判定结果 */
 const VALID_VERDICTS = ['passed', 'deviated', 'blocked', 'pending_human'];
@@ -46,6 +47,7 @@ function getRequiredDimensions(intent) {
 export function writeVerification(versionDir, verificationsDir, record) {
   const errors = [];
   let atelierEvidence = null;
+  let expertiseEvidence = null;
   if (!record.intent_id) errors.push('缺少 intent_id');
   if (!record.verdict || !VALID_VERDICTS.includes(record.verdict)) {
     errors.push(`verdict 非法: "${record.verdict}" (合法: ${VALID_VERDICTS.join('|')})`);
@@ -104,6 +106,13 @@ export function writeVerification(versionDir, verificationsDir, record) {
       errors.push(error.message);
     }
   }
+  if (record.verdict === 'passed' && intent) {
+    try {
+      expertiseEvidence = assertExpertiseReady(versionDir, record.intent_id);
+    } catch (error) {
+      errors.push(`passed 前必须闭合外部能力获取强门: ${error.message}`);
+    }
+  }
   if (intent?.quality_strategy === 'atelier' && record.verdict === 'passed') {
     try {
       atelierEvidence = validateAtelierRecord(versionDir, record.intent_id);
@@ -162,6 +171,14 @@ export function writeVerification(versionDir, verificationsDir, record) {
       stance_revision: atelierEvidence.stance_revision,
       status: atelierEvidence.status,
     } : undefined,
+    expertise: expertiseEvidence ? {
+      record_ref: `10_EXPERTISE_PACKS/${record.intent_id}.json`,
+      intent_revision: expertiseEvidence.intent_revision,
+      required_node_ids: expertiseEvidence.required_node_ids,
+      source_count: expertiseEvidence.source_count,
+      capsule_count: expertiseEvidence.capsule_count,
+      pack_digest: expertiseEvidence.pack_digest,
+    } : undefined,
     reproduction_command: record.reproduction_command,
     deviation_detail: record.deviation_detail,
     reset_suggested: record.reset_suggested,

package/meta/INTENT_LOOP.md

@@ -110,6 +110,13 @@ Forge 在实现前形成临时 Expertise Pack：
 
 Capability Graph 先提供当前 Intent 相关的项目事实、风险、约束和 Capability Brief；Expertise Compiler 再按 Brief 的获取计划加载真实技能、工具或资料。它不把整张图或历史会话当成当前任务上下文。
 
+当 capability 显式为 `external_required`，或高影响 capability 未显式豁免时，External
+Acquisition Gate 启用。Forge 只能自行生成 Search Plan，必须实际使用 find skill、
+网络、官方文档或研究资料获取内容，再把可回查来源与项目化 Capability Capsules 写入
+`.loom/vN/10_EXPERTISE_PACKS/<intent-id>.json`。Graph 不保存固定站点、Skill 或关键词。
+模型记忆、未打开的搜索摘要和自生成原则不能替代来源。Pack 绑定 Intent revision；Keeper
+不继承 Capsule 结论，而是重新打开关键来源并在 passed 记录中绑定当前 Pack。
+
 `quality_strategy=atelier` 时运行 Identity Compiler：将项目判断编译为可执行的 Authorial
 Stance，而不是模仿名人的 Persona。Forge 在 `.loom/vN/09_ATELIER/<intent-id>.json`
 保存唯一 Atelier Record；普通 Intent 不创建该文件。

package/meta/ROLE_ACTIVATION.md

@@ -69,6 +69,11 @@ Context Pack 不会清除 Agent 既有记忆。发生冲突时，以 system、de
 Expertise Pack。Domain、Taste、Author、Critic、Verifier 是按需认知职能，不是新增角色。
 Author 只在需要形成创作命题时启用，不是常驻 Persona。
 
+未显式豁免的高影响专业能力会让 Context Pack 先打开 External Acquisition Gate：Forge
+从项目事实派生查询并实际检索，将来源化 Capability Capsules 写入当前
+Intent revision 的 `10_EXPERTISE_PACKS`；门闭合后才注入 Author/Atelier。Keeper 只接收
+Pack 的证据入口和计数，必须独立重开关键来源，不继承 Forge 的综合结论。
+
 ### Quality Arena
 
 答案明确时直接实现；声明质量提升时保存基线、比较机制不同的候选。完成契约是

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/loom",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "LOOM — 哲学驱动开发框架。Agent 通过 CLI 访问 Intent Map / 哲学 / 验证记录，不直接读文件",
   "type": "module",
   "bin": {
@@ -15,7 +15,8 @@
     "templates",
     "dimensions",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "EXTERNAL_ACQUISITION_DESIGN.md"
   ],
   "publishConfig": {
     "access": "public",

package/roles/architect.md

@@ -29,7 +29,7 @@
 1. 一个 Intent 产生可观察的完整结果，能独立验证，并可在一次受控工作周期内完成。
 2. 在创建正式 Intent Map 前，先用 Capability Graph 检查适用的用户旅程、体验、系统、资产、横切质量和风险；每个透镜必须展开、覆盖或明确排除。
 3. Graph 不是任务列表：未知与调研留在 Graph；只有边界清楚、可独立验证的结果才进入 Intent Map。
-4. 高影响 capability 节点需要外部知识、专业方法或会进入当前 Intent 时，创建短小的 Capability Brief；不要为每个低价值叶子制造文档。
+4. 高影响 capability 默认进入外部获取强门并创建短小的 Capability Brief；只有证据表明按任务自适应更合适时才显式写 `acquisition_mode: adaptive`，纯内部机械任务可写带理由的 `project_only`。Graph 不保存网站、Skill 或关键词，不为低价值叶子制造文档。
 5. 每个 Intent 必须回链至少一个 Graph 节点；每个高影响 Graph 节点必须有明确路由。
 6. 只引入当前目标确实需要的边界和抽象；不为想象中的扩展性提前付费。
 7. `acceptance` 是完成契约：包含功能承诺、关键失败边界和防御承诺。

package/roles/forge.md

@@ -45,8 +45,15 @@ Stance。Stance 至少包含 creative thesis、gaze、tension、signature bet、
 medium grammar、surprise budget、anti-fixation 与 verification lens。人格故事、设计师
 名号和风格形容词不能替代这些决策。
 
-Context Pack 中出现 Skill 名称只代表可发现。只有实际检查环境并加载后，才算进入
-Expertise Pack。Pack 默认只存在于当前工作上下文，不新增项目文件。
+Context Pack 中出现 Skill 名称只代表可发现。若 External Acquisition Gate 为 OPEN，
+先从 Capability question、项目事实、媒介约束与已观察缺口派生 Search Plan，并实际使用
+find skill、网络、官方文档或研究资料。模型自行生成的常识、未打开的搜索摘要和只有标题的
+结果不能成为来源。
+
+required Pack 写入 `.loom/vN/10_EXPERTISE_PACKS/<intent-id>.json`，只保存来源定位和
+项目化 Capability Capsules，不复制第三方内容。每个 Capsule 必须直接引用已打开的外部
+来源并写出规则、决策门、失败模式与验证信号。运行 `loom expertise validate <intent-id>`
+闭合强门后，才能进入 Author/Atelier 或非机械性实现。
 
 Author 的观察先分流：当前命题、机制、媒介语法或候选选择失效，写入 Atelier Record 的
 `corrections[]` 并递增 `stance_revision`；新的用户结果、约束、研究证据、风险、能力缺口

package/roles/keeper.md

@@ -33,6 +33,8 @@ Keeper 默认运行在新的 Agent thread 中。只接收：
 - BASELINE、acceptance 与按需的 quality_contract。
 - verification_method、当前产物与可复现入口。
 - 当前 revision 的验证历史。
+- External Acquisition Gate required 时，读取当前 Expertise Pack 的 evidence binding，
+  重新打开至少一个决定性来源；不继承 Forge 的 Capsule 结论。
 - `quality_strategy=atelier` 时，读取当前 revision 的 Atelier Record 及其产物引用；不接收
   Forge 为结果辩护的隐藏推理。
 

package/templates/CAPABILITY_BRIEF_TEMPLATE.md

@@ -19,8 +19,9 @@
 
 ## 能力获取计划
 
-- 需要的 Skill、工具、官方资料、项目事实或人类输入：
-- 为什么这些入口适用于当前节点：
+- 需要回答的专业决策问题：
+- 可用的检索通道、工具、项目事实或人类输入（不在 Brief 写死网站和关键词）：
+- Forge 应依据哪些项目信号派生本轮查询：
 - 不可用时的降级或回流：
 
 ## 产出与验证入口

package/templates/CAPABILITY_GRAPH_TEMPLATE.json

@@ -1,6 +1,6 @@
 {
   "_meta": {
-    "_description": "Capability Graph 起点：从项目初衷展开问题面、能力缺口、风险与证据，再编译为 Intent。不是待办列表。",
+    "_description": "Capability Graph 起点：从项目初衷展开问题面、能力缺口、风险与证据，再编译为 Intent。capability 可选 acquisition_mode=adaptive|external_required|project_only；Graph 不保存网站、Skill 或搜索词。",
     "_version": "1.0",
     "_loom_version": "v1",
     "_generated_by": "architect",

package/templates/EXPERTISE_PACK_TEMPLATE.json

@@ -0,0 +1,22 @@
+{
+  "_meta": {
+    "_description": "当前 Intent 的外部能力获取记录。只保存检索计划、来源定位与项目化核心信息，不复制第三方 Skill 或网站内容。",
+    "_version": "1.0",
+    "_loom_version": "v1",
+    "_generated_by": "forge"
+  },
+  "intent_id": "INT-001",
+  "intent_revision": 1,
+  "required_capability_refs": [],
+  "status": "draft",
+  "search_plan": {
+    "decision_question": "",
+    "project_signals": [],
+    "derived_queries": [],
+    "constraints": [],
+    "stop_condition": ""
+  },
+  "sources": [],
+  "capsules": [],
+  "blocker": null
+}