@haaaiawd/loom 1.0.0 → 1.1.0

package/cli/src/diagnostics.js

@@ -11,6 +11,10 @@ import { validatePatches } from './patch.js';
 import { formatIntentRef } from './shared/intent-ref.js';
 import { commandCoversVerificationMethod, getIntentVerificationMethod } from './shared/verification-method.js';
 import { resolveQualityProofReference } from './shared/proof-reference.js';
+import { getCapabilityCoverage, getCapabilityGraphPath, loadCapabilityGraph } from './capability-graph.js';
+import { listCapabilityProposals } from './capability-proposals.js';
+import { getAssetManifestPath, validateAssetLibrary } from './asset-library.js';
+import { validateAtelierRecord } from './atelier.js';
 
 function readIntentMapRaw(versionDir) {
   const filePath = join(versionDir, '04_INTENT_MAP.json');
@@ -161,7 +165,20 @@ const FIX_HINTS = {
   preservation_dimension_missing: '为 continuity_required 的 Intent 补写并通过 preservation_achievement，证据必须覆盖旧状态到新操作后的完整序列',
   patch_changelog_invalid: '运行 loom patch validate 查看具体错误；修正 06_CHANGELOG.json 后重新生成 Markdown 投影',
   patch_projection_drift: '不要手工编辑 06_CHANGELOG.md；重新运行 loom init 或下一次 loom patch record 生成投影',
-};
+  capability_graph_missing: '这是 1.0 项目的兼容提示；迁移时运行 loom activate architect，创建 07_CAPABILITY_GRAPH.json 并路由高影响节点',
+  capability_graph_template: '运行 loom activate architect，先将愿景展开为 Capability Graph，再创建或修订 Intent Map',
+  capability_graph_invalid: '修正 07_CAPABILITY_GRAPH.json 的节点、关系或枚举值后运行 loom capability coverage',
+  capability_frontier_open: '为高影响节点继续展开、创建 Capability Brief、编译为 Intent，或明确延后/排除理由',
+  capability_plan_missing: '为高影响 capability 节点补齐可用 Brief 与获取计划，或改为明确的其他路由',
+  capability_route_evidence: '为该节点补齐路由所需的 Intent 回链、Brief 或延后/排除理由，避免只写一个状态标签',
+  capability_outcome_unexpanded: '将 outcome 连接到至少一个 concern，明确项目初衷需要被处理的问题面',
+  capability_outcome_unobservable: '为高影响 outcome 新建或补齐 evidence 节点，并以 validated_by 连接；evidence 必须写明观察目标、复现步骤、通过标准、证据产物，并回链承担验证的 Intent',
+  intent_graph_unmapped: '将该 Intent 回链到至少一个 Capability Graph 节点；不要让执行承诺失去项目初衷和能力来源',
+  capability_proposal_pending: '由 Architect 审核 proposal：判定已覆盖、更新 Graph、生成/修订 Intent、改变 acceptance，或升级 Minor/Major；Forge 不得静默把候选写进正式图谱。',
+  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。',
+};
 
 /**
  * 给 issue 补 fix_hint——把 {id} {dep} 等占位符替换成实际值。
@@ -196,8 +213,76 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
     return { issues: issuesWithHints, summary: summarizeIssues(issuesWithHints) };
   }
 
-  const { intents } = mapState.validMap;
-
+  const { intents } = mapState.validMap;
+  const atelierRecords = new Map();
+
+  for (const [id, intent] of Object.entries(intents)) {
+    if (intent.quality_strategy !== 'atelier' || intent.status === 'pending' || intent.status === 'blocked') continue;
+    try {
+      const record = validateAtelierRecord(versionDir, id);
+      atelierRecords.set(id, record);
+      if (intent.status === 'completed' && !['selected', 'baseline_retained'].includes(record.status)) {
+        issues.push({ id, type: 'atelier_record_invalid', severity: 'high', msg: `${id} 已 completed，但 Atelier Record 仍是 ${record.status}` });
+      }
+    } catch (error) {
+      issues.push({ id, type: 'atelier_record_invalid', severity: 'high', msg: error.message });
+    }
+  }
+
+  // 0. Incoming Graph changes are an Architect gate, not Forge implementation scope.
+  try {
+    for (const proposal of listCapabilityProposals(versionDir, { unresolvedOnly: true })) {
+      issues.push({ id: proposal.id, type: 'capability_proposal_pending', severity: 'high', msg: `${proposal.id} 是尚未闭合的 ${proposal.origin} 候选（${proposal.candidate_kind}: ${proposal.title}）；必须由 Architect 决定其影响。` });
+    }
+  } catch (error) {
+    issues.push({ id: 'capability_proposals', type: 'capability_proposal_pending', severity: 'high', msg: `Capability Graph proposal 无法审计: ${error.message}` });
+  }
+
+  // Asset Library is optional for a project, but once initialized it is a local source of truth.
+  if (existsSync(getAssetManifestPath(versionDir))) {
+    try { validateAssetLibrary(versionDir); } catch (error) {
+      issues.push({ id: 'asset_library', type: 'asset_library_invalid', severity: 'high', msg: error.message });
+    }
+  }
+
+  // 0. Capability Graph：旧项目允许缺失但提示迁移；图谱一旦存在则必须可读、可路由。
+  const capabilityGraphPath = getCapabilityGraphPath(versionDir);
+  if (!existsSync(capabilityGraphPath)) {
+    issues.push({ id: 'capability_graph', type: 'capability_graph_missing', severity: 'medium', msg: '缺少 07_CAPABILITY_GRAPH.json；现有项目仍可运行，但不会获得图谱驱动的能力拆分与覆盖检查。' });
+  } else {
+    try {
+      const graph = loadCapabilityGraph(versionDir);
+      if (graph._meta?._template === true) {
+        issues.push({ id: 'capability_graph', type: 'capability_graph_template', severity: 'high', msg: 'Capability Graph 仍是模板；不得在未路由项目问题与能力缺口时宣告架构完成。' });
+      } else {
+        const coverage = getCapabilityCoverage(versionDir);
+        for (const node of coverage.high_unrouted) {
+          issues.push({ id: node.id, type: 'capability_frontier_open', severity: 'high', msg: `${node.id} 是尚未路由的高影响 Capability Graph 节点: ${node.title}` });
+        }
+        for (const item of coverage.capabilities_without_plan) {
+          issues.push({ id: item.node_id, type: 'capability_plan_missing', severity: 'high', msg: `${item.node_id} 的能力获取计划不完整: ${item.reason}` });
+        }
+        for (const item of coverage.routing_gaps) {
+          issues.push({ id: item.node_id, type: 'capability_route_evidence', severity: 'high', msg: `${item.node_id} 的图谱路由缺少依据: ${item.reason}` });
+        }
+        for (const item of coverage.outcomes_without_concern) {
+          issues.push({ id: item.node_id, type: 'capability_outcome_unexpanded', severity: 'high', msg: `${item.node_id} 没有展开为项目问题面: ${item.reason}` });
+        }
+        for (const item of coverage.high_outcomes_without_observable_evidence) {
+          issues.push({ id: item.node_id, type: 'capability_outcome_unobservable', severity: 'high', msg: `${item.node_id} 缺少真实呈现或交付的验证入口: ${item.reason}` });
+        }
+        for (const item of coverage.orphan_intent_refs) {
+          issues.push({ id: item.node_id, type: 'intent_graph_unmapped', severity: 'high', msg: `${item.node_id} 引用了不存在的 Intent: ${item.intent_id}` });
+        }
+        for (const intentId of coverage.unmapped_intents) {
+          issues.push({ id: intentId, type: 'intent_graph_unmapped', severity: 'high', msg: `${intentId} 没有 Capability Graph 回链；执行承诺缺少能力与问题来源。` });
+        }
+      }
+    } catch (error) {
+      issues.push({ id: 'capability_graph', type: 'capability_graph_invalid', severity: 'high', msg: error.message });
+    }
+  }
+
   // 1. 状态一致性：completed 必须由当前 revision 的最后一条 passed 验证支撑。
   for (const [id, intent] of Object.entries(intents)) {
     const history = getVerificationHistory(verificationsDir, id);
@@ -229,6 +314,20 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
         }
       }
     }
+    if (intent.quality_strategy === 'atelier' && latest?.verdict === 'passed') {
+      const atelier = atelierRecords.get(id);
+      if (!atelier
+        || latest.atelier?.record_ref !== `09_ATELIER/${id}.json`
+        || latest.atelier?.stance_revision !== atelier.stance_revision
+        || latest.atelier?.status !== atelier.status) {
+        issues.push({
+          id,
+          type: 'atelier_verification_missing',
+          severity: 'high',
+          msg: `${id} 的最新 passed 未绑定当前 Atelier Record、status 与 stance_revision`,
+        });
+      }
+    }
     if (intent.continuity_required && latest?.verdict === 'passed') {
       const preservation = latest.dimensions?.preservation_achievement;
       if (!preservation || preservation.verdict !== 'passed') {

package/cli/src/guide.js

@@ -6,6 +6,8 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { readCurrentPointer } from './version.js';
 import { loadIntentMap } from './intent-map.js';
+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';
 
@@ -70,11 +72,26 @@ export function guideProject(projectDir, options = {}) {
       outputs: [`.loom/${current}/01_VISION.md`],
       verify_command: 'loom guide',
     },
-    need_architecture: {
-      inputs: ['roles/architect.md', `.loom/${current}/01_VISION.md`],
-      outputs: [`.loom/${current}/02_ARCHITECTURE.md`, `.loom/${current}/04_INTENT_MAP.json`],
-      verify_command: 'loom doctor',
-    },
+    need_architecture: {
+      inputs: ['roles/architect.md', `.loom/${current}/01_VISION.md`],
+      outputs: [`.loom/${current}/02_ARCHITECTURE.md`, `.loom/${current}/04_INTENT_MAP.json`],
+      verify_command: 'loom doctor',
+    },
+    need_capability_graph: {
+      inputs: ['roles/architect.md', `.loom/${current}/01_VISION.md`],
+      outputs: [`.loom/${current}/07_CAPABILITY_GRAPH.json`, `.loom/${current}/07_CAPABILITY_BRIEFS/`],
+      verify_command: 'loom capability coverage',
+    },
+    capability_graph_incomplete: {
+      inputs: ['roles/architect.md', `.loom/${current}/07_CAPABILITY_GRAPH.json`, `.loom/${current}/04_INTENT_MAP.json`],
+      outputs: [`.loom/${current}/07_CAPABILITY_GRAPH.json`, `.loom/${current}/07_CAPABILITY_BRIEFS/`],
+      verify_command: 'loom capability coverage',
+    },
+    capability_graph_proposals_pending: {
+      inputs: ['roles/architect.md', `.loom/${current}/07_GRAPH_PROPOSALS/`, `.loom/${current}/07_CAPABILITY_GRAPH.json`],
+      outputs: [`.loom/${current}/07_GRAPH_PROPOSALS/`, `.loom/${current}/07_CAPABILITY_GRAPH.json`, `.loom/${current}/04_INTENT_MAP.json`],
+      verify_command: 'loom capability proposal list',
+    },
     intent_map_broken: {
       inputs: [`.loom/${current}/04_INTENT_MAP.json`],
       outputs: [`.loom/${current}/04_INTENT_MAP.json`],
@@ -169,8 +186,9 @@ function diagnoseStage(cwd, loomRoot, auto) {
 
   const versionDir = join(loomRoot, current);
   const philosophyDir = join(versionDir, '00_PHILOSOPHY');
-  const visionPath = join(versionDir, '01_VISION.md');
-  const intentMapPath = join(versionDir, '04_INTENT_MAP.json');
+  const visionPath = join(versionDir, '01_VISION.md');
+  const intentMapPath = join(versionDir, '04_INTENT_MAP.json');
+  const capabilityGraphPath = join(versionDir, '07_CAPABILITY_GRAPH.json');
 
   // 状态 1: 哲学未织造
   const philosophyFile = join(philosophyDir, 'PRODUCT_PHILOSOPHY.md');
@@ -199,16 +217,77 @@ function diagnoseStage(cwd, loomRoot, auto) {
     };
   }
 
-  // 状态 3: 愿景已定义，Intent Map 未设计
-  if (isTemplate(intentMapPath)) {
-    return {
-      stage: 'need_architecture',
-      stage_num: 3,
-      details: { version: current },
-      auto,
-      next_action: '设计系统架构 + Intent Map',
-      next_command: 'loom activate architect',
-      message: `当前版本 ${current}：愿景已定义，Intent Map 还是模板，需要 Architect 设计。`,
+  // 状态 3: 愿景已定义，先展开项目问题面与能力缺口，再承诺 Intent。
+  if (existsSync(capabilityGraphPath) && isTemplate(capabilityGraphPath)) {
+    return {
+      stage: 'need_capability_graph',
+      stage_num: 3,
+      details: { version: current },
+      auto,
+      next_action: '展开 Capability Graph，路由高影响问题与能力缺口',
+      next_command: 'loom activate architect',
+      message: `当前版本 ${current}：愿景已定义，但 Capability Graph 还是模板。Architect 必须先判断哪些体验、系统、资产、风险与能力适用，再创建正式 Intent。`,
+    };
+  }
+
+  // 图谱一旦存在，就不能把不完整路由悄悄跨过去。旧项目缺少该文件仍保留兼容路径。
+  if (existsSync(capabilityGraphPath)) {
+    try {
+      const pendingProposals = listCapabilityProposals(versionDir, { unresolvedOnly: true });
+      if (pendingProposals.length) {
+        return {
+          stage: 'capability_graph_proposals_pending',
+          stage_num: 3,
+          details: { version: current, proposals: pendingProposals.map((proposal) => proposal.id) },
+          auto,
+          next_action: '审计新信息对 Capability Graph、Intent 和契约的影响',
+          next_command: 'loom capability proposal list',
+          message: `当前版本 ${current} 有 ${pendingProposals.length} 个未闭合的 Capability Graph proposal。它们是新要求、研究或实现发现，不得由 Forge 静默变成当前 Intent 范围。`,
+        };
+      }
+    } catch (error) {
+      return {
+        stage: 'capability_graph_proposals_pending', stage_num: 3, details: { version: current, error: error.message }, auto,
+        next_action: '修复 Capability Graph proposal', next_command: 'loom capability proposal list',
+        message: `Capability Graph proposal 无法审计: ${error.message}`,
+      };
+    }
+    try {
+      const coverage = getCapabilityCoverage(versionDir);
+      if (!coverage.summary.ready) {
+        return {
+          stage: 'capability_graph_incomplete',
+          stage_num: 3.1,
+          details: { version: current, coverage: coverage.summary },
+          auto,
+          next_action: '补齐 Capability Graph 的路由、可观察验证入口与 Intent 回链',
+          next_command: 'loom capability coverage',
+          message: `当前版本 ${current}：Capability Graph 尚未闭合（高影响前沿 ${coverage.summary.high_unrouted}、路由缺口 ${coverage.summary.routing_gaps}、不可观察 outcome ${coverage.summary.high_outcomes_without_observable_evidence}、未映射 Intent ${coverage.summary.unmapped_intents}）。先由 Architect 补图谱，再继续设计 Intent。`,
+        };
+      }
+    } catch (error) {
+      return {
+        stage: 'capability_graph_incomplete',
+        stage_num: 3.1,
+        details: { version: current, error: error.message },
+        auto,
+        next_action: '修复 Capability Graph',
+        next_command: 'loom capability coverage',
+        message: `Capability Graph 无法通过校验: ${error.message}`,
+      };
+    }
+  }
+
+  // 状态 3.5: 图谱已建立，Intent Map 未设计。
+  if (isTemplate(intentMapPath)) {
+    return {
+      stage: 'need_architecture',
+      stage_num: 3.5,
+      details: { version: current },
+      auto,
+      next_action: '从 Capability Graph 编译系统架构 + Intent Map',
+      next_command: 'loom activate architect',
+      message: `当前版本 ${current}：Capability Graph 已建立，Intent Map 还是模板。Architect 需要将已路由的问题面编译为系统架构与可闭合 Intent。`,
     };
   }
 
@@ -291,10 +370,24 @@ 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);
-    return {
+  // 状态 5: 有 in_progress
+  if (counts.in_progress > 0) {
+    const inProgressIds = allIntents.filter((i) => i.status === 'in_progress').map((i) => i.id);
+    const atelierWithoutRecord = allIntents.find((intent) => intent.status === 'in_progress'
+      && intent.quality_strategy === 'atelier'
+      && !existsSync(join(versionDir, '09_ATELIER', `${intent.id}.json`)));
+    if (atelierWithoutRecord) {
+      return {
+        stage: 'in_loop',
+        stage_num: 5,
+        details: { version: current, counts, in_progress_ids: inProgressIds, atelier_intent: atelierWithoutRecord.id },
+        auto,
+        next_action: '创建 Atelier Record 并冻结基线',
+        next_command: `loom atelier init ${atelierWithoutRecord.id}`,
+        message: `${atelierWithoutRecord.id} 已进入 Atelier Path，但还没有唯一创作记录。先创建 Record，再按 Forge Context Pack 形成 Authorial Stance。`,
+      };
+    }
+    return {
       stage: 'in_loop',
       stage_num: 5,
       details: { version: current, counts, in_progress_ids: inProgressIds },

package/cli/src/init.js

@@ -46,8 +46,11 @@ export function createVersionStructure(projectDir, version, parentVersion = null
     '.loom',
     `.loom/${v}`,
     `.loom/${v}/00_PHILOSOPHY`,
-    `.loom/${v}/verifications`,
-    `.loom/${v}/03_DECISIONS`,
+    `.loom/${v}/verifications`,
+    `.loom/${v}/03_DECISIONS`,
+    `.loom/${v}/07_CAPABILITY_BRIEFS`,
+    `.loom/${v}/07_GRAPH_PROPOSALS`,
+    `.loom/${v}/08_ASSET_LIBRARY/files`,
   ];
 
   for (const d of dirs) {
@@ -63,7 +66,9 @@ export function createVersionStructure(projectDir, version, parentVersion = null
   const templates = [
     ['templates/INTENT_MAP_TEMPLATE.json', `.loom/${v}/04_INTENT_MAP.json`],
     ['templates/PHILOSOPHY_TEMPLATE.md', `.loom/${v}/00_PHILOSOPHY/PRODUCT_PHILOSOPHY.md`],
-    ['templates/VISION_TEMPLATE.md', `.loom/${v}/01_VISION.md`],
+    ['templates/VISION_TEMPLATE.md', `.loom/${v}/01_VISION.md`],
+    ['templates/CAPABILITY_GRAPH_TEMPLATE.json', `.loom/${v}/07_CAPABILITY_GRAPH.json`],
+    ['templates/ASSET_LIBRARY_MANIFEST_TEMPLATE.json', `.loom/${v}/08_ASSET_LIBRARY/manifest.json`],
   ];
 
   // 02_ARCHITECTURE.md 和 05_VERIFICATION.md 没有"填空模板"——
@@ -114,7 +119,7 @@ export function createVersionStructure(projectDir, version, parentVersion = null
       skipped.push(dst);
     } else if (existsSync(srcPath)) {
       copyFileSync(srcPath, dstPath);
-      if (dst.endsWith('04_INTENT_MAP.json')) {
+      if (dst.endsWith('04_INTENT_MAP.json') || dst.endsWith('07_CAPABILITY_GRAPH.json') || dst.endsWith('08_ASSET_LIBRARY/manifest.json')) {
         const map = JSON.parse(readFileSync(dstPath, 'utf-8'));
         map._meta._loom_version = v;
         map._meta._parent_version = parentVersion;

package/cli/src/intent-map.js

@@ -174,6 +174,17 @@ function validateLifecycle(data, id, lifecycle, errors) {
 
 function validateOptionalIntentFields(id, intent, errors) {
   const prefix = `intents["${id}"]`;
+  const qualityStrategy = intent.quality_strategy ?? 'adaptive';
+
+  if (!['adaptive', 'atelier'].includes(qualityStrategy)) {
+    errors.push(`${prefix}.quality_strategy 非法: ${JSON.stringify(qualityStrategy)} (合法: adaptive|atelier)`);
+  }
+
+  if ('proposal_refs' in intent) {
+    if (!Array.isArray(intent.proposal_refs) || intent.proposal_refs.some((ref) => typeof ref !== 'string' || !ref.trim())) {
+      errors.push(`${prefix}.proposal_refs 必须是非空 proposal ID 字符串数组`);
+    }
+  }
 
   if ('continuity_required' in intent && typeof intent.continuity_required !== 'boolean') {
     errors.push(`${prefix}.continuity_required 必须是布尔值；仅在本 Intent 会变更既有用户或系统状态且必须证明未误伤旧状态时设为 true`);
@@ -210,6 +221,15 @@ function validateOptionalIntentFields(id, intent, errors) {
       errors.push(`${prefix}.creative_scope 必须说明可以改变什么、必须保持什么`);
     }
   }
+
+  if (qualityStrategy === 'atelier') {
+    if (typeof intent.quality_contract !== 'string' || intent.quality_contract.trim().length < 10) {
+      errors.push(`${prefix}.quality_strategy=atelier 必须声明有效 quality_contract`);
+    }
+    if (typeof intent.creative_scope !== 'string' || intent.creative_scope.trim().length < 10) {
+      errors.push(`${prefix}.quality_strategy=atelier 必须声明有效 creative_scope`);
+    }
+  }
 }
 
 function validateLineage(data, id, lineage, errors) {

package/cli/src/verify.js

@@ -7,6 +7,7 @@ import { extractMdSection, readJsonFile } from './shared/md-utils.js';
 import { getIntent, getEffectiveVerificationEpoch, hasLegacyIntentRevision } from './intent-map.js';
 import { formatIntentRef, resolveIntentRef } from './shared/intent-ref.js';
 import { resolveQualityProofReference } from './shared/proof-reference.js';
+import { validateAtelierRecord } from './atelier.js';
 
 /** 合法判定结果 */
 const VALID_VERDICTS = ['passed', 'deviated', 'blocked', 'pending_human'];
@@ -44,6 +45,7 @@ function getRequiredDimensions(intent) {
  */
 export function writeVerification(versionDir, verificationsDir, record) {
   const errors = [];
+  let atelierEvidence = 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('|')})`);
@@ -102,6 +104,16 @@ export function writeVerification(versionDir, verificationsDir, record) {
       errors.push(error.message);
     }
   }
+  if (intent?.quality_strategy === 'atelier' && record.verdict === 'passed') {
+    try {
+      atelierEvidence = validateAtelierRecord(versionDir, record.intent_id);
+      if (!['selected', 'baseline_retained'].includes(atelierEvidence.status)) {
+        errors.push(`quality_strategy=atelier 通过前，Atelier Record 必须是 selected 或 baseline_retained（当前: ${atelierEvidence.status}）`);
+      }
+    } catch (error) {
+      errors.push(`quality_strategy=atelier 通过前必须有当前且合法的 Atelier Record: ${error.message}`);
+    }
+  }
   if (errors.length > 0) {
     throw new Error(`验证记录校验失败:\n  - ${errors.join('\n  - ')}`);
   }
@@ -144,7 +156,12 @@ export function writeVerification(versionDir, verificationsDir, record) {
     verdict: record.verdict,
     timestamp: record.timestamp,
     summary: record.summary,
-    dimensions: record.dimensions,
+    dimensions: record.dimensions,
+    atelier: atelierEvidence ? {
+      record_ref: `09_ATELIER/${record.intent_id}.json`,
+      stance_revision: atelierEvidence.stance_revision,
+      status: atelierEvidence.status,
+    } : undefined,
     reproduction_command: record.reproduction_command,
     deviation_detail: record.deviation_detail,
     reset_suggested: record.reset_suggested,

package/dimensions/AUTHORSHIP.md

@@ -0,0 +1,45 @@
+# Authorship — Identity Compiler 与 Atelier Method
+
+本维度只在 `quality_strategy=atelier` 时加载。目标不是扮演某位大师，而是迫使本次创作
+形成可反驳的命题、明确的选择与可观察的作品差异。
+
+## Identity Compiler
+
+先读取当前 Intent、Doctrine anchors、Capability Graph / Brief、quality contract、
+creative scope、真实媒介约束与参考机制，再形成 Authorial Stance：
+
+1. `creative_thesis`：作品要让用户以什么不同方式理解或感受问题。
+2. `gaze`：这次优先看见什么。
+3. `tension`：哪两个价值必须同时成立。
+4. `signature_bet`：主张、实现机制与主要代价。
+5. `refusals`：拒绝哪些安全但平庸的默认解。
+6. `medium_grammar`：构图、节奏、动效、材质、语言或声音如何承载命题。
+7. `surprise_budget`：允许陌生到什么程度，哪些边界不可牺牲。
+8. `anti_fixation`：至少一个主动打破首个构想的约束。
+9. `verification_lens`：不看阐述时，怎样从作品与用户行为判断命题成立。
+
+如果这些内容不会改变任何构图、交互、资产、语言或验证动作，Stance 无效。
+
+## Atelier
+
+1. 在修改前冻结真实基线。
+2. 定义至少两个会改变用户体验机制的差异轴。
+3. 独立产生媒介原型；换色、换皮、同义改写不算不同候选。
+4. 每个候选先过 Reliability Floor，再进入质量比较。
+5. 交换顺序或隐藏来源进行比较；没有候选胜过基线时保留基线。
+6. 完整实现胜出机制，观察真实宿主并修正。
+
+唯一记录位于 `.loom/vN/09_ATELIER/<intent-id>.json`。每个候选必须绑定
+`stance_revision`；Stance 改变后，旧候选要重新资格检查或归档。
+
+## Correction Triage
+
+- 当前命题、机制、媒介语法或候选选择失效：写 `corrections[]`，递增
+  `stance_revision`。
+- 新用户结果、约束、能力缺口、风险或项目证据：提交带 provenance 的 Capability Graph
+  proposal，由 Architect 裁决。
+- Intent、契约或 Doctrine 错误：按 LOOM reflow 回到对应上层。
+- 多个任务经 Quality Proof 重复验证的方法：作为 learning candidate，人工晋升为 Skill；
+  只有跨 Intent 的长期创作判断才考虑 Creative Lineage。
+
+Author 不能修改 Graph、Intent 或验收标准，也不能裁决自己的 proposal。

package/meta/INTENT_LOOP.md

@@ -3,7 +3,7 @@
 Intent Loop 将一个产品意图变成可验证结果，并在证据不足时回流到真正负责的层。
 
 ```text
-Doctrine → Intent → Contract
+Doctrine → Intent narrative → Capability Graph → Contract
 → Expertise Compiler → Quality Arena → Quality Proof
 → Close or Reflow
 ```
@@ -14,8 +14,8 @@ Doctrine → Intent → Contract
 |---|---|
 | 长期价值、卓越标准、反模式 | Weaver |
 | 产品目标、非目标、Intent narrative | Visionary |
-| 系统边界、Intent DAG、完成/质量契约 | Architect |
-| Expertise Pack、候选、实现、自测 | Forge |
+| Capability Graph、系统边界、Intent DAG、完成/质量契约 | Architect |
+| Expertise Pack、Authorial Stance、Atelier 候选、实现、自测 | Forge |
 | 独立判定、Quality Proof | Keeper |
 
 Keeper 不修改契约；Forge 不以实现困难改写 Intent；Visionary 不写 acceptance；Weaver 不拆实施模块。
@@ -38,11 +38,22 @@ Keeper 不修改契约；Forge 不以实现困难改写 Intent；Visionary 不
 - `quality_contract`：相对基线可观察的质量主张与最小有意义差异。
 - `capability_needs`：任务需要的专业认知、工具或审美能力。
 - `creative_scope`：允许探索与不得改变的边界。
+- `quality_strategy`：`adaptive | atelier`，缺失等价于 `adaptive`；Atelier 只用于明确需要作者命题、媒介原型与独立候选比较的结果。
 - `verification_method`：可复现验证方法。
 
 `acceptance` 是 Reliability Floor；`quality_contract` 是 Distinctive Ceiling。二者不能合并成一串模糊
 “高质量要求”，否则完成与卓越都无法诚实判定。
 
+### 2.1 Capability Graph Gate
+
+Capability Graph 在 Vision 与 Intent Map 之间展开：`outcome`、`concern`、`capability`、`risk`、`evidence` 节点及其关系。它不是执行 DAG；未知、调研和分叉留在 Graph，只有边界清楚、可独立验收的结果才进入 Intent。
+
+- 所有高影响节点必须路由为 `expand`、`brief`、`intent`、`defer`、`exclude` 或 `covered_by`，不能停留在 `open`。
+- 每个高影响 `outcome` 必须以 `validated_by` 连接到一个有验证计划的 `evidence` 节点。该计划至少声明：结果在何处被观察（`target`）、怎么复现（`procedure`）、什么算通过（`pass_criteria`）、留下什么证据（`artifact`）和由哪个 Intent 产出它。`artifact` 必须是当前版本内 `verifications/` 或 `08_ASSET_LIBRARY/files/` 下真实存在的普通文件；接口可用、文件存在于版本外或 URL 可访问都不能替代目标宿主、用户界面、外部接收方或交付物中的实际可观察结果。
+- 每个当前 Intent 必须由至少一个 Graph 节点的 `intent_refs` 回链；Graph 是这份关联的唯一真相源，避免双写漂移。
+- 需要专业方法、外部知识、研究或即将进入当前 Intent 的能力节点，才使用 `.loom/vN/07_CAPABILITY_BRIEFS/<node-id>.md` 写项目化 Brief。
+- `loom capability coverage` 是 Architect 完成图谱后的门；`loom capability compile <id>` 是 Forge 的只读编译入口。Forge 发现新的缺口必须回流 Architect，不能把猜测静默变成实现范围。
+
 ## 3. 状态与 revision
 
 状态：
@@ -68,7 +79,7 @@ completed → needs_review → in_progress
 3. Hard Invariants
 4. Success Contracts
 5. Project Judgment
-6. Expertise Inputs
+6. Expertise Inputs（含当前 Intent 编译得到的 Capability Graph 节点与 Brief）
 7. Working Facts
 8. Role Contract / Output / Reflow / Stop
 
@@ -83,6 +94,7 @@ loom intent update <id> --status in_progress
 ```
 
 只选择 pending、所有依赖 completed、未弃用的 Intent。一次 Forge 作用域只包含一个当前 Intent。
+进入选择前，Graph coverage 必须没有未路由的高影响节点、无计划能力节点和未映射 Intent。
 
 ## 6. Expertise Compiler
 
@@ -90,10 +102,34 @@ Forge 在实现前形成临时 Expertise Pack：
 
 - **Domain**：领域机制、失败边界和项目事实。
 - **Taste**：什么区分普通、可靠和出众。
+- **Author**：这次提出什么可反驳的创作命题，选择什么并拒绝什么。
 - **Critic**：最可能出现的平庸方案、自我欺骗与反例。
 - **Verifier**：如何观察、比较和复现。
 
-这四项是认知功能，不是必须创建四个角色或四份文档。
+这五项是认知功能，不是必须创建五个角色或五份文档。
+
+Capability Graph 先提供当前 Intent 相关的项目事实、风险、约束和 Capability Brief；Expertise Compiler 再按 Brief 的获取计划加载真实技能、工具或资料。它不把整张图或历史会话当成当前任务上下文。
+
+`quality_strategy=atelier` 时运行 Identity Compiler：将项目判断编译为可执行的 Authorial
+Stance，而不是模仿名人的 Persona。Forge 在 `.loom/vN/09_ATELIER/<intent-id>.json`
+保存唯一 Atelier Record；普通 Intent 不创建该文件。
+
+### 2.2 Graph Change Proposal Gate
+
+新用户要求是 `outcome` 或 `constraint` 候选；论文、资料与运行发现是带 provenance 的 `capability`、`risk` 或 `evidence` 候选。它们先写入 `.loom/vN/07_GRAPH_PROPOSALS/CGP-*.json`，必须记录来源、观察时间、具体证据、为什么现在需要处理。Proposal 不是正式 Graph，Forge/Keeper 不得借它静默扩大当前 Intent。
+
+Architect 必须把每个 proposal 判定为：已覆盖、Graph 更新、Intent 变更、acceptance 变更、Minor、Major 或拒绝；关闭时必须提交与决策相符的结构化 resolution，CLI 会从决策时磁盘基线验证 Graph / Intent / acceptance / 决策记录的真实变化或现有有效覆盖，不能以任意 implementation_ref 文本关闭。`constraint` 若决定为 Graph 更新，必须进入正式 Graph 的 `constraints` 字段并回链受影响节点。`covered_by` 必须显式指向另一个已覆盖、非 `covered_by` 路由的节点，并同时保留同目标的关系。`loom guide` 与 `loom doctor` 对未闭合 proposal 回流 Architect。
+
+Author 的自我更正不得绕过该门：局部命题、机制、媒介语法或候选选择变化写入 Atelier
+Record `corrections[]` 并递增 `stance_revision`；只有新的用户结果、约束、能力缺口、风险
+或项目证据才提交 Graph proposal。Architect 裁决并修订磁盘真相源后，Capability compile
+把新输入交回 Author。Author 不得裁决自己的 proposal，也不得修改考纲后自证通过。
+
+### 2.3 Asset Library Protocol
+
+若项目使用图片、音频、视频、模型或其他交付素材，`.loom/vN/08_ASSET_LIBRARY/manifest.json` 与同目录 `files/` 是版本化的一等真相源。每条资产必须有内容派生稳定 ID、kind、中文/其他标签、来源/作者/许可、SHA-256、库内相对路径、status 与 approval。`loom asset import` 只接受明确的本地普通文件、复制后校验哈希，并拒绝路径逃逸、重复字节和未批准/缺少许可元数据。
+
+素材字节能下载不等于素材可呈现；远程 URL 不是呈现证据。资产若用于 Capability Graph 的 evidence，资产 `evidence_refs` 与 evidence 节点 `asset_refs` 必须双向一致，Keeper 仍需在目标宿主验证实际呈现。
 
 技能、工具和资料必须经历：
 
@@ -123,6 +159,16 @@ Discover → Load → Translate → Use
 
 候选不强制落盘，不设置固定数量。没有候选胜过基线时，保留原方案或回流契约。
 
+### Atelier Path
+
+当 `quality_strategy=atelier` 时，Arena 增加明确作者命题与落盘证据：
+
+1. 编译 Authorial Stance 并冻结修改前基线。
+2. 定义质量差异轴，独立形成机制不同的媒介原型。
+3. 候选先过 Reliability Floor，再匿名比较或保留基线。
+4. 每个候选绑定 `stance_revision`；Stance 改变后重新资格检查或归档旧候选。
+5. 选择证据、主要代价和 corrections 写入唯一 Atelier Record，再进入完整实现。
+
 ## 8. Independent Quality Proof
 
 Keeper 在独立任务中只加载当前 revision、真实产物、契约、Doctrine 和必要验证工具。不要加载 Forge 的
@@ -210,6 +256,7 @@ Codex 的 goal/status 用于驱动循环与恢复工作，不是替代上述证
 | 长期价值或质量观缺失 | Weaver |
 | 产品目标、非目标或 narrative 错误 | Visionary |
 | 系统边界、依赖、契约不可成立 | Architect |
+| 图谱分支遗漏、能力缺口或高影响节点未路由 | Architect 更新 Capability Graph |
 | 专业能力、候选或实现不足 | Forge |
 | 证据不足、验证偏差或需人类感知 | Keeper |
 

package/meta/ROLE_ACTIVATION.md

@@ -3,7 +3,7 @@
 角色是决策权边界，不是人格表演。LOOM 的执行链是：
 
 ```text
-Doctrine → Intent → Contract → Expertise Compiler
+Doctrine → Intent narrative → Capability Graph → Contract → Expertise Compiler
 → Quality Arena → Quality Proof → Reflow
 ```
 
@@ -18,11 +18,11 @@ Doctrine → Intent → Contract → Expertise Compiler
 3. Hard Invariants：BASELINE 摘要与命中的项目底线。
 4. Success Contracts：acceptance、按需的 continuity_required / quality_contract、verification_method；其中状态守恒规则仍只写在 acceptance。
 5. Project Judgment：相关 Doctrine anchors 与决策记录。
-6. Expertise Inputs：capability_needs、可发现的 Skill / 工具 / 资产入口和获取边界。
+6. Expertise Inputs：当前 Intent 编译得到的 Capability Graph 节点与 Brief、`capability_needs`、`quality_strategy`、可发现的 Skill / 工具 / 资产入口和获取边界；仅当 `quality_strategy=atelier` 时注入 Authorship Method 与 Atelier Record 要求。
 7. Working Facts：相关架构、代码、资产、基线和产物路径。
 8. Output / Reflow / Stop：交付、证据、回流与停止条件。
 
-Context Pack 编译器只选择事实和能力入口。Expertise Compiler 在角色激活后检查真实环境，
+Context Pack 编译器只选择事实和能力入口。Capability Graph 保留项目问题面、能力缺口、风险、证据与 Intent 回链；它不是任务列表，只有当前 Intent 关联的节点和 Brief 会进入 Context Pack。Expertise Compiler 在角色激活后检查真实环境，
 再形成 Expertise Pack；看见 Skill 名称不等于已经加载能力。
 
 Context Pack 不会清除 Agent 既有记忆。发生冲突时，以 system、developer 和用户指令
@@ -42,14 +42,18 @@ Context Pack 不会清除 Agent 既有记忆。发生冲突时，以 system、de
 
 ### Architect
 
-- 拥有系统边界、Intent DAG、公共契约、质量契约和验证入口。
-- 声明 capability_needs 与 creative_scope。
+- 拥有 Capability Graph、系统边界、Intent DAG、公共契约、质量契约和验证入口。
+- 先路由高影响图谱节点并保证每个 Intent 回链，再声明 capability_needs 与 creative_scope。
 - 不实现，也不给出通过结论。
 
 ### Forge
 
 - 为当前 Intent 编译 Expertise Pack，运行 Quality Arena 并完成实现和自测。
 - 可以做必要局部设计、错误处理和可逆探索。
+- `quality_strategy=atelier` 时增加 Author 认知职能：用 Identity Compiler 形成可反驳的
+  Authorial Stance，并将基线、候选、修正和选择写入唯一 Atelier Record。
+- 局部创作假设更正只递增 `stance_revision`；结构性新发现提交 Capability Graph proposal，
+  由 Architect 裁决后再经 Capability compile 进入下一版 Stance。
 - 不改变上层目标、公共契约或架构边界。
 
 ### Keeper
@@ -62,7 +66,8 @@ Context Pack 不会清除 Agent 既有记忆。发生冲突时，以 system、de
 ### Expertise Compiler
 
 按任务组合项目事实、Skill、工具、资产、参考、质量机制、失败模型与验证手段，输出临时
-Expertise Pack。Domain、Taste、Critic、Verifier 是按需认知职能，不是新增角色。
+Expertise Pack。Domain、Taste、Author、Critic、Verifier 是按需认知职能，不是新增角色。
+Author 只在需要形成创作命题时启用，不是常驻 Persona。
 
 ### Quality Arena
 
@@ -79,6 +84,7 @@ Reliability Floor，质量契约是 Distinctive Ceiling。没有候选胜过基
 
 - 实现错误、遗漏或局部质量不足 → Forge。
 - acceptance、verification_method、依赖或架构错误 → Architect。
+- 项目问题面遗漏、能力缺口或图谱回链缺失 → Architect 更新 Capability Graph。
 - 目标、非目标或 narrative 错误 → Visionary。
 - 长期项目原则持续失效 → Weaver / 新版本。
 - 缺少外部授权或主观裁决 → 人类。