@haaaiawd/loom 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 1.2.2 — 2026-07-31
+
+### Fixed
+
+- `guide` 只输出下一步命令、Context Pack 提示与完成校验，不再展示文件输入/输出清单；当下一步是角色激活时，由该命令装配 Context Pack。
+- `activate weaver` 直接注入检索方法与哲学维度目录；`activate architect` 在无 Intent 的设计阶段直接注入愿景、当前 Capability Graph、Intent Map 与未闭合 proposal。
+- Capability Graph 未闭合或 proposal 待裁决时，`guide` 重新指向可推进工作的 Architect Context Pack，而不是重复运行只读检查。
+- `loom intent next` 返回开始该 Intent 和获取 Forge Context Pack 的明确后续命令。
+
+## 1.2.1 — 2026-07-31
+
+### Fixed
+
+- `verify pass` 现在要求声明独立 Keeper 或人类复核来源，并将该来源写入验证记录；普通自检不能再被快捷命令包装成 `passed`。
+- 高影响 capability 若选择 `adaptive`，必须留下为何不启用外部获取强门的理由；无理由的 `adaptive` 不再是静默绕过路径。
+- Intent 模板不再默认引用不存在的质量契约章节，并增加叙事语义守恒与反例验证的提示。
+
+### Compatibility
+
+- 旧版结构化验证记录仍可读取；新的 passed 记录（包括 `verify write`）必须声明验证来源。旧记录可供历史追溯，但不自动获得独立验证声明。
+
 ## 1.2.0 — 2026-07-31
 
 ### Added

package/README.md

@@ -87,11 +87,14 @@ loom guide --dry-run  # 只读诊断，不写 heartbeat
 guide 检测项目当前在哪个阶段，输出"你在阶段 X，下一步做 Y"。
 Agent 每完成一步都跑 guide 确认下一步。
 如果只是审计或探测，不希望产生任何状态写入，用 `loom guide --dry-run`。
+
+当 `guide` 的下一步是 `loom activate <role>` 时，先运行这条命令：它会把该阶段需要的
+规范与版本化输入编译为 Context Pack。`guide` 只负责导航，不输出待阅读文件清单。
 
 ### AUTO 模式
 
 ```bash
-loom auto on      # Agent 自动连续执行，不等确认
+loom auto on      # Agent 在允许阶段连续推进；不会跳过契约、证据或 Keeper 门禁
 loom auto off     # 每步需要用户确认
 ```
 

package/cli/bin/loom.js

@@ -274,9 +274,19 @@ try {
           }));
           break;
         }
-        case 'next':
-          output(getNextIntent(versionDir) ?? '没有可执行的 Intent');
-          break;
+        case 'next':
+          {
+            const next = getNextIntent(versionDir);
+            output(next ? {
+              ...next,
+              suggested_flow: {
+                start: `loom intent update ${next.id} --status in_progress`,
+                forge_context: `loom activate forge --intent ${next.id}`,
+                note: '先显式开始 Intent，再由 activate 命令装配该 Intent 的叙事、契约、图谱路由与专业输入。',
+              },
+            } : '没有可执行的 Intent');
+          }
+          break;
         case 'status': {
           const s = getStatus(versionDir);
           const fmt = (ids) => ids.map((id) => s.titles[id] ? `${id}(${s.titles[id]})` : id).join(', ') || '-';
@@ -518,7 +528,7 @@ try {
               const icon = issue.severity === 'high' ? '⚠' : '·';
               console.log(`  ${icon} [${issue.severity}] ${issue.msg}`);
             }
-            console.log('\n参见 meta/PHILOSOPHY_WEAVER.md + dimensions/SEARCH_METHODOLOGY.md。');
+            console.log('\n下一步: 运行 loom activate weaver；命令会重新输出哲学阶段所需的 Context Pack。');
             exit(1);
           }
           break;
@@ -592,7 +602,7 @@ try {
         }
         case 'pass':
         case 'fail': {
-          // loom verify pass <id> --summary "..." [--reproduction-command "..."] [--preservation-evidence "..."] [--quality-proof "..."]
+          // loom verify pass <id> --summary "..." --verified-by <id> --verification-context <independent_thread|human_review>
           // loom verify fail <id> --summary "..." [--deviation "..."] [--reproduction-command "..."]
           const id = rest[0];
           if (!id) die(`用法: loom verify ${sub} <id> --summary "..." [--reproduction-command "..."]${sub === 'pass' ? ' [--preservation-evidence "..."] [--quality-proof "..."]' : ' [--deviation "..."]'}`);
@@ -601,6 +611,8 @@ try {
           const deviationIdx = argv.indexOf('--deviation');
           const qualityProofIdx = argv.indexOf('--quality-proof');
           const preservationIdx = argv.indexOf('--preservation-evidence');
+          const verifiedByIdx = argv.indexOf('--verified-by');
+          const verificationContextIdx = argv.indexOf('--verification-context');
           const summary = summaryIdx !== -1 ? argv[summaryIdx + 1] : null;
           if (!summary) die(`缺少 --summary: loom verify ${sub} ${id} --summary "..."`);
           const intent = getIntent(versionDir, id);
@@ -610,11 +622,15 @@ try {
           if (sub === 'pass' && intent.quality_contract && !(qualityProofIdx !== -1 && argv[qualityProofIdx + 1])) {
             die(`Intent ${id} 声明了 quality_contract；通过前必须提供 --quality-proof，指向项目内真实的 Quality Proof Markdown 锚点。`);
           }
+          if (sub === 'pass' && !(verifiedByIdx !== -1 && argv[verifiedByIdx + 1] && verificationContextIdx !== -1 && argv[verificationContextIdx + 1])) {
+            die(`Intent ${id} 通过前必须声明独立验证来源：--verified-by <thread/run/人类标识> --verification-context <independent_thread|human_review>。同一会话自检请记录为自检，不得写 passed。`);
+          }
           const extras = {};
           if (reproIdx !== -1 && argv[reproIdx + 1]) extras.reproduction_command = argv[reproIdx + 1];
           if (sub === 'fail' && deviationIdx !== -1 && argv[deviationIdx + 1]) extras.deviation_detail = argv[deviationIdx + 1];
           if (sub === 'pass' && qualityProofIdx !== -1 && argv[qualityProofIdx + 1]) extras.quality_proof_ref = argv[qualityProofIdx + 1];
           if (sub === 'pass' && preservationIdx !== -1 && argv[preservationIdx + 1]) extras.preservation_evidence = argv[preservationIdx + 1];
+          if (sub === 'pass') extras.verification_provenance = { verified_by: argv[verifiedByIdx + 1], context: argv[verificationContextIdx + 1] };
           const verdict = sub === 'pass' ? 'passed' : 'deviated';
           const result = createQuickVerification(versionDir, verificationsDir, id, verdict, summary, extras);
           console.log(`验证记录已写入: ${result.filePath}`);
@@ -732,7 +748,7 @@ try {
             console.log(`    → 修复: ${issue.fix_hint}`);
           }
         }
-        console.log(`\n参见 meta/PHILOSOPHY_WEAVER.md + dimensions/SEARCH_METHODOLOGY.md。`);
+        console.log('\n下一步: 运行 loom guide；它会根据当前状态给出可执行动作与所需 Context Pack。');
       }
       break;
     }
@@ -782,17 +798,12 @@ try {
       };
       console.log(`模式: ${modeDesc[result.auto_mode] || result.auto_mode}`);
       console.log(`\n${result.message}`);
-      console.log(`\n下一步: ${result.next_action}`);
-      console.log(`  → ${result.next_command}`);
-      if (result.inputs && result.inputs.length > 0) {
-        console.log(`\n需要读取:`);
-        for (const f of result.inputs) console.log(`  - ${f}`);
-      }
-      if (result.outputs && result.outputs.length > 0) {
-        console.log(`\n需要产出:`);
-        for (const f of result.outputs) console.log(`  - ${f}`);
-      }
-      if (result.verify_command) {
+      console.log(`\n下一步: ${result.next_action}`);
+      console.log(`  → ${result.next_command}`);
+      if (result.input_delivery === 'context_pack') {
+        console.log('\n上下文: 直接运行这条命令；它会输出当前阶段所需的 Context Pack。');
+      }
+      if (result.verify_command) {
         console.log(`\n完成后校验: ${result.verify_command}`);
       }
       if (result.auto_mode === 'manual' && result.stage_num > 0 && result.stage_num < 6) {

package/cli/help/doctor.md

@@ -49,7 +49,9 @@ loom philosophy check
 快速命令：
 
 ```bash
-loom verify pass <id> --summary "<证据>" --quality-proof "<ref>"
+loom verify pass <id> --summary "<证据>" --quality-proof "<ref>" \
+  --verified-by "<keeper-thread-or-human>" \
+  --verification-context independent_thread
 ```
 
 若只达到完成契约，写 `deviated` 或完整验证记录，不要伪造质量通过。

package/cli/help/loop.md

@@ -28,7 +28,7 @@ Forge 先形成任务级 Expertise Pack：
 - 已实际加载的技能、资料、工具及其用途。
 - Critic 视角与验证方法。
 
-Pack 是任务级认知配置，不写成新的长期规范。External Acquisition Gate required 时，Pack
+Pack 是任务级认知配置，不写成新的长期规范。高影响 capability 默认进入 External Acquisition Gate；若明确选择 `adaptive`，也必须写明为何此处不启用外部获取。Pack
 必须落盘到 `10_EXPERTISE_PACKS/<intent-id>.json`：Search Plan 可由 AI 派生，但 Capsule 内容
 必须来自实际打开的外部来源，并写出判断门、失败模式和验证信号。明显的机械任务可以保持
 `adaptive`；高质量任务必须足以解释为什么某个专业手法适合这个项目。
@@ -60,6 +60,10 @@ Keeper 独立检查基础四维；有质量契约时增加第五维：
   "verdict": "passed",
   "timestamp": "2026-07-28T12:00:00.000Z",
   "summary": "具体、可定位、可复现的判定摘要",
+  "verification_provenance": {
+    "verified_by": "keeper thread 或人类复核标识",
+    "context": "independent_thread"
+  },
   "reproduction_command": "npm test",
   "dimensions": {
     "intent_fidelity": {
@@ -87,6 +91,14 @@ Keeper 独立检查基础四维；有质量契约时增加第五维：
 }
 ```
 
+快捷写入 `passed` 时，也必须声明这一来源：
+
+```bash
+loom verify pass INT-001 --summary "..." \
+  --verified-by "keeper-run-123" \
+  --verification-context independent_thread
+```
+
 若 Intent 声明 `continuity_required: true`，Keeper 还必须写入并通过：
 
 ```json

package/cli/help/workflow.md

@@ -9,6 +9,9 @@ loom context
 
 只读探测使用 `loom guide --dry-run`。
 
+若 `guide` 指向 `loom activate <role>`，直接运行该命令。它会输出已经装配的 Context Pack；
+`guide` 只负责给出当前动作，不要求 Agent 逐个寻找文件。
+
 ## 1. Doctrine — Weaver
 
 ```bash

package/cli/src/activate.js

@@ -1,7 +1,7 @@
 // activate — compile a role- and intent-scoped Context Pack.
 
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
 import { getLoomRoot } from './shared/paths.js';
 import { getIntent, getNarrative } from './intent-map.js';
 import { getIntentDraft } from './intent-draft.js';
@@ -11,6 +11,7 @@ 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';
+import { listCapabilityProposals } from './capability-proposals.js';
 
 const VALID_ROLES = ['weaver', 'visionary', 'architect', 'forge', 'keeper'];
 
@@ -354,6 +355,92 @@ function compileWorkingFacts(versionDir, objective) {
   return refs.join('\n');
 }
 
+function readStageFile(path, label) {
+  if (!existsSync(path)) return `> ${label} 当前不存在；不要猜测其内容。按角色契约创建或回流。`;
+  return readFileSync(path, 'utf-8').trim();
+}
+
+function listMarkdownFiles(root, current = root) {
+  if (!existsSync(current)) return [];
+  return readdirSync(current, { withFileTypes: true })
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .flatMap((entry) => {
+      const path = join(current, entry.name);
+      if (entry.isDirectory()) return listMarkdownFiles(root, path);
+      return entry.isFile() && entry.name.endsWith('.md')
+        ? [relative(root, path).replaceAll('\\', '/')]
+        : [];
+    });
+}
+
+/**
+ * Compile the stage inputs that used to be merely named by `loom guide`.
+ * These are intentionally separate from Working Facts: they are the source
+ * material for a role's immediate decision, not a request to hunt for paths.
+ */
+function compileStageInputs(role, versionDir, objective) {
+  if (role === 'weaver') {
+    const dimensionsRoot = join(getLoomRoot(), 'dimensions');
+    const catalog = listMarkdownFiles(dimensionsRoot)
+      .filter((path) => path !== 'SEARCH_METHODOLOGY.md')
+      .map((path) => `- dimensions/${path}`);
+    return [
+      '本节由 `loom activate weaver` 直接装配。不要为了取得这些输入而搜索 CLI 安装目录。',
+      '',
+      '### Search Methodology',
+      '',
+      readStageFile(join(dimensionsRoot, 'SEARCH_METHODOLOGY.md'), 'SEARCH_METHODOLOGY.md'),
+      '',
+      '### Available Dimension Catalog',
+      '',
+      catalog.length
+        ? `${catalog.join('\n')}\n\n只打开会实质改变当前项目原则或取舍的维度；目录本身不是要求逐个阅读。`
+        : '> 当前没有可用的 dimensions 文档。',
+    ].join('\n');
+  }
+
+  if (role === 'architect' && versionDir && !objective.intent && !objective.draft) {
+    let proposals = [];
+    let proposalsError = null;
+    try {
+      proposals = listCapabilityProposals(versionDir, { unresolvedOnly: true });
+    } catch (error) {
+      proposalsError = error.message;
+    }
+    return [
+      '本节由 `loom activate architect` 直接装配。以下是当前设计决策所需的版本化输入，不要先手动查找路径。',
+      '',
+      '### Vision Input (01_VISION.md)',
+      '',
+      readStageFile(join(versionDir, '01_VISION.md'), '01_VISION.md'),
+      '',
+      '### Capability Graph Input (07_CAPABILITY_GRAPH.json)',
+      '',
+      readStageFile(join(versionDir, '07_CAPABILITY_GRAPH.json'), '07_CAPABILITY_GRAPH.json'),
+      '',
+      '### Intent Map Input (04_INTENT_MAP.json)',
+      '',
+      readStageFile(join(versionDir, '04_INTENT_MAP.json'), '04_INTENT_MAP.json'),
+      '',
+      '### Open Capability Graph Proposals',
+      '',
+      proposalsError
+        ? `> Proposal 记录无法读取：${proposalsError}。先修复这份记录，不要猜测其状态。`
+        : proposals.length
+        ? `\`\`\`json\n${JSON.stringify(proposals, null, 2)}\n\`\`\``
+        : '无。',
+    ].join('\n');
+  }
+
+  if (role === 'visionary') {
+    return '产品哲学与决策准则已在上方 Project Judgment 中装配；不要重新搜索 `.loom` 目录。';
+  }
+  if (role === 'forge' || role === 'keeper') {
+    return '当前 Intent 的叙事、契约、图谱路由与已就绪的 Expertise 输入已在上方装配；只有产物本身需要按 Working Facts 检查。';
+  }
+  return '当前角色没有额外的阶段输入。';
+}
+
 /**
  * Compile a role-scoped Context Pack.
  * @param {string} role
@@ -377,9 +464,10 @@ export function activateRole(role, versionDir, intentId = null) {
     section('3. Hard Invariants', compileInvariants(role, versionDir)),
     section('4. Success Contracts', compileContracts(role, versionDir, objective)),
     section('5. Project Judgment', compileProjectJudgment(role, versionDir, objective)),
-    section('6. Expertise Inputs', compileExpertiseInputs(role, versionDir, objective)),
-    section('7. Working Facts', compileWorkingFacts(versionDir, objective)),
-    section('8. Role Contract / Output / Reflow / Stop', readRole(role)),
+    section('6. Stage Inputs (command-assembled)', compileStageInputs(role, versionDir, objective)),
+    section('7. Expertise Inputs', compileExpertiseInputs(role, versionDir, objective)),
+    section('8. Working Facts', compileWorkingFacts(versionDir, objective)),
+    section('9. Role Contract / Output / Reflow / Stop', readRole(role)),
   ];
   return `${parts.join('\n\n---\n\n')}\n`;
 }

package/cli/src/capability-graph.js

@@ -78,6 +78,10 @@ function validateNode(id, node, allIds, errors) {
     && (typeof node.acquisition_rationale !== 'string' || !node.acquisition_rationale.trim())) {
     errors.push(`nodes["${id}"].acquisition_mode=project_only 必须声明 acquisition_rationale`);
   }
+  if (node.impact === 'high' && node.acquisition_mode === 'adaptive'
+    && (typeof node.acquisition_rationale !== 'string' || !node.acquisition_rationale.trim())) {
+    errors.push(`nodes["${id}"] 为高影响 capability 且选择 adaptive 时必须声明 acquisition_rationale；说明为何此处不启用 external_required`);
+  }
   if (node.verification !== undefined) {
     if (node.kind !== 'evidence') {
       errors.push(`nodes["${id}"].verification 只允许写在 evidence 节点`);
@@ -267,6 +271,7 @@ export function getCapabilityCoverage(versionDir) {
   const capabilitiesWithoutPlan = [];
   const routingGaps = [];
   const outcomesWithoutConcern = [];
+  const evidenceArtifactGaps = [];
 
   for (const node of nodes) {
     for (const intentId of node.intent_refs || []) {
@@ -305,6 +310,12 @@ export function getCapabilityCoverage(versionDir) {
     if (node.kind === 'outcome' && !(node.relationships || []).some((relation) => graph.nodes[relation.target]?.kind === 'concern')) {
       outcomesWithoutConcern.push({ node_id: node.id, reason: 'outcome 没有连接到 concern，项目初衷尚未展开为问题面' });
     }
+    if (node.kind === 'evidence' && node.verification?.artifact) {
+      const ownedCompletedIntent = (node.intent_refs || []).some((intentId) => intentMap.intents[intentId]?.status === 'completed');
+      if (ownedCompletedIntent && !resolveEvidenceArtifact(versionDir, node.verification.artifact)) {
+        evidenceArtifactGaps.push({ node_id: node.id, reason: `已完成 Intent 的 evidence artifact 不存在或不可读: ${node.verification.artifact}` });
+      }
+    }
     if (node.brief_ref) {
       try { resolveBrief(versionDir, node.brief_ref); } catch (error) {
         capabilitiesWithoutPlan.push({ node_id: node.id, reason: error.message });
@@ -326,6 +337,7 @@ export function getCapabilityCoverage(versionDir) {
       routing_gaps: routingGaps.length,
       outcomes_without_concern: outcomesWithoutConcern.length,
       high_outcomes_without_observable_evidence: highOutcomesWithoutObservableEvidence.length,
+      evidence_artifact_gaps: evidenceArtifactGaps.length,
       intent_mapping_required: intentMappingRequired,
       unmapped_intents: unmappedIntents.length,
       ready: highUnrouted.length === 0
@@ -334,6 +346,7 @@ export function getCapabilityCoverage(versionDir) {
         && routingGaps.length === 0
         && outcomesWithoutConcern.length === 0
         && highOutcomesWithoutObservableEvidence.length === 0
+        && evidenceArtifactGaps.length === 0
         && unmappedIntents.length === 0,
     },
     high_unrouted: highUnrouted,
@@ -342,6 +355,7 @@ export function getCapabilityCoverage(versionDir) {
     routing_gaps: routingGaps,
     outcomes_without_concern: outcomesWithoutConcern,
     high_outcomes_without_observable_evidence: highOutcomesWithoutObservableEvidence,
+    evidence_artifact_gaps: evidenceArtifactGaps,
     unmapped_intents: unmappedIntents,
   };
 }

package/cli/src/diagnostics.js

@@ -274,6 +274,9 @@ export function doctor(versionDir, verificationsDir, philosophyDir) {
         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.evidence_artifact_gaps || []) {
+          issues.push({ id: item.node_id, type: 'capability_evidence_artifact_missing', 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}` });
         }

package/cli/src/guide.js

@@ -63,35 +63,41 @@ export function guideProject(projectDir, options = {}) {
       outputs: ['.loom/v1/'],
       verify_command: 'loom guide',
     },
-    need_philosophy: {
+    need_philosophy: {
       inputs: ['meta/PHILOSOPHY_WEAVER.md', 'meta/BASELINE.md', 'dimensions/SEARCH_METHODOLOGY.md'],
-      outputs: [`.loom/${current}/00_PHILOSOPHY/PRODUCT_PHILOSOPHY.md`, `.loom/${current}/00_PHILOSOPHY/ENGINEERING_CREED.md`, `.loom/${current}/00_PHILOSOPHY/DECISION_RUBRIC.md`],
-      verify_command: 'loom philosophy check',
-    },
-    need_vision: {
-      inputs: ['roles/visionary.md', `.loom/${current}/00_PHILOSOPHY/`],
-      outputs: [`.loom/${current}/01_VISION.md`],
-      verify_command: 'loom guide',
-    },
+      outputs: [`.loom/${current}/00_PHILOSOPHY/PRODUCT_PHILOSOPHY.md`, `.loom/${current}/00_PHILOSOPHY/ENGINEERING_CREED.md`, `.loom/${current}/00_PHILOSOPHY/DECISION_RUBRIC.md`],
+      verify_command: 'loom philosophy check',
+      input_delivery: 'context_pack',
+    },
+    need_vision: {
+      inputs: ['roles/visionary.md', `.loom/${current}/00_PHILOSOPHY/`],
+      outputs: [`.loom/${current}/01_VISION.md`],
+      verify_command: 'loom guide',
+      input_delivery: 'context_pack',
+    },
     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',
+      input_delivery: 'context_pack',
     },
     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',
+      input_delivery: 'context_pack',
     },
     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',
+      input_delivery: 'context_pack',
     },
     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',
+      input_delivery: 'context_pack',
     },
     intent_map_broken: {
       inputs: [`.loom/${current}/04_INTENT_MAP.json`],
@@ -120,9 +126,10 @@ export function guideProject(projectDir, options = {}) {
     },
   };
   const meta = stageMeta[result.stage] || {};
-  result.inputs = meta.inputs || [];
-  result.outputs = meta.outputs || [];
-  result.verify_command = meta.verify_command || null;
+  result.inputs = meta.inputs || [];
+  result.outputs = meta.outputs || [];
+  result.verify_command = meta.verify_command || null;
+  result.input_delivery = meta.input_delivery || null;
   // 统一后处理：写心跳 + 加 AUTO 提示词 + 判断是否需要人类 review
   if (existsSync(loomRoot) && !options.dryRun) {
     try {
@@ -146,7 +153,7 @@ export function guideProject(projectDir, options = {}) {
     }
   } else if (result.stage_num >= 4) {
     if (auto) {
-      result.message += '\n\n> AUTO 模式开启——直接执行 next_command，无需人类确认。';
+      result.message += '\n\n> AUTO 模式开启——可继续进入下一阶段；契约、证据与 Keeper 门禁仍不会被跳过。';
     } else {
       result.message += '\n\n> ⚠ AUTO 模式关闭——执行 next_command 后等人类确认再继续。';
     }
@@ -242,14 +249,14 @@ function diagnoseStage(cwd, loomRoot, auto) {
           details: { version: current, proposals: pendingProposals.map((proposal) => proposal.id) },
           auto,
           next_action: '审计新信息对 Capability Graph、Intent 和契约的影响',
-          next_command: 'loom capability proposal list',
+          next_command: 'loom activate architect',
           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',
+        next_action: '修复 Capability Graph proposal', next_command: 'loom activate architect',
         message: `Capability Graph proposal 无法审计: ${error.message}`,
       };
     }
@@ -262,7 +269,7 @@ function diagnoseStage(cwd, loomRoot, auto) {
           details: { version: current, coverage: coverage.summary },
           auto,
           next_action: '补齐 Capability Graph 的路由、可观察验证入口与 Intent 回链',
-          next_command: 'loom capability coverage',
+          next_command: 'loom activate architect',
           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。`,
         };
       }
@@ -273,7 +280,7 @@ function diagnoseStage(cwd, loomRoot, auto) {
         details: { version: current, error: error.message },
         auto,
         next_action: '修复 Capability Graph',
-        next_command: 'loom capability coverage',
+        next_command: 'loom activate architect',
         message: `Capability Graph 无法通过校验: ${error.message}`,
       };
     }

package/cli/src/init.js

@@ -169,6 +169,7 @@ export function initProject(projectDir) {
       '3. 只在当前角色的权限内行动；发现目标、契约或架构需要改变时，按 LOOM 回流，不要静默扩展范围。',
       '4. 完成前运行当前 Intent 的验证方法与 `loom doctor`；声称质量提升时必须提供基线相对 Quality Proof，以磁盘证据而非会话记忆判断状态。',
       '5. Keeper 验证必须运行在新的 Agent thread 中；同一会话切换角色不构成独立验证。',
+      '6. 协作节奏默认是手动；需要让 Agent 在已允许阶段连续推进时，显式运行 `loom auto on`。AUTO 不会跳过契约、证据或 Keeper 门禁。',
       '',
       '常用入口：',
       '- `loom --help`',

package/cli/src/verify.js

@@ -11,7 +11,8 @@ import { validateAtelierRecord } from './atelier.js';
 import { assertExpertiseReady } from './expertise-pack.js';
 
 /** 合法判定结果 */
-const VALID_VERDICTS = ['passed', 'deviated', 'blocked', 'pending_human'];
+const VALID_VERDICTS = ['passed', 'deviated', 'blocked', 'pending_human'];
+const VALID_VERIFICATION_CONTEXTS = ['independent_thread', 'human_review'];
 
 /** 每个 Intent 都必须覆盖的基础验证维度。 */
 const BASE_DIMENSIONS = [
@@ -59,6 +60,15 @@ export function writeVerification(versionDir, verificationsDir, record) {
     errors.push(`Intent ${record.intent_id} 当前状态为 ${intent.status}；只能为 in_progress 或 needs_review 的 Intent 写入验证记录`);
   }
   const requiredDimensions = getRequiredDimensions(intent);
+  if (record.verdict === 'passed') {
+    const provenance = record.verification_provenance;
+    if (!provenance || typeof provenance !== 'object') {
+      errors.push('passed 必须声明 verification_provenance（verified_by + context）；实现者自检不能单独闭合 Intent');
+    } else {
+      if (typeof provenance.verified_by !== 'string' || !provenance.verified_by.trim()) errors.push('verification_provenance.verified_by 必须是非空验证者标识');
+      if (!VALID_VERIFICATION_CONTEXTS.includes(provenance.context)) errors.push(`verification_provenance.context 非法: ${provenance.context}（合法: ${VALID_VERIFICATION_CONTEXTS.join('|')}）`);
+    }
+  }
   // dimensions 结构校验：每个维度必须是 { verdict, evidence } 对象
   if (record.dimensions) {
     for (const dim of requiredDimensions) {
@@ -164,7 +174,8 @@ export function writeVerification(versionDir, verificationsDir, record) {
     verification_epoch: getEffectiveVerificationEpoch(intent),
     verdict: record.verdict,
     timestamp: record.timestamp,
-    summary: record.summary,
+    summary: record.summary,
+    verification_provenance: record.verification_provenance,
     dimensions: record.dimensions,
     atelier: atelierEvidence ? {
       record_ref: `09_ATELIER/${record.intent_id}.json`,
@@ -243,7 +254,7 @@ export function getAcrossVersionVerificationHistory(currentVersionDir, inputRef)
 
 /**
  * 快捷创建验证记录——Agent 不用手动构造完整 JSON。
- * 内部用 summary 填充适用维度的 evidence，生成标准记录格式。
+ * 快捷记录只能用于低风险的结构化核验；passed 仍必须显式声明独立验证来源。
  * @param {string} versionDir — 当前 .loom/v{N}/ 目录
  * @param {string} verificationsDir — verifications/ 目录路径
  * @param {string} intentId — 如 "INT-001"
@@ -279,6 +290,7 @@ export function createQuickVerification(versionDir, verificationsDir, intentId,
     summary,
     dimensions,
     reproduction_command: extras.reproduction_command || null,
+    verification_provenance: extras.verification_provenance || null,
     deviation_detail: extras.deviation_detail || null,
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/loom",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "LOOM — 哲学驱动开发框架。Agent 通过 CLI 访问 Intent Map / 哲学 / 验证记录，不直接读文件",
   "type": "module",
   "bin": {

package/roles/architect.md

@@ -41,7 +41,9 @@
 12. `creative_scope` 说明 Forge 可以大胆改变什么、必须保持什么。
 13. 每个高影响 `outcome` 必须用 `validated_by` 连接到一个 `evidence` 节点。该节点必须写出 `verification.method`、`target`、`procedure`、`pass_criteria` 和 `artifact`，并回链负责把证据真正产出的 Intent。`artifact` 必须是当前版本 `verifications/` 或 `08_ASSET_LIBRARY/files/` 中实际存在的文件。`target` 是结果实际被接收、呈现或消费的位置：用户界面、目标宿主、外部系统、交付物或人工验收现场。不能用“接口返回成功”“URL 可访问”替代目标宿主中的可观察结果。
 14. 对每个重要 Intent 做简短 Pre-Mortem：最可能出现什么“表面完成”，并将其转成
-   acceptance 或 verification_method。
+   acceptance 或 verification_method。当 narrative 的核心现象可能被一个更容易实现、但
+   语义不同的代理替换时，写 `semantic_guard`：明确哪种替代不算完成，以及 Keeper 应
+   使用什么反例验证它。它不把 Intent 切成技术碎片，只防止“看似相近”偷换用户结果。
 15. 新要求、论文/资料发现、Keeper 或 Forge 发现先进入 `07_GRAPH_PROPOSALS/`，带来源、观察证据和候选类型。Architect 明确判定它已被覆盖、需要改 Graph、生成/修订 Intent、改变 acceptance，还是 Minor/Major；不得把候选静默写入正式 Graph。
 16. 当项目使用素材时，`08_ASSET_LIBRARY/manifest.json` 是唯一可用素材与来源/作者/许可/哈希的真相源。只允许已批准、可验证的本地资产进入交付；若资产构成结果证据，让 evidence 节点与资产记录双向回链。
 17. `quality_strategy` 缺失等价于 `adaptive`。只有结果确实需要作者命题、媒介原型和独立候选比较时才设为 `atelier`，且必须同时声明 `quality_contract` 与 `creative_scope`。

package/roles/keeper.md

@@ -52,6 +52,8 @@ Keeper 默认运行在新的 Agent thread 中。只接收：
 | quality_achievement | 仅在存在质量契约时，目标水准是否有证据成立？ |
 
 每个维度都必须记录“对照了什么、观察到什么、如何复现”。“合规”“没问题”不是证据。
+若 Intent 声明 `semantic_guard`，Keeper 必须执行其中的反例检查；实现看起来拥有相近
+控件或数据，不能代替叙事要求的真实现象。
 
 若 `continuity_required` 为 true，缺少明确的旧状态、操作和新状态证据时，`preservation_achievement` 不得通过；“页面目前看起来正常”不构成守恒证据。
 实现方式与 Architect 设想不同不构成偏差，只要公共契约和意图仍成立。

package/templates/INTENT_MAP_TEMPLATE.json

@@ -18,7 +18,7 @@
       "depends_on": [],
       "acceptance": "[必须] 完成契约：什么算可观察地完成，包含功能承诺、关键失败边界和防御承诺。可内联或引用 05_VERIFICATION.md。",
       "continuity_required": "[可选] true：本 Intent 改动既有用户/系统状态，必须在 acceptance 写明保留项与时序验证；验证时额外要求 preservation_achievement。一次性、无既有状态任务省略。",
-      "quality_contract": "see 05_VERIFICATION.md#int-001-quality",
+      "quality_contract": "[可选] 只有声明高于功能正确性的质量目标时才填写；若引用 05_VERIFICATION.md，必须先创建对应章节。",
       "quality_strategy": "adaptive",
       "capability_needs": ["visual hierarchy", "responsive interaction"],
       "creative_scope": "可以改变布局与动效；不得改变业务流程、数据结构和公开接口。",
@@ -58,6 +58,7 @@
     "quality_strategy": "[可选] adaptive | atelier，缺失等价于 adaptive。atelier 只用于明确需要作者命题、媒介原型和独立候选比较的 Intent，并要求 quality_contract 与 creative_scope。",
     "capability_needs": "[可选] Expertise Compiler 需要补齐的专业领域字符串数组。",
     "creative_scope": "[可选] Forge 可以大胆改变什么、必须保持什么。",
+    "semantic_guard": "[可选] 当叙事核心容易被相似实现偷换时，写明不算完成的替代物与 Keeper 的反例验证方式。",
     "philosophy_anchors": "[必须] 哲学文档引用列表。Forge 加载哲学的指引。",
     "status": "[必须] pending | in_progress | completed | blocked | needs_review",
     "lifecycle.deprecation": "[可选] { deprecated_at, reason, replacement }。与 status 分离；弃用后 status 保持 completed。",