docassert 0.20.1__tar.gz → 0.20.2__tar.gz

{docassert-0.20.1/docassert.egg-info → docassert-0.20.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.20.1
+Version: 0.20.2
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Documentation
 Classifier: Topic :: Text Processing :: Markup :: Markdown

{docassert-0.20.1 → docassert-0.20.2}/docassert/__init__.py

@@ -5,4 +5,4 @@ standard: deterministic structural checks that gate a merge, plus optional
 AI-graded semantic checks that advise.
 """
 
-__version__ = "0.20.1"
+__version__ = "0.20.2"

{docassert-0.20.1 → docassert-0.20.2}/docassert/bridge/board.py

@@ -15,9 +15,7 @@ FIELD_SPECS: dict[str, dict] = {
     "PMO Project": {"dataType": "TEXT"},
 }
 
-_FIELDS_QUERY = """
-query($owner: String!, $number: Int!) {
-  user(login: $owner) {
+_PROJECT_FRAGMENT = """
     projectV2(number: $number) {
       id
       title
@@ -28,8 +26,18 @@ query($owner: String!, $number: Int!) {
         }
       }
     }
-  }
-}
+"""
+
+_FIELDS_QUERY = f"""
+query($owner: String!, $number: Int!) {{
+  user(login: $owner) {{ {_PROJECT_FRAGMENT} }}
+}}
+"""
+
+_FIELDS_QUERY_ORG = f"""
+query($owner: String!, $number: Int!) {{
+  organization(login: $owner) {{ {_PROJECT_FRAGMENT} }}
+}}
 """
 
 
@@ -48,7 +56,23 @@ def create_project(gh: GhRunner, title: str) -> dict:
 
 
 def get_project(gh: GhRunner, owner: str, number: int) -> dict:
-    proj = gh.graphql(_FIELDS_QUERY, owner=owner, number=number)["user"]["projectV2"]
+    """Look the board up under a user owner first, then an organization —
+    GraphQL has no owner-agnostic ProjectV2 lookup, and a login of the wrong
+    type raises NOT_FOUND rather than returning null."""
+    proj = None
+    try:
+        proj = (gh.graphql(_FIELDS_QUERY, owner=owner, number=number)
+                .get("user") or {}).get("projectV2")
+    except GhError:
+        pass
+    if proj is None:
+        try:
+            proj = (gh.graphql(_FIELDS_QUERY_ORG, owner=owner, number=number)
+                    .get("organization") or {}).get("projectV2")
+        except GhError:
+            pass
+    if proj is None:
+        raise GhError(f"no ProjectV2 #{number} owned by '{owner}' (user or organization)")
     fields = {}
     for node in proj["fields"]["nodes"]:
         if not node:

{docassert-0.20.1 → docassert-0.20.2}/docassert/bridge/ops.py

@@ -37,10 +37,16 @@ def _marker_of(issue: dict) -> str | None:
 
 
 def _index(issues: list[dict]) -> dict[str, dict]:
+    """marker -> its authoritative issue. The REST API lists issues newest
+    first, and a converged duplicate is always newer than the issue it lost
+    to — so rank open before closed, then lowest number, or a closed
+    duplicate would shadow the real open issue and report it as done."""
+    def rank(issue: dict) -> tuple:
+        return (issue.get("state") != "open", issue.get("number", 0))
     out: dict[str, dict] = {}
     for i in issues:
         key = _marker_of(i)
-        if key and key not in out:          # first (oldest) wins
+        if key and (key not in out or rank(i) < rank(out[key])):
             out[key] = i
     return out
 

{docassert-0.20.1 → docassert-0.20.2}/docassert/bridge/plan.py

@@ -186,8 +186,11 @@ def plans_by_repo(plan: BridgePlan) -> dict[str, BridgePlan]:
             + " (add `repo: OWNER/NAME` to project.md or pass --repo)")
     groups: dict[str, BridgePlan] = {}
     for proj in plan.projects:
-        groups.setdefault(proj["repo"],
-                          BridgePlan(skipped=plan.skipped)).projects.append(proj)
+        if proj["repo"] not in groups:
+            # Each sub-plan gets its own copy: shared state across repos would
+            # let one repo's run mutate another's, and skip lines print per repo.
+            groups[proj["repo"]] = BridgePlan(skipped=list(plan.skipped))
+        groups[proj["repo"]].projects.append(proj)
     return groups
 
 

{docassert-0.20.1 → docassert-0.20.2}/docassert/cli.py

@@ -54,7 +54,13 @@ def _build_id_index(documents_dir: Path) -> dict[str, list[str]]:
 
 def _validate_one(path: str, id_index: dict) -> list[CheckResult]:
     doc = load(path)
-    kind = doc.kind or "charter"
+    kind = doc.kind or ""
+    if not kind:
+        # Refuse to guess: validating an unkinded document against an arbitrary
+        # kind's criteria would produce misleading failures (or worse, passes).
+        return [CheckResult("kind", False, True,
+                            "document declares no `kind` in its frontmatter",
+                            kind="structural")]
     criteria = config.read_criteria(kind)
     schema = config.read_schema(kind)
 
@@ -237,8 +243,14 @@ def cmd_pages(args: argparse.Namespace) -> int:
         import json as _json
         data = _json.loads(Path(args.execution).read_text())
         for proj in data.get("projects", []):
-            execution[proj["id"]] = {**proj, "scope": data.get("scope"),
-                                     "repo": proj.get("repo") or data.get("repo")}
+            repo = proj.get("repo") or data.get("repo")
+            # Scope findings belong to the repo a project routes to; showing
+            # another repo's strays on this project's page would misattribute.
+            scope = data.get("scope") or {}
+            scoped = {k: [i for i in scope.get(k, [])
+                          if not repo or i.get("repo") in (None, repo)]
+                      for k in ("unverified", "orphaned")}
+            execution[proj["id"]] = {**proj, "scope": scoped, "repo": repo}
 
     def _activity(project_id: str) -> list[dict]:
         """Recent documents/ commits for one project (best-effort, git only)."""
@@ -369,6 +381,10 @@ def cmd_bridge(args: argparse.Namespace) -> int:
                   "(needed for --project-number)", file=sys.stderr)
             return 2
         bgh = gh if isinstance(gh, ghmod.DryRunner) else ghmod.GhRunner(token=token)
+        if not args.project_owner and not repo_plans:
+            print("docassert bridge: --project-number needs --project-owner when "
+                  "no project routes to a repository", file=sys.stderr)
+            return 2
         owner = args.project_owner or next(iter(repo_plans)).split("/")[0]
         board_cfg = {"gh": bgh, "owner": owner,
                      "number": args.project_number, "init": args.init_board}

{docassert-0.20.1 → docassert-0.20.2}/docassert/config.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import json
 import shutil
+from functools import lru_cache
 from importlib.resources import files
 from pathlib import Path
 
@@ -30,8 +31,22 @@ def _resolve(local: Path, packaged_rel: str) -> Path | None:
     return packaged if packaged.is_file() else None
 
 
+# Criteria and schemas are read once per check per document, which multiplies
+# fast on a portfolio (projects × documents × checks). Cache on (path, mtime)
+# so an edit mid-process still invalidates. Cached objects are shared: callers
+# treat them as read-only.
+@lru_cache(maxsize=256)
+def _read_yaml_cached(path_str: str, mtime_ns: int) -> dict:
+    return yaml.safe_load(Path(path_str).read_text(encoding="utf-8")) or {}
+
+
+@lru_cache(maxsize=256)
+def _read_json_cached(path_str: str, mtime_ns: int) -> dict:
+    return json.loads(Path(path_str).read_text(encoding="utf-8"))
+
+
 def _read_yaml(path: Path) -> dict:
-    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    return _read_yaml_cached(str(path), path.stat().st_mtime_ns)
 
 
 # ── criteria ────────────────────────────────────────────────────────────────
@@ -57,7 +72,7 @@ def read_schema(kind: str) -> dict:
     path = _resolve(Path("schema") / f"{kind}.schema.json", f"schema/{kind}.schema.json")
     if path is None:
         raise FileNotFoundError(f"no schema for kind '{kind}'")
-    return json.loads(path.read_text(encoding="utf-8"))
+    return _read_json_cached(str(path), path.stat().st_mtime_ns)
 
 
 # ── consistency config ──────────────────────────────────────────────────────

{docassert-0.20.1 → docassert-0.20.2}/docassert/consistency.py

@@ -3,10 +3,13 @@
 Structural checks are deterministic and blocking:
   - item-id-uniqueness   : IDs unique across the repo (always blocks)
   - referential-integrity: every link target exists (always blocks)
+  - sequence-acyclic     : the `after` digraph has no cycle (always blocks)
   - required-links       : downstream items declare their upstream link
                            (blocks only when the item's doc is approved)
   - coverage             : every parent item has >=1 downstream child
                            (blocks only when the parent's doc is approved)
+  - profile-completeness : enforced projects carry their profile's required
+                           documents (blocks when enforced or profile unknown)
 
 Semantic alignment is AI-graded and advisory (never blocks).
 """
@@ -50,31 +53,40 @@ def check_unique_item_ids(graph) -> CheckResult:
 
 
 def check_sequence_acyclic(graph) -> CheckResult:
-    """The `after` digraph contains no cycle (a cycle is broken sequencing)."""
+    """The `after` digraph contains no cycle (a cycle is broken sequencing).
+
+    Iterative three-color DFS: a dependency chain as long as the item count
+    must not hit the interpreter recursion limit.
+    """
     edges: dict[str, list[str]] = {}
     for item in graph.all_items():
         for target in item.links.get("after", []):
             edges.setdefault(item.id, []).append(target)
-    state: dict[str, int] = {}  # 0 visiting, 1 done
-
-    def visit(node, path):
-        if state.get(node) == 1:
-            return None
-        if state.get(node) == 0:
-            return path[path.index(node):] + [node]
-        state[node] = 0
-        for nxt in edges.get(node, []):
-            cycle = visit(nxt, path + [node])
-            if cycle:
-                return cycle
-        state[node] = 1
-        return None
-
+    WHITE, GRAY, BLACK = 0, 1, 2
+    color: dict[str, int] = {}
     for start in list(edges):
-        cycle = visit(start, [])
-        if cycle:
-            return CheckResult("sequence-acyclic", False, True,
-                               "after-cycle: " + " → ".join(cycle))
+        if color.get(start, WHITE) != WHITE:
+            continue
+        color[start] = GRAY
+        path = [start]
+        stack = [iter(edges.get(start, ()))]
+        while stack:
+            advanced = False
+            for nxt in stack[-1]:
+                c = color.get(nxt, WHITE)
+                if c == GRAY:
+                    cycle = path[path.index(nxt):] + [nxt]
+                    return CheckResult("sequence-acyclic", False, True,
+                                       "after-cycle: " + " → ".join(cycle))
+                if c == WHITE:
+                    color[nxt] = GRAY
+                    path.append(nxt)
+                    stack.append(iter(edges.get(nxt, ())))
+                    advanced = True
+                    break
+            if not advanced:
+                color[path.pop()] = BLACK
+                stack.pop()
     n = sum(len(v) for v in edges.values())
     return CheckResult("sequence-acyclic", True, True,
                        f"{n} after link(s), no cycles.")

{docassert-0.20.1 → docassert-0.20.2}/docassert/profiles.py

@@ -2,8 +2,10 @@
 
 A profile (profiles/<name>.yaml) lists the document kinds a project is expected
 to carry, at two levels:
-  - required    : must be present and complete; a missing one blocks CI once the
-                  project reaches the profile's `enforce_when` lifecycle stage.
+  - required    : must be present and complete; a missing one blocks CI while
+                  the project's status equals the profile's `enforce_when`
+                  stage (deliberately exact: an on-hold or closed project is
+                  not punished for its document set).
   - recommended : surfaced as a gap on the project page, but never blocking.
 
 A project opts in with `profile: <name>` in its project.md. No profile means no

{docassert-0.20.1 → docassert-0.20.2}/docassert/status/__init__.py

@@ -8,6 +8,7 @@ from .derive import (
     build_status,
     completeness_report,
     derive_rag,
+    load_corpus,
 )
 from .render import (
     render_badge_json,
@@ -20,7 +21,7 @@ from .render import (
 
 __all__ = [
     "DOCUMENTS_DIR", "APPROVED",
-    "build_status", "build_index", "completeness_report", "derive_rag",
+    "build_status", "build_index", "completeness_report", "derive_rag", "load_corpus",
     "render_markdown", "render_json", "render_html",
     "render_index_markdown", "render_index_html", "render_badge_json",
 ]

{docassert-0.20.1 → docassert-0.20.2}/docassert/status/derive.py

@@ -234,16 +234,25 @@ def _latest_report(docs):
 
 
 # ── the model + derived RAG ─────────────────────────────────────────────────
-def build_status(documents_dir=DOCUMENTS_DIR, project: str | None = None) -> dict:
+def load_corpus(documents_dir=DOCUMENTS_DIR) -> tuple[list, object, dict]:
+    """(all documents, item graph, consistency config) for one tree — loaded
+    once and shared across the per-project derivations of an index or pages
+    build via build_status(..., _corpus=...)."""
+    all_docs = [load(p) for p in sorted(Path(documents_dir).rglob("*.md"))]
+    graph = build_graph(documents_dir)
+    cfg = config_mod.read_consistency_config()
+    return all_docs, graph, cfg
+
+
+def build_status(documents_dir=DOCUMENTS_DIR, project: str | None = None,
+                 *, _corpus=None) -> dict:
     """Derive the status model for the whole repo, or for one project.
 
     `project` is a canonical project id (PRJ-NNN-CODE). When given, documents,
     coverage, risks, broken references and the latest report are all scoped to
     that project; the graph stays global so cross-project targets still resolve.
     """
-    all_docs = [load(p) for p in sorted(Path(documents_dir).rglob("*.md"))]
-    graph = build_graph(documents_dir)
-    cfg = config_mod.read_consistency_config()
+    all_docs, graph, cfg = _corpus if _corpus else load_corpus(documents_dir)
 
     code = project.split("-")[-1] if project else None
     if project:
@@ -314,9 +323,11 @@ def completeness_report(documents_dir=DOCUMENTS_DIR) -> list[dict]:
     """Per-project completeness for every profiled project (used by the
     blocking profile-completeness consistency check)."""
     from .. import projects as projects_mod
+    corpus = load_corpus(documents_dir)
     out = []
     for p in projects_mod.load_projects(documents_dir):
-        comp = build_status(documents_dir, project=p["id"]).get("completeness")
+        comp = build_status(documents_dir, project=p["id"],
+                            _corpus=corpus).get("completeness")
         if comp:
             out.append({"id": p["id"], "name": p["name"], "lifecycle": p["status"], **comp})
     return out
@@ -339,9 +350,10 @@ def build_index(documents_dir=DOCUMENTS_DIR) -> dict:
     """The multi-project view: each project's derived RAG + headline signals,
     plus the whole-repo rollup."""
     from .. import projects as projects_mod
+    corpus = load_corpus(documents_dir)
     cards = []
     for p in projects_mod.load_projects(documents_dir):
-        m = build_status(documents_dir, project=p["id"])
+        m = build_status(documents_dir, project=p["id"], _corpus=corpus)
         cards.append({
             "id": p["id"], "code": p["code"], "name": p["name"],
             "sponsor": p["sponsor"], "lifecycle": p["status"],
@@ -357,7 +369,8 @@ def build_index(documents_dir=DOCUMENTS_DIR) -> dict:
             "broken": len(m["broken_references"]),
             "completeness": m.get("completeness"),
         })
-    return {"projects": cards, "overall": build_status(documents_dir)}
+    return {"projects": cards,
+            "overall": build_status(documents_dir, _corpus=corpus)}
 
 
 def derive_rag(model) -> str:

{docassert-0.20.1 → docassert-0.20.2}/docassert/status/render.py

@@ -48,8 +48,10 @@ def render_markdown(model, summary: bool = False) -> str:
                    f"{comp['required_complete']}/{comp['required_total']} complete{detail}")
 
     if model["broken_references"]:
+        shown = ", ".join(model["broken_references"][:3])
+        more = "…" if len(model["broken_references"]) > 3 else ""
         out.append(f"- 🔴 **Broken references**: {len(model['broken_references'])} "
-                   f"({', '.join(model['broken_references'][:3])}…)")
+                   f"({shown}{more})")
     failing = [d["id"] for d in model["documents"] if not d["passing"]]
     if failing:
         out.append(f"- 🔴 **Documents failing audit**: {', '.join(failing)}")
@@ -142,8 +144,35 @@ def _today():
     return datetime.date.today()
 
 
+def _cap(s: str) -> str:
+    """Uppercase the first character only (str.capitalize lowercases the rest)."""
+    return s[:1].upper() + s[1:]
+
+
+def _amber_completeness_causes(comp) -> list[str]:
+    """The non-blocking profile gaps that amber the derived RAG."""
+    if not comp:
+        return []
+    if comp.get("unknown"):
+        return [f"profile '{comp['profile']}' not found under profiles/"]
+    causes = []
+    if comp["missing_required"]:
+        causes.append(f"{len(comp['missing_required'])} required document kind(s) "
+                      f"missing ({', '.join(comp['missing_required'])})")
+    if comp["incomplete_required"]:
+        causes.append(f"{len(comp['incomplete_required'])} required document kind(s) "
+                      f"not yet complete ({', '.join(comp['incomplete_required'])})")
+    if comp.get("recommended_gaps"):
+        causes.append(f"{len(comp['recommended_gaps'])} recommended document kind(s) open")
+    return causes
+
+
 def _verdict_causes(model) -> list[str]:
-    """The raw cause strings behind the verdict (also the verdict tooltip)."""
+    """The raw cause strings behind the verdict (also the verdict tooltip).
+
+    Mirrors derive_rag exactly: every condition that can amber or red the RAG
+    appears here, so an amber page can never claim it has no recorded causes.
+    """
     causes = []
     gaps = [c for c in model["coverage"] if c["gaps"]]
     if gaps:
@@ -156,6 +185,8 @@ def _verdict_causes(model) -> list[str]:
     comp = model.get("completeness")
     if comp and comp.get("blocks"):
         causes.append("required documents missing under an enforced profile")
+    else:
+        causes.extend(_amber_completeness_causes(comp))
     thr = model.get("risk_amber_score", 6)
     open_r = [r for r in model["risks"] if r.get("disposition", "open") == "open"
               and (thr == 0 or r.get("score", 0) >= thr)]
@@ -164,6 +195,9 @@ def _verdict_causes(model) -> list[str]:
     stale = [o for o in model.get("operations", []) if not o["fresh"]]
     if stale:
         causes.append(f"operations review overdue since {stale[0]['review_by']}")
+    reported = (model.get("latest_report") or {}).get("rag")
+    if reported in ("amber", "red"):
+        causes.append(f"latest status report recorded {reported}")
     return causes
 
 
@@ -176,35 +210,48 @@ def _verdict(model) -> str:
         causes_amber.append(f"{len(gaps)} coverage chain(s) carry gaps")
     else:
         goods.append("coverage is complete")
-    failing = [d for d in model["documents"] if not d["passing"]]
-    if failing:
-        causes_red.append(f"{len(failing)} document(s) fail audit")
+    failing_approved = [d for d in model["documents"]
+                        if not d["passing"] and d["status"] in ("approved", "baselined")]
+    failing_draft = [d for d in model["documents"]
+                     if not d["passing"] and d["status"] not in ("approved", "baselined")]
+    if failing_approved:
+        causes_red.append(f"{len(failing_approved)} approved document(s) fail audit")
     else:
-        goods.append("every document passes audit")
+        goods.append("every approved document passes audit")
     if model["broken_references"]:
         causes_red.append(f"{len(model['broken_references'])} reference(s) are broken")
     comp = model.get("completeness")
     if comp and comp.get("blocks"):
         causes_red.append("required documents are missing under an enforced profile")
-    open_r = [r for r in model["risks"] if r.get("disposition", "open") == "open"]
-    hi = [r for r in open_r if r.get("impact") in ("high", "critical")]
-    if open_r:
-        clause = f"{len(open_r)} risk(s) stay open"
+    else:
+        causes_amber.extend(_amber_completeness_causes(comp))
+    thr = model.get("risk_amber_score", 6)
+    open_thr = [r for r in model["risks"] if r.get("disposition", "open") == "open"
+                and (thr == 0 or r.get("score", 0) >= thr)]
+    hi = [r for r in open_thr if r.get("impact") in ("high", "critical")]
+    if open_thr:
+        clause = f"{len(open_thr)} risk(s) at or above the appetite stay open"
         if hi:
             clause += f", {len(hi)} of them high-impact"
         causes_amber.append(clause)
     stale = [o for o in model.get("operations", []) if not o["fresh"]]
     if stale:
         causes_amber.append(f"the operations review is overdue since {stale[0]['review_by']}")
+    reported = (model.get("latest_report") or {}).get("rag")
+    if reported in ("amber", "red"):
+        causes_amber.append(f"the latest status report recorded {reported}")
+    draft_note = (f" ({len(failing_draft)} draft document(s) still failing checks — "
+                  "work in progress, never punished)" if failing_draft else "")
     if rag == "green":
-        return ("Coverage is complete, every document passes audit, and no open risk "
-                "or overdue review stands against this project. Green is earned, not assumed.")
+        return ("Coverage is complete, every approved document passes audit, and no "
+                "open risk or overdue review stands against this project"
+                + draft_note + ". Green is earned, not assumed.")
     if rag == "red":
-        return (" and ".join(causes_red).capitalize()
+        return (_cap(" and ".join(causes_red))
                 + " — red means something is objectively broken, and the gates say what.")
-    lead = " and ".join(goods[:2]).capitalize() if goods else "The structure holds"
+    lead = _cap(" and ".join(goods[:2])) if goods else "The structure holds"
     tail = "; ".join(causes_amber) if causes_amber else "signals carry residual risk"
-    return f"{lead} — but {tail}. Amber is a recorded state, not neglect."
+    return f"{lead} — but {tail}{draft_note}. Amber is a recorded state, not neglect."
 
 
 def _days_label(days: int) -> str:
@@ -215,18 +262,25 @@ def _days_label(days: int) -> str:
     return f"IN {days} DAYS"
 
 
+def _days_until(date_str) -> int | None:
+    """Days from today to an ISO date string, or None when it isn't one.
+    Every date that reaches the renderer goes through this: derive tolerates
+    malformed frontmatter (e.g. review_by '2026-13-45'), so rendering must too."""
+    import datetime
+    try:
+        return (datetime.date.fromisoformat(str(date_str)) - _today()).days
+    except (TypeError, ValueError):
+        return None
+
+
 def _next_marker(model):
     """Nearest upcoming dated marker: milestone or operations review."""
     cands = [(m["days"], m["label"], m["date"]) for m in model.get("milestones", [])
              if m["days"] >= 0]
     for o in model.get("operations", []):
-        try:
-            import datetime
-            d = (datetime.date.fromisoformat(o["review_by"]) - _today()).days
-            if d >= 0:
-                cands.append((d, "Operations review", o["review_by"]))
-        except ValueError:
-            pass
+        d = _days_until(o["review_by"])
+        if d is not None and d >= 0:
+            cands.append((d, "Operations review", o["review_by"]))
     return min(cands) if cands else None
 
 
@@ -237,18 +291,18 @@ def _pct(d, w0, span):
 
 
 def _json_embed(data) -> str:
-    return json.dumps(data).replace("</", "<\\\\/")
+    """JSON for an inline <script>, with `</` split so the parser can never
+    see `</script>`. JSON reads `\\/` as `/`, so the payload is lossless."""
+    return json.dumps(data).replace("</", "<\\/")
 
 
 def render_html(model) -> str:
-    import datetime
     rag = model["rag"]
     c = model["counts"]
     rc, rt = _RAGC[rag], _RAGT[rag]
     title = esc(model.get("title", "Project Status"))
     pid = model.get("project") or ""
     gen = _now_utc()
-    today = _today()
 
     passing = sum(1 for d in model["documents"] if d["passing"])
     open_r = [r for r in model["risks"] if r.get("disposition", "open") == "open"]
@@ -281,11 +335,11 @@ def render_html(model) -> str:
         ("OPEN RISKS", str(len(open_r)), _C["amberT"] if open_r else _C["green"],
          f"{disp_r} dispositioned" if disp_r else "0 dispositioned"),
         ("NEXT MILESTONE", (f"{nxt[0]}d" if nxt else "—"), _C["text"],
-         (f"{esc(nxt[1])} · {nxt[2]}" if nxt else "no dated milestone")),
+         (f"{nxt[1]} · {nxt[2]}" if nxt else "no dated milestone")),
         ("DOC SET", docset_v, docset_c, docset_sub),
     ]
     stat_tips = {
-        "HEALTH": "Derived RAG. Red: failing approved docs, broken references, or enforced profile gaps. Amber: coverage gaps, open risks at or above the risk appetite, stale operations review, or an amber/red status report. Green: none of those.",
+        "HEALTH": "Derived RAG. Red: failing approved docs, broken references, or enforced profile gaps. Amber: coverage gaps, open risks at or above the risk appetite, stale operations review, an amber/red status report, or profile completeness gaps (required kinds missing/incomplete, recommended kinds open, unknown profile). Green: none of those.",
         "DOCS APPROVED": "Documents with approved or baselined status, of all documents in this project. The sub-line counts documents passing every blocking structural check.",
         "COVERAGE": "Traceability links present over links required, across every configured chain (BR→PR, PR→AC, AC→TC, and any others).",
         "OPEN RISKS": "Risks with disposition open. Dispositioned risks (mitigated, accepted, closed) stay on the register as record but do not count here.",
@@ -297,7 +351,7 @@ def render_html(model) -> str:
         f'<div class="chiplabel" style="margin-bottom:14px;">{k}</div>'
         f'<div style="font-family:Archivo,system-ui,sans-serif;font-weight:800;font-size:30px;letter-spacing:-.02em;'
         f'line-height:1;color:{col};font-variant-numeric:tabular-nums;">{esc(v)}</div>'
-        f'<div style="font-size:11px;color:{_C["muted"]};margin-top:9px;line-height:1.4;">{sub}</div></div>'
+        f'<div style="font-size:11px;color:{_C["muted"]};margin-top:9px;line-height:1.4;">{esc(sub)}</div></div>'
         for k, v, col, sub in stats)
 
     # ── 01 coverage meters + doc set ────────────────────────────────────────
@@ -358,8 +412,7 @@ def render_html(model) -> str:
     ms = list(model.get("milestones", []))
     for o in model.get("operations", []):
         ms.append({"label": "Operations review", "date": o["review_by"],
-                   "days": (datetime.date.fromisoformat(o["review_by"]) - today).days
-                   if len(o["review_by"]) == 10 else 0,
+                   "days": _days_until(o["review_by"]) or 0,
                    "when": "upcoming" if o["fresh"] else "elapsed"})
     ms.sort(key=lambda m: m["date"])
     timeline_html = ""
@@ -674,7 +727,7 @@ function riskCtl(){
   el.innerHTML = '<span class="chiplabel" style="margin-right:2px;">SORT</span>';
   el.appendChild(btn('severity', S.sort==='severity', ()=>{S.sort='severity';render();}));
   el.appendChild(btn('id', S.sort==='id', ()=>{S.sort='id';render();}));
-  if(S.sel){ el.appendChild(btn('isolating '+S.sel.split('RISK-')[1]+' ×', true, ()=>{S.sel=null;render();})); }
+  if(S.sel){ el.appendChild(btn('isolating '+(S.sel.split('RISK-')[1]||S.sel)+' ×', true, ()=>{S.sel=null;render();})); }
 }
 
 function riskTable(){

{docassert-0.20.1 → docassert-0.20.2/docassert.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.20.1
+Version: 0.20.2
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Documentation
 Classifier: Topic :: Text Processing :: Markup :: Markdown

{docassert-0.20.1 → docassert-0.20.2}/docassert.egg-info/SOURCES.txt

@@ -101,6 +101,7 @@ docassert/bridge/plan.py
 docassert/status/__init__.py
 docassert/status/derive.py
 docassert/status/render.py
+tests/test_audit_0_20_2.py
 tests/test_badge.py
 tests/test_bridge.py
 tests/test_config.py

{docassert-0.20.1 → docassert-0.20.2}/pyproject.toml

@@ -16,6 +16,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Quality Assurance",
     "Topic :: Software Development :: Documentation",
     "Topic :: Text Processing :: Markup :: Markdown",