Datasets:

imecai
/

cl-agentic-vault

#!/usr/bin/env python3
"""Mechanical structural-integrity checks for the vault.
The judgment-heavy work (idea merges, author-spelling merges, extraction
spot-audits) stays in the vault-audit skill; this script is the deterministic
pass it — and end_of_wave.py — run first, so nobody re-derives these checks by
hand each time. Four groups: edges (papers/ + influences/), ideas, metadata
and controlled vocabulary (every enumerated frontmatter value and
scenario/benchmark token must be in _vocab.md, the single home of those
values), and meta (the process layer — PROJECT.md, skills, agents, templates
— must match the repo: no absolute paths, no references to missing scripts or
reference files, every skill listed in PROJECT.md and linked into .claude/).
    python3 _scripts/check_integrity.py            # full report
    python3 _scripts/check_integrity.py --strict   # exit 1 if any ERROR found
Read-only. Errors are real bugs; warnings are smells to eyeball. Info lines
(to-read danglers, deliberate origin-less ideas) are counts, not problems.
"""
import glob
import os
import re
import sys

VAULT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
STANCE = ("first-mention", "argues-for", "argues-against", "nuances", "tests")
COND_EDGES = ("argues-for", "argues-against", "nuances")  # must carry a (condition)
LINEAGE = ("variant-of", "refines", "combines")
PAPER_SHAPED = re.compile(r"^[a-z][a-z-]*\d{4}")  # author+year slug, e.g. rebuffi2017-icarl


def read(p):
    return open(p, encoding="utf-8").read()


def slugset(d):
    return {os.path.basename(f)[:-3] for f in glob.glob(os.path.join(VAULT, d, "*.md"))}


def strip_code(t):
    """Drop fenced blocks, inline-code spans, and HTML comments — links there are
    examples or batch-mode edges held back for the consolidator, not live edges."""
    t = re.sub(r"<!--.*?-->", "", t, flags=re.S)
    t = re.sub(r"```.*?```", "", t, flags=re.S)
    return re.sub(r"`[^`]*`", "", t)


def frontmatter(t):
    m = re.match(r"^---\n(.*?)\n---", t, re.S)
    return m.group(1) if m else ""


def fm_list(fmt, field):
    m = re.search(rf"^{field}:\s*\[(.*?)\]", fmt, re.M)
    return [x.strip().strip("\"'") for x in m.group(1).split(",") if x.strip()] if m else []


def load_vocab():
    """Parse _vocab.md: scenario table, benchmark token list, constrained-fields table."""
    v = read(os.path.join(VAULT, "_vocab.md"))

    def section(title):
        m = re.search(rf"^## {re.escape(title)}\n(.*?)(?=^## |\Z)", v, re.S | re.M)
        return m.group(1) if m else ""

    scen = set(re.findall(r"^\| `([^`]+)` \|", section("`scenario` tokens"), re.M))
    bench = {t.strip() for ln in section("`benchmarks` tokens").splitlines() if "·" in ln
             for t in ln.split("·") if t.strip()}
    fields = {}
    for kind, field, vals in re.findall(r"^\| (paper|idea|method) \| `([^`]+)` \| (.*?) \|$",
                                        section("Other constrained fields"), re.M):
        fields.setdefault(kind, {})[field] = set(re.findall(r"`([^`]+)`", vals))
    return {"scenario": scen, "benchmarks": bench, "fields": fields}


def meta_checks():
    """The process layer (PROJECT.md, skills, agents, templates) must match the repo:
    no absolute paths, every referenced script/reference file exists, every skill is
    listed in PROJECT.md and linked into .claude/. These drift silently otherwise."""
    errs = []
    skill_dirs = sorted(os.path.basename(d.rstrip("/")) for d in glob.glob(os.path.join(VAULT, "skills", "*/")))
    agent_files = sorted(os.path.basename(a) for a in glob.glob(os.path.join(VAULT, "agents", "*.md")))
    process_docs = (glob.glob(os.path.join(VAULT, "skills", "**", "*.md"), recursive=True)
                    + [os.path.join(VAULT, "agents", a) for a in agent_files])
    docs = process_docs + [os.path.join(VAULT, "PROJECT.md"), os.path.join(VAULT, "_vocab.md")] \
        + glob.glob(os.path.join(VAULT, "_templates", "*.md"))
    script_dirs = {"_scripts": os.path.join(VAULT, "_scripts"),
                   "_blog/scripts": os.path.join(VAULT, "_blog", "scripts")}
    ref_re = re.compile(r"(?:(_blog/scripts|_scripts)/)?\b((?:make|check|fetch|suggest|end)_[a-z_]+\.py|link_skills\.sh)\b")
    for f in docs:
        rel, t = os.path.relpath(f, VAULT), read(f)
        if f in process_docs:
            for m in re.finditer(r"(?<![\w.~])/(?:Users|home)/[^\s`'\")]+", t):
                errs.append(f"[meta-abs-path] {rel}: absolute path `{m.group(0)}` — use vault-relative paths")
            for m in re.finditer(r"\breferences/[\w.-]+\.md\b", t):
                if not os.path.exists(os.path.join(os.path.dirname(f), m.group(0))) and \
                        not glob.glob(os.path.join(VAULT, "skills", "*", m.group(0))):
                    errs.append(f"[meta-missing-ref] {rel}: `{m.group(0)}` does not exist")
        for m in ref_re.finditer(t):
            where = [script_dirs[m.group(1)]] if m.group(1) else list(script_dirs.values())
            if not any(os.path.exists(os.path.join(d, m.group(2))) for d in where):
                errs.append(f"[meta-missing-script] {rel}: `{m.group(0)}` does not exist")
    proj = read(os.path.join(VAULT, "PROJECT.md"))
    listed = set(re.findall(r"^- `/([a-z0-9-]+)`", proj, re.M))
    for s in skill_dirs:
        if s not in listed:
            errs.append(f"[meta-skill-unlisted] skills/{s} is not listed in PROJECT.md ## Skills")
        link = os.path.join(VAULT, ".claude", "skills", s)
        if os.path.realpath(link) != os.path.realpath(os.path.join(VAULT, "skills", s)):
            errs.append(f"[meta-skill-unlinked] .claude/skills/{s} missing or wrong — run bash _scripts/link_skills.sh")
    for s in sorted(listed - set(skill_dirs)):
        errs.append(f"[meta-skill-missing] PROJECT.md lists /{s} but skills/{s} does not exist")
    for a in agent_files:
        link = os.path.join(VAULT, ".claude", "agents", a)
        if os.path.realpath(link) != os.path.realpath(os.path.join(VAULT, "agents", a)):
            errs.append(f"[meta-agent-unlinked] .claude/agents/{a} missing or wrong — run bash _scripts/link_skills.sh")
    return errs


def main():
    strict = "--strict" in sys.argv
    ideas = slugset("ideas")
    papers = slugset("papers")
    methods = slugset("methods")
    infl = slugset("influences")
    concepts = slugset("concepts")
    authors = slugset("authors")
    notes = ideas | papers | methods | infl | concepts | authors
    paper_files = glob.glob(os.path.join(VAULT, "papers", "*.md")) + \
        glob.glob(os.path.join(VAULT, "influences", "*.md"))

    errors, warns, infos = [], [], []

    # ---- edge-level checks over papers/ + influences/ -----------------------
    fm_holders = {}  # idea -> set(papers holding first-mention)
    incoming = set()  # ideas that any stance edge points at
    for f in paper_files:
        s = os.path.basename(f)[:-3]
        body = strip_code(read(f))
        edge_lines = [ln for ln in body.splitlines()
                      if re.match(rf"^\s*({'|'.join(STANCE + ('builds-on',) + LINEAGE)})::", ln)]
        n_edges = 0
        for ln in edge_lines:
            kind = ln.strip().split("::", 1)[0]
            tgt = re.search(r"\[\[([^\]]+)\]\]", ln)
            if not tgt:
                errors.append(f"[malformed-edge] {s}: `{ln.strip()[:70]}` has no [[link]]")
                continue
            n_edges += 1
            t = tgt.group(1)
            if kind in STANCE:
                if t not in notes:
                    errors.append(f"[dangling-stance] {s}: {kind}:: [[{t}]] — no such note")
                elif t not in ideas:
                    errors.append(f"[stance-not-idea] {s}: {kind}:: [[{t}]] targets a "
                                  f"{'method' if t in methods else 'concept' if t in concepts else 'paper/author'}, not an idea")
                else:
                    if kind == "first-mention":
                        fm_holders.setdefault(t, set()).add(s)
                    incoming.add(t)
                if kind in COND_EDGES and "(" not in ln.split("]]", 1)[1]:
                    warns.append(f"[edge-no-condition] {s}: {kind}:: [[{t}]] — no (condition)")
            elif kind == "builds-on":
                if t not in notes:
                    infos.append(f"[to-read] {s} builds-on [[{t}]]")
            elif kind in LINEAGE:  # in methods/, but tolerate here
                if t not in notes and PAPER_SHAPED.match(t):
                    errors.append(f"[lineage-paper-shaped] {s}: {kind}:: [[{t}]] — paper-shaped, inflates to-read")

        if s in papers and n_edges == 0:
            warns.append(f"[zero-edge-paper] {s}: no stance/first-mention/builds-on edge "
                         f"— scope smell (influence candidate?)")

        # metadata gaps (papers only; influences are exempt from scenario/venue)
        if s in papers:
            fmt = frontmatter(read(f))
            ptype = (re.search(r"^type:\s*(.*)$", fmt, re.M) or [None, ""])
            ptype = ptype.group(1).strip().strip('"') if hasattr(ptype, "group") else ""
            # scenario is only expected of papers tied to a concrete setting;
            # surveys/position/theory/book/dataset legitimately have none.
            no_scenario_ok = ptype in ("survey", "position", "theory", "book", "dataset")
            for field in ("venue", "status", "year", "citekey", "scenario"):
                if field == "scenario" and no_scenario_ok:
                    continue
                m = re.search(rf"^{field}:\s*(.*)$", fmt, re.M)
                val = (m.group(1).strip() if m else "").strip('"[] ')
                if not val:
                    warns.append(f"[metadata-gap] {s}: empty `{field}`" + (f" (type: {ptype})" if ptype else ""))
            pdf = re.search(r"^pdf:\s*(.*)$", fmt, re.M)
            if pdf:
                rel = pdf.group(1).strip().strip('"')
                if rel and not os.path.exists(os.path.join(VAULT, rel)):
                    errors.append(f"[pdf-missing] {s}: pdf: {rel} does not exist")

    # ---- method lineage checks ---------------------------------------------
    for f in glob.glob(os.path.join(VAULT, "methods", "*.md")):
        s = os.path.basename(f)[:-3]
        body = strip_code(read(f))
        for kind in LINEAGE:
            for mm in re.finditer(rf"(?<![a-z]){kind}::\s*\[\[([^\]]+)\]\]", body):
                t = mm.group(1)
                if t not in notes and PAPER_SHAPED.match(t):
                    errors.append(f"[lineage-paper-shaped] {s}: {kind}:: [[{t}]] — paper-shaped slug")

    # ---- idea-level checks --------------------------------------------------
    for f in glob.glob(os.path.join(VAULT, "ideas", "*.md")):
        s = os.path.basename(f)[:-3]
        t = read(f)
        holders = fm_holders.get(s, set())
        if not holders:
            infos.append(f"[no-first-mention] {s}")
        elif len(holders) >= 2:
            warns.append(f"[multi-first-mention] {s}: {sorted(holders)} — legitimate only if "
                         f"the First-mention section records a concurrent/adjudicated split")
        if s not in incoming and not holders:
            warns.append(f"[orphan-idea] {s}: no paper edge points to it")
        # stale first-mention prose: names a paper that is not a current holder
        m = re.search(r"## First mention\n(.*?)(\n## |\Z)", t, re.S)
        if m and holders:
            for mm in re.finditer(r"[Ff]irst[- ]ment\w*\s+(?:in|by)\s+\[\[([^\]]+)\]\]",
                                  strip_code(m.group(1))):
                if mm.group(1) not in holders:
                    warns.append(f"[stale-fm-prose] {s}: prose credits [[{mm.group(1)}]] but "
                                 f"first-mention edge is held by {sorted(holders)}")
        # parent resolution + self-cycle
        pm = re.search(r"^parent:\s*\"?\[\[([^\]]+)\]\]", frontmatter(t), re.M)
        if pm:
            if pm.group(1) not in ideas:
                errors.append(f"[bad-parent] {s}: parent [[{pm.group(1)}]] is not an idea note")
            elif pm.group(1) == s:
                errors.append(f"[parent-cycle] {s}: is its own parent")

    # ---- orphan PDFs --------------------------------------------------------
    referenced_pdfs = set()
    for f in paper_files:
        m = re.search(r"^pdf:\s*(.*)$", frontmatter(read(f)), re.M)
        if m:
            referenced_pdfs.add(os.path.basename(m.group(1).strip().strip('"')))
    for p in glob.glob(os.path.join(VAULT, "pdf", "*.pdf")):
        if os.path.basename(p) not in referenced_pdfs:
            warns.append(f"[orphan-pdf] pdf/{os.path.basename(p)}: no paper note points to it")

    # ---- controlled vocabulary (_vocab.md is the single home of every enum) ---
    vocab = load_vocab()
    note_dirs = {"paper": ["papers", "influences"], "idea": ["ideas"], "method": ["methods"]}
    for kind, dirs in note_dirs.items():
        for d in dirs:
            for f in glob.glob(os.path.join(VAULT, d, "*.md")):
                s, fmt = os.path.basename(f)[:-3], frontmatter(read(f))
                for field, allowed in vocab["fields"].get(kind, {}).items():
                    m = re.search(rf"^{re.escape(field)}:[ \t]*([^#\n]*)", fmt, re.M)
                    val = m.group(1).strip().strip("\"'") if m else ""
                    if val and val not in allowed:
                        warns.append(f"[vocab] {s}: {field}: `{val}` not in _vocab.md")
                if kind == "paper":
                    for field in ("scenario", "benchmarks"):
                        for tok in fm_list(fmt, field):
                            if tok not in vocab[field]:
                                warns.append(f"[vocab] {s}: {field} token `{tok}` not in _vocab.md")

    # ---- meta: do the docs/skills match the repository? ---------------------
    errors.extend(meta_checks())

    # ---- report -------------------------------------------------------------
    def block(title, items, cap=None):
        print(f"\n=== {title} ({len(items)}) ===")
        for x in (items[:cap] if cap else items):
            print(f"  {x}")
        if cap and len(items) > cap:
            print(f"  ... +{len(items) - cap} more")

    print(f"integrity: {len(ideas)} ideas, {len(papers)} papers, {len(methods)} methods, "
          f"{len(infl)} influences")
    block("ERRORS — real bugs", errors)
    block("WARNINGS — smells to eyeball", warns, cap=60)
    # infos: summarize, don't spam
    from collections import Counter
    kinds = Counter(re.match(r"\[([^\]]+)\]", i).group(1) for i in infos)
    print(f"\n=== INFO (counts only) ===")
    for k, c in kinds.most_common():
        print(f"  {c}  {k}")
    print(f"\nsummary: {len(errors)} errors, {len(warns)} warnings")
    if strict and errors:
        sys.exit(1)


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Mechanical structural-integrity checks for the vault.

	The judgment-heavy work (idea merges, author-spelling merges, extraction
	spot-audits) stays in the vault-audit skill; this script is the deterministic
	pass it — and end_of_wave.py — run first, so nobody re-derives these checks by
	hand each time. Four groups: edges (papers/ + influences/), ideas, metadata
	and controlled vocabulary (every enumerated frontmatter value and
	scenario/benchmark token must be in _vocab.md, the single home of those
	values), and meta (the process layer — PROJECT.md, skills, agents, templates
	— must match the repo: no absolute paths, no references to missing scripts or
	reference files, every skill listed in PROJECT.md and linked into .claude/).

	python3 _scripts/check_integrity.py # full report
	python3 _scripts/check_integrity.py --strict # exit 1 if any ERROR found

	Read-only. Errors are real bugs; warnings are smells to eyeball. Info lines
	(to-read danglers, deliberate origin-less ideas) are counts, not problems.
	"""
	import glob
	import os
	import re
	import sys

	VAULT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
	STANCE = ("first-mention", "argues-for", "argues-against", "nuances", "tests")
	COND_EDGES = ("argues-for", "argues-against", "nuances") # must carry a (condition)
	LINEAGE = ("variant-of", "refines", "combines")
	PAPER_SHAPED = re.compile(r"^[a-z][a-z-]*\d{4}") # author+year slug, e.g. rebuffi2017-icarl


	def read(p):
	return open(p, encoding="utf-8").read()


	def slugset(d):
	return {os.path.basename(f)[:-3] for f in glob.glob(os.path.join(VAULT, d, "*.md"))}


	def strip_code(t):
	"""Drop fenced blocks, inline-code spans, and HTML comments — links there are
	examples or batch-mode edges held back for the consolidator, not live edges."""
	t = re.sub(r"<!--.*?-->", "", t, flags=re.S)
	t = re.sub(r"```.*?```", "", t, flags=re.S)
	return re.sub(r"`[^`]*`", "", t)


	def frontmatter(t):
	m = re.match(r"^---\n(.*?)\n---", t, re.S)
	return m.group(1) if m else ""


	def fm_list(fmt, field):
	m = re.search(rf"^{field}:\s\[(.?)\]", fmt, re.M)
	return [x.strip().strip("\"'") for x in m.group(1).split(",") if x.strip()] if m else []


	def load_vocab():
	"""Parse _vocab.md: scenario table, benchmark token list, constrained-fields table."""
	v = read(os.path.join(VAULT, "_vocab.md"))

	def section(title):
	m = re.search(rf"^## {re.escape(title)}\n(.*?)(?=^## \|\Z)", v, re.S \| re.M)
	return m.group(1) if m else ""

	scen = set(re.findall(r"^\\| `([^`]+)` \\|", section("`scenario` tokens"), re.M))
	bench = {t.strip() for ln in section("`benchmarks` tokens").splitlines() if "·" in ln
	for t in ln.split("·") if t.strip()}
	fields = {}
	for kind, field, vals in re.findall(r"^\\| (paper\|idea\|method) \\| `([^`]+)` \\| (.*?) \\|$",
	section("Other constrained fields"), re.M):
	fields.setdefault(kind, {})[field] = set(re.findall(r"`([^`]+)`", vals))
	return {"scenario": scen, "benchmarks": bench, "fields": fields}


	def meta_checks():
	"""The process layer (PROJECT.md, skills, agents, templates) must match the repo:
	no absolute paths, every referenced script/reference file exists, every skill is
	listed in PROJECT.md and linked into .claude/. These drift silently otherwise."""
	errs = []
	skill_dirs = sorted(os.path.basename(d.rstrip("/")) for d in glob.glob(os.path.join(VAULT, "skills", "*/")))
	agent_files = sorted(os.path.basename(a) for a in glob.glob(os.path.join(VAULT, "agents", "*.md")))
	process_docs = (glob.glob(os.path.join(VAULT, "skills", "*", ".md"), recursive=True)
	+ [os.path.join(VAULT, "agents", a) for a in agent_files])
	docs = process_docs + [os.path.join(VAULT, "PROJECT.md"), os.path.join(VAULT, "_vocab.md")] \
	+ glob.glob(os.path.join(VAULT, "_templates", "*.md"))
	script_dirs = {"_scripts": os.path.join(VAULT, "_scripts"),
	"_blog/scripts": os.path.join(VAULT, "_blog", "scripts")}
	ref_re = re.compile(r"(?:(_blog/scripts\|_scripts)/)?\b((?:make\|check\|fetch\|suggest\|end)_[a-z_]+\.py\|link_skills\.sh)\b")
	for f in docs:
	rel, t = os.path.relpath(f, VAULT), read(f)
	if f in process_docs:
	for m in re.finditer(r"(?<![\w.~])/(?:Users\|home)/[^\s`'\")]+", t):
	errs.append(f"[meta-abs-path] {rel}: absolute path `{m.group(0)}` — use vault-relative paths")
	for m in re.finditer(r"\breferences/[\w.-]+\.md\b", t):
	if not os.path.exists(os.path.join(os.path.dirname(f), m.group(0))) and \
	not glob.glob(os.path.join(VAULT, "skills", "*", m.group(0))):
	errs.append(f"[meta-missing-ref] {rel}: `{m.group(0)}` does not exist")
	for m in ref_re.finditer(t):
	where = [script_dirs[m.group(1)]] if m.group(1) else list(script_dirs.values())
	if not any(os.path.exists(os.path.join(d, m.group(2))) for d in where):
	errs.append(f"[meta-missing-script] {rel}: `{m.group(0)}` does not exist")
	proj = read(os.path.join(VAULT, "PROJECT.md"))
	listed = set(re.findall(r"^- `/([a-z0-9-]+)`", proj, re.M))
	for s in skill_dirs:
	if s not in listed:
	errs.append(f"[meta-skill-unlisted] skills/{s} is not listed in PROJECT.md ## Skills")
	link = os.path.join(VAULT, ".claude", "skills", s)
	if os.path.realpath(link) != os.path.realpath(os.path.join(VAULT, "skills", s)):
	errs.append(f"[meta-skill-unlinked] .claude/skills/{s} missing or wrong — run bash _scripts/link_skills.sh")
	for s in sorted(listed - set(skill_dirs)):
	errs.append(f"[meta-skill-missing] PROJECT.md lists /{s} but skills/{s} does not exist")
	for a in agent_files:
	link = os.path.join(VAULT, ".claude", "agents", a)
	if os.path.realpath(link) != os.path.realpath(os.path.join(VAULT, "agents", a)):
	errs.append(f"[meta-agent-unlinked] .claude/agents/{a} missing or wrong — run bash _scripts/link_skills.sh")
	return errs


	def main():
	strict = "--strict" in sys.argv
	ideas = slugset("ideas")
	papers = slugset("papers")
	methods = slugset("methods")
	infl = slugset("influences")
	concepts = slugset("concepts")
	authors = slugset("authors")
	notes = ideas \| papers \| methods \| infl \| concepts \| authors
	paper_files = glob.glob(os.path.join(VAULT, "papers", "*.md")) + \
	glob.glob(os.path.join(VAULT, "influences", "*.md"))

	errors, warns, infos = [], [], []

	# ---- edge-level checks over papers/ + influences/ -----------------------
	fm_holders = {} # idea -> set(papers holding first-mention)
	incoming = set() # ideas that any stance edge points at
	for f in paper_files:
	s = os.path.basename(f)[:-3]
	body = strip_code(read(f))
	edge_lines = [ln for ln in body.splitlines()
	if re.match(rf"^\s*({'\|'.join(STANCE + ('builds-on',) + LINEAGE)})::", ln)]
	n_edges = 0
	for ln in edge_lines:
	kind = ln.strip().split("::", 1)[0]
	tgt = re.search(r"\[\[([^\]]+)\]\]", ln)
	if not tgt:
	errors.append(f"[malformed-edge] {s}: `{ln.strip()[:70]}` has no [[link]]")
	continue
	n_edges += 1
	t = tgt.group(1)
	if kind in STANCE:
	if t not in notes:
	errors.append(f"[dangling-stance] {s}: {kind}:: [[{t}]] — no such note")
	elif t not in ideas:
	errors.append(f"[stance-not-idea] {s}: {kind}:: [[{t}]] targets a "
	f"{'method' if t in methods else 'concept' if t in concepts else 'paper/author'}, not an idea")
	else:
	if kind == "first-mention":
	fm_holders.setdefault(t, set()).add(s)
	incoming.add(t)
	if kind in COND_EDGES and "(" not in ln.split("]]", 1)[1]:
	warns.append(f"[edge-no-condition] {s}: {kind}:: [[{t}]] — no (condition)")
	elif kind == "builds-on":
	if t not in notes:
	infos.append(f"[to-read] {s} builds-on [[{t}]]")
	elif kind in LINEAGE: # in methods/, but tolerate here
	if t not in notes and PAPER_SHAPED.match(t):
	errors.append(f"[lineage-paper-shaped] {s}: {kind}:: [[{t}]] — paper-shaped, inflates to-read")

	if s in papers and n_edges == 0:
	warns.append(f"[zero-edge-paper] {s}: no stance/first-mention/builds-on edge "
	f"— scope smell (influence candidate?)")

	# metadata gaps (papers only; influences are exempt from scenario/venue)
	if s in papers:
	fmt = frontmatter(read(f))
	ptype = (re.search(r"^type:\s(.)$", fmt, re.M) or [None, ""])
	ptype = ptype.group(1).strip().strip('"') if hasattr(ptype, "group") else ""
	# scenario is only expected of papers tied to a concrete setting;
	# surveys/position/theory/book/dataset legitimately have none.
	no_scenario_ok = ptype in ("survey", "position", "theory", "book", "dataset")
	for field in ("venue", "status", "year", "citekey", "scenario"):
	if field == "scenario" and no_scenario_ok:
	continue
	m = re.search(rf"^{field}:\s(.)$", fmt, re.M)
	val = (m.group(1).strip() if m else "").strip('"[] ')
	if not val:
	warns.append(f"[metadata-gap] {s}: empty `{field}`" + (f" (type: {ptype})" if ptype else ""))
	pdf = re.search(r"^pdf:\s(.)$", fmt, re.M)
	if pdf:
	rel = pdf.group(1).strip().strip('"')
	if rel and not os.path.exists(os.path.join(VAULT, rel)):
	errors.append(f"[pdf-missing] {s}: pdf: {rel} does not exist")

	# ---- method lineage checks ---------------------------------------------
	for f in glob.glob(os.path.join(VAULT, "methods", "*.md")):
	s = os.path.basename(f)[:-3]
	body = strip_code(read(f))
	for kind in LINEAGE:
	for mm in re.finditer(rf"(?<![a-z]){kind}::\s*\[\[([^\]]+)\]\]", body):
	t = mm.group(1)
	if t not in notes and PAPER_SHAPED.match(t):
	errors.append(f"[lineage-paper-shaped] {s}: {kind}:: [[{t}]] — paper-shaped slug")

	# ---- idea-level checks --------------------------------------------------
	for f in glob.glob(os.path.join(VAULT, "ideas", "*.md")):
	s = os.path.basename(f)[:-3]
	t = read(f)
	holders = fm_holders.get(s, set())
	if not holders:
	infos.append(f"[no-first-mention] {s}")
	elif len(holders) >= 2:
	warns.append(f"[multi-first-mention] {s}: {sorted(holders)} — legitimate only if "
	f"the First-mention section records a concurrent/adjudicated split")
	if s not in incoming and not holders:
	warns.append(f"[orphan-idea] {s}: no paper edge points to it")
	# stale first-mention prose: names a paper that is not a current holder
	m = re.search(r"## First mention\n(.*?)(\n## \|\Z)", t, re.S)
	if m and holders:
	for mm in re.finditer(r"[Ff]irst[- ]ment\w*\s+(?:in\|by)\s+\[\[([^\]]+)\]\]",
	strip_code(m.group(1))):
	if mm.group(1) not in holders:
	warns.append(f"[stale-fm-prose] {s}: prose credits [[{mm.group(1)}]] but "
	f"first-mention edge is held by {sorted(holders)}")
	# parent resolution + self-cycle
	pm = re.search(r"^parent:\s*\"?\[\[([^\]]+)\]\]", frontmatter(t), re.M)
	if pm:
	if pm.group(1) not in ideas:
	errors.append(f"[bad-parent] {s}: parent [[{pm.group(1)}]] is not an idea note")
	elif pm.group(1) == s:
	errors.append(f"[parent-cycle] {s}: is its own parent")

	# ---- orphan PDFs --------------------------------------------------------
	referenced_pdfs = set()
	for f in paper_files:
	m = re.search(r"^pdf:\s(.)$", frontmatter(read(f)), re.M)
	if m:
	referenced_pdfs.add(os.path.basename(m.group(1).strip().strip('"')))
	for p in glob.glob(os.path.join(VAULT, "pdf", "*.pdf")):
	if os.path.basename(p) not in referenced_pdfs:
	warns.append(f"[orphan-pdf] pdf/{os.path.basename(p)}: no paper note points to it")

	# ---- controlled vocabulary (_vocab.md is the single home of every enum) ---
	vocab = load_vocab()
	note_dirs = {"paper": ["papers", "influences"], "idea": ["ideas"], "method": ["methods"]}
	for kind, dirs in note_dirs.items():
	for d in dirs:
	for f in glob.glob(os.path.join(VAULT, d, "*.md")):
	s, fmt = os.path.basename(f)[:-3], frontmatter(read(f))
	for field, allowed in vocab["fields"].get(kind, {}).items():
	m = re.search(rf"^{re.escape(field)}:[ \t]([^#\n])", fmt, re.M)
	val = m.group(1).strip().strip("\"'") if m else ""
	if val and val not in allowed:
	warns.append(f"[vocab] {s}: {field}: `{val}` not in _vocab.md")
	if kind == "paper":
	for field in ("scenario", "benchmarks"):
	for tok in fm_list(fmt, field):
	if tok not in vocab[field]:
	warns.append(f"[vocab] {s}: {field} token `{tok}` not in _vocab.md")

	# ---- meta: do the docs/skills match the repository? ---------------------
	errors.extend(meta_checks())

	# ---- report -------------------------------------------------------------
	def block(title, items, cap=None):
	print(f"\n=== {title} ({len(items)}) ===")
	for x in (items[:cap] if cap else items):
	print(f" {x}")
	if cap and len(items) > cap:
	print(f" ... +{len(items) - cap} more")

	print(f"integrity: {len(ideas)} ideas, {len(papers)} papers, {len(methods)} methods, "
	f"{len(infl)} influences")
	block("ERRORS — real bugs", errors)
	block("WARNINGS — smells to eyeball", warns, cap=60)
	# infos: summarize, don't spam
	from collections import Counter
	kinds = Counter(re.match(r"\[([^\]]+)\]", i).group(1) for i in infos)
	print(f"\n=== INFO (counts only) ===")
	for k, c in kinds.most_common():
	print(f" {c} {k}")
	print(f"\nsummary: {len(errors)} errors, {len(warns)} warnings")
	if strict and errors:
	sys.exit(1)


	if __name__ == "__main__":
	main()