@dommaker/harness 1.6.0 → 1.8.0

package/dist/knowledge/audit.js

@@ -2,573 +2,112 @@
 /**
  * 知识库质量审计引擎
  *
- * 纯代码检测，零 token 成本。
- * 7 维度覆盖：结构完整性 / 内容质量 / 去重有效性 / 成熟度健康 / 新鲜度 / 飞轮验证 / 增量存活
+ * 纯代码检测，零 token 成本。打分判定（D1–D7 规则表、维度分、健康分）是纯模块
+ * `audit-scoring.ts`，本文件只做存储侧装配：取条目、取环境数据、落地修复动作。
  *
  * 两种模式：
- * - validate(entry): 单条入库检查（ingest gate）
- * - run(autoFix): 全量扫描（日兜底 / 手动）
+ * - validate(entry): 单条入库检查（ingest gate），不读盘
+ * - run(autoFix): 全量扫描（日兜底 / 手动），修复走 store.applyAll 单次索引重写
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KnowledgeAudit = exports.AUDIT_RULE_LABELS = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const store_1 = require("./store");
-const flywheel_metrics_1 = require("./flywheel-metrics");
-// ── Constants ─────────────────────────────────────────────
-const DEFAULT_SHORT_CONTENT_THRESHOLD = 50;
-const ZERO_CONTENT_THRESHOLD = 20;
-const DEFAULT_STALE_DAYS = 90;
-const DEFAULT_PROMOTION_BLOCK_DAYS = 30;
-const MAX_SOURCE_REFS = 20;
-const TEST_TAG_PATTERNS = [/^test-scope-/, /^test-empty-/, /^test-\d/];
-const DAILY_AUDIT_PATTERN = /^\[Auditor\] Daily audit/;
-const EVENT_NOISE_PATTERNS = [
-    /^\[Monitor\]\s/,
-    /^KnowledgeSync cycle:/,
-    /^\[Triage Fix\]\s/,
-    /^\[Session Feature\]\s/,
-];
-const REQUIRED_FRONTMATTER = ['id', 'type', 'title', 'maturity'];
-const perEntryRules = [
-    // D1: 结构完整性
-    {
-        name: 'frontmatter-missing',
-        label: 'frontmatter 缺失',
-        severity: 'high',
-        action: 'reject',
-        scope: 'all',
-        detect: (entry) => {
-            const missing = REQUIRED_FRONTMATTER.filter(f => {
-                const val = entry[f];
-                return val === undefined || val === null || val === '';
-            });
-            if (missing.length > 0) {
-                return `缺少必填字段: ${missing.join(', ')}`;
-            }
-            return null;
-        },
-    },
-    // D2: 内容质量
-    {
-        name: 'test-data-pollution',
-        label: '测试数据污染',
-        severity: 'critical',
-        action: 'archive',
-        scope: 'active',
-        detect: (entry) => {
-            // Match test ID patterns
-            if (/^(test-|inj-test)/.test(entry.id)) {
-                return `测试 ID: "${entry.id}"`;
-            }
-            const hasTestTag = (entry.tags ?? []).some(t => TEST_TAG_PATTERNS.some(p => p.test(t)));
-            if (hasTestTag) {
-                return `测试标签: ${(entry.tags ?? []).filter(t => TEST_TAG_PATTERNS.some(p => p.test(t))).join(', ')}`;
-            }
-            if (/^(Test Entry|Test pattern|Test incident|Empty Test)$/i.test(entry.title.trim())) {
-                return `测试标题: "${entry.title}"`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'daily-audit-noise',
-        label: '每日审计噪音',
-        severity: 'high',
-        action: 'archive',
-        scope: 'active',
-        detect: (entry) => {
-            if (DAILY_AUDIT_PATTERN.test(entry.title)) {
-                return `每日审计摘要: "${entry.title}"`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'event-noise',
-        label: '运维事件噪音',
-        severity: 'critical',
-        action: 'archive',
-        scope: 'active',
-        detect: (entry) => {
-            for (const pattern of EVENT_NOISE_PATTERNS) {
-                if (pattern.test(entry.title)) {
-                    return `运维事件标题: "${entry.title}"`;
-                }
-            }
-            return null;
-        },
-    },
-    {
-        name: 'zero-content-proven',
-        label: '零内容 proven',
-        severity: 'critical',
-        action: 'demote',
-        scope: 'all',
-        detect: (entry) => {
-            if (entry.maturity === 'proven' && entry.content.trim().length < ZERO_CONTENT_THRESHOLD) {
-                return `proven 条目内容仅 ${entry.content.trim().length} 字符`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'maturity-inflation',
-        label: '成熟度虚高',
-        severity: 'high',
-        action: 'demote',
-        scope: 'all',
-        detect: (entry) => {
-            if (entry.maturity === 'verified' && entry.content.trim().length < ZERO_CONTENT_THRESHOLD) {
-                return `verified 条目内容仅 ${entry.content.trim().length} 字符`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'short-content',
-        label: '短内容',
-        severity: 'medium',
-        action: 'flag',
-        scope: 'active',
-        detect: (entry, ctx) => {
-            const len = entry.content.trim().length;
-            if (len < ctx.shortContentThreshold && len >= ZERO_CONTENT_THRESHOLD) {
-                return `内容 ${len} 字符 (阈值 ${ctx.shortContentThreshold})`;
-            }
-            return null;
-        },
-    },
-    // D3: 去重有效性
-    {
-        name: 'title-duplicate',
-        label: '标题重复',
-        severity: 'medium',
-        action: 'flag',
-        scope: 'active',
-        detect: (entry, ctx) => {
-            if (!ctx.allEntries)
-                return null;
-            if (!entry.title)
-                return null;
-            const dupes = ctx.allEntries.filter(e => e.id !== entry.id &&
-                e.maturity !== 'archived' &&
-                e.type === entry.type &&
-                e.title?.toLowerCase().trim() === entry.title.toLowerCase().trim());
-            if (dupes.length > 0) {
-                return `与 ${dupes.map(e => e.id).join(', ')} 标题重复`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'source-refs-bloat',
-        label: 'sourceReferences 膨胀',
-        severity: 'low',
-        action: 'trim',
-        scope: 'all',
-        detect: (entry) => {
-            if ((entry.sourceReferences?.length || 0) > MAX_SOURCE_REFS) {
-                return `sourceReferences ${entry.sourceReferences.length} 条 (上限 ${MAX_SOURCE_REFS})`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'fragment-cluster',
-        label: '碎片集群',
-        severity: 'medium',
-        action: 'flag',
-        scope: 'active',
-        detect: (entry, ctx) => {
-            if (!ctx.allEntries || entry.content.trim().length >= 100)
-                return null;
-            if (!entry.tags?.length)
-                return null;
-            // Find peers: same type, short body, shared tags ≥2
-            const entryTags = new Set(entry.tags);
-            const peers = ctx.allEntries.filter(e => e.id !== entry.id &&
-                e.maturity !== 'archived' &&
-                e.type === entry.type &&
-                e.content.trim().length < 100 &&
-                e.tags?.filter(t => entryTags.has(t)).length >= 2);
-            if (peers.length >= 2) {
-                return `碎片集群：与 ${peers.map(e => e.id).join(', ')} 同 type+tags 且 body 均 <100 字符，建议合并`;
-            }
-            return null;
-        },
-    },
-    // D4: 成熟度健康
-    {
-        name: 'promotion-blocked',
-        label: 'promotion 受阻',
-        severity: 'medium',
-        action: 'flag',
-        scope: 'all',
-        detect: (entry, ctx) => {
-            if (entry.maturity !== 'draft')
-                return null;
-            const created = new Date(entry.created);
-            const daysSinceCreated = (Date.now() - created.getTime()) / (1000 * 60 * 60 * 24);
-            if (daysSinceCreated > ctx.promotionBlockDays && !entry.lastReferenced) {
-                return `draft 已 ${Math.floor(daysSinceCreated)} 天未被引用`;
-            }
-            return null;
-        },
-    },
-    {
-        name: 'orphan-draft',
-        label: '孤儿 draft',
-        severity: 'low',
-        action: 'flag',
-        scope: 'all',
-        detect: (entry) => {
-            if (entry.maturity !== 'draft')
-                return null;
-            if (entry.contributors.length === 0 && entry.projects.length === 0 && (0, flywheel_metrics_1.genuineRefs)(entry.referencedBy).length === 0) {
-                return `draft 无贡献者/项目/引用`;
-            }
-            return null;
-        },
-    },
-    // D5: 新鲜度
-    {
-        name: 'stale-entry',
-        label: '过期条目',
-        severity: 'medium',
-        action: 'flag',
-        scope: 'active',
-        detect: (entry, ctx) => {
-            const lastRef = entry.lastReferenced || entry.created;
-            if (!lastRef)
-                return null;
-            const daysSinceRef = (Date.now() - new Date(lastRef).getTime()) / (1000 * 60 * 60 * 24);
-            if (daysSinceRef > ctx.staleDays) {
-                return `超过 ${Math.floor(daysSinceRef)} 天未引用 (阈值 ${ctx.staleDays})`;
-            }
-            return null;
-        },
-    },
-    // D2b: 领域相关性 — 检测已废弃领域的残留条目
-    {
-        name: 'deprecated-domain',
-        label: '废弃领域残留',
-        severity: 'high',
-        action: 'archive',
-        scope: 'active',
-        detect: (entry) => {
-            const tags = (entry.tags ?? []).map(t => t.toLowerCase());
-            // Tag-level: "pipeline" tag is deprecated (Studio Pipeline superseded by Agent Network)
-            if (tags.includes('pipeline')) {
-                return `标签 "pipeline" 属于已废弃领域（已被 Agent Network 取代）`;
-            }
-            // Title-level: strong domain-specific terms
-            const title = entry.title || '';
-            if (/pipeline|管线|GoalExecution|DeployAgent|Integration step/i.test(title)) {
-                return `标题引用已废弃领域: "${title}"`;
-            }
-            return null;
-        },
-    },
-];
-/** 规则 label 正本表（#109，ADR-0002 定义即注册）：派生自 perEntryRules，与规则键集编译期闭环，CLI 展示层直接消费 */
-exports.AUDIT_RULE_LABELS = Object.fromEntries(perEntryRules.map(r => [r.name, r.label]));
-// ── Audit Engine ──────────────────────────────────────────
-/** 按 scope 决定是否评估：active 规则对 archived 条目不判定（人口过滤唯一落点） */
-function ruleDetail(rule, entry, ctx) {
-    if (rule.scope === 'active' && entry.maturity === 'archived')
-        return null;
-    return rule.detect(entry, ctx);
+exports.KnowledgeAudit = void 0;
+const audit_scoring_1 = require("./audit-scoring");
+/** 数值槽清单（harness#163）：显式传入的脏值（NaN/±Infinity/负数）构造期抛 TypeError，不放行到打分层静默关判定 */
+const NUMERIC_OPTION_SLOTS = ['shortContentThreshold', 'staleDays', 'promotionBlockDays'];
+/** 守卫在 `resolveThresholds` 上游（构造期）：`??` 语义不动，两处不重复兜；未传/显式 undefined 跳过，显式 0 合法 */
+function assertValidThresholds(options) {
+    for (const slot of NUMERIC_OPTION_SLOTS) {
+        const value = options[slot];
+        if (value !== undefined && (!Number.isFinite(value) || value < 0)) {
+            throw new TypeError(`KnowledgeAudit: ${slot} 需为非负有限数，实参 ${value}`);
+        }
+    }
 }
 class KnowledgeAudit {
     store;
-    shortContentThreshold;
-    staleDays;
-    promotionBlockDays;
-    constructor(options) {
-        this.store = new store_1.FileKnowledgeStore({ baseDir: options?.baseDir });
-        this.shortContentThreshold = options?.shortContentThreshold ?? DEFAULT_SHORT_CONTENT_THRESHOLD;
-        this.staleDays = options?.staleDays ?? DEFAULT_STALE_DAYS;
-        this.promotionBlockDays = options?.promotionBlockDays ?? DEFAULT_PROMOTION_BLOCK_DAYS;
+    options;
+    constructor(store, options) {
+        if (options)
+            assertValidThresholds(options);
+        this.store = store;
+        this.options = options ?? {};
     }
     /**
      * 单条入库检查（ingest gate 模式）
      */
     validate(entry) {
-        const ctx = {
-            shortContentThreshold: this.shortContentThreshold,
-            staleDays: this.staleDays,
-            promotionBlockDays: this.promotionBlockDays,
-        };
-        return this.scanEntries([entry], ctx);
+        return (0, audit_scoring_1.scanEntries)([entry], this.options);
     }
     /**
      * 全量扫描（日兜底 / 手动模式）
      */
     run(options) {
         const entries = this.store.list({ excludeArchived: false }).filter(e => e.title && e.type && e.content != null);
-        const ctx = {
-            shortContentThreshold: this.shortContentThreshold,
-            staleDays: this.staleDays,
-            promotionBlockDays: this.promotionBlockDays,
-            allEntries: entries,
-        };
         // Per-entry issues
-        const allIssues = this.scanEntries(entries, ctx);
-        // Summary
-        const summary = {};
-        for (const rule of perEntryRules)
-            summary[rule.name] = 0;
-        for (const issue of allIssues)
-            summary[issue.rule]++;
-        // Dimension metrics
-        const dimensions = this.computeDimensions(entries, allIssues);
+        const allIssues = (0, audit_scoring_1.scanEntries)(entries, this.options, entries);
+        // Dimension metrics（环境数据由 store 供给，打分本体零 IO）
+        const dimensions = (0, audit_scoring_1.computeDimensions)(entries, allIssues, this.readEnv());
         // Health score (before)
-        const healthBefore = this.calculateHealthScore(entries, allIssues);
+        const healthBefore = (0, audit_scoring_1.calculateHealthScore)(entries, allIssues);
         // Auto-fix
         let autoFixed = 0;
         if (options?.autoFix) {
             autoFixed = this.applyFixes(allIssues);
         }
-        // Health score (after)
+        // Health score (after)——重扫沿用修复前的人口作跨条目规则对照（现状口径，#134 不动判定）
         const entriesAfter = options?.autoFix ? this.store.list({ excludeArchived: false }) : entries;
-        const issuesAfter = options?.autoFix ? this.scanEntries(entriesAfter, ctx) : allIssues;
-        const healthAfter = this.calculateHealthScore(entriesAfter, issuesAfter);
+        const issuesAfter = options?.autoFix ? (0, audit_scoring_1.scanEntries)(entriesAfter, this.options, entries) : allIssues;
+        const healthAfter = (0, audit_scoring_1.calculateHealthScore)(entriesAfter, issuesAfter);
         return {
             timestamp: new Date().toISOString(),
             totalEntries: entries.length,
             issues: allIssues,
-            summary,
+            summary: (0, audit_scoring_1.summarizeIssues)(allIssues),
             dimensions,
             autoFixed,
             healthScore: { before: healthBefore, after: healthAfter },
         };
     }
-    // ── Dimensions ────────────────────────────────────────────
-    computeDimensions(entries, issues) {
-        const active = entries.filter(e => e.maturity !== 'archived');
-        const now = Date.now();
-        // D1: 结构完整性
-        const d1Issues = issues.filter(i => i.rule === 'frontmatter-missing');
-        const d1Score = entries.length === 0 ? 100 : Math.max(0, 100 - (d1Issues.length / entries.length) * 100);
-        // D2: 内容质量
-        const d2Rules = ['test-data-pollution', 'daily-audit-noise', 'event-noise', 'zero-content-proven', 'short-content', 'maturity-inflation', 'deprecated-domain'];
-        const d2Issues = issues.filter(i => d2Rules.includes(i.rule));
-        const d2Score = active.length === 0 ? 100 : Math.max(0, 100 - (d2Issues.length / active.length) * 100);
-        // D3: 去重有效性
-        const d3Rules = ['title-duplicate', 'source-refs-bloat', 'fragment-cluster'];
-        const d3Issues = issues.filter(i => d3Rules.includes(i.rule));
-        const d3Score = active.length === 0 ? 100 : Math.max(0, 100 - (d3Issues.length / active.length) * 100);
-        // D4: 成熟度健康
-        const d4Rules = ['promotion-blocked', 'orphan-draft'];
-        const d4Issues = issues.filter(i => d4Rules.includes(i.rule));
-        const byMaturity = {};
-        for (const e of entries)
-            byMaturity[e.maturity] = (byMaturity[e.maturity] || 0) + 1;
-        const draftRatio = entries.length > 0 ? (byMaturity['draft'] || 0) / entries.length : 0;
-        const provenRatio = entries.length > 0 ? (byMaturity['proven'] || 0) / entries.length : 0;
-        // Penalize: draft >50% or proven <2% or proven >20% (test inflation)
-        let d4Penalty = d4Issues.length * 2;
-        if (draftRatio > 0.5)
-            d4Penalty += 10;
-        if (provenRatio < 0.02 && entries.length > 20)
-            d4Penalty += 5;
-        if (provenRatio > 0.2)
-            d4Penalty += 5; // likely test inflation
-        const d4Score = entries.length === 0 ? 100 : Math.max(0, 100 - (d4Penalty / entries.length) * 100);
-        // D5: 新鲜度
-        const d5Issues = issues.filter(i => i.rule === 'stale-entry');
-        const ages = active.map(e => {
-            const lastRef = e.lastReferenced || e.created;
-            return lastRef ? (now - new Date(lastRef).getTime()) / (1000 * 60 * 60 * 24) : 999;
-        });
-        const avgAge = ages.length > 0 ? ages.reduce((a, b) => a + b, 0) / ages.length : 0;
-        const staleRatio = active.length > 0 ? d5Issues.length / active.length : 0;
-        const d5Score = active.length === 0 ? 100 : Math.max(0, 100 - (staleRatio * 100));
-        // D6: 飞轮验证 —— 指标计算唯一实现在 flywheel-metrics，此处只做 fs 读取与报告层映射
-        let dailyConsumptionEvents = 0;
-        try {
-            const statsPath = path.join(this.store.getBaseDir(), '.consumption-stats.json');
-            if (fs.existsSync(statsPath)) {
-                const stats = JSON.parse(fs.readFileSync(statsPath, 'utf-8'));
-                dailyConsumptionEvents = stats.dailyEvents || 0;
-            }
-        }
-        catch { /* best-effort */ }
-        const metrics = (0, flywheel_metrics_1.evaluateFlywheel)({ entries: active, dailyConsumptionEvents });
-        // Score: refCoverage * 50 + avgRefs * 20 + consumptionHitRate * 30
-        const d6Score = Math.min(100, Math.round(metrics.refCoverage * 50 +
-            Math.min(metrics.avgRefs / 5, 1) * 20 +
-            metrics.consumptionHitRate * 30));
-        return {
-            structure: {
-                score: Math.round(d1Score),
-                issues: d1Issues.length,
-                details: { invalidEntries: d1Issues.length },
-            },
-            content: {
-                score: Math.round(d2Score),
-                issues: d2Issues.length,
-                details: {
-                    testData: issues.filter(i => i.rule === 'test-data-pollution').length,
-                    dailyAudit: issues.filter(i => i.rule === 'daily-audit-noise').length,
-                    zeroContent: issues.filter(i => i.rule === 'zero-content-proven').length,
-                    shortContent: issues.filter(i => i.rule === 'short-content').length,
-                    maturityInflation: issues.filter(i => i.rule === 'maturity-inflation').length,
-                },
-            },
-            dedup: {
-                score: Math.round(d3Score),
-                issues: d3Issues.length,
-                details: {
-                    titleDuplicates: issues.filter(i => i.rule === 'title-duplicate').length,
-                    sourceRefsBloat: issues.filter(i => i.rule === 'source-refs-bloat').length,
-                },
-            },
-            maturity: {
-                score: Math.round(d4Score),
-                issues: d4Issues.length,
-                details: {
-                    draft: byMaturity['draft'] || 0,
-                    verified: byMaturity['verified'] || 0,
-                    proven: byMaturity['proven'] || 0,
-                    archived: byMaturity['archived'] || 0,
-                    draftRatio: Math.round(draftRatio * 100),
-                    provenRatio: Math.round(provenRatio * 100),
-                    promotionBlocked: issues.filter(i => i.rule === 'promotion-blocked').length,
-                },
-            },
-            freshness: {
-                score: Math.round(d5Score),
-                issues: d5Issues.length,
-                details: {
-                    avgAgeDays: Math.round(avgAge),
-                    staleEntries: d5Issues.length,
-                    staleRatio: Math.round(staleRatio * 100),
-                },
-            },
-            flywheel: {
-                score: d6Score,
-                issues: 0,
-                details: {
-                    activeEntries: metrics.activeEntries,
-                    entriesWithRefs: metrics.entriesWithRefs,
-                    refCoverage: Math.round(metrics.refCoverage * 100),
-                    avgRefCount: Math.round(metrics.avgRefs * 10) / 10,
-                    dailyConsumptionEvents: metrics.dailyConsumptionEvents,
-                    consumptionHitRate: Math.round(metrics.consumptionHitRate * 100),
-                },
-            },
-            incremental: this.computeIncremental(),
-        };
-    }
-    computeIncremental() {
-        const survival = this.store.getSurvivalRate(30);
-        if (!survival) {
-            return { score: 100, issues: 0, details: { note: 'no 30d snapshot available' } };
-        }
-        // Score = survival rate directly (80% target → 80/100)
+    // ── Internal ────────────────────────────────────────────
+    /** 打分要用的环境数据在此一次取齐（D6 消费统计、D7 快照存活） */
+    readEnv() {
         return {
-            score: survival.rate,
-            issues: survival.total - survival.survived,
-            details: {
-                survivalRate: survival.rate,
-                survived: survival.survived,
-                total: survival.total,
-                snapshotDate: survival.snapshotDate,
-            },
+            dailyConsumptionEvents: this.store.getConsumptionStats()?.dailyEvents ?? 0,
+            survival: this.store.getSurvivalRate(audit_scoring_1.SURVIVAL_SNAPSHOT_DAYS),
         };
     }
-    // ── Internal ────────────────────────────────────────────
-    /**
-     * 逐条目跑 perEntryRules（#111 收口）：validate（单条目）、run（全量）与 autoFix 重扫共用
-     */
-    scanEntries(entries, ctx) {
-        const issues = [];
-        for (const entry of entries) {
-            for (const rule of perEntryRules) {
-                const detail = ruleDetail(rule, entry, ctx);
-                if (detail) {
-                    issues.push({
-                        rule: rule.name,
-                        entryId: entry.id,
-                        title: entry.title,
-                        severity: rule.severity,
-                        action: rule.action,
-                        detail,
-                    });
-                }
-            }
-        }
-        return issues;
-    }
+    /** 修复动作先聚合再经 `applyAll` 落盘：一次审计只重写一次 index.json（#134） */
     applyFixes(issues) {
-        let fixed = 0;
+        const updates = [];
         const processed = new Set();
         for (const issue of issues) {
             if (processed.has(issue.entryId))
                 continue;
             switch (issue.action) {
                 case 'archive':
-                    this.store.update(issue.entryId, { maturity: 'archived' });
+                    updates.push({ id: issue.entryId, partial: { maturity: 'archived' } });
                     processed.add(issue.entryId);
-                    fixed++;
                     break;
                 case 'demote':
-                    this.store.update(issue.entryId, { maturity: 'draft' });
+                    updates.push({ id: issue.entryId, partial: { maturity: 'draft' } });
                     processed.add(issue.entryId);
-                    fixed++;
                     break;
                 case 'flag': {
                     const entry = this.store.get(issue.entryId);
                     if (entry && !entry.tags.includes('low_quality')) {
-                        this.store.update(issue.entryId, { tags: [...entry.tags, 'low_quality'] });
+                        updates.push({ id: issue.entryId, partial: { tags: [...entry.tags, 'low_quality'] } });
                         processed.add(issue.entryId);
-                        fixed++;
                     }
                     break;
                 }
                 case 'trim': {
                     const entry = this.store.get(issue.entryId);
-                    if (entry && entry.sourceReferences && entry.sourceReferences.length > MAX_SOURCE_REFS) {
-                        this.store.update(issue.entryId, {
-                            sourceReferences: entry.sourceReferences.slice(-MAX_SOURCE_REFS),
+                    if (entry && entry.sourceReferences && entry.sourceReferences.length > audit_scoring_1.MAX_SOURCE_REFS) {
+                        updates.push({
+                            id: issue.entryId,
+                            partial: { sourceReferences: entry.sourceReferences.slice(-audit_scoring_1.MAX_SOURCE_REFS) },
                         });
                         processed.add(issue.entryId);
-                        fixed++;
                     }
                     break;
                 }
@@ -576,22 +115,8 @@ class KnowledgeAudit {
                     break;
             }
         }
-        return fixed;
-    }
-    calculateHealthScore(entries, issues) {
-        if (entries.length === 0)
-            return 100;
-        const penalty = issues.reduce((sum, issue) => {
-            switch (issue.severity) {
-                case 'critical': return sum + 10;
-                case 'high': return sum + 5;
-                case 'medium': return sum + 2;
-                case 'low': return sum + 1;
-                default: return sum;
-            }
-        }, 0);
-        const maxPenalty = entries.length * 10;
-        return Math.max(0, 100 - Math.round((penalty / Math.max(maxPenalty, 1)) * 100));
+        this.store.applyAll(updates);
+        return updates.length;
     }
 }
 exports.KnowledgeAudit = KnowledgeAudit;