@haaaiawd/loom 1.2.2 → 2.0.0

package/cli/src/shared/verification-method.js

@@ -1,32 +0,0 @@
-export function getIntentVerificationMethod(intent) {
-  return intent?.verification_method || intent?._optional?.verification_method || null;
-}
-
-function normalize(command) {
-  return String(command || '')
-    .replace(/^\s*(?:run|exec)\s+/i, '')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function normalizePackageManager(command) {
-  return ['npm', 'pnpm', 'bun', 'yarn'].reduce(
-    (result, manager) => result.replace(new RegExp(`\\b${manager}\\b`, 'g'), '<PM>'),
-    command,
-  );
-}
-
-/** Whether a recorded reproduction command covers the Architect-declared method. */
-export function commandCoversVerificationMethod(actualCommand, expectedMethod) {
-  const actual = normalize(actualCommand);
-  const expected = normalize(expectedMethod);
-  if (!actual || !expected) return false;
-  return expected.split('&&').every((part) => {
-    const expectedPart = normalize(part);
-    if (!expectedPart || actual.includes(expectedPart)) return true;
-    const actualNorm = normalizePackageManager(actual);
-    const expectedNorm = normalizePackageManager(expectedPart);
-    if (actualNorm.includes(expectedNorm)) return true;
-    return expectedPart.startsWith('node --test') && actualNorm.includes('<PM> test');
-  });
-}

package/cli/src/verify.js

@@ -1,394 +0,0 @@
-// verify.js — 验证记录的读写和查询
-// 验证记录存放在 .loom/v{N}/verifications/ 下，每个 Intent 一份 JSON + 一份 MD。
-
-import { readFileSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-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';
-import { assertExpertiseReady } from './expertise-pack.js';
-
-/** 合法判定结果 */
-const VALID_VERDICTS = ['passed', 'deviated', 'blocked', 'pending_human'];
-const VALID_VERIFICATION_CONTEXTS = ['independent_thread', 'human_review'];
-
-/** 每个 Intent 都必须覆盖的基础验证维度。 */
-const BASE_DIMENSIONS = [
-  'intent_fidelity',
-  'philosophy_consistency',
-  'baseline_compliance',
-  'acceptance_achievement',
-];
-
-function getRequiredDimensions(intent) {
-  const dimensions = [...BASE_DIMENSIONS];
-  if (intent?.continuity_required) dimensions.push('preservation_achievement');
-  if (intent?.quality_contract) dimensions.push('quality_achievement');
-  return dimensions;
-}
-
-/**
- * 写入一条验证记录（追加模式——同一 Intent 多次验证保留完整历史）。
- * 文件格式: { intent_id, records: [{ round, verdict, timestamp, ... }] }
- * @param {string} versionDir — 当前 .loom/v{N}/ 目录，用于可信读取 Intent revision
- * @param {string} verificationsDir — verifications/ 目录路径
- * @param {object} record — 验证记录
- * @param {string} record.intent_id — 如 "INT-001"
- * @param {string} record.verdict — passed | deviated | blocked
- * @param {string} record.timestamp — ISO 8601
- * @param {string} record.summary — 验证摘要
- * @param {object} record.dimensions — 基础维度，以及质量契约存在时的 quality_achievement
- * @param {string} [record.reproduction_command] — 复现验证的命令（如 "LLM_API_KEY=mock npm test"）
- * @param {string} [record.deviation_detail] — 偏离说明（deviated 时）
- * @param {boolean} [record.reset_suggested] — 是否建议重置上下文
- * @returns {{ filePath: string, round: number, deviated_count: number, should_escalate: boolean }}
- */
-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('|')})`);
-  }
-  if (!record.timestamp) errors.push('缺少 timestamp');
-  if (!record.dimensions) errors.push('缺少 dimensions（适用验证维度结果）');
-  const intent = record.intent_id ? getIntent(versionDir, record.intent_id) : null;
-  if (intent && !['in_progress', 'needs_review'].includes(intent.status)) {
-    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) {
-      const v = record.dimensions[dim];
-      if (v === undefined) {
-        errors.push(`dimensions.${dim} 缺失（当前 Intent 的适用维度必须全覆盖）`);
-      } else if (typeof v === 'string') {
-        errors.push(`dimensions.${dim} 是旧格式（枚举值），必须改成 { verdict, evidence } 对象`);
-      } else if (typeof v !== 'object' || v === null) {
-        errors.push(`dimensions.${dim} 必须是 { verdict, evidence } 对象`);
-      } else {
-        if (!VALID_VERDICTS.includes(v.verdict)) {
-          errors.push(`dimensions.${dim}.verdict 非法: "${v.verdict}" (合法: ${VALID_VERDICTS.join('|')})`);
-        }
-        if (record.verdict === 'passed' && v.verdict !== 'passed') {
-          errors.push(`整体 verdict 为 passed 时，dimensions.${dim}.verdict 也必须是 passed`);
-        }
-        if (!v.evidence || typeof v.evidence !== 'string' || v.evidence.trim() === '') {
-          errors.push(`dimensions.${dim}.evidence 缺失——必须给出具体证据，不能只写"合规"`);
-        } else {
-          // evidence 质量校验：长度 + 废话检测
-          const ev = v.evidence.trim();
-          if (ev.length < 10) {
-            errors.push(`dimensions.${dim}.evidence 太短（${ev.length}字符 < 10）——必须给出具体证据，不能只写"合规"`);
-          }
-          const NONSENSE = ['合规', '通过', 'OK', 'ok', '没问题', '符合要求', '已检查', 'pass', 'passed', 'done'];
-          if (NONSENSE.includes(ev)) {
-            errors.push(`dimensions.${dim}.evidence "${ev}" 是通用评价而非具体证据——必须写"对照了什么 + 在代码哪里看到/没看到"`);
-          }
-        }
-      }
-    }
-  }
-  const qualityProofRef = record.dimensions?.quality_achievement?.quality_proof_ref;
-  if (intent?.quality_contract && record.verdict === 'passed' && !qualityProofRef) {
-    errors.push('声明 quality_contract 的 Intent 通过时必须提供 dimensions.quality_achievement.quality_proof_ref');
-  }
-  if (qualityProofRef !== undefined
-    && (typeof qualityProofRef !== 'string' || qualityProofRef.trim() === '')) {
-    errors.push('dimensions.quality_achievement.quality_proof_ref 必须是非空字符串');
-  } else if (qualityProofRef !== undefined) {
-    try {
-      resolveQualityProofReference(versionDir, qualityProofRef);
-    } catch (error) {
-      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);
-      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  - ')}`);
-  }
-
-  const intentRevision = getEffectiveIntentRevision(intent);
-
-  const filePath = join(verificationsDir, `${record.intent_id}.json`);
-
-  // 读取已有记录（如果有）
-  let data;
-  if (existsSync(filePath)) {
-    data = readJsonFile(filePath, '验证记录');
-    // 结构校验：已有文件必须是 { intent_id, records: [] } 格式
-    if (!data || typeof data !== 'object' || !Array.isArray(data.records)) {
-      throw new Error(
-        `已有验证记录格式错误: ${filePath}\n` +
-        `期望格式: { intent_id, records: [...] }\n` +
-        `实际格式: ${JSON.stringify(data).slice(0, 200)}\n` +
-        `修复: 删除或修正该文件后重试。`
-      );
-    }
-  } else {
-    data = { intent_id: record.intent_id, records: [] };
-  }
-
-  // 计算轮次和连续 deviated 计数。规范要求中间出现 passed/blocked 后重置。
-  const round = data.records.length + 1;
-  const recordsWithCurrent = [...data.records, record];
-  let deviatedCount = 0;
-  for (let i = recordsWithCurrent.length - 1; i >= 0; i--) {
-    if (recordsWithCurrent[i].verdict !== 'deviated') break;
-    deviatedCount++;
-  }
-
-  // 追加新记录
-  data.records.push({
-    round,
-    intent_revision: intentRevision,
-    verification_epoch: getEffectiveVerificationEpoch(intent),
-    verdict: record.verdict,
-    timestamp: record.timestamp,
-    summary: record.summary,
-    verification_provenance: record.verification_provenance,
-    dimensions: record.dimensions,
-    atelier: atelierEvidence ? {
-      record_ref: `09_ATELIER/${record.intent_id}.json`,
-      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,
-  });
-
-  writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
-
-  // 检查是否应该升级 blocked（连续 3 轮 deviated，默认值）
-  const DEVIATED_LIMIT = 3;
-  const shouldEscalate = record.verdict === 'deviated' && deviatedCount >= DEVIATED_LIMIT;
-
-  return { filePath, round, deviated_count: deviatedCount, should_escalate: shouldEscalate };
-}
-
-/**
- * 读取某 Intent 的验证历史。
- * @returns {{ intent_id: string, records: array } | null}
- */
-export function getVerificationHistory(verificationsDir, intentId) {
-  const filePath = join(verificationsDir, `${intentId}.json`);
-  if (!existsSync(filePath)) {
-    return null;
-  }
-  return readJsonFile(filePath, '验证记录');
-}
-
-/** Read each owning version's local records along the explicit predecessor graph. */
-export function getAcrossVersionVerificationHistory(currentVersionDir, inputRef) {
-  const root = resolveIntentRef(currentVersionDir, inputRef);
-  const histories = [];
-  const visited = new Set();
-  const active = new Set();
-
-  function walk(resolved) {
-    if (active.has(resolved.ref)) throw new Error(`Intent lineage 存在循环: ${[...active, resolved.ref].join(' -> ')}`);
-    if (visited.has(resolved.ref)) return;
-    active.add(resolved.ref);
-    const intent = getIntent(resolved.versionDir, resolved.intentId);
-    const local = getVerificationHistory(join(resolved.versionDir, 'verifications'), resolved.intentId);
-    histories.push({
-      ref: resolved.ref,
-      source_version: resolved.version,
-      source_intent: resolved.intentId,
-      source_intent_id: resolved.intentId,
-      records: (local?.records || []).map((record) => ({
-        ...record,
-        source_version: resolved.version,
-        source_intent: resolved.intentId,
-        source_intent_id: resolved.intentId,
-      })),
-    });
-    for (const predecessor of intent.lineage?.predecessors || []) {
-      walk(resolveIntentRef(currentVersionDir, formatIntentRef(predecessor.version, predecessor.intent_id)));
-    }
-    active.delete(resolved.ref);
-    visited.add(resolved.ref);
-  }
-
-  walk(root);
-  return { intent_ref: root.ref, across_versions: true, histories };
-}
-
-/**
- * 快捷创建验证记录——Agent 不用手动构造完整 JSON。
- * 快捷记录只能用于低风险的结构化核验；passed 仍必须显式声明独立验证来源。
- * @param {string} versionDir — 当前 .loom/v{N}/ 目录
- * @param {string} verificationsDir — verifications/ 目录路径
- * @param {string} intentId — 如 "INT-001"
- * @param {string} verdict — 'passed' | 'deviated' | 'blocked'
- * @param {string} summary — 验证摘要（也会作为所有适用维度的 evidence）
- * @param {object} [extras]
- * @param {string} [extras.reproduction_command] — 复现命令
- * @param {string} [extras.quality_proof_ref] — Quality Proof 证据引用
- * @param {string} [extras.preservation_evidence] — 对既有状态守恒的独立证据
- * @param {string} [extras.deviation_detail] — 偏离说明（deviated 时）
- * @returns {{ filePath: string, round: number, deviated_count: number, should_escalate: boolean }}
- */
-export function createQuickVerification(versionDir, verificationsDir, intentId, verdict, summary, extras = {}) {
-  const timestamp = new Date().toISOString();
-  const intent = getIntent(versionDir, intentId);
-  // 用 summary 填充适用维度的 evidence——快捷命令不要求 Agent 逐维度写
-  const dimensions = {};
-  for (const dim of getRequiredDimensions(intent)) {
-    dimensions[dim] = {
-      verdict,
-      evidence: dim === 'preservation_achievement'
-        ? (extras.preservation_evidence || summary)
-        : summary,
-    };
-  }
-  if (extras.quality_proof_ref && dimensions.quality_achievement) {
-    dimensions.quality_achievement.quality_proof_ref = extras.quality_proof_ref;
-  }
-  return writeVerification(versionDir, verificationsDir, {
-    intent_id: intentId,
-    verdict,
-    timestamp,
-    summary,
-    dimensions,
-    reproduction_command: extras.reproduction_command || null,
-    verification_provenance: extras.verification_provenance || null,
-    deviation_detail: extras.deviation_detail || null,
-  });
-}
-
-/**
- * 返回所有待验证的 Intent（有实现产物但还没验证记录的）。
- * 需要传入 Intent Map 来判断哪些 Intent 是 in_progress。
- */
-export function getPendingVerifications(versionDir, verificationsDir) {
-  const intentMap = readJsonFile(join(versionDir, '04_INTENT_MAP.json'), 'Intent Map');
-  const pending = [];
-  for (const [id, intent] of Object.entries(intentMap.intents)) {
-    if (intent.status === 'in_progress' || intent.status === 'needs_review') {
-      const history = getVerificationHistory(verificationsDir, id);
-      if (!hasCurrentPassedVerification(intent, history)) pending.push(id);
-    }
-  }
-  return pending;
-}
-
-/** Missing Intent revisions are revision 1 without mutating the map. */
-export function getEffectiveIntentRevision(intent) {
-  return intent.revision ?? 1;
-}
-
-/**
- * Legacy records count as revision 1 only while the Intent itself is legacy.
- * Once revision is explicit, an untagged record cannot prove freshness.
- */
-export function getVerificationIntentRevision(intent, record) {
-  if (Number.isInteger(record?.intent_revision) && record.intent_revision >= 1) {
-    return record.intent_revision;
-  }
-  return hasLegacyIntentRevision(intent) ? 1 : null;
-}
-
-export function isVerificationCurrent(intent, record) {
-  return getVerificationIntentRevision(intent, record) === getEffectiveIntentRevision(intent)
-    && getVerificationEpoch(intent, record) === getEffectiveVerificationEpoch(intent);
-}
-
-export function getVerificationEpoch(intent, record) {
-  if (Number.isInteger(record?.verification_epoch) && record.verification_epoch >= 1) {
-    return record.verification_epoch;
-  }
-  return intent?.verification_epoch === undefined ? 1 : null;
-}
-
-export function getLatestPassedVerification(history) {
-  if (!Array.isArray(history?.records)) return null;
-  return [...history.records].reverse().find((record) => record.verdict === 'passed') ?? null;
-}
-
-export function hasCurrentPassedVerification(intent, history) {
-  const latest = history?.records?.[history.records.length - 1];
-  return latest?.verdict === 'passed' && isVerificationCurrent(intent, latest);
-}
-
-/**
- * 列出所有验证记录文件。
- * 只列出正式验证记录——文件名匹配 INT-XXX 格式且内容含 records 字段。
- * 过滤掉用户写入的临时输入文件（如 INT-001.verify.json、_tmp_*.json）。
- */
-export function listVerifications(verificationsDir) {
-  if (!existsSync(verificationsDir)) return [];
-  return readdirSync(verificationsDir)
-    .filter((f) => f.endsWith('.json'))
-    .filter((f) => /^INT-\d+\.json$/.test(f))
-    .map((f) => f.replace('.json', ''));
-}
-
-/**
- * 获取某 Intent 的验证契约（acceptance 字段的解析结果）。
- * 如果 acceptance 是内联定义，直接返回。
- * 如果是引用（如 "see 05_VERIFICATION.md#int-001"），解析引用并返回对应章节内容。
- * @param {string} versionDir — .loom/v{N}/ 目录
- * @param {string} intentId — Intent ID
- * @returns {string} 验收契约内容
- */
-export function getVerificationContract(versionDir, intentId) {
-  const intentMap = readJsonFile(join(versionDir, '04_INTENT_MAP.json'), 'Intent Map');
-  if (!(intentId in intentMap.intents)) {
-    throw new Error(`Intent 不存在: ${intentId}`);
-  }
-  const acceptance = intentMap.intents[intentId].acceptance;
-
-  // 检测是否是引用格式: "see 05_VERIFICATION.md#section" 或 "05_VERIFICATION.md#section"
-  const refMatch = acceptance.match(/(?:see\s+)?(\w+\.md)#([\w-]+)/i);
-  if (refMatch) {
-    const [, file, section] = refMatch;
-    const filePath = join(versionDir, file);
-    if (!existsSync(filePath)) {
-      throw new Error(`验证契约引用的文件不存在: ${filePath}`);
-    }
-    const content = readFileSync(filePath, 'utf-8');
-    return extractMdSection(content, section, '验证契约');
-  }
-
-  // 内联定义，直接返回
-  return acceptance;
-}

package/cli/src/version.js

@@ -1,134 +0,0 @@
-// version — LOOM 版本管理
-// 提供 list / current / new / use / diff 五个原子操作。
-// CLI 只做数据操作，演进决策（Minor/Major）由 Agent + 用户对话完成。
-
-import { existsSync, readdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { createVersionStructure } from './init.js';
-
-/**
- * 列出所有版本目录。
- * @param {string} loomRoot — .loom 目录路径
- * @returns {{ versions: string[], current: string|null }}
- */
-export function listVersions(loomRoot) {
-  if (!existsSync(loomRoot)) {
-    throw new Error(`找不到 .loom 目录: ${loomRoot}`);
-  }
-  const versions = readdirSync(loomRoot)
-    .filter((d) => /^v\d+$/.test(d) && statSync(join(loomRoot, d)).isDirectory())
-    .sort((a, b) => parseInt(a.slice(1)) - parseInt(b.slice(1)));
-  const current = readCurrentPointer(loomRoot);
-  return { versions, current };
-}
-
-/**
- * 读取当前版本指针。
- * 优先读 .loom/current 文件；不存在则回退到自动探测最新版本。
- * @param {string} loomRoot — .loom 目录路径
- * @returns {string|null} 版本号如 'v1'，或 null（无版本）
- */
-export function readCurrentPointer(loomRoot) {
-  const pointerPath = join(loomRoot, 'current');
-  if (existsSync(pointerPath)) {
-    const v = readFileSync(pointerPath, 'utf-8').trim();
-    if (/^v\d+$/.test(v) && existsSync(join(loomRoot, v))) return v;
-  }
-  // 回退：自动探测最新版本
-  if (!existsSync(loomRoot)) return null;
-  const versions = readdirSync(loomRoot)
-    .filter((d) => /^v\d+$/.test(d) && statSync(join(loomRoot, d)).isDirectory())
-    .sort((a, b) => parseInt(b.slice(1)) - parseInt(a.slice(1)));
-  return versions[0] ?? null;
-}
-
-/**
- * 创建新版本 v{N+1}，自动切换为当前版本。
- * 不复制旧版本内容——空目录 + 模板强制 Agent 重新思考。
- * @param {string} projectDir — 项目根目录
- * @returns {{ version: string, created: string[], skipped: string[] }}
- */
-export function newVersion(projectDir) {
-  const loomRoot = join(projectDir, '.loom');
-  const { versions } = listVersions(loomRoot);
-  const parentVersion = readCurrentPointer(loomRoot);
-  const nextNum = versions.length === 0
-    ? 1
-    : parseInt(versions[versions.length - 1].slice(1)) + 1;
-  const nextV = `v${nextNum}`;
-  const result = createVersionStructure(projectDir, nextV, parentVersion);
-  // 自动切换为当前版本
-  writeFileSync(join(loomRoot, 'current'), nextV, 'utf-8');
-  result.created.push('.loom/current');
-  return { version: nextV, created: result.created, skipped: result.skipped };
-}
-
-/**
- * 切换当前版本指针。
- * @param {string} loomRoot — .loom 目录路径
- * @param {string} version — 目标版本号如 'v1'
- */
-export function useVersion(loomRoot, version) {
-  const v = version.startsWith('v') ? version : `v${version}`;
-  if (!existsSync(join(loomRoot, v))) {
-    throw new Error(`版本不存在: ${v}`);
-  }
-  writeFileSync(join(loomRoot, 'current'), v, 'utf-8');
-  return v;
-}
-
-/**
- * 对比两个版本的文件差异。
- * 只对比文件存在性和大小，不做内容 diff（内容 diff 用 Git）。
- * @param {string} loomRoot — .loom 目录路径
- * @param {string} v1 — 版本 A
- * @param {string} v2 — 版本 B
- * @returns {{ only_in_a: string[], only_in_b: string[], different_size: string[], same: string[] }}
- */
-export function diffVersions(loomRoot, v1, v2) {
-  const a = v1.startsWith('v') ? v1 : `v${v1}`;
-  const b = v2.startsWith('v') ? v2 : `v${v2}`;
-  const dirA = join(loomRoot, a);
-  const dirB = join(loomRoot, b);
-  if (!existsSync(dirA)) throw new Error(`版本不存在: ${a}`);
-  if (!existsSync(dirB)) throw new Error(`版本不存在: ${b}`);
-
-  const filesA = listFilesRelative(dirA);
-  const filesB = listFilesRelative(dirB);
-  const setA = new Set(filesA);
-  const setB = new Set(filesB);
-
-  const onlyInA = filesA.filter((f) => !setB.has(f));
-  const onlyInB = filesB.filter((f) => !setA.has(f));
-  const common = filesA.filter((f) => setB.has(f));
-  const differentSize = common.filter((f) => {
-    const sa = statSync(join(dirA, f)).size;
-    const sb = statSync(join(dirB, f)).size;
-    return sa !== sb;
-  });
-  const same = common.filter((f) => {
-    const sa = statSync(join(dirA, f)).size;
-    const sb = statSync(join(dirB, f)).size;
-    return sa === sb;
-  });
-
-  return { only_in_a: onlyInA, only_in_b: onlyInB, different_size: differentSize, same };
-}
-
-/**
- * 递归列出目录下所有文件的相对路径。
- */
-function listFilesRelative(dir, base = '') {
-  const result = [];
-  if (!existsSync(dir)) return result;
-  for (const entry of readdirSync(dir)) {
-    const full = join(dir, entry);
-    const rel = base ? join(base, entry) : entry;
-    if (statSync(full).isDirectory()) {
-      result.push(...listFilesRelative(full, rel));
-    } else {
-      result.push(rel);
-    }
-  }
-  return result.sort();
-}

package/dimensions/AUTHORSHIP.md

@@ -1,45 +0,0 @@
-# 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/dimensions/PART_DECOMPOSITION.md

@@ -1,42 +0,0 @@
-# Responsibility and Intent Slicing
-
-> 这是 Architect 的按需方法，不是 Weaver 的必填清单，也不是 CLI 通过条件。
-
-## 何时使用
-
-只有在以下情况使用拆分：
-
-- 一个目标跨越多个独立系统责任。
-- 不同部分可以单独验证或具有明确依赖。
-- 一次实现会产生过大风险、上下文或回滚成本。
-
-如果拆分不会改善边界、验证或交付顺序，就保持一个 Intent。
-
-## 三种不能混淆的结构
-
-1. **Doctrine 领域**：会反复影响未来决策的长期判断，由 Weaver 负责。
-2. **系统责任**：模块、数据、接口与依赖边界，由 Architect 负责。
-3. **Intent 切片**：能够独立保护和验证的用户结果，由 Architect 负责。
-
-不要从技术目录直接推导 Intent，也不要让 Doctrine 文档变成模块清单。
-
-## 最小拆分法
-
-对候选切片逐一询问：
-
-- 它保护的用户结果能否独立描述。
-- 它是否有独立的完成契约。
-- 它失败时能否独立回流或回滚。
-- 它与其他切片的依赖是否单向且必要。
-- 合并后是否更简单，且不会模糊验证。
-
-只有前三项明确、依赖可解释时才创建独立 Intent。
-
-## 输出
-
-拆分结果只进入：
-
-- `02_ARCHITECTURE.md` 的系统责任与依赖说明。
-- `04_INTENT_MAP.json` 的 Intent DAG。
-
-它不进入 Project Doctrine，也不以“数量足够多”作为质量信号。