@research-copilot/plugin 1.1.17 → 1.1.19

package/dist/skills/llm-wiki/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/dist/skills/llm-wiki/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/dist/skills/llm-wiki/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"]);
+  });
+});

package/dist/skills/llm-wiki/tests/lib/graph-html-engine-helpers.sh

@@ -0,0 +1,110 @@
+#!/bin/bash
+
+set -euo pipefail
+
+GRAPH_HTML_BASIC="tests/fixtures/graph-interactive-basic"
+
+fail() {
+    echo "FAIL: $1" >&2
+    exit 1
+}
+
+assert_file_exists() {
+    local file="$1"
+
+    [ -f "$file" ] || fail "Expected file to exist: $file"
+}
+
+assert_file_not_exists() {
+    local file="$1"
+
+    [ ! -e "$file" ] || fail "Expected file to not exist: $file"
+}
+
+assert_file_contains() {
+    local file="$1"
+    local text="$2"
+
+    if ! grep -F -- "$text" "$file" > /dev/null; then
+        fail "Expected $file to contain: $text"
+    fi
+}
+
+assert_file_not_contains() {
+    local file="$1"
+    local text="$2"
+
+    if grep -F -- "$text" "$file" > /dev/null; then
+        fail "Expected $file to not contain: $text"
+    fi
+}
+
+ensure_graph_engine_dist() {
+    if [ -f "$REPO_ROOT/packages/graph-engine/dist/engine.iife.js" ]; then
+        return 0
+    fi
+
+    npm run build -w @llm-wiki/graph-engine > /dev/null 2>&1 \
+        || fail "graph-engine build should succeed before offline HTML regression"
+}
+
+build_graph_html_fixture() {
+    local tmp_dir="$1"
+    local output_dir="$tmp_dir/wiki"
+
+    ensure_graph_engine_dist
+    mkdir -p "$output_dir"
+    cp "$REPO_ROOT/$GRAPH_HTML_BASIC/wiki/graph-data.json" "$output_dir/graph-data.json"
+
+    bash "$REPO_ROOT/scripts/build-graph-html.sh" \
+        "$tmp_dir" > /dev/null 2>&1 \
+        || fail "build-graph-html.sh should succeed on basic fixture"
+}
+
+build_graph_html_fixture_with_layout() {
+    local tmp_dir="$1"
+
+    mkdir -p "$tmp_dir/wiki"
+    cp "$REPO_ROOT/$GRAPH_HTML_BASIC/wiki/graph-data.json" "$tmp_dir/wiki/graph-data.json"
+    cat > "$tmp_dir/.wiki-graph-layout.json" <<'JSON'
+{
+  "version": 1,
+  "pins": {
+    "/fake/wiki/entities/A.md": { "x": 240, "y": 180 }
+  },
+  "updatedAt": "2026-06-12T00:00:00.000Z"
+}
+JSON
+
+    ensure_graph_engine_dist
+    bash "$REPO_ROOT/scripts/build-graph-html.sh" \
+        "$tmp_dir" > /dev/null 2>&1 \
+        || fail "build-graph-html.sh should succeed on basic fixture with layout"
+}
+
+assert_single_file_engine_output() {
+    local output_dir="$1"
+    local html="$output_dir/knowledge-graph.html"
+
+    assert_file_exists "$html"
+    assert_file_not_exists "$output_dir/d3.min.js"
+    assert_file_not_exists "$output_dir/rough.min.js"
+    assert_file_not_exists "$output_dir/marked.min.js"
+    assert_file_not_exists "$output_dir/purify.min.js"
+    assert_file_not_exists "$output_dir/graph-wash.js"
+    assert_file_not_exists "$output_dir/graph-wash-helpers.js"
+    assert_file_not_exists "$output_dir/LICENSE-d3.txt"
+    assert_file_not_exists "$output_dir/LICENSE-roughjs.txt"
+    assert_file_not_exists "$output_dir/LICENSE-marked.txt"
+    assert_file_not_exists "$output_dir/LICENSE-purify.txt"
+
+    assert_file_contains "$html" '<script id="graph-data" type="application/json">'
+    assert_file_contains "$html" '<script id="graph-layout" type="application/json">'
+    assert_file_contains "$html" "var LlmWikiGraphEngine="
+    assert_file_contains "$html" "window.LlmWikiGraphEngine.createGraphEngine"
+    assert_file_contains "$html" "persistPins: function"
+    assert_file_contains "$html" "window.__LLM_WIKI_GRAPH_PINS_KEY__"
+    assert_file_not_contains "$html" 'src="graph-wash.js"'
+    assert_file_not_contains "$html" 'src="d3.min.js"'
+    assert_file_not_contains "$html" 'sourceMappingURL'
+}

package/dist/skills/llm-wiki/tests/lint-output.regression-1.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# lint-output.regression-1.sh — 验证 lint 输出结构（排除时间和路径）
+set -eu
+
+SKILL_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+FIXTURE="$SKILL_DIR/tests/fixtures/lint-sample-wiki"
+EXPECTED="$SKILL_DIR/tests/expected/lint-output.txt"
+
+if [ ! -f "$EXPECTED" ]; then
+  echo "FAIL: expected output not found: $EXPECTED"
+  exit 1
+fi
+
+# 运行 lint，捕获输出
+ACTUAL=$(bash "$SKILL_DIR/scripts/lint-runner.sh" "$FIXTURE" 2>/dev/null)
+
+# 稳定化：替换时间为占位符，替换绝对路径为相对路径
+ACTUAL_STABLE=$(echo "$ACTUAL" | \
+  sed -E 's/时间：[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}/时间：YYYY-MM-DD HH:MM/' | \
+  sed "s|$FIXTURE|tests/fixtures/lint-sample-wiki|g")
+
+EXPECTED_STABLE=$(cat "$EXPECTED")
+
+if [ "$ACTUAL_STABLE" = "$EXPECTED_STABLE" ]; then
+  echo "PASS: lint output regression"
+  exit 0
+else
+  echo "FAIL: lint output does not match expected"
+  echo "--- diff (actual vs expected) ---"
+  diff <(echo "$ACTUAL_STABLE") <(echo "$EXPECTED_STABLE") || true
+  exit 1
+fi