@dommaker/harness 0.13.0 → 0.13.2

package/src/monitoring/__tests__/knowledge-doctor.test.ts

@@ -0,0 +1,276 @@
+import { KnowledgeDoctor } from '../knowledge-doctor';
+import type { KnowledgeEntry, LintIssue } from '../../knowledge/types';
+
+function makeEntry(overrides: Partial<KnowledgeEntry> = {}): KnowledgeEntry {
+  return {
+    id: 'entry-1',
+    type: 'guideline',
+    title: 'Test Entry',
+    content: 'content',
+    maturity: 'draft',
+    layer: 'team',
+    created: '2025-01-01T00:00:00Z',
+    lastReferenced: new Date().toISOString(),
+    contributors: ['user-1'],
+    projects: ['proj-1'],
+    tags: ['test'],
+    applicablePhases: ['implementation'],
+    sourceReferences: [],
+    referencedBy: ['ref-1'],
+    ...overrides,
+  };
+}
+
+describe('KnowledgeDoctor', () => {
+  describe('基础诊断', () => {
+    it('空知识库返回满分', () => {
+      const doctor = new KnowledgeDoctor();
+      const report = doctor.diagnose([]);
+      expect(report.healthScore).toBe(100);
+      expect(report.totalEntries).toBe(0);
+      expect(report.diagnoses).toHaveLength(0);
+    });
+
+    it('健康条目不产生诊断', () => {
+      const doctor = new KnowledgeDoctor();
+      const entry = makeEntry({ maturity: 'verified', referencedBy: ['r1', 'r2', 'r3'], projects: ['p1'] });
+      const report = doctor.diagnose([entry]);
+      // 可能有 low_reference 诊断，但不会有 orphan/outdated/decay
+      const criticalDiags = report.diagnoses.filter(d => d.type === 'orphan' || d.type === 'outdated' || d.type === 'decay');
+      expect(criticalDiags).toHaveLength(0);
+    });
+  });
+
+  describe('孤儿检测', () => {
+    it('检测无引用、无贡献者、无项目的 draft 条目', () => {
+      const doctor = new KnowledgeDoctor();
+      const orphan = makeEntry({
+        id: 'orphan-1',
+        maturity: 'draft',
+        referencedBy: [],
+        contributors: [],
+        projects: [],
+      });
+      const report = doctor.diagnose([orphan]);
+      const orphanDiags = report.diagnoses.filter(d => d.type === 'orphan');
+      expect(orphanDiags).toHaveLength(1);
+      expect(orphanDiags[0].entryId).toBe('orphan-1');
+      expect(orphanDiags[0].severity).toBe('low');
+    });
+
+    it('archived 条目不检测为孤儿', () => {
+      const doctor = new KnowledgeDoctor();
+      const archived = makeEntry({
+        maturity: 'archived',
+        referencedBy: [],
+        contributors: [],
+        projects: [],
+      });
+      const report = doctor.diagnose([archived]);
+      expect(report.diagnoses.filter(d => d.type === 'orphan')).toHaveLength(0);
+    });
+
+    it('有引用的 draft 条目不检测为孤儿', () => {
+      const doctor = new KnowledgeDoctor();
+      const entry = makeEntry({ maturity: 'draft', referencedBy: ['r1'], contributors: [], projects: [] });
+      const report = doctor.diagnose([entry]);
+      expect(report.diagnoses.filter(d => d.type === 'orphan')).toHaveLength(0);
+    });
+  });
+
+  describe('过时检测', () => {
+    it('检测超过阈值天数未引用的 draft 条目', () => {
+      const doctor = new KnowledgeDoctor({ outdatedDays: 30 });
+      const old = makeEntry({
+        id: 'old-1',
+        maturity: 'draft',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const report = doctor.diagnose([old]);
+      const outdated = report.diagnoses.filter(d => d.type === 'outdated');
+      expect(outdated).toHaveLength(1);
+      expect(outdated[0].entryId).toBe('old-1');
+    });
+
+    it('verified/proven 条目不检测为过时', () => {
+      const doctor = new KnowledgeDoctor({ outdatedDays: 1 });
+      const entry = makeEntry({
+        maturity: 'verified',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const report = doctor.diagnose([entry]);
+      expect(report.diagnoses.filter(d => d.type === 'outdated')).toHaveLength(0);
+    });
+  });
+
+  describe('衰减检测', () => {
+    it('检测长期未引用的 proven 条目', () => {
+      const doctor = new KnowledgeDoctor({ decayWarningDays: 30 });
+      const entry = makeEntry({
+        id: 'decay-1',
+        maturity: 'proven',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const report = doctor.diagnose([entry]);
+      const decay = report.diagnoses.filter(d => d.type === 'decay');
+      expect(decay).toHaveLength(1);
+      expect(decay[0].severity).toBe('high');
+    });
+
+    it('检测长期未引用的 verified 条目（medium severity）', () => {
+      const doctor = new KnowledgeDoctor({ decayWarningDays: 30 });
+      const entry = makeEntry({
+        maturity: 'verified',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const report = doctor.diagnose([entry]);
+      const decay = report.diagnoses.filter(d => d.type === 'decay');
+      expect(decay).toHaveLength(1);
+      expect(decay[0].severity).toBe('medium');
+    });
+
+    it('draft 条目不检测衰减', () => {
+      const doctor = new KnowledgeDoctor({ decayWarningDays: 1 });
+      const entry = makeEntry({
+        maturity: 'draft',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const report = doctor.diagnose([entry]);
+      expect(report.diagnoses.filter(d => d.type === 'decay')).toHaveLength(0);
+    });
+  });
+
+  describe('低引用检测', () => {
+    it('检测引用次数低于阈值的非 draft 条目', () => {
+      const doctor = new KnowledgeDoctor({ lowReferenceThreshold: 5 });
+      const entry = makeEntry({
+        maturity: 'verified',
+        referencedBy: ['r1'],
+      });
+      const report = doctor.diagnose([entry]);
+      const lowRef = report.diagnoses.filter(d => d.type === 'low_reference');
+      expect(lowRef).toHaveLength(1);
+      expect(lowRef[0].severity).toBe('low');
+    });
+
+    it('archived 和 draft 条目不检测低引用', () => {
+      const doctor = new KnowledgeDoctor({ lowReferenceThreshold: 100 });
+      const archived = makeEntry({ id: 'a1', maturity: 'archived', referencedBy: [] });
+      const draft = makeEntry({ id: 'd1', maturity: 'draft', referencedBy: [] });
+      const report = doctor.diagnose([archived, draft]);
+      expect(report.diagnoses.filter(d => d.type === 'low_reference')).toHaveLength(0);
+    });
+  });
+
+  describe('Lint issues 转换', () => {
+    it('将 LintIssue 转换为诊断', () => {
+      const doctor = new KnowledgeDoctor();
+      const issue: LintIssue = {
+        type: 'orphan',
+        entryId: 'e1',
+        severity: 'medium',
+        description: 'Orphan entry',
+        suggestion: 'Archive it',
+      };
+      const report = doctor.diagnose([], [issue]);
+      expect(report.diagnoses).toHaveLength(1);
+      expect(report.diagnoses[0].type).toBe('orphan');
+      expect(report.diagnoses[0].severity).toBe('medium');
+      expect(report.diagnoses[0].recommendations).toContain('Archive it');
+    });
+
+    it('覆盖所有 LintIssue 类型的根因和影响推断', () => {
+      const doctor = new KnowledgeDoctor();
+      const types: LintIssue['type'][] = ['contradiction', 'outdated', 'duplicate', 'index_inconsistent'];
+      for (const type of types) {
+        const issue: LintIssue = { type, severity: 'low', description: `test ${type}`, suggestion: 'fix' };
+        const report = doctor.diagnose([], [issue]);
+        const diag = report.diagnoses.find(d => d.type === type);
+        expect(diag).toBeDefined();
+        expect(diag!.rootCause).toBeTruthy();
+        expect(diag!.impact).toBeTruthy();
+      }
+    });
+
+    it('未知 LintIssue 类型使用默认根因和影响', () => {
+      const doctor = new KnowledgeDoctor();
+      const issue = { type: 'unknown_type', severity: 'low', description: 'unknown', suggestion: 'fix' } as unknown as LintIssue;
+      const report = doctor.diagnose([], [issue]);
+      expect(report.diagnoses[0].rootCause).toBe('未知原因');
+      expect(report.diagnoses[0].impact).toBe('未知影响');
+    });
+  });
+
+  describe('健康分数', () => {
+    it('无问题时返回 100', () => {
+      const doctor = new KnowledgeDoctor();
+      const entry = makeEntry({ maturity: 'verified', referencedBy: ['r1', 'r2', 'r3'], projects: ['p1', 'p2'] });
+      const report = doctor.diagnose([entry]);
+      expect(report.healthScore).toBe(100);
+    });
+
+    it('有问题时扣分', () => {
+      const doctor = new KnowledgeDoctor({ decayWarningDays: 1, lowReferenceThreshold: 100 });
+      const entry = makeEntry({
+        maturity: 'proven',
+        lastReferenced: '2020-01-01T00:00:00Z',
+        referencedBy: ['r1'],
+        projects: ['p1'],
+      });
+      const report = doctor.diagnose([entry]);
+      expect(report.healthScore).toBeLessThan(100);
+    });
+
+    it('critical 严重度扣 10 分', () => {
+      const doctor = new KnowledgeDoctor();
+      const issue: LintIssue = { type: 'contradiction', severity: 'high', entryId: 'e1', description: 'critical issue', suggestion: 'fix' };
+      // 直接构造 critical 诊断来测试 calculateHealthScore 的 critical 分支
+      // LintIssue severity 只有 low/medium/high，所以通过 checkDecay 的 high 来测试
+      const entry = makeEntry({ maturity: 'proven', lastReferenced: '2020-01-01T00:00:00Z' });
+      const report = doctor.diagnose([entry]);
+      const decayDiag = report.diagnoses.find(d => d.type === 'decay');
+      expect(decayDiag).toBeDefined();
+      expect(decayDiag!.severity).toBe('high');
+    });
+  });
+
+  describe('报告生成', () => {
+    it('生成 Markdown 报告', () => {
+      const doctor = new KnowledgeDoctor();
+      const report = doctor.diagnose([makeEntry()]);
+      const md = doctor.generateReport(report);
+      expect(md).toContain('# 知识库健康报告');
+      expect(md).toContain('健康分数');
+      expect(md).toContain('## 问题统计');
+    });
+
+    it('有诊断时生成详情', () => {
+      const doctor = new KnowledgeDoctor({ decayWarningDays: 1 });
+      const entry = makeEntry({
+        maturity: 'proven',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const report = doctor.diagnose([entry]);
+      const md = doctor.generateReport(report);
+      expect(md).toContain('## 诊断详情');
+      expect(md).toContain('衰减预警');
+    });
+  });
+
+  describe('配置', () => {
+    it('使用默认配置', () => {
+      const doctor = new KnowledgeDoctor();
+      // 默认 lowReferenceThreshold=2
+      const entry = makeEntry({ maturity: 'verified', referencedBy: ['r1'] });
+      const report = doctor.diagnose([entry]);
+      expect(report.diagnoses.filter(d => d.type === 'low_reference')).toHaveLength(1);
+    });
+
+    it('自定义配置覆盖默认值', () => {
+      const doctor = new KnowledgeDoctor({ lowReferenceThreshold: 0 });
+      const entry = makeEntry({ maturity: 'verified', referencedBy: [] });
+      const report = doctor.diagnose([entry]);
+      expect(report.diagnoses.filter(d => d.type === 'low_reference')).toHaveLength(0);
+    });
+  });
+});

package/src/monitoring/__tests__/knowledge-evolver.test.ts

@@ -0,0 +1,365 @@
+import { KnowledgeEvolver } from '../knowledge-evolver';
+import type { KnowledgeDiagnosis } from '../knowledge-doctor';
+import type { KnowledgeEntry } from '../../knowledge/types';
+
+function makeEntry(overrides: Partial<KnowledgeEntry> = {}): KnowledgeEntry {
+  return {
+    id: 'entry-1',
+    type: 'guideline',
+    title: 'Test Entry',
+    content: 'content',
+    maturity: 'draft',
+    layer: 'team',
+    created: '2025-01-01T00:00:00Z',
+    lastReferenced: new Date().toISOString(),
+    contributors: ['user-1'],
+    projects: ['proj-1'],
+    tags: ['test'],
+    applicablePhases: ['implementation'],
+    sourceReferences: [],
+    referencedBy: ['ref-1'],
+    ...overrides,
+  };
+}
+
+describe('KnowledgeEvolver', () => {
+  describe('升级提案', () => {
+    it('draft 有引用时提议升级为 verified', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ maturity: 'draft', referencedBy: ['r1'] });
+      const proposals = evolver.generateProposals([entry]);
+      const promote = proposals.filter(p => p.action === 'promote');
+      expect(promote).toHaveLength(1);
+      expect(promote[0].targetMaturity).toBe('verified');
+      expect(promote[0].risk).toBe('low');
+      expect(promote[0].autoApprovable).toBe(true);
+    });
+
+    it('draft 无引用时不提议升级', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ maturity: 'draft', referencedBy: [] });
+      const proposals = evolver.generateProposals([entry]);
+      expect(proposals.filter(p => p.action === 'promote')).toHaveLength(0);
+    });
+
+    it('verified 有足够项目验证时提议升级为 proven', () => {
+      const evolver = new KnowledgeEvolver({ promoteThreshold: 2 });
+      const entry = makeEntry({ maturity: 'verified', projects: ['p1', 'p2'] });
+      const proposals = evolver.generateProposals([entry]);
+      const promote = proposals.filter(p => p.action === 'promote');
+      expect(promote).toHaveLength(1);
+      expect(promote[0].targetMaturity).toBe('proven');
+    });
+
+    it('verified 项目数不足时不提议升级', () => {
+      const evolver = new KnowledgeEvolver({ promoteThreshold: 5 });
+      const entry = makeEntry({ maturity: 'verified', projects: ['p1'] });
+      const proposals = evolver.generateProposals([entry]);
+      expect(proposals.filter(p => p.action === 'promote')).toHaveLength(0);
+    });
+
+    it('proven 不会提议升级（已到顶）', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ maturity: 'proven', referencedBy: ['r1', 'r2'], projects: ['p1', 'p2'] });
+      const proposals = evolver.generateProposals([entry]);
+      expect(proposals.filter(p => p.action === 'promote')).toHaveLength(0);
+    });
+  });
+
+  describe('降级提案', () => {
+    it('长期未引用的 verified 提议降级', () => {
+      const evolver = new KnowledgeEvolver({ demoteDays: 30 });
+      const entry = makeEntry({
+        maturity: 'verified',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const proposals = evolver.generateProposals([entry]);
+      const demote = proposals.filter(p => p.action === 'demote');
+      expect(demote).toHaveLength(1);
+      expect(demote[0].targetMaturity).toBe('draft');
+    });
+
+    it('长期未引用的 proven 提议降级为 verified', () => {
+      const evolver = new KnowledgeEvolver({ demoteDays: 30 });
+      const entry = makeEntry({
+        maturity: 'proven',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const proposals = evolver.generateProposals([entry]);
+      const demote = proposals.filter(p => p.action === 'demote');
+      expect(demote).toHaveLength(1);
+      expect(demote[0].targetMaturity).toBe('verified');
+    });
+
+    it('draft 不会提议降级（已到底）', () => {
+      const evolver = new KnowledgeEvolver({ demoteDays: 1 });
+      const entry = makeEntry({
+        maturity: 'draft',
+        lastReferenced: '2020-01-01T00:00:00Z',
+      });
+      const proposals = evolver.generateProposals([entry]);
+      expect(proposals.filter(p => p.action === 'demote')).toHaveLength(0);
+    });
+
+    it('近期有引用的不提议降级', () => {
+      const evolver = new KnowledgeEvolver({ demoteDays: 180 });
+      const entry = makeEntry({ maturity: 'verified' });
+      const proposals = evolver.generateProposals([entry]);
+      expect(proposals.filter(p => p.action === 'demote')).toHaveLength(0);
+    });
+  });
+
+  describe('archived 条目', () => {
+    it('跳过 archived 条目', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ maturity: 'archived' });
+      const proposals = evolver.generateProposals([entry]);
+      expect(proposals).toHaveLength(0);
+    });
+  });
+
+  describe('矛盾诊断 → freeze 提案', () => {
+    it('从矛盾诊断生成 freeze 提案', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ id: 'e1', maturity: 'verified' });
+      const diagnosis: KnowledgeDiagnosis = {
+        id: 'd1',
+        type: 'contradiction',
+        severity: 'high',
+        entryId: 'e1',
+        title: 'Contradiction',
+        description: 'Conflicting entries',
+        rootCause: 'Same tag different maturity',
+        impact: 'Confusion',
+        recommendations: ['Freeze'],
+        timestamp: new Date().toISOString(),
+      };
+      const proposals = evolver.generateProposals([entry], [diagnosis]);
+      const freeze = proposals.filter(p => p.action === 'freeze');
+      expect(freeze).toHaveLength(1);
+      expect(freeze[0].risk).toBe('medium');
+      expect(freeze[0].autoApprovable).toBe(false);
+    });
+
+    it('无 entryId 的矛盾诊断不生成提案', () => {
+      const evolver = new KnowledgeEvolver();
+      const diagnosis: KnowledgeDiagnosis = {
+        id: 'd1',
+        type: 'contradiction',
+        severity: 'high',
+        title: 'Contradiction',
+        description: 'Conflicting entries',
+        rootCause: 'Unknown',
+        impact: 'Unknown',
+        recommendations: [],
+        timestamp: new Date().toISOString(),
+      };
+      const proposals = evolver.generateProposals([], [diagnosis]);
+      expect(proposals).toHaveLength(0);
+    });
+  });
+
+  describe('审核', () => {
+    it('低风险自动通过提案自动批准', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ maturity: 'draft', referencedBy: ['r1'] });
+      const proposals = evolver.generateProposals([entry]);
+      const result = evolver.review(proposals[0]);
+      expect(result.approved).toBe(true);
+    });
+
+    it('proven 直接归档被拒绝', () => {
+      const evolver = new KnowledgeEvolver();
+      const proposal = {
+        id: 'p1',
+        entryId: 'e1',
+        action: 'archive' as const,
+        currentMaturity: 'proven' as const,
+        targetMaturity: 'archived' as const,
+        reason: 'test',
+        evidence: [],
+        risk: 'low' as const,
+        autoApprovable: true,
+        status: 'pending' as const,
+        createdAt: new Date().toISOString(),
+      };
+      const result = evolver.review(proposal);
+      expect(result.approved).toBe(false);
+      expect(result.reason).toContain('proven');
+    });
+
+    it('高风险升级被拒绝', () => {
+      const evolver = new KnowledgeEvolver();
+      const proposal = {
+        id: 'p1',
+        entryId: 'e1',
+        action: 'promote' as const,
+        currentMaturity: 'draft' as const,
+        targetMaturity: 'verified' as const,
+        reason: 'test',
+        evidence: [],
+        risk: 'high' as const,
+        autoApprovable: false,
+        status: 'pending' as const,
+        createdAt: new Date().toISOString(),
+      };
+      const result = evolver.review(proposal);
+      expect(result.approved).toBe(false);
+      expect(result.reason).toContain('高风险');
+    });
+
+    it('中等风险提案通过审核', () => {
+      const evolver = new KnowledgeEvolver();
+      const proposal = {
+        id: 'p1',
+        entryId: 'e1',
+        action: 'freeze' as const,
+        currentMaturity: 'verified' as const,
+        targetMaturity: 'verified' as const,
+        reason: 'test',
+        evidence: [],
+        risk: 'medium' as const,
+        autoApprovable: false,
+        status: 'pending' as const,
+        createdAt: new Date().toISOString(),
+      };
+      const result = evolver.review(proposal);
+      expect(result.approved).toBe(true);
+      expect(result.reason).toBe('提案通过审核');
+    });
+  });
+
+  describe('执行提案', () => {
+    it('无 store 时返回 false', () => {
+      const evolver = new KnowledgeEvolver();
+      const proposal = {
+        id: 'p1',
+        entryId: 'e1',
+        action: 'promote' as const,
+        currentMaturity: 'draft' as const,
+        targetMaturity: 'verified' as const,
+        reason: 'test',
+        evidence: [],
+        risk: 'low' as const,
+        autoApprovable: true,
+        status: 'approved' as const,
+        createdAt: new Date().toISOString(),
+      };
+      expect(evolver.implement(proposal)).toBe(false);
+    });
+
+    it('非 approved 状态返回 false', () => {
+      const evolver = new KnowledgeEvolver();
+      const proposal = {
+        id: 'p1',
+        entryId: 'e1',
+        action: 'promote' as const,
+        currentMaturity: 'draft' as const,
+        targetMaturity: 'verified' as const,
+        reason: 'test',
+        evidence: [],
+        risk: 'low' as const,
+        autoApprovable: true,
+        status: 'pending' as const,
+        createdAt: new Date().toISOString(),
+      };
+      expect(evolver.implement(proposal)).toBe(false);
+    });
+
+    it('store 中不存在条目时返回 false', () => {
+      const mockStore = { get: () => undefined, update: jest.fn() };
+      const evolver = new KnowledgeEvolver({}, mockStore as any);
+      const proposal = {
+        id: 'p1', entryId: 'e1', action: 'promote' as const,
+        currentMaturity: 'draft' as const, targetMaturity: 'verified' as const,
+        reason: 'test', evidence: [], risk: 'low' as const,
+        autoApprovable: true, status: 'approved' as const,
+        createdAt: new Date().toISOString(),
+      };
+      expect(evolver.implement(proposal)).toBe(false);
+    });
+
+    it('archive 操作执行成功', () => {
+      const mockStore = { get: () => makeEntry(), update: jest.fn() };
+      const evolver = new KnowledgeEvolver({}, mockStore as any);
+      const proposal = {
+        id: 'p1', entryId: 'entry-1', action: 'archive' as const,
+        currentMaturity: 'draft' as const, targetMaturity: 'archived' as const,
+        reason: 'test', evidence: [], risk: 'low' as const,
+        autoApprovable: true, status: 'approved' as const,
+        createdAt: new Date().toISOString(),
+      };
+      expect(evolver.implement(proposal)).toBe(true);
+      expect(mockStore.update).toHaveBeenCalledWith('entry-1', { maturity: 'archived' });
+      expect(proposal.status).toBe('implemented');
+    });
+
+    it('freeze 操作不调用 update', () => {
+      const mockStore = { get: () => makeEntry(), update: jest.fn() };
+      const evolver = new KnowledgeEvolver({}, mockStore as any);
+      const proposal = {
+        id: 'p1', entryId: 'entry-1', action: 'freeze' as const,
+        currentMaturity: 'verified' as const, targetMaturity: 'verified' as const,
+        reason: 'test', evidence: [], risk: 'medium' as const,
+        autoApprovable: false, status: 'approved' as const,
+        createdAt: new Date().toISOString(),
+      };
+      expect(evolver.implement(proposal)).toBe(true);
+      expect(mockStore.update).not.toHaveBeenCalled();
+      expect(proposal.status).toBe('implemented');
+    });
+
+    it('未知 action 返回 false', () => {
+      const mockStore = { get: () => makeEntry(), update: jest.fn() };
+      const evolver = new KnowledgeEvolver({}, mockStore as any);
+      const proposal = {
+        id: 'p1', entryId: 'entry-1', action: 'merge' as const,
+        currentMaturity: 'draft' as const, targetMaturity: 'verified' as const,
+        reason: 'test', evidence: [], risk: 'low' as const,
+        autoApprovable: true, status: 'approved' as const,
+        createdAt: new Date().toISOString(),
+      };
+      expect(evolver.implement(proposal)).toBe(false);
+    });
+  });
+
+  describe('批量处理', () => {
+    it('processProposals 审核并生成报告', () => {
+      const evolver = new KnowledgeEvolver();
+      const entry = makeEntry({ maturity: 'draft', referencedBy: ['r1'] });
+      const proposals = evolver.generateProposals([entry]);
+      const report = evolver.processProposals(proposals);
+      expect(report.proposals.length).toBeGreaterThan(0);
+      expect(report.proposals[0].status).toBe('approved');
+      expect(report.summary).toBeDefined();
+    });
+
+    it('processProposals 拒绝高风险提案', () => {
+      const evolver = new KnowledgeEvolver();
+      const proposal = {
+        id: 'p1', entryId: 'e1', action: 'promote' as const,
+        currentMaturity: 'draft' as const, targetMaturity: 'verified' as const,
+        reason: 'test', evidence: [], risk: 'high' as const,
+        autoApprovable: false, status: 'pending' as const,
+        createdAt: new Date().toISOString(),
+      };
+      const report = evolver.processProposals([proposal]);
+      expect(report.proposals[0].status).toBe('rejected');
+    });
+
+    it('autoImplement 模式自动执行低风险提案', () => {
+      const mockStore = {
+        get: (id: string) => makeEntry({ id, maturity: 'draft' }),
+        update: jest.fn(),
+      };
+      const evolver = new KnowledgeEvolver({ autoImplement: true }, mockStore as any);
+      const entry = makeEntry({ maturity: 'draft', referencedBy: ['r1'] });
+      const proposals = evolver.generateProposals([entry]);
+      const report = evolver.processProposals(proposals);
+      const promote = report.proposals.find(p => p.action === 'promote');
+      if (promote?.autoApprovable) {
+        expect(promote.status).toBe('implemented');
+      }
+    });
+  });
+});