@dommaker/harness 0.13.3 → 0.16.0

package/src/knowledge/ingest.ts

@@ -12,7 +12,43 @@ import type {
   IngestOptions,
   SourceRef,
 } from './types';
-import { KnowledgeStore } from './store';
+import type { KnowledgeStore } from './store';
+import { KnowledgeAudit } from './audit';
+
+const MAX_SOURCE_REFS = 20;
+const MAX_EXTERNAL_CONTENT_LENGTH = 5000;
+
+/** Known prompt injection patterns to strip from external content */
+const INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?previous\s+instructions/gi,
+  /ignore\s+(all\s+)?prior\s+instructions/gi,
+  /system:\s*/gi,
+  /\[INST\]/gi,
+  /\[\/INST\]/gi,
+  /<\|im_start\|>/gi,
+  /<\|im_end\|>/gi,
+  /you\s+are\s+now\s+/gi,
+  /forget\s+(everything|all)\s+(you|about)/gi,
+  /new\s+instructions?:/gi,
+  /override\s+(your|system)\s+(instructions|prompt)/gi,
+];
+
+/**
+ * Sanitize external content for safe ingest.
+ * - Strips known prompt injection patterns
+ * - Limits content length
+ * - Returns sanitized string
+ */
+export function sanitizeExternalContent(content: string): string {
+  let sanitized = content;
+  for (const pattern of INJECTION_PATTERNS) {
+    sanitized = sanitized.replace(pattern, '[FILTERED]');
+  }
+  if (sanitized.length > MAX_EXTERNAL_CONTENT_LENGTH) {
+    sanitized = sanitized.slice(0, MAX_EXTERNAL_CONTENT_LENGTH) + '...[truncated]';
+  }
+  return sanitized;
+}
 
 // ── Ingest ─────────────────────────────────────────────────
 
@@ -34,14 +70,49 @@ export class KnowledgeIngest {
   ): KnowledgeEntry {
     const entry = this.buildEntry(partial, options);
 
+    // Quality gate: audit before saving
+    const audit = new KnowledgeAudit({ baseDir: this.store.getBaseDir() });
+    let issues = audit.validate(entry);
+    const critical = issues.filter(i => i.action === 'reject');
+    if (critical.length > 0) {
+      // Reject: return entry without saving, caller can check issues
+      (entry as any).__rejected = true;
+      (entry as any).__rejectReasons = critical.map(i => i.detail);
+      return entry;
+    }
+
+    // If caller explicitly set maturity, skip demote actions from audit.
+    // Demote is for auto-inferred maturity that's too high; explicit is a user decision.
+    if (options.maturity) {
+      issues = issues.filter(i => i.action !== 'demote');
+    }
+
     // Dedup check: same title + same type
-    const existing = this.findDuplicate(entry.title, entry.type);
+    const existing = this.findDuplicate(entry.title, entry.content, entry.type);
     if (existing) {
       // Merge: update existing entry with new content and metadata
       return this.mergeEntries(existing, entry, options);
     }
 
     this.store.save(entry);
+
+    // Post-save: apply auto-fixes (archive/demote/flag)
+    const fixable = issues.filter(i => i.action !== 'reject');
+    if (fixable.length > 0) {
+      for (const issue of fixable) {
+        if (issue.action === 'archive') {
+          this.store.update(entry.id, { maturity: 'archived' });
+        } else if (issue.action === 'demote') {
+          this.store.update(entry.id, { maturity: 'draft' });
+        } else if (issue.action === 'flag') {
+          const saved = this.store.get(entry.id);
+          if (saved && !saved.tags.includes('low_quality')) {
+            this.store.update(entry.id, { tags: [...saved.tags, 'low_quality'] });
+          }
+        }
+      }
+    }
+
     return entry;
   }
 
@@ -56,6 +127,23 @@ export class KnowledgeIngest {
     return partials.map(p => this.ingestEntry(p, options));
   }
 
+  /**
+   * Ingest external content with sanitization.
+   * - Sanitizes content (strips injection patterns, limits length)
+   * - Forces origin: 'external'
+   * - Uses consumptionMode from options (default: 'reference')
+   */
+  ingestExternal(
+    partial: Partial<KnowledgeEntry>,
+    options: Omit<IngestOptions, 'origin'> & { fullContentPath?: string },
+  ): KnowledgeEntry {
+    const sanitizedContent = sanitizeExternalContent(partial.content || '');
+    return this.ingestEntry(
+      { ...partial, content: sanitizedContent },
+      { ...options, origin: 'external' },
+    );
+  }
+
   // ── Internal ───────────────────────────────────────────────
 
   private buildEntry(
@@ -81,6 +169,11 @@ export class KnowledgeIngest {
       applicablePhases: partial.applicablePhases || [],
       sourceReferences: partial.sourceReferences || this.defaultSourceRef(options.source),
       referencedBy: partial.referencedBy || [],
+      executionResults: partial.executionResults || [],
+      consumptionMode: partial.consumptionMode || options.consumptionMode || 'reference',
+      origin: partial.origin || options.origin || 'agent',
+      fullContentPath: partial.fullContentPath || options.fullContentPath,
+      skillId: partial.skillId,
     };
   }
 
@@ -96,9 +189,79 @@ export class KnowledgeIngest {
     return 'guideline';
   }
 
-  private findDuplicate(title: string, type: KnowledgeType): KnowledgeEntry | undefined {
-    const all = this.store.list({ types: [type] });
-    return all.find(e => e.title.toLowerCase() === title.toLowerCase());
+  private findDuplicate(title: string, content: string, type: KnowledgeType): KnowledgeEntry | undefined {
+    // A1: Read from disk directly to avoid stale index causing dedup failure
+    const all = this.store.readEntriesFromDisk().filter(e => e.type === type);
+
+    // Exact match (case-insensitive)
+    const exact = all.find(e => e.title.toLowerCase() === title.toLowerCase());
+    if (exact) return exact;
+
+    // Semantic dedup: content prefix + title substring + keyword overlap
+    return this.findSemanticDuplicate(title, content, all);
+  }
+
+  /**
+   * Semantic dedup: detect same knowledge with different title wording.
+   * Signal priority: content prefix > title substring > title keyword overlap.
+   */
+  private findSemanticDuplicate(title: string, content: string, entries: KnowledgeEntry[]): KnowledgeEntry | undefined {
+    const normalized = this.normalizeForDedup(title);
+    const contentPrefix = this.getContentPrefix(content);
+
+    for (const entry of entries) {
+      const entryNorm = this.normalizeForDedup(entry.title);
+
+      // 1. Content prefix match (first 50 chars — shared root cause description)
+      if (contentPrefix.length >= 30) {
+        const entryPrefix = this.getContentPrefix(entry.content);
+        if (entryPrefix.length >= 30 && contentPrefix === entryPrefix) return entry;
+      }
+
+      // 2. Title substring match after normalization
+      if (normalized.length >= 6 && entryNorm.length >= 6) {
+        if (normalized.includes(entryNorm) || entryNorm.includes(normalized)) {
+          return entry;
+        }
+      }
+
+      // 3. Title keyword overlap >= 60%
+      if (this.titleOverlap(normalized, entryNorm) >= 0.6) {
+        return entry;
+      }
+    }
+
+    return undefined;
+  }
+
+  /** Strip [prefix] tags and normalize for comparison */
+  private normalizeForDedup(title: string): string {
+    const t = title.replace(/^\[.*?\]\s*/g, '').trim();
+    // Keep spaces between character types (Latin/Chinese boundary) for tokenization
+    return t.replace(/[，。、：；！？]/g, '').toLowerCase();
+  }
+
+  /** Extract first 50 chars of content body (after frontmatter), stripped of whitespace */
+  private getContentPrefix(content: string): string {
+    // Strip YAML frontmatter (may be nested if content includes raw markdown)
+    const body = content.replace(/^---[\s\S]*?---\n?/, '').trim();
+    return body.slice(0, 50).replace(/\s+/g, '');
+  }
+
+  /** Calculate keyword overlap ratio between two normalized titles */
+  private titleOverlap(a: string, b: string): number {
+    // Extract Chinese characters as individual tokens + Latin words
+    const tokenize = (s: string): string[] => {
+      const chinese = [...s.matchAll(/\p{Script=Han}/gu)].map(m => m[0]);
+      const latin = s.match(/[a-z0-9]{2,}/g) || [];
+      return [...chinese, ...latin];
+    };
+    const tokensA = tokenize(a);
+    const tokensB = tokenize(b);
+    if (tokensA.length === 0 || tokensB.length === 0) return 0;
+    const setB = new Set(tokensB);
+    const overlap = tokensA.filter(t => setB.has(t)).length;
+    return overlap / Math.max(tokensA.length, tokensB.length);
   }
 
   private mergeEntries(
@@ -108,11 +271,12 @@ export class KnowledgeIngest {
   ): KnowledgeEntry {
     const merged: Partial<KnowledgeEntry> = {
       content: incoming.content || existing.content,
+      maturity: options.maturity || existing.maturity,
       lastReferenced: new Date().toISOString(),
       contributors: [...new Set([...existing.contributors, ...incoming.contributors])],
       projects: [...new Set([...existing.projects, ...incoming.projects])],
       tags: [...new Set([...existing.tags, ...incoming.tags])],
-      sourceReferences: [...existing.sourceReferences, ...incoming.sourceReferences],
+      sourceReferences: [...existing.sourceReferences, ...incoming.sourceReferences].slice(-MAX_SOURCE_REFS),
     };
     return this.store.update(existing.id, merged)!;
   }

package/src/knowledge/lifecycle-hooks.ts

@@ -7,7 +7,7 @@
  */
 
 import type { KnowledgeEntry, KnowledgeType } from './types';
-import { KnowledgeStore } from './store';
+import type { KnowledgeStore } from './store';
 import { KnowledgeQuery } from './query';
 import type { ContextSource } from '../context/types';
 
@@ -194,6 +194,9 @@ export class KnowledgeLifecycleHooks {
         timestamp: new Date().toISOString(),
       }],
       referencedBy: [],
+      executionResults: [],
+      consumptionMode: 'reference',
+      origin: 'agent',
     };
   }
 }

package/src/knowledge/lifecycle.ts

@@ -12,24 +12,47 @@ import type {
   DecayConfig,
 } from './types';
 import { DEFAULT_DECAY_CONFIG } from './types';
-import { KnowledgeStore } from './store';
+import type { KnowledgeStore } from './store';
+
+const MAX_REFERENCED_BY = 20;
+const MIN_CONTENT_FOR_PROVEN = 100;
+const TEST_ID_PATTERN = /^(test-|inj-test)/;
+const SIGNAL_SATURATION_THRESHOLD = 3;
+const CONTEXT_DECAY_MONTHS = 3;
+const RULE_MIN_RESULTS_FOR_DECAY = 3;
+const RULE_FAIL_THRESHOLD = 0.5;
 
 // ── Lifecycle ──────────────────────────────────────────────
 
+export interface ConsumptionEvent {
+  entryId: string;
+  contributor: string;
+  timestamp: string;
+  context?: string;
+  success?: boolean;
+}
+
 export class KnowledgeLifecycle {
   private store: KnowledgeStore;
   private config: DecayConfig;
+  private onReferenceCallbacks: Array<(event: ConsumptionEvent) => void> = [];
 
   constructor(store: KnowledgeStore, config?: Partial<DecayConfig>) {
     this.store = store;
     this.config = { ...DEFAULT_DECAY_CONFIG, ...config };
   }
 
+  /** Register a callback fired on every recordReference() call */
+  onReference(callback: (event: ConsumptionEvent) => void): void {
+    this.onReferenceCallbacks.push(callback);
+  }
+
   /**
    * Record that an entry was referenced.
    * Updates lastReferenced timestamp, contributors, and referencedBy.
+   * Optionally records execution success/failure.
    */
-  recordReference(entryId: string, contributor?: string): KnowledgeEntry | undefined {
+  recordReference(entryId: string, contributor?: string, success?: boolean, source?: 'human' | 'auto'): KnowledgeEntry | undefined {
     const entry = this.store.get(entryId);
     if (!entry) return undefined;
 
@@ -39,84 +62,93 @@ export class KnowledgeLifecycle {
       : entry.contributors;
 
     const refKey = `${contributor || 'unknown'}:${now.slice(0, 10)}`;
-    const referencedBy = entry.referencedBy.includes(refKey)
-      ? entry.referencedBy
-      : [...entry.referencedBy, refKey];
+    const execSource = source || (contributor?.startsWith('auto-') ? 'auto' : undefined);
 
-    return this.store.update(entryId, {
+    // B4: Skip file write if this refKey already exists (same-day, same contributor)
+    if (entry.referencedBy.includes(refKey)) {
+      // But still record execution result if provided
+      if (success !== undefined) {
+        const executionResults = [
+          ...(entry.executionResults || []),
+          { contributor: contributor || 'unknown', success, timestamp: now, source: execSource },
+        ].slice(-MAX_REFERENCED_BY);
+        this.store.update(entryId, { executionResults });
+      }
+      return entry;
+    }
+
+    const referencedBy = [...entry.referencedBy, refKey].slice(-MAX_REFERENCED_BY);
+    const executionResults = success !== undefined
+      ? [...(entry.executionResults || []), { contributor: contributor || 'unknown', success, timestamp: now, source: execSource }].slice(-MAX_REFERENCED_BY)
+      : entry.executionResults;
+
+    const updated = this.store.update(entryId, {
       lastReferenced: now,
       contributors,
       referencedBy,
+      executionResults,
     });
+
+    // Fire consumption event callbacks
+    for (const cb of this.onReferenceCallbacks) {
+      try {
+        cb({ entryId, contributor: contributor || 'unknown', timestamp: now, success });
+      } catch { /* non-blocking */ }
+    }
+
+    return updated;
   }
 
   /**
    * Check if an entry meets promotion criteria.
    * Returns the target maturity level if promotion is warranted, otherwise undefined.
    *
-   * Rules:
-   * - draft → verified: lastReferenced is set (referenced at least once)
-   * - verified → proven: two paths
-   *   A) Multi-project: contributors >= 3 AND projects >= 2
-   *   B) Single-project: referencedBy >= 3 AND sourceReferences from 2+ distinct workflows
+   * Branches by consumptionMode:
+   * - rule: draft→active (1 success execution)
+   * - reference: draft→verified→proven (existing logic)
+   * - context: draft→active (1 reference)
+   * - signal: no promotion
    */
   checkPromotion(entryId: string): MaturityLevel | undefined {
     const entry = this.store.get(entryId);
     if (!entry) return undefined;
 
-    switch (entry.maturity) {
-      case 'draft':
-        if (entry.lastReferenced) return 'verified';
-        return undefined;
+    // RC2: block test entries from any promotion
+    if (TEST_ID_PATTERN.test(entryId)) return undefined;
 
-      case 'verified': {
-        // Path A: multi-project validation
-        if (entry.contributors.length >= 3 && entry.projects.length >= 2) {
-          return 'proven';
-        }
-        // Path B: single-project — multiple independent references from different sources
-        const refCount = entry.referencedBy?.length || 0;
-        const distinctSources = new Set(entry.sourceReferences?.map(s => s.workflow).filter(Boolean) || []);
-        if (refCount >= 3 && distinctSources.size >= 2) {
-          return 'proven';
-        }
-        return undefined;
-      }
+    const mode = entry.consumptionMode || 'reference';
 
-      case 'proven':
-      case 'archived':
-        return undefined;
+    switch (mode) {
+      case 'rule':      return this.checkRulePromotion(entry);
+      case 'context':   return this.checkContextPromotion(entry);
+      case 'signal':    return undefined; // signal never promotes
+      case 'reference': return this.checkReferencePromotion(entry);
     }
   }
 
   /**
-   * Check if an entry should decay based on time since last reference.
+   * Check if an entry should decay.
    * Returns the target maturity level if decay is warranted, otherwise undefined.
+   *
+   * - decayAt hard expiry takes precedence (all modes)
+   * - Then branches by consumptionMode for mode-specific decay
    */
   checkEntryDecay(entryId: string): MaturityLevel | undefined {
     const entry = this.store.get(entryId);
     if (!entry) return undefined;
 
-    const lastRef = entry.lastReferenced || entry.created;
-    if (!lastRef) return undefined;
-
-    const monthsSinceRef = this.monthsSince(lastRef);
-
-    switch (entry.maturity) {
-      case 'proven':
-        if (monthsSinceRef >= this.config.provenDecayMonths) return 'verified';
-        return undefined;
-
-      case 'verified':
-        if (monthsSinceRef >= this.config.verifiedDecayMonths) return 'draft';
-        return undefined;
+    // decayAt hard expiry — all modes, highest priority
+    if (entry.decayAt && new Date(entry.decayAt) <= new Date()) {
+      return 'archived';
+    }
 
-      case 'draft':
-        if (monthsSinceRef >= this.config.draftDecayMonths) return 'archived';
-        return undefined;
+    const mode = entry.consumptionMode || 'reference';
 
-      case 'archived':
-        return undefined;
+    switch (mode) {
+      case 'rule':      return this.checkRuleDecay(entry);
+      case 'reference': return this.checkReferenceDecay(entry);
+      case 'context':   return this.checkContextDecay(entry);
+      case 'signal':    return this.checkSignalDecay(entry);
     }
   }
 
@@ -165,6 +197,143 @@ export class KnowledgeLifecycle {
     return change;
   }
 
+  /**
+   * Check if a source should auto-promote to verified on ingest.
+   * Used by KnowledgeBus to decide initial maturity level.
+   */
+  shouldAutoPromote(source: string): boolean {
+    return this.config.autoPromoteSources.some(s => source.includes(s));
+  }
+
+  /**
+   * Get execution success rate for an entry.
+   * Returns { rate, total } or undefined if no execution data.
+   */
+  getExecutionSuccessRate(entryId: string): { rate: number; total: number } | undefined {
+    const entry = this.store.get(entryId);
+    if (!entry || !entry.executionResults || entry.executionResults.length === 0) return undefined;
+    const total = entry.executionResults.length;
+    const successes = entry.executionResults.filter(r => r.success).length;
+    return { rate: successes / total, total };
+  }
+
+  /**
+   * Get execution success rate for human-sourced results only.
+   * Returns { rate, total } or undefined if no human execution data.
+   */
+  getHumanSuccessRate(entryId: string): { rate: number; total: number } | undefined {
+    const entry = this.store.get(entryId);
+    if (!entry || !entry.executionResults || entry.executionResults.length === 0) return undefined;
+    const humanResults = entry.executionResults.filter(r => r.source === 'human');
+    if (humanResults.length === 0) return undefined;
+    const total = humanResults.length;
+    const successes = humanResults.filter(r => r.success).length;
+    return { rate: successes / total, total };
+  }
+
+  // ── Per-mode promotion ─────────────────────────────────────
+
+  /** rule: draft→active with 1 success execution */
+  private checkRulePromotion(entry: KnowledgeEntry): MaturityLevel | undefined {
+    if (entry.maturity !== 'draft') return undefined;
+    const rate = this.getExecutionSuccessRate(entry.id);
+    if (rate && rate.total >= 1 && rate.rate >= 1.0) return 'active';
+    return undefined;
+  }
+
+  /** reference: draft→verified→proven (existing logic) */
+  private checkReferencePromotion(entry: KnowledgeEntry): MaturityLevel | undefined {
+    switch (entry.maturity) {
+      case 'draft':
+        if (entry.lastReferenced && entry.content.trim().length >= 50) return 'verified';
+        return undefined;
+
+      case 'verified': {
+        if (entry.content.trim().length < MIN_CONTENT_FOR_PROVEN) return undefined;
+        const humanRate = this.getHumanSuccessRate(entry.id);
+        if (humanRate && humanRate.total >= 3 && humanRate.rate >= 0.8) return 'proven';
+        const execRate = this.getExecutionSuccessRate(entry.id);
+        if (execRate && execRate.total >= 3 && execRate.rate >= 0.8) return 'proven';
+        if (entry.contributors.length >= 3 && entry.projects.length >= 2) return 'proven';
+        const refCount = entry.referencedBy?.length || 0;
+        const distinctSources = new Set(entry.sourceReferences?.map(s => s.workflow).filter(Boolean) || []);
+        if (refCount >= 3 && distinctSources.size >= 2) return 'proven';
+        return undefined;
+      }
+
+      default:
+        return undefined;
+    }
+  }
+
+  /** context: draft→active with 1 reference */
+  private checkContextPromotion(entry: KnowledgeEntry): MaturityLevel | undefined {
+    if (entry.maturity !== 'draft') return undefined;
+    if (entry.referencedBy.length >= 1) return 'active';
+    return undefined;
+  }
+
+  // ── Per-mode decay ─────────────────────────────────────────
+
+  /** rule: active→deprecated when fail rate >= 50% with 3+ results */
+  private checkRuleDecay(entry: KnowledgeEntry): MaturityLevel | undefined {
+    if (entry.maturity !== 'active') return undefined;
+    const rate = this.getExecutionSuccessRate(entry.id);
+    if (rate && rate.total >= RULE_MIN_RESULTS_FOR_DECAY && rate.rate < RULE_FAIL_THRESHOLD) return 'deprecated';
+    return undefined;
+  }
+
+  /** reference: proven→verified→draft→archived by time (existing logic) */
+  private checkReferenceDecay(entry: KnowledgeEntry): MaturityLevel | undefined {
+    const lastRef = entry.lastReferenced || entry.created;
+    if (!lastRef) return undefined;
+    const monthsSinceRef = this.monthsSince(lastRef);
+
+    switch (entry.maturity) {
+      case 'proven':
+        if (monthsSinceRef >= this.config.provenDecayMonths) return 'verified';
+        return undefined;
+      case 'verified':
+        if (monthsSinceRef >= this.config.verifiedDecayMonths) return 'draft';
+        return undefined;
+      case 'draft':
+        if (monthsSinceRef >= this.config.draftDecayMonths) return 'archived';
+        return undefined;
+      default:
+        return undefined;
+    }
+  }
+
+  /** context: active→archived after CONTEXT_DECAY_MONTHS unreferenced */
+  private checkContextDecay(entry: KnowledgeEntry): MaturityLevel | undefined {
+    if (entry.maturity !== 'active') return undefined;
+    const lastRef = entry.lastReferenced || entry.created;
+    if (!lastRef) return undefined;
+    if (this.monthsSince(lastRef) >= CONTEXT_DECAY_MONTHS) return 'archived';
+    return undefined;
+  }
+
+  /**
+   * signal: active→archived by consumption saturation.
+   * Saturated = referencedBy >= threshold AND newer same-tag signal entry exists.
+   */
+  private checkSignalDecay(entry: KnowledgeEntry): MaturityLevel | undefined {
+    if (entry.maturity !== 'active') return undefined;
+    const refCount = entry.referencedBy?.length || 0;
+    if (refCount < SIGNAL_SATURATION_THRESHOLD) return undefined;
+
+    const newer = this.store.list({
+      tags: entry.tags,
+      excludeArchived: false,
+    }).find(e =>
+      e.id !== entry.id &&
+      (e.consumptionMode || 'reference') === 'signal' &&
+      e.created > entry.created
+    );
+    if (newer) return 'archived';
+    return undefined;
+  }
+
   // ── Internal ───────────────────────────────────────────────
 
   private monthsSince(dateStr: string): number {

package/src/knowledge/lint.ts

@@ -10,10 +10,12 @@
  * - 成熟度衰减
  */
 
-import { KnowledgeStore } from './store';
+import type { KnowledgeStore } from './store';
 import { ReferenceTracker } from './reference-tracker';
 import type { KnowledgeEntry, LintIssue, LintIssueType, MaturityLevel } from './types';
 
+const MAX_SOURCE_REFS = 20;
+
 export interface LintReport {
   timestamp: string;
   totalEntries: number;
@@ -77,7 +79,7 @@ export class KnowledgeLinter {
    */
   checkIndexConsistency(entries: KnowledgeEntry[]): LintIssue[] {
     const issues: LintIssue[] = [];
-    const index = this.store['readIndex']();
+    const index = this.store.readIndex();
 
     // 检查索引中的条目是否都有对应文件
     for (const indexEntry of index) {
@@ -214,7 +216,7 @@ export class KnowledgeLinter {
     // 按 tag 组合分组
     for (const entry of entries) {
       if (entry.maturity === 'archived') continue;
-      if (entry.tags.length === 0) continue;
+      if (!entry.tags || entry.tags.length === 0) continue;
 
       const tagKey = entry.tags.sort().join(',');
       const existing = byTagGroup.get(tagKey) || [];
@@ -284,7 +286,7 @@ export class KnowledgeLinter {
     }
 
     // Contradicts proven entry with same tags
-    if (entry.tags.length > 0) {
+    if (entry.tags && entry.tags.length > 0) {
       const allEntries = this.store.list({ excludeArchived: false });
       for (const existing of allEntries) {
         if (existing.maturity !== 'proven') continue;
@@ -342,6 +344,45 @@ export class KnowledgeLinter {
   private autoFix(issues: LintIssue[]): number {
     let fixed = 0;
 
+    // A3: Deduplicate — group by entryId, keep newest, archive rest
+    const duplicateIssues = issues.filter(i => i.type === 'duplicate' && i.entryId);
+    const processedGroups = new Set<string>();
+    for (const issue of duplicateIssues) {
+      // Extract group from suggestion field: "考虑合并: GUI-003, GUI-004"
+      const match = issue.suggestion?.match(/: (.+)$/);
+      if (!match) continue;
+      const groupKey = match[1];
+      if (processedGroups.has(groupKey)) continue;
+      processedGroups.add(groupKey);
+
+      const ids = groupKey.split(', ').map(s => s.trim());
+      const entries = ids.map(id => this.store.get(id)).filter(Boolean) as KnowledgeEntry[];
+      if (entries.length <= 1) continue;
+
+      // Keep the one with most recent lastReferenced
+      entries.sort((a, b) => (b.lastReferenced || '').localeCompare(a.lastReferenced || ''));
+      const keep = entries[0];
+      for (let i = 1; i < entries.length; i++) {
+        this.store.update(entries[i].id, { maturity: 'archived' });
+        fixed++;
+      }
+      // Merge sourceReferences from archived entries into kept entry
+      const allRefs = entries.flatMap(e => e.sourceReferences || []);
+      if (allRefs.length > 0) {
+        const existing = keep.sourceReferences || [];
+        const merged = [...existing, ...allRefs];
+        // Deduplicate by workflow+timestamp
+        const seen = new Set<string>();
+        const deduped = merged.filter(ref => {
+          const key = `${ref.workflow}:${ref.timestamp}`;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        }).slice(-MAX_SOURCE_REFS);
+        this.store.update(keep.id, { sourceReferences: deduped });
+      }
+    }
+
     for (const issue of issues) {
       if (issue.type === 'index_inconsistent') {
         this.store.rebuildIndex();