feat: mirror tag-vocabulary summary and note-type validation

Ports two changes from the knowledge-base vault this skeleton is extracted
from, keeping the shared scripts byte-identical across the pair:

- `graph_summary` reports `by_tag` and `tag_count`, sized by `topTags`, and
  drops the `by_type`/`by_status` breakdowns. An MCP-only agent could not
  otherwise discover the tag spellings that `graph_search_nodes` matches
  verbatim.
- `generate-graph.py --validate` now enforces a controlled vocabulary for a
  note's `type`, which is where the drift signal `by_type` used to give now
  lives. `AGENT_QUERY_GUIDE.md`, both skills and the-knowing-one quote the
  enforced enum.

`tests/test_generate_graph.py` is new; `make test` is 50 tests. Regenerating
the graph also drops a stale `GLOBAL_AGENTS` node for a file this skeleton
does not carry.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/test_generate_graph.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""Tests for the graph generator's validation gate.
+
+`--validate` is the only thing standing between a typo in a note's frontmatter
+and a vault whose facets quietly stop meaning anything, so these tests pin the
+controlled vocabularies it enforces: the edge relationship types and the node
+`type` enum. Each filesystem test builds a throwaway vault, never the real one.
+"""
+
+from __future__ import annotations
+
+import importlib
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SCRIPTS = Path(__file__).resolve().parents[1] / "scripts"
+sys.path.insert(0, str(SCRIPTS))
+
+gen = importlib.import_module("generate-graph")
+
+
+def _node(node_id: str, note_type: str) -> dict:
+    return {"id": node_id, "path": f"{node_id}.md", "type": note_type}
+
+
+class TestNoteTypeVocabulary(unittest.TestCase):
+    """The node `type` enum is the drift signal; it has to be enforced."""
+
+    def test_covers_every_type_the_taxonomy_documents(self) -> None:
+        self.assertLessEqual(
+            {
+                "hub",
+                "project",
+                "area",
+                "guideline",
+                "policy",
+                "feature",
+                "roadmap",
+                "decision",
+                "note",
+                "meta",
+                "reference",
+            },
+            gen.NOTE_TYPES,
+        )
+
+    def test_accepts_a_graph_whose_nodes_are_all_in_the_vocabulary(self) -> None:
+        graph = {"nodes": [_node("a", "note"), _node("b", "area")], "edges": []}
+        self.assertEqual(gen.find_invalid_node_types(graph), [])
+
+    def test_reports_a_node_whose_type_is_outside_the_vocabulary(self) -> None:
+        graph = {"nodes": [_node("a", "note"), _node("b", "refrence")], "edges": []}
+        invalid = gen.find_invalid_node_types(graph)
+        self.assertEqual([n["id"] for n in invalid], ["b"])
+
+
+class TestValidateExitCode(unittest.TestCase):
+    """--validate must fail the run, not just print, on an unknown node type."""
+
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name).resolve() / "vault"
+        (self.root / "scripts").mkdir(parents=True)
+        (self.root / "03_resources").mkdir()
+        (self.root / "scripts" / "generate-graph.py").write_text(
+            (SCRIPTS / "generate-graph.py").read_text(encoding="utf-8"),
+            encoding="utf-8",
+        )
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def write_note(self, name: str, note_type: str) -> None:
+        (self.root / "03_resources" / name).write_text(
+            f"---\nid: {name[:-3]}\ntitle: {name}\ntype: {note_type}\n---\n\n# {name}\n",
+            encoding="utf-8",
+        )
+
+    def validate(self) -> subprocess.CompletedProcess:
+        return subprocess.run(
+            [sys.executable, "scripts/generate-graph.py", "--validate"],
+            cwd=self.root,
+            capture_output=True,
+            text=True,
+        )
+
+    def test_passes_on_a_vault_of_known_types(self) -> None:
+        self.write_note("good.md", "decision")
+        proc = self.validate()
+        self.assertEqual(proc.returncode, 0, proc.stdout + proc.stderr)
+        self.assertIn("all node types are in the controlled vocabulary", proc.stdout)
+
+    def test_fails_and_names_the_offending_note(self) -> None:
+        self.write_note("good.md", "decision")
+        self.write_note("bad.md", "descision")
+        proc = self.validate()
+        self.assertEqual(proc.returncode, 1)
+        self.assertIn("descision", proc.stdout)
+        self.assertIn("bad", proc.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()