@appchy/jarvis 0.1.36 → 0.1.39

package/harness/harness/lint.py

@@ -0,0 +1,505 @@
+import json
+import re
+import sys
+from pathlib import Path
+
+from .tree import (
+    EPIC_TASK_FLOOR,
+    HANDOFF_CAP,
+    PRODUCT_STATES,
+    ACTIVE,
+    TASK_FILES_OK,
+    TASK_REGION_CAP,
+)
+from .frontmatter import as_list, parse_frontmatter, split_frontmatter
+from .model import locate_feature, scan, scan_features
+from .registry import code_vocabulary, locate_domain
+
+#: The MCP server this repo names as its graph engine, bound by `config.apply`.
+#: `None` is the shipped default and a fully supported mode — the planning loop
+#: degrades to a wide grep sweep and the plan says so.
+GRAPH_MCP = None
+
+
+def _research_dir_warnings(d: Path, label: str) -> list:
+    # The summary is canonically 00-report.md, but any 00-*.md leading file
+    # (00-synthesis.md, 00-analysis.md, …) counts as the distilled entry point.
+    if d.is_dir() and not any(d.glob("00-*.md")):
+        return [f"{label}: research dir has no 00-*.md summary (≤30 lines)"]
+    return []
+def _task_lint(t: "Task") -> list:
+    """Drift warnings for a single task folder. Completed tasks are frozen
+    (cleaned at archive) so they're skipped — the lint guards ACTIVE work."""
+    if t.status == "complete":
+        return []
+    warns = []
+    label = t.name
+    files = sorted(p.name for p in t.folder.glob("*.md"))
+    subdirs = [p.name for p in t.folder.iterdir() if p.is_dir()]
+
+    if t.status in (None, "queue"):
+        # A queued / backlog task is a brief and nothing else.
+        extra = [f for f in files if f != "task.md"] + subdirs
+        if extra:
+            warns.append(
+                f"{label}: queue/backlog task carries {', '.join(extra)} — "
+                f"plan at pickup; keep only task.md")
+        return warns
+
+    # in-progress: recognised spine + conditional extras only.
+    for f in files:
+        if f in TASK_FILES_OK:
+            continue
+        if f in ("state.md", "stories.md"):
+            warns.append(f"{label}: {f} is retired — fold into plan.md "
+                         f"(## As-found) / task.md acceptance criteria")
+        elif f == "decisions.md":
+            warns.append(f"{label}: decisions.md is retired — small calls go in "
+                         f"handoff.md, durable ones in the domain or system that "
+                         f"owns them (`jarvis work where <id>` resolves it)")
+        else:
+            warns.append(f"{label}: unrecognised file {f} "
+                         f"(suffix variants like plan-*.md are not allowed)")
+    for sub in subdirs:
+        if sub != "research":
+            warns.append(f"{label}: unexpected subdir {sub}/")
+    warns += _research_dir_warnings(t.folder / "research", label)
+
+    # Approach must hand over to plan.md once a plan exists.
+    if "plan.md" in files:
+        body = split_frontmatter((t.folder / "task.md").read_text())[1]
+        m = re.search(r"^##\s+Approach\s*\n(.*?)(?=^##\s|\Z)", body,
+                      re.MULTILINE | re.DOTALL)
+        if m and len(m.group(1).strip()) > len("Approach → plan.md") + 4:
+            warns.append(f"{label}: task.md still has an ## Approach body but a "
+                         f"plan.md exists — collapse it to 'Approach → plan.md'")
+
+    # Handoff is the CROSS-CONVERSATION artifact, not a per-task requirement: an absent or untouched
+    # scaffold mid-work is fine (a task can complete in one session without a filled handoff). Only lint
+    # the cap, and only if someone actually wrote one (the scaffold itself is short).
+    handoff = t.folder / "handoff.md"
+    if handoff.is_file():
+        n = len(handoff.read_text().splitlines())
+        if n > HANDOFF_CAP:
+            warns.append(f"{label}: handoff.md is {n} lines (>{HANDOFF_CAP}) — "
+                         f"prune-on-absorb: durable facts to their owning domain "
+                         f"or system, then drop the log tail")
+    return warns
+def _shape_lint(root: Path, s: dict) -> list:
+    """The rules the version/epic/task reshape added. Each one names a measured
+    failure, not a preference — see `tree.py` for the numbers.
+
+    A fifth rule, the queued brief's 30-line budget, was DELETED with
+    `TASK_LINE_BUDGET` (founder call): length was never the failure, a brief that
+    becomes a competing plan is, and the artifact lint already catches that."""
+    warns = []
+    active = [t for v in s["versions"] for t in v.all_tasks()
+              if t.status in ACTIVE] + s["backlog"]
+
+    # There is deliberately NO length lint on a queued task.md. It used to warn
+    # over 30 lines; the founder removed it, and the reasoning holds: the cost a
+    # brief actually imposes is a session starting cold and re-deriving what
+    # somebody already knew. Context that survives the gap between sessions is
+    # worth more than a short file, and trimming to a number throws away exactly
+    # the findings, dead ends and warnings the next session needs. Length was
+    # never the failure — a brief that quietly becomes a competing PLAN is, and
+    # the artifact lint below already catches that by looking for the files.
+
+    # 2 — a task spanning too many code regions is a version wearing a task
+    #     costume: it cannot land as one coherent end-to-end slice.
+    for t in active:
+        if len(t.code) >= TASK_REGION_CAP:
+            warns.append(f"{t.name}: spans {len(t.code)} code regions "
+                         f"({', '.join(t.code)}) — a task is ONE goal; at "
+                         f"{TASK_REGION_CAP}+ it is an epic, not a task")
+
+    # 3 — an epic with no `covers:` moves no stated acceptance criterion, so
+    #     nobody can tell when it is finished. Released epics have no epic.md
+    #     left to carry one, and are history — skip them.
+    #
+    #     ONE class is exempt, and it is a real one rather than an escape hatch:
+    #     an epic whose `owner:` is an ORG-DOMAIN. A domain hosts rules, not
+    #     `AC-nn`, so there is no criterion for such an epic to point at and the
+    #     warning could only ever be answered by naming criteria it does not
+    #     move. Naming the domain IS the stated finish line, and it is checked —
+    #     an `owner:` that resolves to nothing exempts nothing, so the field
+    #     cannot be used to silence this by writing anything in it. An epic
+    #     owned by a FEATURE is not exempt: it has criteria available.
+    for e in [e for v in s["versions"] for e in v.epics] + s["backlog_epics"]:
+        if not e.planned:
+            continue
+        if not e.covers:
+            if e.owner and locate_domain(root, e.owner):
+                continue
+            warns.append(f"epic {e.name}: no covers: — name the feature "
+                         f"acceptance criteria it moves (`<feature>/AC-nn`), or "
+                         f"set `owner:` to the org-domain it answers to if it "
+                         f"moves no product criterion")
+            continue
+        for c in e.covers:
+            feature = c.split("/")[0]
+            if "/" not in c:
+                warns.append(f"epic {e.name}: covers '{c}' is not "
+                             f"feature-qualified — an epic spans features")
+            elif not locate_feature(root, feature):
+                warns.append(f"epic {e.name}: covers '{c}' names no "
+                             f"work/product/{feature}.md")
+
+    # 3a — a THIN epic: fewer than EPIC_TASK_FLOOR tasks. The epic tier exists so
+    #      the design happens ONCE for a whole goal; at one or two tasks there is
+    #      no "whole goal", and the board fills with topics wearing epic costumes.
+    #      Skip a DONE epic (`<v>/complete/`) — it is history, and an epic that
+    #      shipped two tasks was never the failure this catches.
+    for e in [e for v in s["versions"] for e in v.epics] + s["backlog_epics"]:
+        if not e.planned or e.done_tier:
+            continue
+        n = len(e.all_tasks())
+        if n < EPIC_TASK_FLOOR:
+            warns.append(
+                f"epic {e.name}: {n} task(s) — an epic is the goal you plan "
+                f"TOGETHER, and under {EPIC_TASK_FLOOR} there is no together. "
+                f"Fold {'it' if n == 1 else 'them'} into an existing epic that "
+                f"fits, unless §Plan names the slices not yet cut")
+
+    # 3b — a task inside an epic carrying its own plan.md. The design is settled
+    #      ONCE in `epic.md` §Plan; a second design doc per task is the
+    #      re-analyse-per-task cost the tier exists to remove. Warn, don't block:
+    #      sometimes pickup genuinely surfaces a call the epic plan missed — but
+    #      then the answer belongs UP in the epic, where the siblings can read it.
+    for e in [e for v in s["versions"] for e in v.epics] + s["backlog_epics"]:
+        if not e.planned:
+            continue
+        planned = [t.name for t in e.all_tasks()
+                   if t.status != "complete" and (t.folder / "plan.md").is_file()]
+        if planned:
+            warns.append(f"epic {e.name}: {len(planned)} task(s) carry their own "
+                         f"plan.md ({', '.join(planned)}) — the design belongs in "
+                         f"epic.md §Plan, written once; fold it up unless it is "
+                         f"genuinely task-local")
+
+    # 4 — a version with no release outcome is a container, not a release.
+    for v in s["versions"]:
+        if not v.outcome:
+            warns.append(f"version {v.name}: no outcome: — state in one line what "
+                         f"a user can newly DO when it ships")
+
+    # 5 — a loose task in a version that HAS adopted epics. Scoped that way on
+    #     purpose: a fully-flat version predates the tier and is grandfathered
+    #     (v20/v24 held live work at the reshape), while a MIXED one is a real
+    #     straggler. Derived from the tree, so there is no exemption flag to sync.
+    for v in s["versions"]:
+        if not v.epics:
+            continue
+        for t in v.loose_tasks():
+            if t.status in ACTIVE:
+                warns.append(f"{t.name}: loose in version {v.name}, which uses "
+                             f"epics — every task belongs to one "
+                             f"(`jarvis work place {t.name} --version {v.name} "
+                             f"--epic <e>`)")
+    return warns
+def _feature_id_warnings(feature_md: Path, flabel: str) -> list:
+    """A feature's B-/AC- ids are the trace unit (tasks + tests cite them), so
+    each must be DEFINED at most once. Definition lines look like `- AC-01:` or
+    `- [ ] AC-01:` (references like `→ AC-01` don't count). Also flag a
+    `shipped` feature that still has unchecked `- [ ] AC-` boxes — shipped means
+    every in-scope criterion has passing evidence."""
+    text = feature_md.read_text()
+    warns = []
+    seen = set()
+    # One pass, one regex. This used to run its own `re.findall` for duplicates and
+    # its own `re.search` for the shipped check — three copies of the line format in
+    # a file whose own docstring claims a single owner, which is the drift class it
+    # exists to catch.
+    lines = _id_lines(text)
+    for _, id_, _level in lines:
+        if id_ in seen:
+            warns.append(f"{flabel}: duplicate id {id_} — B-/AC- ids "
+                         f"are defined once (the trace unit must stay stable)")
+        seen.add(id_)
+    state = parse_frontmatter(text).get("state")
+    if state == "shipped" and any(not checked and id_.startswith("AC-")
+                                  for checked, id_, _ in lines):
+        warns.append(f"{flabel}: state is 'shipped' but has unchecked "
+                     f"AC- criteria — shipped needs every in-scope AC met")
+    # A criterion that declares no level cannot be checked against the test that
+    # claims it, and silently counts as run-provable — so an unannotated one is
+    # reported, not assumed.
+    missing, unknown = [], []
+    for ac, (level, built) in feature_ac_levels(text).items():
+        if level is None:
+            # Only a BUILT criterion owes a level. A level on behaviour nobody
+            # has written is a prediction, so the 124 unticked ones are
+            # deliberately unannotated — and warning about them made this fire
+            # 11 times a run against a decision the same phase took. Measured
+            # when it was narrowed: 0 built unlevelled, 124 unbuilt. It stays
+            # useful because it now catches the real gap — a box ticked with
+            # nothing saying what could ever settle it — and `coverage` still
+            # reports the unbuilt count, so nothing went invisible.
+            if built:
+                missing.append(ac)
+        elif level not in AC_LEVELS:
+            unknown.append(f"{ac} ({level})")
+    if unknown:
+        warns.append(f"{flabel}: unknown level on {', '.join(sorted(unknown))} — "
+                     f"one of {', '.join(AC_LEVELS)}")
+    if missing:
+        warns.append(f"{flabel}: {len(missing)} criteria declare no level — "
+                     f"{', '.join(sorted(missing)[:4])}"
+                     f"{' …' if len(missing) > 4 else ''}")
+    return warns
+def _product_lint(root: Path) -> list:
+    """Drift + format guards for work/product/: every `<feature>.md` declares
+    `type: feature` and a `state:` in PRODUCT_STATES. There is no app tier and
+    no folder tier — a repo is ONE product, so a feature is a FILE directly
+    under `product/` and its name is its whole address. A leftover DIRECTORY is
+    itself a finding: the flatten (`AC-20`) made the path permanent, so a folder
+    reappearing here means someone re-created the tier it removed. Feature
+    B-/AC- id bookkeeping is checked via `_feature_id_warnings`."""
+    warns = []
+    product_dir = root / "product"
+    if not product_dir.is_dir():
+        return warns
+    for stray in sorted(p for p in product_dir.iterdir()
+                        if p.is_dir() and p.name != "wireframes"):
+        warns.append(f"product/{stray.name}/ is a DIRECTORY — a feature is "
+                     f"`product/{stray.name}.md`; a sibling asset goes in "
+                     f"`product/wireframes/{stray.name}/`, never beside the spec")
+    for feature_md in scan_features(root):
+        flabel = f"product/{feature_md.name}"
+        ffm = parse_frontmatter(feature_md.read_text())
+        if ffm.get("type") != "feature":
+            warns.append(f"{flabel}: frontmatter type must be 'feature'")
+        if ffm.get("state") not in PRODUCT_STATES:
+            warns.append(f"{flabel}: state must be one of "
+                         f"{', '.join(PRODUCT_STATES)} (got '{ffm.get('state')}')")
+        for dep in as_list(ffm.get("depends_on")):
+            if "/" in dep:
+                warns.append(f"{flabel}: depends_on '{dep}' is "
+                             f"app-qualified — there is no app tier, name the "
+                             f"feature alone")
+                continue
+            if not locate_feature(root, dep):
+                warns.append(f"{flabel}: depends_on '{dep}' does not "
+                             f"match any work/product/{dep}.md")
+        warns += _feature_id_warnings(feature_md, flabel)
+    return warns
+def _owner_ref_lint(root: Path, s: dict) -> list:
+    """Warn (never block) when a task's `owner:` doesn't resolve. An owner is a
+    product reference (a bare `<feature>`) OR a bare org-domain
+    (`operations`, `quality`, …) — the latter is what retired the `product: infra`
+    sentinel: infrastructure is a domain, not a fake app. Existence is a lint
+    concern, not a write-time gate, so a task can name a feature before it is
+    scaffolded."""
+    warns = []
+    for t in [task for v in s["versions"] for task in v.all_tasks()] + s["backlog"]:
+        # The rename warning is ACTIVE work only — a completed task's frontmatter
+        # is frozen history, and 90 lines of migration noise makes `list` unreadable.
+        # `migrate-owner` rewrites every task regardless of bucket.
+        if t.legacy_product and t.status in (None,) + ACTIVE:
+            warns.append(f"{t.name}: `product:` is the old spelling — rename the "
+                         f"key to `owner:` (`jarvis work migrate-owner` does it)")
+        value = t.owner
+        if not value:
+            continue  # empty is _graph_lint's warning, and only for active work
+        if "/" in value:
+            warns.append(f"{t.name}: owner: '{value}' is app-qualified — there is "
+                         f"no app tier, name the feature or domain alone")
+            continue
+        found = locate_feature(root, value) or locate_domain(root, value)
+        if not found:
+            warns.append(f"{t.name}: owner: '{value}' matches no "
+                         f"work/product/{value}.md and no work/{value}/README.md")
+
+    # An EPIC's `owner:` is optional, but a dangling one has to say so — it is
+    # what exempts a covers-less epic from rule 3 above, so a typo would silently
+    # buy nothing and report only the confusing half ("no covers:") with no clue
+    # that the exemption was reaching for a domain that is not there.
+    for e in [e for v in s["versions"] for e in v.epics] + s["backlog_epics"]:
+        if not e.planned or not e.owner:
+            continue
+        if not (locate_feature(root, e.owner) or locate_domain(root, e.owner)):
+            warns.append(f"epic {e.name}: owner: '{e.owner}' matches no "
+                         f"work/product/{e.owner}.md and no "
+                         f"work/{e.owner}/README.md")
+    return warns
+#: The four levels a criterion can declare — the evidence that settles it.
+#: `unit` and `integration` are both a vitest run and no lint tells them apart:
+#: the distinction is real to a reader and not derivable from a run, so it is
+#: documented rather than checked.
+AC_LEVELS = ("e2e", "integration", "unit", "eyes-on")
+
+#: THE one owner of the criterion-line format — `- [x] AC-03 (unit): …`, with the
+#: level optional so an unannotated feature file still parses. Everything that
+#: reads criteria goes through this, so the graph, coverage and shipped-state
+#: lints cannot drift apart on what a criterion line looks like.
+#: THE one owner of the B-/AC- line format — `- [x] AC-03 (unit): …`. The checkbox
+#: is optional (a `B-nn` never has one); the level is optional TO PARSE so a
+#: missing one can be REPORTED rather than silently read as no criterion at all. A
+#: reference like `→ AC-01` has no leading dash-id-colon and never matches.
+#:
+#: It covers `B-nn` as well as `AC-nn` because duplicate-id detection is about the
+#: trace unit, and a `B-nn` is one. Four accessors below read this and nothing else
+#: — the id lint, the AC-id set, the checked set and the level map — so a change to
+#: what a criterion line looks like cannot land in three of the four.
+_ID_LINE = re.compile(
+    r"^-\s+(?:\[(?P<box>[ xX])\]\s+)?(?P<id>(?:B|AC)-\d+)"
+    r"(?:\s+\((?P<level>[a-z0-9-]+)\))?:",
+    re.MULTILINE,
+)
+
+
+def _id_lines(text: str) -> list:
+    """`[(checked, id, level), …]` for one feature body — level is `None` when the
+    line declares none, so "unannotated" stays distinguishable from a level that
+    happens to be empty."""
+    return [((m["box"] or "").lower() == "x", m["id"], m["level"])
+            for m in _ID_LINE.finditer(split_frontmatter(text)[1])]
+
+
+def _feature_ac_ids(text: str) -> set:
+    """The `AC-nn` ids a feature declares."""
+    return {id_ for _, id_, _ in _id_lines(text) if id_.startswith("AC-")}
+
+
+def _feature_ac_checked(text: str) -> set:
+    """The `AC-nn` ids a feature has TICKED — a claim, which `align` then compares
+    against the bindings a run actually produced."""
+    return {id_ for checked, id_, _ in _id_lines(text)
+            if checked and id_.startswith("AC-")}
+
+
+def feature_ac_levels(text: str) -> dict:
+    """`{'AC-03': ('unit', True)}` — each criterion's declared level and whether it
+    is ticked as BUILT. The level is `None` until the file is annotated.
+
+    Two axes, never one: the box says the app DOES this, the level says which
+    evidence could ever settle it. An `eyes-on` criterion is not a coverage hole —
+    no run will ever prove it — so the report has to be able to tell the two apart
+    before it divides anything.
+
+    Keyed on `AC-nn` only: a `B-nn` states behaviour and is proved through the
+    criteria beneath it, so it carries no level and belongs in no ratio."""
+    return {id_: (level, checked) for checked, id_, level in _id_lines(text)
+            if id_.startswith("AC-")}
+def _graph_lint(root: Path, s: dict) -> list:
+    """Graph-integrity warnings beyond `_owner_ref_lint`'s owner format/
+    dangling check (the connected product→feature→task graph): every
+    task should link a feature, a task's `covers:` AC ids must exist in that
+    linked feature.md, and a hand-edited `code:` entry must name a region some
+    system owns (write-time enforcement is `cmd_new`'s block; this is the
+    read-time mirror for files touched by hand). Scoped to ACTIVE work only —
+    `complete` tasks (incl. archived, which stay in the `complete` bucket) are
+    frozen history; retrofitting their graph links is a separate task, not lint
+    noise on every `list`."""
+    warns = []
+    vocabulary = code_vocabulary(root)
+    for t in [task for v in s["versions"] for task in v.all_tasks()
+              if task.status in ACTIVE]:
+        value = t.owner
+        if not value:
+            warns.append(f"{t.name}: no owner link (a feature or a domain)")
+        elif t.covers:
+            # An owner is a BARE feature name — there is no app tier, so this
+            # resolves directly. (It read `locate_feature(root, parts[0],
+            # parts[1])` until 2026-08-01: three args into a two-arg function,
+            # left behind by the app-tier flatten and reachable by any task with
+            # both a slash-qualified owner and a covers: list.)
+            fmd = locate_feature(root, value)
+            if fmd:
+                ac_ids = _feature_ac_ids(fmd.read_text())
+                for ac in t.covers:
+                    if ac not in ac_ids:
+                        warns.append(f"{t.name}: covers {ac} not in feature {value}")
+        for c in t.code:
+            if c not in vocabulary:
+                warns.append(f"{t.name}: code '{c}' is owned by no system "
+                             f"(regions come from work/architecture/*.md)")
+    return warns
+def _graph_engine_lint(root: Path) -> list:
+    """`graph.mcp` names a server this repo's own MCP config does not serve.
+
+    The worst of the three states, and the only one that is silent. With no engine
+    the harness says so and the plan degrades honestly; with a working one it maps.
+    With a name nothing answers, every session is told it HAS a map, calls
+    `mcp__<name>__*` tools that do not exist, and nothing explains why — which is
+    precisely the "As-found implying a map you did not get" that `SKILL.md` forbids.
+    Found 2026-08-13 in a repo that had been pointing at a retired engine for days.
+
+    **Only `.mcp.json` is checked, and only when it exists.** A server can also come
+    from user-level config or `--mcp-config`, neither of which this can see — so an
+    absent file is silence, not a warning. Naming what the file DOES serve is what
+    makes the warning actionable rather than an accusation.
+    """
+    if not GRAPH_MCP:
+        return []
+    mcp_json = root.parent / ".mcp.json"
+    if not mcp_json.is_file():
+        return []
+    try:
+        servers = json.loads(mcp_json.read_text()).get("mcpServers", {})
+    except (json.JSONDecodeError, AttributeError):
+        return [".mcp.json is not readable JSON, so `graph.mcp` cannot be checked "
+                "against it"]
+    if not isinstance(servers, dict) or GRAPH_MCP in servers:
+        return []
+    served = ", ".join(sorted(servers)) or "nothing"
+    return [f"graph.mcp names '{GRAPH_MCP}', which .mcp.json does not serve — "
+            f"sessions will be told to call mcp__{GRAPH_MCP}__* tools that do not "
+            f"exist. It serves: {served}. Set graph.mcp to one of those, or to null"]
+
+
+def _coverage_lint(root: Path, s: dict) -> list:
+    """Feature coverage rollup: union `covers:` across a feature's
+    COMPLETED tasks vs its declared `AC-nn` set. Extends `_feature_id_warnings`'
+    shipped-state check with evidence — a `shipped` feature with an AC no
+    completed task covers is a gap, not just an unchecked box."""
+    warns = []
+    product_dir = root / "product"
+    if not product_dir.is_dir():
+        return warns
+
+    covered: dict = {}
+    for t in [task for v in s["versions"] for task in v.all_tasks()] + s["backlog"]:
+        if t.status != "complete" or not t.covers:
+            continue
+        if t.owner:
+            covered.setdefault(t.owner, set()).update(t.covers)
+
+    # A feature IS a file directly under product/ — no app tier, no folder tier.
+    # (This walked `product/<app>/<feature>/` until 2026-08-01, left behind by
+    # the app-tier flatten: it descended one level too far, so it silently
+    # matched nothing and this whole rollup was dead code wearing a passing
+    # test. `scan_features` is now the single owner of that glob, so the next
+    # layout change cannot leave one caller behind.)
+    for feature_md in scan_features(root):
+        text = feature_md.read_text()
+        if parse_frontmatter(text).get("state") != "shipped":
+            continue
+        have = covered.get(feature_md.stem, set())
+        for ac in sorted(_feature_ac_ids(text)):
+            if ac not in have:
+                warns.append(f"feature {feature_md.stem} shipped but {ac} has "
+                             f"no covering completed task")
+    return warns
+def lint_warnings(root: Path) -> list:
+    s = scan(root)
+    warns = []
+    for v in s["versions"]:
+        for t in v.all_tasks():
+            warns += _task_lint(t)
+    for t in s["backlog"]:
+        warns += _task_lint(t)
+    research = root / "research"
+    if research.is_dir():
+        for d in sorted(research.iterdir()):
+            warns += _research_dir_warnings(d, f"research/{d.name}")
+    warns += _product_lint(root)
+    warns += _owner_ref_lint(root, s)
+    warns += _graph_lint(root, s)
+    warns += _graph_engine_lint(root)
+    warns += _coverage_lint(root, s)
+    warns += _shape_lint(root, s)
+    return warns
+def print_lint(root: Path):
+    for w in lint_warnings(root):
+        print(f"  WARN  {w}", file=sys.stderr)