recallnest 3.0.0 → 4.0.0

package/src/__tests__/skill-promotion.test.ts

@@ -1,654 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { scanForPromotions, formatPromotionResult, type PromotionScanResult } from "../skill-promotion.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Mock Helpers
-// ---------------------------------------------------------------------------
-
-let idSeq = 0;
-
-function makeEntry(overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  idSeq += 1;
-  return {
-    id: `entry-${String(idSeq).padStart(4, "0")}`,
-    text: `Case about deploying to production #${idSeq}`,
-    vector: [1, 0, 0],
-    category: "cases",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: 1_700_000_000_000 + idSeq,
-    metadata: JSON.stringify({
-      evolution: {
-        status: "active",
-        version: 1,
-        accessCount: 0,
-        lastAccessedAt: null,
-        supersededBy: null,
-        consolidatedInto: null,
-        sourceMemories: [],
-        validFrom: Date.now(),
-        validUntil: null,
-      },
-    }),
-    ...overrides,
-  };
-}
-
-/** Create a vector that is similar to the base [1,0,0] with controlled similarity. */
-function similarVector(sim: number): number[] {
-  // For cosine similarity, we want cos(theta) = sim
-  // Use 2D vector [sim, sqrt(1-sim^2), 0] dot [1, 0, 0] = sim
-  const complement = Math.sqrt(1 - sim * sim);
-  return [sim, complement, 0];
-}
-
-/**
- * Mock 复刻生产 MemoryStore 的真实语义——这是 Bug B 的直接教训:旧 mock 的
- * list 返回带向量的行,而生产 list/listPage 恒返回 vector:[],导致聚类在生产
- * 全部跳过、测试却全绿。任何与生产行为不一致的 mock 简化都可能掩盖同类 bug:
- * - listPage 永远返回 vector: [](轻列语义)
- * - 向量只能通过 getVectors 回填
- * - vectorSearch 的 score = 1/(1+cosineDistance) = 1/(2-cosSim),不是 cosine
- */
-function createMockStore(entries: MemoryEntry[]) {
-  const calls = { listPage: 0 };
-  return {
-    calls,
-    async listPage(opts: {
-      scopeFilter?: string[];
-      category?: string;
-      limit?: number;
-      offset?: number;
-      includeVector?: boolean;
-    } = {}): Promise<MemoryEntry[]> {
-      calls.listPage++;
-      const { category, limit = 1000, offset = 0 } = opts;
-      const filtered = category ? entries.filter(e => e.category === category) : entries;
-      return filtered.slice(offset, offset + limit).map(e => ({ ...e, vector: [] }));
-    },
-    async getVectors(ids: string[]): Promise<Map<string, number[]>> {
-      const m = new Map<string, number[]>();
-      for (const id of ids) {
-        const e = entries.find(x => x.id === id);
-        if (e && e.vector && e.vector.length > 0) m.set(id, e.vector);
-      }
-      return m;
-    },
-    async vectorSearch(
-      vector: number[],
-      limit = 5,
-      minScore = 0.3,
-      _scopeFilter?: string[],
-    ): Promise<MemorySearchResult[]> {
-      const scored = entries
-        .filter(e => e.vector?.length > 0)
-        .map(e => {
-          let dot = 0, normA = 0, normB = 0;
-          for (let i = 0; i < vector.length; i++) {
-            dot += vector[i] * (e.vector[i] ?? 0);
-            normA += vector[i] * vector[i];
-            normB += (e.vector[i] ?? 0) * (e.vector[i] ?? 0);
-          }
-          const cos = (normA > 0 && normB > 0)
-            ? dot / (Math.sqrt(normA) * Math.sqrt(normB))
-            : 0;
-          return { entry: e, score: 1 / (2 - cos) };
-        })
-        .filter(r => r.score >= minScore)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, Math.min(limit, 20));
-      return scored;
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("scanForPromotions", () => {
-  it("returns 0 candidates for empty scope", async () => {
-    const store = createMockStore([]);
-    const result = await scanForPromotions(store, "project:empty");
-
-    expect(result.candidates).toHaveLength(0);
-    expect(result.scannedCases).toBe(0);
-    expect(result.scannedPatterns).toBe(0);
-  });
-
-  it("returns 0 candidates when fewer than minCaseOccurrences similar cases", async () => {
-    // Two cases with the same vector — below default threshold of 3
-    const entries = [
-      makeEntry({ vector: [1, 0, 0] }),
-      makeEntry({ vector: [0.99, 0.14, 0] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test");
-
-    expect(result.candidates).toHaveLength(0);
-    expect(result.scannedCases).toBe(2);
-  });
-
-  it("produces case_to_pattern candidate when 3+ similar cases exist", async () => {
-    const entries = [
-      makeEntry({ text: "Deploy error: missing env var", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy failure: env variable not set", vector: similarVector(0.95) }),
-      makeEntry({ text: "Deploy issue: environment config missing", vector: similarVector(0.90) }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-    });
-
-    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
-    const caseCandidate = result.candidates.find(c => c.type === "case_to_pattern");
-    expect(caseCandidate).toBeDefined();
-    expect(caseCandidate!.sourceEntries.length).toBeGreaterThanOrEqual(3);
-    expect(caseCandidate!.suggestedName).toBeTruthy();
-    expect(caseCandidate!.suggestedDescription).toContain("cases");
-  });
-
-  it("does not produce candidates from dissimilar cases", async () => {
-    // 3 cases with very different vectors
-    const entries = [
-      makeEntry({ text: "Case A", vector: [1, 0, 0] }),
-      makeEntry({ text: "Case B", vector: [0, 1, 0] }),
-      makeEntry({ text: "Case C", vector: [0, 0, 1] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-    });
-
-    expect(result.candidates).toHaveLength(0);
-  });
-
-  it("computes confidence using Bayesian smoothing", async () => {
-    // 4 similar cases: confidence = 4 / (4 + 2) = 0.667
-    const entries = [
-      makeEntry({ text: "Deploy error A", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy error B", vector: similarVector(0.95) }),
-      makeEntry({ text: "Deploy error C", vector: similarVector(0.92) }),
-      makeEntry({ text: "Deploy error D", vector: similarVector(0.88) }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-    });
-
-    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
-    const c = result.candidates[0];
-    // cluster of 4: confidence = 4/(4+2) = 0.6667
-    expect(c.confidence).toBeCloseTo(4 / 6, 2);
-  });
-
-  it("produces pattern_to_skill when pattern has steps and related cases", async () => {
-    const patternVec: number[] = [0.9, 0.43, 0]; // cos sim with [1,0,0] ~ 0.9
-    const entries = [
-      makeEntry({
-        category: "patterns",
-        text: "Production Deploy Pattern\n\nSteps:\n1. Check environment\n2. Run preflight\n3. Deploy containers",
-        vector: patternVec,
-      }),
-      makeEntry({ text: "Deploy case: ran preflight then deployed", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy fix: environment check before push", vector: similarVector(0.88) }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      caseSimilarityThreshold: 0.75,
-    });
-
-    const skillCandidate = result.candidates.find(c => c.type === "pattern_to_skill");
-    expect(skillCandidate).toBeDefined();
-    expect(skillCandidate!.suggestedImplementation).toContain("Check environment");
-    expect(skillCandidate!.sourceEntries.length).toBeGreaterThanOrEqual(3); // pattern + 2 cases
-  });
-
-  it("does not produce pattern_to_skill when pattern lacks structured steps", async () => {
-    const patternVec: number[] = [0.9, 0.43, 0];
-    const entries = [
-      makeEntry({
-        category: "patterns",
-        text: "Just a general note about deploying without structured steps",
-        vector: patternVec,
-      }),
-      makeEntry({ text: "Deploy case one", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy case two", vector: similarVector(0.88) }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      caseSimilarityThreshold: 0.75,
-    });
-
-    const skillCandidate = result.candidates.find(c => c.type === "pattern_to_skill");
-    expect(skillCandidate).toBeUndefined();
-  });
-
-  it("respects maxCandidates limit", async () => {
-    // Create two distinct clusters of 3, but set maxCandidates=1
-    const entries = [
-      // Cluster 1
-      makeEntry({ text: "Deploy A", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy B", vector: similarVector(0.95) }),
-      makeEntry({ text: "Deploy C", vector: similarVector(0.90) }),
-      // Cluster 2
-      makeEntry({ text: "Auth fix A", vector: [0, 1, 0] }),
-      makeEntry({ text: "Auth fix B", vector: [0.1, 0.99, 0] }),
-      makeEntry({ text: "Auth fix C", vector: [0.15, 0.98, 0] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-      maxCandidates: 1,
-    });
-
-    expect(result.candidates).toHaveLength(1);
-  });
-
-  it("filters out archived entries", async () => {
-    const archivedMeta = JSON.stringify({
-      evolution: {
-        status: "archived",
-        version: 1,
-        accessCount: 0,
-        lastAccessedAt: null,
-        supersededBy: null,
-        consolidatedInto: null,
-        sourceMemories: [],
-        validFrom: Date.now(),
-        validUntil: null,
-      },
-    });
-    const entries = [
-      makeEntry({ text: "Active case", vector: [1, 0, 0] }),
-      makeEntry({ text: "Archived case", vector: similarVector(0.95), metadata: archivedMeta }),
-      makeEntry({ text: "Another archived", vector: similarVector(0.90), metadata: archivedMeta }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-    });
-
-    // Only 1 active case, so no candidates
-    expect(result.candidates).toHaveLength(0);
-    expect(result.scannedCases).toBe(1);
-  });
-
-  it("skips entries whose vectors are missing from the store, with disclosure", async () => {
-    // getVectors has nothing for these ids (vector: [] in the source data)
-    const entries = [
-      makeEntry({ text: "No vector case A", vector: [] }),
-      makeEntry({ text: "No vector case B", vector: [] }),
-      makeEntry({ text: "No vector case C", vector: [] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test");
-
-    expect(result.candidates).toHaveLength(0);
-    expect(result.vectorlessSkipped).toBe(3);
-  });
-
-  it("Bug B regression: clusters vectorless list rows via getVectors backfill", async () => {
-    // listPage 永远返回 vector:[](生产语义)——候选必须依赖 getVectors 回填产生。
-    // 修复前:聚类直接读 list 行的 vector → 全部 continue → 产出恒为零。
-    const entries = [
-      makeEntry({ text: "Deploy error: missing env var", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy failure: env variable not set", vector: similarVector(0.95) }),
-      makeEntry({ text: "Deploy issue: environment config missing", vector: similarVector(0.9) }),
-    ];
-    const store = createMockStore(entries);
-
-    // 防御:确认 mock 的 listPage 确实是 vectorless(防 mock 又静默回到带向量)
-    const rows = await store.listPage({ category: "cases" });
-    expect(rows.every(r => r.vector.length === 0)).toBe(true);
-
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-    });
-    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
-    expect(result.vectorlessSkipped).toBe(0);
-  });
-
-  it("paginates the full corpus instead of a single fixed-limit page", async () => {
-    // 7 cases with pageSize 2 → at least 4 listPage calls for the cases category
-    const entries = Array.from({ length: 7 }, (_, i) =>
-      makeEntry({ text: `Deploy error variant ${i}`, vector: similarVector(0.95 - i * 0.01) }),
-    );
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-      pageSize: 2,
-    });
-
-    expect(store.calls.listPage).toBeGreaterThanOrEqual(4);
-    expect(result.scannedCases).toBe(7);
-    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it("does not starve the patterns budget when cases hit maxScanEntries", async () => {
-    // 首次生产 dry-run 实测回归:共享预算下 20000 cases 拉满 → patterns scanned=0。
-    const entries = [
-      ...Array.from({ length: 5 }, (_, i) =>
-        makeEntry({ text: `Deploy case ${i}`, vector: similarVector(0.95 - i * 0.01) }),
-      ),
-      makeEntry({
-        category: "patterns",
-        text: "Deploy Pattern\n\nSteps:\n1. Preflight\n2. Ship",
-        vector: [1, 0, 0],
-      }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", { maxScanEntries: 5 });
-
-    expect(result.scannedCases).toBe(5);
-    expect(result.scannedPatterns).toBe(1);
-  });
-
-  it("clusters within topicTag buckets and discloses bucket-cap truncation", async () => {
-    const tagged = (tag: string, text: string, vec: number[]) =>
-      makeEntry({
-        text,
-        vector: vec,
-        metadata: JSON.stringify({ topicTag: tag, evolution: { status: "active" } }),
-      });
-    const entries = [
-      tagged("deploy", "Deploy err 1", [1, 0, 0]),
-      tagged("deploy", "Deploy err 2", similarVector(0.95)),
-      tagged("deploy", "Deploy err 3", similarVector(0.92)),
-      tagged("deploy", "Deploy err 4", similarVector(0.9)),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-      maxBucketSize: 3,
-    });
-
-    // 4 cases in one bucket, cap 3 → 1 truncated (most recent 3 kept, still clusters)
-    expect(result.truncatedCases).toBe(1);
-    expect(result.candidates.length).toBeGreaterThanOrEqual(1);
-    const text = formatPromotionResult(result);
-    expect(text).toContain("truncated by bucket cap");
-  });
-
-  it("candidates are sorted by confidence descending", async () => {
-    // Cluster 1: 5 similar cases -> confidence 5/7
-    // Cluster 2: 3 similar cases -> confidence 3/5
-    const entries = [
-      // Large cluster
-      makeEntry({ text: "Deploy err 1", vector: [1, 0, 0] }),
-      makeEntry({ text: "Deploy err 2", vector: similarVector(0.95) }),
-      makeEntry({ text: "Deploy err 3", vector: similarVector(0.93) }),
-      makeEntry({ text: "Deploy err 4", vector: similarVector(0.91) }),
-      makeEntry({ text: "Deploy err 5", vector: similarVector(0.89) }),
-      // Small cluster (orthogonal direction)
-      makeEntry({ text: "Auth bug 1", vector: [0, 1, 0] }),
-      makeEntry({ text: "Auth bug 2", vector: [0.1, 0.99, 0] }),
-      makeEntry({ text: "Auth bug 3", vector: [0.15, 0.98, 0] }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", {
-      minCaseOccurrences: 3,
-      caseSimilarityThreshold: 0.75,
-    });
-
-    if (result.candidates.length >= 2) {
-      expect(result.candidates[0].confidence).toBeGreaterThanOrEqual(result.candidates[1].confidence);
-    }
-  });
-});
-
-describe("formatPromotionResult", () => {
-  it("formats empty results", () => {
-    const result: PromotionScanResult = {
-      candidates: [],
-      scannedCases: 5,
-      scannedPatterns: 2,
-      truncatedCases: 0,
-      vectorlessSkipped: 0,
-    };
-    const text = formatPromotionResult(result);
-    expect(text).toContain("5 cases");
-    expect(text).toContain("2 patterns");
-    expect(text).toContain("No promotion candidates found");
-  });
-
-  it("formats candidates with type and confidence", () => {
-    const result: PromotionScanResult = {
-      candidates: [{
-        type: "case_to_pattern",
-        sourceEntries: [{ id: "a", text: "test", score: 0.9 }],
-        suggestedName: "Test Pattern",
-        suggestedDescription: "A test",
-        confidence: 0.6,
-      }],
-      scannedCases: 3,
-      scannedPatterns: 1,
-      truncatedCases: 0,
-      vectorlessSkipped: 0,
-    };
-    const text = formatPromotionResult(result);
-    expect(text).toContain("case_to_pattern");
-    expect(text).toContain("Test Pattern");
-    expect(text).toContain("60.0%");
-  });
-
-  it("includes implementation in pattern_to_skill output", () => {
-    const result: PromotionScanResult = {
-      candidates: [{
-        type: "pattern_to_skill",
-        sourceEntries: [{ id: "a", text: "test", score: 1.0 }],
-        suggestedName: "Deploy Skill",
-        suggestedDescription: "Deploy automation",
-        suggestedImplementation: "1. Check env\n2. Deploy",
-        confidence: 0.5,
-      }],
-      scannedCases: 2,
-      scannedPatterns: 1,
-      truncatedCases: 0,
-      vectorlessSkipped: 0,
-    };
-    const text = formatPromotionResult(result);
-    expect(text).toContain("1. Check env");
-    expect(text).toContain("Implementation:");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// A2 · skill verifier integration
-// ---------------------------------------------------------------------------
-
-function metaWithTools(key: "caseMemory" | "workflowPattern", tools: string[]): string {
-  return JSON.stringify({
-    evolution: {
-      status: "active", version: 1, accessCount: 0, lastAccessedAt: null,
-      supersededBy: null, consolidatedInto: null, sourceMemories: [],
-      validFrom: 1_700_000_000_000, validUntil: null,
-    },
-    [key]: { tools },
-  });
-}
-
-describe("A2 verifier integration", () => {
-  it("attaches passing verification when pattern tools ⊆ supporting cases and narrative resonates", async () => {
-    const entries = [
-      makeEntry({
-        category: "patterns",
-        text: "Deploy Pattern\n\nSteps:\n1. Run preflight check\n2. Deploy containers\nTools: git, docker",
-        vector: [0.95, 0.312, 0],
-        metadata: metaWithTools("workflowPattern", ["git", "docker"]),
-      }),
-      makeEntry({
-        text: "Deploy case: ran preflight check then deploy containers",
-        vector: [1, 0, 0],
-        metadata: metaWithTools("caseMemory", ["git", "docker"]),
-      }),
-      // 第二个 case 走正文 Tools fallback（metadata 无 caseMemory.tools）
-      makeEntry({
-        text: "Deploy fix: preflight check before deploy containers\nTools: git",
-        vector: similarVector(0.9),
-      }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", { caseSimilarityThreshold: 0.75 });
-    const c = result.candidates.find(x => x.type === "pattern_to_skill");
-    expect(c).toBeDefined();
-    expect(c!.verification).toBeDefined();
-    expect(c!.verification!.ok).toBe(true);
-    expect(c!.verification!.coverage).toBe(1);
-  });
-
-  it("flags verification.ok=false when pattern claims a tool absent from supporting cases (hallucination)", async () => {
-    const entries = [
-      makeEntry({
-        category: "patterns",
-        text: "Deploy Pattern\n\nSteps:\n1. Run preflight check\n2. Deploy containers",
-        vector: [0.95, 0.312, 0],
-        metadata: metaWithTools("workflowPattern", ["nonexistent_cmd"]),
-      }),
-      makeEntry({
-        text: "Deploy case: ran preflight check then deploy containers",
-        vector: [1, 0, 0],
-        metadata: metaWithTools("caseMemory", ["git"]),
-      }),
-      makeEntry({
-        text: "Deploy fix: preflight check before deploy containers",
-        vector: similarVector(0.9),
-        metadata: metaWithTools("caseMemory", ["git"]),
-      }),
-    ];
-    const store = createMockStore(entries);
-    const result = await scanForPromotions(store, "project:test", { caseSimilarityThreshold: 0.75 });
-    const c = result.candidates.find(x => x.type === "pattern_to_skill");
-    expect(c).toBeDefined();
-    expect(c!.verification!.ok).toBe(false);
-    expect(c!.verification!.unmappedTools).toContain("nonexistent_cmd");
-  });
-
-  it("ranks verifier-passed candidate before failed one even when failed has higher confidence", async () => {
-    const entries = [
-      // cluster 1 (passing): pattern tools ⊆ cases, 2 supporting cases → confidence 0.5
-      makeEntry({
-        category: "patterns",
-        text: "Deploy Pattern\n\nSteps:\n1. Run preflight check\n2. Deploy containers\nTools: git",
-        vector: [0.95, 0.312, 0],
-        metadata: metaWithTools("workflowPattern", ["git"]),
-      }),
-      makeEntry({ text: "Deploy preflight check then deploy containers", vector: [1, 0, 0], metadata: metaWithTools("caseMemory", ["git"]) }),
-      makeEntry({ text: "Deploy preflight check before deploy containers", vector: similarVector(0.92), metadata: metaWithTools("caseMemory", ["git"]) }),
-      // cluster 2 (failing): pattern claims fake tool, 3 supporting cases → confidence 0.6 (higher!)
-      makeEntry({
-        category: "patterns",
-        text: "Rollback Pattern\n\nSteps:\n1. Run preflight check\n2. Deploy containers\nTools: fake_cmd",
-        vector: [0, 0.95, 0.312],
-        metadata: metaWithTools("workflowPattern", ["fake_cmd"]),
-      }),
-      makeEntry({ text: "Rollback preflight check then deploy containers", vector: [0, 1, 0], metadata: metaWithTools("caseMemory", ["git"]) }),
-      makeEntry({ text: "Rollback preflight check before deploy containers", vector: [0, 0.99, 0.141], metadata: metaWithTools("caseMemory", ["git"]) }),
-      makeEntry({ text: "Rollback preflight check after deploy containers", vector: [0, 0.97, 0.243], metadata: metaWithTools("caseMemory", ["git"]) }),
-    ];
-    const store = createMockStore(entries);
-    // minCaseOccurrences 设高，排除 case_to_pattern 候选，只看 pattern_to_skill 排序
-    const result = await scanForPromotions(store, "project:test", { caseSimilarityThreshold: 0.75, minCaseOccurrences: 99 });
-    const skillCandidates = result.candidates.filter(c => c.type === "pattern_to_skill");
-    expect(skillCandidates.length).toBe(2);
-    expect(result.candidates[0].verification!.ok).toBe(true);
-    expect(result.candidates[1].verification!.ok).toBe(false);
-    // 失败候选 confidence 更高，却排在通过候选之后
-    expect(result.candidates[1].confidence).toBeGreaterThan(result.candidates[0].confidence);
-  });
-
-  it("formatPromotionResult discloses verifier verdict (pass and fail)", () => {
-    const result: PromotionScanResult = {
-      candidates: [
-        {
-          type: "pattern_to_skill",
-          sourceEntries: [{ id: "a", text: "t", score: 1 }],
-          suggestedName: "Good Skill",
-          suggestedDescription: "ok",
-          suggestedImplementation: "1. step",
-          confidence: 0.6,
-          verification: { ok: true, coverage: 1, resonance: 1, unmappedTools: [] },
-        },
-        {
-          type: "pattern_to_skill",
-          sourceEntries: [{ id: "b", text: "t", score: 1 }],
-          suggestedName: "Bad Skill",
-          suggestedDescription: "hallucinated",
-          suggestedImplementation: "1. step",
-          confidence: 0.9,
-          verification: { ok: false, coverage: 0, resonance: 1, unmappedTools: ["fake_cmd"], reason: "coverage=0.00<0.5" },
-        },
-      ],
-      scannedCases: 2,
-      scannedPatterns: 2,
-      truncatedCases: 0,
-      vectorlessSkipped: 0,
-    };
-    const text = formatPromotionResult(result);
-    expect(text).toContain("pass");
-    expect(text).toContain("FAILED");
-    expect(text).toContain("fake_cmd");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Read evidence (Artel read-driven promotion) — aggregateReadEvidence / applyReadBoost
-// ---------------------------------------------------------------------------
-
-import { aggregateReadEvidence, applyReadBoost } from "../skill-promotion.js";
-
-describe("aggregateReadEvidence", () => {
-  it("sums accessCount and unions readerIds across entries", () => {
-    const entries = [
-      { metadata: JSON.stringify({ accessCount: 3, readerIds: ["r-a", "r-b"], distinctReaderCount: 2 }) },
-      { metadata: JSON.stringify({ accessCount: 2, readerIds: ["r-b", "r-c"], distinctReaderCount: 2 }) },
-    ];
-    const ev = aggregateReadEvidence(entries);
-    expect(ev.totalAccess).toBe(5);
-    expect(ev.distinctReaders).toBe(3); // union {r-a, r-b, r-c}
-  });
-
-  it("falls back to saturated per-entry count when readerIds capped", () => {
-    // READER_ID_CAP 饱和后 readerIds 停增但 distinctReaderCount 保留饱和值
-    const entries = [
-      { metadata: JSON.stringify({ accessCount: 10, readerIds: ["r-a"], distinctReaderCount: 8 }) },
-    ];
-    const ev = aggregateReadEvidence(entries);
-    expect(ev.distinctReaders).toBe(8); // max(union=1, saturated=8)
-  });
-
-  it("tolerates missing and broken metadata", () => {
-    const ev = aggregateReadEvidence([
-      { metadata: undefined },
-      { metadata: "not-json{" },
-      { metadata: JSON.stringify({ accessCount: 1 }) },
-    ]);
-    expect(ev.totalAccess).toBe(1);
-    expect(ev.distinctReaders).toBe(0);
-  });
-});
-
-describe("applyReadBoost", () => {
-  it("adds no boost for zero readers", () => {
-    expect(applyReadBoost(0.5, 0)).toBe(0.5);
-  });
-
-  it("scales boost linearly and saturates at 4 readers", () => {
-    expect(applyReadBoost(0.5, 2)).toBeCloseTo(0.5 + 0.075, 5); // half of max 0.15
-    expect(applyReadBoost(0.5, 4)).toBeCloseTo(0.65, 5);        // full boost
-    expect(applyReadBoost(0.5, 12)).toBeCloseTo(0.65, 5);       // saturated
-  });
-
-  it("caps combined confidence at 0.99", () => {
-    expect(applyReadBoost(0.95, 4)).toBe(0.99);
-  });
-});