@joekytc/dsh-swarm 0.1.2 → 0.3.0

package/skills/llm-wiki-skill/tests/js/graph-wash-queue.test.js

@@ -0,0 +1,115 @@
+const { describe, it } = require("node:test");
+// DEPRECATED: Covers the legacy wash helpers; remove in the same retirement cycle as templates/graph-styles/wash/.
+const assert = require("node:assert/strict");
+const {
+  getWikiStorageNamespace,
+  defaultQueue,
+  normalizeQueue,
+  toggleQueueFavorite,
+  appendQueueNote,
+  summarizeQueue
+} = require("../../templates/graph-styles/wash/graph-wash-helpers");
+
+describe("getWikiStorageNamespace", () => {
+  it("returns a stable namespace for the same wiki", () => {
+    const a = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki/graph.html");
+    const b = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki/graph.html");
+    assert.equal(a, b);
+    assert.match(a, /^llm-wiki:/);
+  });
+
+  it("changes namespace when pathname changes", () => {
+    const a = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki-a/graph.html");
+    const b = getWikiStorageNamespace({ wiki_title: "AI知识图谱Demo" }, "/wiki-b/graph.html");
+    assert.notEqual(a, b);
+  });
+});
+
+describe("defaultQueue and normalizeQueue", () => {
+  it("returns an empty queue by default", () => {
+    assert.deepEqual(defaultQueue(), {
+      version: 1,
+      favorites: [],
+      notes: [],
+      recentNoteIds: []
+    });
+  });
+
+  it("normalizes malformed queue data", () => {
+    const queue = normalizeQueue({
+      favorites: ["n1", "n1", 2, null],
+      notes: [
+        { id: "a", node_id: "n1", label: "节点 A", text: "摘录", created_at: "2026-04-24T00:00:00Z" },
+        { bad: true }
+      ],
+      recentNoteIds: ["a", "missing", "a"]
+    });
+
+    assert.deepEqual(queue.favorites, ["n1", "2"]);
+    assert.equal(queue.notes.length, 1);
+    assert.deepEqual(queue.recentNoteIds, ["a"]);
+  });
+});
+
+describe("toggleQueueFavorite", () => {
+  it("adds and removes favorites", () => {
+    let queue = defaultQueue();
+    queue = toggleQueueFavorite(queue, "n1");
+    assert.deepEqual(queue.favorites, ["n1"]);
+
+    queue = toggleQueueFavorite(queue, "n2");
+    assert.deepEqual(queue.favorites, ["n2", "n1"]);
+
+    queue = toggleQueueFavorite(queue, "n1");
+    assert.deepEqual(queue.favorites, ["n2"]);
+  });
+});
+
+describe("appendQueueNote", () => {
+  it("prepends note and updates recent ids", () => {
+    let queue = defaultQueue();
+    queue = appendQueueNote(queue, {
+      id: "note-1",
+      node_id: "n1",
+      label: "节点一",
+      text: "第一条",
+      created_at: "2026-04-24T00:00:00Z"
+    });
+    queue = appendQueueNote(queue, {
+      id: "note-2",
+      node_id: "n2",
+      label: "节点二",
+      text: "第二条",
+      created_at: "2026-04-24T00:01:00Z"
+    });
+
+    assert.deepEqual(queue.notes.map((note) => note.id), ["note-2", "note-1"]);
+    assert.deepEqual(queue.recentNoteIds, ["note-2", "note-1"]);
+  });
+});
+
+describe("summarizeQueue", () => {
+  it("summarizes counts and recent items", () => {
+    let queue = defaultQueue();
+    queue = toggleQueueFavorite(queue, "n3");
+    queue = appendQueueNote(queue, {
+      id: "note-1",
+      node_id: "n1",
+      label: "节点一",
+      text: "摘录一",
+      created_at: "2026-04-24T00:00:00Z"
+    });
+
+    const summary = summarizeQueue(queue, {
+      n1: { id: "n1", label: "节点一" },
+      n3: { id: "n3", label: "节点三" }
+    }, 4);
+
+    assert.equal(summary.favorite_count, 1);
+    assert.equal(summary.note_count, 1);
+    assert.deepEqual(summary.recent_items, [
+      { kind: "note", node_id: "n1", label: "节点一", text: "摘录一" },
+      { kind: "favorite", node_id: "n3", label: "节点三", text: "" }
+    ]);
+  });
+});

package/skills/llm-wiki-skill/tests/js/graph-wash-runtime-state.test.js

@@ -0,0 +1,282 @@
+const { describe, it } = require("node:test");
+// DEPRECATED: Covers the legacy wash helpers; remove in the same retirement cycle as templates/graph-styles/wash/.
+const assert = require("node:assert/strict");
+const {
+  resolveVisibleSnapshot,
+  buildAtlasModel,
+  deriveAtlasLayout,
+  resolveAtlasVisibleSnapshot,
+  resolveAtlasSelectedNodeId,
+  getAtlasDensityMode,
+  atlasNodePoint,
+  getAtlasModelBounds,
+  fitAtlasViewport,
+  centerAtlasViewportOnPoint,
+  zoomAtlasViewport,
+  atlasViewportRect,
+  atlasPointToMinimap,
+  minimapPointToAtlasPoint,
+  atlasViewportToMinimapRect
+} = require("../../templates/graph-styles/wash/graph-wash-helpers");
+
+describe("resolveVisibleSnapshot", () => {
+  const nodes = [
+    { id: "n1", label: "机器学习基础", content: "监督学习与数据预处理", degree: 2 },
+    { id: "n2", label: "深度学习", content: "神经网络与 Transformer", degree: 3 },
+    { id: "n3", label: "Transformer", content: "语言模型核心架构", degree: 2 },
+    { id: "n4", label: "数据清洗", content: "数据预处理的一部分", degree: 1 }
+  ];
+
+  const links = [
+    { id: "e1", source: "n1", target: "n2", type: "EXTRACTED", weight: 0.95 },
+    { id: "e2", source: "n2", target: "n3", type: "EXTRACTED", weight: 0.91 },
+    { id: "e3", source: "n1", target: "n4", type: "INFERRED", weight: 0.55 }
+  ];
+
+  it("combines edge filtering, focus mode, and search query", () => {
+    const snapshot = resolveVisibleSnapshot({
+      nodes,
+      links,
+      baseNodeIds: ["n1", "n2", "n3", "n4"],
+      filters: { EXTRACTED: true, INFERRED: false, AMBIGUOUS: false },
+      focusMode: "high_confidence",
+      searchQuery: "transformer",
+      anchorNodeId: "n2",
+      highConfidenceThreshold: 0.9
+    });
+
+    assert.deepEqual(snapshot.node_ids, ["n2", "n3"]);
+    assert.deepEqual(snapshot.nodes.map((node) => node.id), ["n2", "n3"]);
+    assert.deepEqual(snapshot.links.map((link) => link.id), ["e2"]);
+    assert.deepEqual(snapshot.searchIndex.map((entry) => entry.node.id), ["n1", "n2", "n3"]);
+  });
+
+  it("keeps one-hop scope around the selected anchor", () => {
+    const snapshot = resolveVisibleSnapshot({
+      nodes,
+      links,
+      baseNodeIds: ["n1", "n2", "n3"],
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: false },
+      focusMode: "one_hop",
+      searchQuery: "",
+      anchorNodeId: "n2"
+    });
+
+    assert.deepEqual(snapshot.node_ids, ["n1", "n2", "n3"]);
+    assert.deepEqual(snapshot.links.map((link) => link.id), ["e1", "e2"]);
+  });
+
+  it("returns empty visible nodes when search has no matches", () => {
+    const snapshot = resolveVisibleSnapshot({
+      nodes,
+      links,
+      baseNodeIds: ["n1", "n2", "n3"],
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: false },
+      focusMode: "all",
+      searchQuery: "不存在",
+      anchorNodeId: "n2"
+    });
+
+    assert.deepEqual(snapshot.node_ids, []);
+    assert.deepEqual(snapshot.nodes, []);
+    assert.deepEqual(snapshot.links, []);
+    assert.equal(snapshot.searchIndex.length, 3);
+  });
+
+  it("keeps an explicitly empty current range empty", () => {
+    const snapshot = resolveVisibleSnapshot({
+      nodes,
+      links,
+      baseNodeIds: [],
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: false },
+      focusMode: "all",
+      searchQuery: "机器"
+    });
+
+    assert.deepEqual(snapshot.node_ids, []);
+    assert.deepEqual(snapshot.nodes, []);
+    assert.deepEqual(snapshot.links, []);
+    assert.deepEqual(snapshot.searchIndex, []);
+  });
+});
+
+describe("atlas state contract", () => {
+  const rawGraph = {
+    meta: { wiki_title: "测试知识库", build_date: "2026-04-27" },
+    nodes: [
+      { id: "a", label: "知识编译", type: "topic", community: "method", confidence: "EXTRACTED", content: "# 知识编译\n\n整理一次，持续维护。" },
+      { id: "b", label: "素材消化", type: "topic", community: "method", confidence: "INFERRED", source_path: "wiki/topics/b.md" },
+      { id: "c", label: "网页文章", type: "source", community: "source", confidence: "AMBIGUOUS" }
+    ],
+    edges: [
+      { id: "ab", from: "a", to: "b", type: "EXTRACTED", weight: 0.9 },
+      { id: "ac", from: "a", to: "c", type: "INFERRED", weight: 0.6 }
+    ],
+    learning: {
+      entry: { recommended_start_node_id: "a" },
+      communities: [
+        { id: "method", label: "方法论", node_count: 2, is_primary: true, recommended_start_node_id: "a" },
+        { id: "source", label: "素材来源", node_count: 1, recommended_start_node_id: "c" }
+      ]
+    }
+  };
+
+  it("normalizes raw graph into one atlas model", () => {
+    const model = buildAtlasModel(rawGraph);
+
+    assert.equal(model.meta.wiki_title, "测试知识库");
+    assert.equal(model.nodes.length, 3);
+    assert.equal(model.edges.length, 2);
+    assert.equal(model.byId.a.degree, 2);
+    assert.equal(model.byId.a.summary, "整理一次，持续维护。");
+    assert.deepEqual(model.communities.map((community) => community.label), ["方法论", "素材来源"]);
+    assert.equal(model.starts[0].node.id, "a");
+  });
+
+  it("treats null atlas coordinates as missing layout input", () => {
+    const model = buildAtlasModel({
+      nodes: [
+        { id: "nullish", label: "Nullish", x: null, y: null },
+        { id: "origin", label: "Origin", x: 0, y: 0 }
+      ],
+      edges: []
+    });
+    deriveAtlasLayout(model);
+
+    assert.notDeepEqual(
+      { x: model.byId.nullish.x, y: model.byId.nullish.y },
+      { x: 5, y: 8 }
+    );
+    assert.deepEqual(
+      { x: model.byId.origin.x, y: model.byId.origin.y },
+      { x: 5, y: 8 }
+    );
+  });
+
+  it("uses one visible snapshot for filters, search, density, and starts", () => {
+    const model = buildAtlasModel(rawGraph);
+    const layout = deriveAtlasLayout(model);
+    const snapshot = resolveAtlasVisibleSnapshot(model, layout, {
+      activeCommunityId: "method",
+      focusMode: "all",
+      query: "素材",
+      selectedNodeId: "a",
+      filters: { EXTRACTED: true, INFERRED: true }
+    });
+
+    assert.deepEqual(snapshot.node_ids, ["b"]);
+    assert.deepEqual(snapshot.nodes.map((node) => node.id), ["b"]);
+    assert.deepEqual(snapshot.edges, []);
+    assert.equal(snapshot.densityMode, "card");
+    assert.equal(snapshot.starts[0].node.id, "b");
+    assert.equal(snapshot.importantNodeIds.b, true);
+    assert.equal(snapshot.counts.total_nodes, 3);
+  });
+
+  it("keeps recommended starts and high-priority nodes readable as atlas index slips", () => {
+    const model = buildAtlasModel(rawGraph);
+    const layout = deriveAtlasLayout(model);
+    const snapshot = resolveAtlasVisibleSnapshot(model, layout, {
+      activeCommunityId: "all",
+      focusMode: "all",
+      query: "",
+      selectedNodeId: null,
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: true, UNVERIFIED: true }
+    });
+
+    assert.equal(snapshot.starts[0].node.id, "a");
+    assert.equal(snapshot.startNodeIds.a, true);
+    assert.equal(snapshot.importantNodeIds.a, true);
+    assert.equal(snapshot.labelNodeIds.a, true);
+  });
+
+  it("preserves only explicit selections inside the current visible atlas range", () => {
+    const model = buildAtlasModel(rawGraph);
+    const layout = deriveAtlasLayout(model);
+    const methodSnapshot = resolveAtlasVisibleSnapshot(model, layout, {
+      activeCommunityId: "source",
+      focusMode: "all",
+      query: "",
+      selectedNodeId: "a",
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: true, UNVERIFIED: true }
+    });
+    const emptySnapshot = resolveAtlasVisibleSnapshot(model, layout, {
+      activeCommunityId: "source",
+      focusMode: "all",
+      query: "没有结果",
+      selectedNodeId: "c",
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: true, UNVERIFIED: true }
+    });
+
+    assert.equal(resolveAtlasSelectedNodeId(model, methodSnapshot, "a"), null);
+    assert.equal(resolveAtlasSelectedNodeId(model, methodSnapshot, "c"), "c");
+    assert.equal(resolveAtlasSelectedNodeId(model, emptySnapshot, "c"), null);
+  });
+
+  it("does not auto-select a recommended start on first open", () => {
+    const model = buildAtlasModel(rawGraph);
+    const layout = deriveAtlasLayout(model);
+    const snapshot = resolveAtlasVisibleSnapshot(model, layout, {
+      activeCommunityId: "all",
+      focusMode: "all",
+      query: "",
+      selectedNodeId: null,
+      filters: { EXTRACTED: true, INFERRED: true, AMBIGUOUS: true, UNVERIFIED: true }
+    });
+
+    assert.equal(snapshot.starts[0].node.id, "a");
+    assert.equal(resolveAtlasSelectedNodeId(model, snapshot, null), null);
+  });
+
+  it("selects density mode by visible node budget", () => {
+    assert.equal(getAtlasDensityMode(50), "card");
+    assert.equal(getAtlasDensityMode(120), "compact-card");
+    assert.equal(getAtlasDensityMode(300), "point-plus-focus");
+    assert.equal(getAtlasDensityMode(800), "overview");
+  });
+
+  it("derives one model coordinate space for nodes and bounds", () => {
+    const model = buildAtlasModel(rawGraph);
+    deriveAtlasLayout(model);
+    const point = atlasNodePoint(model.byId.a);
+    const bounds = getAtlasModelBounds(model.nodes, 0);
+
+    assert.equal(point.x, model.byId.a.x * 10);
+    assert.equal(point.y, model.byId.a.y * 6.8);
+    assert.ok(bounds.width > 0);
+    assert.ok(bounds.height > 0);
+    assert.ok(bounds.minX <= point.x && point.x <= bounds.maxX);
+    assert.ok(bounds.minY <= point.y && point.y <= bounds.maxY);
+  });
+
+  it("fits, zooms, and reports the current viewport rectangle", () => {
+    const viewportSize = { width: 1000, height: 680 };
+    const bounds = { minX: 250, minY: 180, maxX: 750, maxY: 500, width: 500, height: 320 };
+    const fitted = fitAtlasViewport(bounds, viewportSize, { padding: 0.8 });
+    const zoomed = zoomAtlasViewport(fitted, 1.5, { x: 500, y: 340 }, viewportSize);
+    const rect = atlasViewportRect(zoomed, viewportSize);
+
+    assert.ok(fitted.scale > 1);
+    assert.ok(zoomed.scale > fitted.scale);
+    assert.ok(rect.width < 1000);
+    assert.ok(rect.height < 680);
+    assert.ok(rect.minX >= 0 && rect.maxX <= 1000);
+    assert.ok(rect.minY >= 0 && rect.maxY <= 680);
+  });
+
+  it("centers viewport on model points and maps minimap clicks back to atlas coordinates", () => {
+    const viewportSize = { width: 800, height: 500 };
+    const point = { x: 250, y: 170 };
+    const centered = centerAtlasViewportOnPoint(point, viewportSize, 1.4);
+    const rect = atlasViewportRect(centered, viewportSize);
+    const miniPoint = atlasPointToMinimap(point);
+    const restored = minimapPointToAtlasPoint(miniPoint);
+    const miniRect = atlasViewportToMinimapRect(centered, viewportSize);
+
+    assert.ok(rect.minX <= point.x && point.x <= rect.maxX);
+    assert.ok(rect.minY <= point.y && point.y <= rect.maxY);
+    assert.deepEqual(restored, point);
+    assert.ok(miniRect.width > 0);
+    assert.ok(miniRect.height > 0);
+  });
+});

package/skills/llm-wiki-skill/tests/js/source-signal-coverage.test.js

@@ -0,0 +1,48 @@
+const { describe, it } = require("node:test");
+const assert = require("node:assert/strict");
+const { scanWiki } = require("../../scripts/source-signal-coverage");
+const path = require("path");
+
+const FIXTURE_ROOT = path.join(__dirname, "..", "fixtures", "coverage-sample-wiki");
+
+describe("scanWiki", () => {
+  it("returns correct summary counts", () => {
+    const { summary } = scanWiki(FIXTURE_ROOT);
+    assert.equal(summary.ok, 2);
+    assert.equal(summary.missing_sources, 1);
+    assert.equal(summary.empty_sources, 1);
+    assert.equal(summary.invalid_sources, 1);
+    assert.equal(summary.not_applicable, 2);
+    assert.equal(summary.applicable_total, 5);
+  });
+
+  it("returns pages for all scanned files", () => {
+    const { pages } = scanWiki(FIXTURE_ROOT);
+    assert.equal(pages.length, 7);
+  });
+
+  it("marks synthesis as not_applicable", () => {
+    const { pages } = scanWiki(FIXTURE_ROOT);
+    const crystal = pages.find((p) => p.id === "Crystal");
+    assert.equal(crystal.reason, "not_applicable");
+  });
+
+  it("marks query as not_applicable", () => {
+    const { pages } = scanWiki(FIXTURE_ROOT);
+    const query = pages.find((p) => p.pageType === "query");
+    assert.equal(query.reason, "not_applicable");
+  });
+
+  it("detects ok with correct sourceCount", () => {
+    const { pages } = scanWiki(FIXTURE_ROOT);
+    const alpha = pages.find((p) => p.id === "Alpha");
+    assert.equal(alpha.reason, "ok");
+    assert.equal(alpha.sourceCount, 2);
+  });
+
+  it("detects invalid_sources", () => {
+    const { pages } = scanWiki(FIXTURE_ROOT);
+    const delta = pages.find((p) => p.id === "Delta");
+    assert.equal(delta.reason, "invalid_sources");
+  });
+});

package/skills/llm-wiki-skill/tests/js/source-signal-eligibility.test.js

@@ -0,0 +1,202 @@
+const { describe, it } = require("node:test");
+const assert = require("node:assert/strict");
+const {
+  SCAN_KINDS,
+  extractFrontmatter,
+  evaluateSourceSignalEligibility,
+  parseSourcesFrontmatter
+} = require("../../scripts/lib/source-signal-eligibility");
+
+describe("extractFrontmatter", () => {
+  it("returns hasFrontmatter:false when no frontmatter", () => {
+    const result = extractFrontmatter("just body text");
+    assert.equal(result.hasFrontmatter, false);
+    assert.equal(result.frontmatter, "");
+    assert.equal(result.body, "just body text");
+  });
+
+  it("extracts frontmatter from valid document", () => {
+    const result = extractFrontmatter("---\ntitle: Test\n---\nbody");
+    assert.equal(result.hasFrontmatter, true);
+    assert.equal(result.frontmatter, "title: Test");
+    assert.equal(result.body, "body");
+  });
+
+  it("returns hasFrontmatter:false for broken frontmatter", () => {
+    const result = extractFrontmatter("---\ntitle: Test\nno closing");
+    assert.equal(result.hasFrontmatter, false);
+  });
+});
+
+describe("parseSourcesFrontmatter", () => {
+  it("returns hasField:false for empty input", () => {
+    const result = parseSourcesFrontmatter("");
+    assert.equal(result.hasField, false);
+    assert.equal(result.parsed, false);
+    assert.deepEqual(result.sources, []);
+  });
+
+  it("returns hasField:false when no sources key", () => {
+    const result = parseSourcesFrontmatter("title: Test\nauthor: me");
+    assert.equal(result.hasField, false);
+  });
+
+  it("parses single string source", () => {
+    const result = parseSourcesFrontmatter('sources: "paper.md"');
+    assert.equal(result.hasField, true);
+    assert.equal(result.parsed, true);
+    assert.deepEqual(result.sources, ["paper.md"]);
+    assert.equal(result.signalAvailable, true);
+  });
+
+  it("parses inline array", () => {
+    const result = parseSourcesFrontmatter('sources: ["a.md", "b.md"]');
+    assert.equal(result.hasField, true);
+    assert.deepEqual(result.sources, ["a.md", "b.md"]);
+  });
+
+  it("parses multiline list", () => {
+    const result = parseSourcesFrontmatter("sources:\n  - paper.md\n  - note.md");
+    assert.equal(result.hasField, true);
+    assert.deepEqual(result.sources, ["note.md", "paper.md"]);
+  });
+
+  it("returns empty_sources for empty array", () => {
+    const result = parseSourcesFrontmatter("sources: []");
+    assert.equal(result.hasField, true);
+    assert.equal(result.parsed, true);
+    assert.deepEqual(result.sources, []);
+    assert.equal(result.signalAvailable, false);
+  });
+
+  it("returns empty_sources for whitespace-only token", () => {
+    const result = parseSourcesFrontmatter('sources:\n  - ""');
+    assert.equal(result.hasField, true);
+    assert.deepEqual(result.sources, []);
+  });
+
+  it("returns parsed:false for broken inline array", () => {
+    const result = parseSourcesFrontmatter("sources: [");
+    assert.equal(result.hasField, true);
+    assert.equal(result.parsed, false);
+    assert.deepEqual(result.sources, []);
+  });
+
+  it("returns parsed:false for invalid multiline content", () => {
+    const result = parseSourcesFrontmatter("sources:\n  foo: bar");
+    assert.equal(result.hasField, true);
+    assert.equal(result.parsed, false);
+  });
+
+  it("handles numeric sources by stringifying", () => {
+    const result = parseSourcesFrontmatter("sources: [1, 2]");
+    assert.equal(result.hasField, true);
+    assert.equal(result.parsed, true);
+    assert.deepEqual(result.sources, ["1", "2"]);
+  });
+});
+
+describe("evaluateSourceSignalEligibility", () => {
+  it("returns not_applicable for synthesis", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "synthesis",
+      frontmatter: "title: Test"
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "not_applicable");
+  });
+
+  it("returns not_applicable for query", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "query",
+      frontmatter: "sources: [a.md]"
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "not_applicable");
+  });
+
+  it("returns not_applicable for unknown page type", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "unknown",
+      frontmatter: "sources: [a.md]"
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "not_applicable");
+  });
+
+  it("returns ok for entity with valid sources", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "entity",
+      frontmatter: "sources:\n  - paper.md\n  - note.md"
+    });
+    assert.equal(result.eligible, true);
+    assert.equal(result.reason, "ok");
+    assert.deepEqual(result.sources, ["note.md", "paper.md"]);
+  });
+
+  it("returns ok for topic with single source", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "topic",
+      frontmatter: 'sources: "paper.md"'
+    });
+    assert.equal(result.eligible, true);
+    assert.equal(result.reason, "ok");
+  });
+
+  it("returns missing_sources when no frontmatter", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "entity",
+      frontmatter: ""
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "missing_sources");
+  });
+
+  it("returns missing_sources when no sources field", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "entity",
+      frontmatter: "title: Test"
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "missing_sources");
+  });
+
+  it("returns empty_sources for empty array", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "entity",
+      frontmatter: "sources: []"
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "empty_sources");
+  });
+
+  it("returns invalid_sources for broken syntax", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "entity",
+      frontmatter: "sources: ["
+    });
+    assert.equal(result.eligible, false);
+    assert.equal(result.reason, "invalid_sources");
+  });
+
+  it("treats comparison as applicable", () => {
+    const result = evaluateSourceSignalEligibility({
+      pageType: "comparison",
+      frontmatter: 'sources: "a.md"'
+    });
+    assert.equal(result.eligible, true);
+    assert.equal(result.reason, "ok");
+  });
+});
+
+describe("SCAN_KINDS", () => {
+  it("includes all 6 page types", () => {
+    const types = SCAN_KINDS.map((k) => k.pageType).sort();
+    assert.deepEqual(types, ["comparison", "entity", "query", "source", "synthesis", "topic"]);
+  });
+
+  it("marks entity/topic/source/comparison as applicable", () => {
+    const applicable = SCAN_KINDS.filter((k) => k.applicable).map((k) => k.pageType).sort();
+    assert.deepEqual(applicable, ["comparison", "entity", "source", "topic"]);
+  });
+});