docassert 0.7.0__tar.gz → 0.7.1__tar.gz

{docassert-0.7.0/docassert.egg-info → docassert-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.7.0
+Version: 0.7.1
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0
@@ -44,6 +44,8 @@ Dynamic: license-file
 [![Python](https://img.shields.io/pypi/pyversions/docassert)](https://pypi.org/project/docassert/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
 
+![docassert demo — a weak charter is blocked, fixed, and cleared](https://raw.githubusercontent.com/c4g-john/docassert/main/docs/demo.svg)
+
 **Unit testing for business documents.** Validate structured Markdown documents
 (charters, BRDs, PRDs, risk registers, …) against a configurable audit standard:
 deterministic structural checks that gate a merge, plus optional AI-graded
@@ -52,7 +54,7 @@ derived from the documents rather than self-reported.
 
 docassert is the reference implementation of **[PMO as Code](https://c4g-john.github.io/pmo-as-code/)** —
 a vendor-neutral standard for running a PMO from version-controlled, declarative
-files. It implements the [PMO as Code specification](https://github.com/c4g-john/pmo-as-code-spec) **v0.1**.
+files. It implements the [PMO as Code specification](https://github.com/c4g-john/pmo-as-code-spec) **v0.2**.
 
 ## Install
 

{docassert-0.7.0 → docassert-0.7.1}/README.md

@@ -4,6 +4,8 @@
 [![Python](https://img.shields.io/pypi/pyversions/docassert)](https://pypi.org/project/docassert/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
 
+![docassert demo — a weak charter is blocked, fixed, and cleared](https://raw.githubusercontent.com/c4g-john/docassert/main/docs/demo.svg)
+
 **Unit testing for business documents.** Validate structured Markdown documents
 (charters, BRDs, PRDs, risk registers, …) against a configurable audit standard:
 deterministic structural checks that gate a merge, plus optional AI-graded
@@ -12,7 +14,7 @@ derived from the documents rather than self-reported.
 
 docassert is the reference implementation of **[PMO as Code](https://c4g-john.github.io/pmo-as-code/)** —
 a vendor-neutral standard for running a PMO from version-controlled, declarative
-files. It implements the [PMO as Code specification](https://github.com/c4g-john/pmo-as-code-spec) **v0.1**.
+files. It implements the [PMO as Code specification](https://github.com/c4g-john/pmo-as-code-spec) **v0.2**.
 
 ## Install
 

{docassert-0.7.0 → docassert-0.7.1}/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.7.0"
+__version__ = "0.7.1"

{docassert-0.7.0 → docassert-0.7.1}/docassert/cli.py

@@ -300,18 +300,19 @@ def main(argv: list[str] | None = None) -> int:
         sp.add_argument("--documents-dir", default=DEFAULT_DOCUMENTS_DIR,
                         help=f"Documents tree to read (default: {DEFAULT_DOCUMENTS_DIR}/).")
 
+    def report_opts(sp: argparse.ArgumentParser) -> None:
+        sp.add_argument("--junit", help="Write a JUnit XML report to this path.")
+        sp.add_argument("--markdown", help="Write a PR-comment markdown report to this path.")
+        sp.add_argument("--json", help="Write a machine-readable JSON report to this path.")
+
     v = sub.add_parser("validate", help="Validate documents against their criteria.")
     v.add_argument("paths", nargs="+", help="Markdown files or globs.")
-    v.add_argument("--junit", help="Write a JUnit XML report to this path.")
-    v.add_argument("--markdown", help="Write a PR-comment markdown report to this path.")
-    v.add_argument("--json", help="Write a machine-readable JSON report to this path.")
+    report_opts(v)
     docs_dir_opt(v)
     v.set_defaults(func=cmd_validate)
 
     c = sub.add_parser("consistency", help="Check cross-document traceability.")
-    c.add_argument("--junit", help="Write a JUnit XML report to this path.")
-    c.add_argument("--markdown", help="Write a PR-comment markdown report to this path.")
-    c.add_argument("--json", help="Write a machine-readable JSON report to this path.")
+    report_opts(c)
     c.add_argument("--no-semantic", action="store_true",
                    help="Skip AI alignment (structural consistency only).")
     docs_dir_opt(c)

{docassert-0.7.0 → docassert-0.7.1}/docassert/report.py

@@ -12,6 +12,11 @@ _CROSS = "✗"
 _DASH = "—"
 
 
+def _all(results_by_doc: dict[str, list[CheckResult]]) -> list[CheckResult]:
+    """Every result across every document, flattened."""
+    return [r for rs in results_by_doc.values() for r in rs]
+
+
 def _mark(r: CheckResult) -> str:
     if r.kind == "semantic" and r.score is None:
         return "○"  # ○ skipped/unavailable
@@ -31,7 +36,7 @@ def console(results_by_doc: dict[str, list[CheckResult]]) -> str:
 
 
 def summary_line(results_by_doc: dict[str, list[CheckResult]]) -> str:
-    blocking = sum(1 for rs in results_by_doc.values() for r in rs if r.is_blocking_failure)
+    blocking = sum(1 for r in _all(results_by_doc) if r.is_blocking_failure)
     docs = len(results_by_doc)
     if blocking:
         return f"{_CROSS} {blocking} blocking failure(s) across {docs} document(s) {_DASH} merge blocked."
@@ -51,7 +56,7 @@ def json_report(results_by_doc: dict[str, list[CheckResult]]) -> str:
         } for r in results]
         for path, results in results_by_doc.items()
     }
-    all_results = [r for rs in results_by_doc.values() for r in rs]
+    all_results = _all(results_by_doc)
     summary = {
         "documents": len(results_by_doc),
         "checks": len(all_results),
@@ -89,9 +94,9 @@ def markdown(results_by_doc: dict[str, list[CheckResult]],
 
 
 def junit(results_by_doc: dict[str, list[CheckResult]]) -> str:
-    total = sum(len(rs) for rs in results_by_doc.values())
-    failures = sum(1 for rs in results_by_doc.values()
-                   for r in rs if r.is_blocking_failure)
+    all_results = _all(results_by_doc)
+    total = len(all_results)
+    failures = sum(1 for r in all_results if r.is_blocking_failure)
     suites = ET.Element("testsuites", tests=str(total), failures=str(failures))
     for path, results in results_by_doc.items():
         suite = ET.SubElement(suites, "testsuite", name=path,

docassert-0.7.1/docassert/status/__init__.py

@@ -0,0 +1,26 @@
+"""Status derivation and rendering, split into `derive` (model) and `render`
+(views). This module re-exports the public API so existing imports are unchanged.
+"""
+from .derive import (
+    APPROVED,
+    DOCUMENTS_DIR,
+    build_index,
+    build_status,
+    completeness_report,
+    derive_rag,
+)
+from .render import (
+    render_badge_json,
+    render_html,
+    render_index_html,
+    render_index_markdown,
+    render_json,
+    render_markdown,
+)
+
+__all__ = [
+    "DOCUMENTS_DIR", "APPROVED",
+    "build_status", "build_index", "completeness_report", "derive_rag",
+    "render_markdown", "render_json", "render_html",
+    "render_index_markdown", "render_index_html", "render_badge_json",
+]

docassert-0.7.1/docassert/status/derive.py

@@ -0,0 +1,231 @@
+"""Derive project and portfolio status from the documents (the model layer).
+
+Pure computation: reads the document graph and returns plain dicts. Rendering
+lives in docassert.status.render.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from .. import config as config_mod
+from .. import profiles as profiles_mod
+from ..graph import build_graph
+from ..loader import load
+from ..structural import _field_value, run_structural
+
+DOCUMENTS_DIR = Path("documents")
+APPROVED = {"approved", "baselined"}
+_SEVERITY = {"low": 1, "medium": 2, "high": 3, "critical": 4}
+
+
+def _doc_passes(doc, id_index) -> bool:
+    kind = doc.kind or ""
+    if not config_mod.criteria_exists(kind):
+        return True
+    criteria = config_mod.read_criteria(kind)
+    try:
+        schema = config_mod.read_schema(kind)
+    except FileNotFoundError:
+        schema = {}
+    ctx = {
+        "schema": schema,
+        "required_sections": criteria.get("required_sections", []),
+        "item_sections": criteria.get("item_sections", []),
+        "steps_sections": criteria.get("steps_sections", []),
+        "measurable_sections": criteria.get("measurable_sections", []),
+        "id_index": id_index,
+    }
+    for spec in criteria.get("checks", []):
+        if spec.get("type") == "structural":
+            if run_structural(doc, spec, ctx).is_blocking_failure:
+                return False
+    return True
+
+
+# ── signal extractors ───────────────────────────────────────────────────────
+# `code` optionally scopes a signal to one project (by item project code, e.g.
+# "AUR"). The graph itself stays global so cross-project link targets resolve.
+def _coverage(graph, config, code=None):
+    out = []
+    for rule in config.get("coverage", []):
+        parent_prefix, relation = rule["parent"], rule["relation"]
+        by_prefix = rule.get("by_prefix")
+        parents = graph.by_type.get(parent_prefix, [])
+        if code:
+            parents = [p for p in parents if p.project == code]
+        covered = [p for p in parents if graph.children(p.id, relation, by_prefix)]
+        out.append({
+            "label": rule.get("label", f"{parent_prefix} → {by_prefix}"),
+            "covered": len(covered),
+            "total": len(parents),
+            "gaps": [p.id for p in parents if p not in covered],
+        })
+    return out
+
+
+def _risks(graph, code=None):
+    risks = []
+    for item in graph.by_type.get("RISK", []):
+        if code and item.project != code:
+            continue
+        prob = (_field_value(item.text, "probability") or "").lower()
+        impact = (_field_value(item.text, "impact") or "").lower()
+        risks.append({
+            "id": item.id,
+            "probability": prob or "?",
+            "impact": impact or "?",
+            "owner": _field_value(item.text, "owner") or "?",
+            "score": _SEVERITY.get(prob, 0) * _SEVERITY.get(impact, 0),
+        })
+    return sorted(risks, key=lambda r: -r["score"])
+
+
+def _broken_references(graph, code=None):
+    broken = []
+    for item in graph.all_items():
+        if code and item.project != code:
+            continue
+        for relation, targets in item.links.items():
+            for target in targets:
+                if not graph.exists(target):
+                    broken.append(f"{item.id} —{relation}→ {target}")
+    return broken
+
+
+def _latest_report(docs):
+    reports = [d for d in docs if d.kind == "status-report"]
+    if not reports:
+        return None
+    reports.sort(key=lambda d: str(d.frontmatter.get("period", "")), reverse=True)
+    top = reports[0]
+    return {
+        "id": top.id,
+        "period": str(top.frontmatter.get("period", "")),
+        "rag": str(top.frontmatter.get("rag", "")).lower(),
+    }
+
+
+# ── the model + derived RAG ─────────────────────────────────────────────────
+def build_status(documents_dir=DOCUMENTS_DIR, project: str | None = 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()
+
+    code = project.split("-")[-1] if project else None
+    if project:
+        docs = [d for d in all_docs
+                if d.frontmatter.get("project") == project
+                or (d.kind == "project" and d.id == project)]
+    else:
+        docs = all_docs
+
+    id_index: dict[str, list[str]] = {}
+    for d in all_docs:                       # uniqueness is always global
+        id_index.setdefault(d.id or "", []).append(d.path)
+
+    documents = [{
+        "kind": d.kind,
+        "id": d.id,
+        "title": d.frontmatter.get("title", d.id),
+        "status": str(d.frontmatter.get("status", "draft")),
+        "passing": _doc_passes(d, id_index),
+    } for d in docs]
+
+    completeness = None
+    if project:
+        anchor = next((d for d in docs if d.kind == "project"), None)
+        title = str(anchor.frontmatter.get("name", project)) if anchor else project
+        if anchor is not None:
+            completeness = _completeness_for(anchor, documents)
+    else:
+        title = "Project Status"
+
+    model = {
+        "project": project,
+        "title": title,
+        "documents": documents,
+        "counts": {
+            "total": len(documents),
+            "kinds": len({d["kind"] for d in documents}),
+            "approved": sum(1 for d in documents if d["status"] in APPROVED),
+            "failing": sum(1 for d in documents if not d["passing"]),
+        },
+        "coverage": _coverage(graph, cfg, code),
+        "risks": _risks(graph, code),
+        "broken_references": _broken_references(graph, code),
+        "latest_report": _latest_report(docs),
+        "completeness": completeness,
+    }
+    model["rag"] = derive_rag(model)
+    return model
+
+
+def _completeness_for(anchor, documents: list[dict]) -> dict | None:
+    """Assess a project's documents against the profile its anchor declares."""
+    prof_name = anchor.frontmatter.get("profile")
+    if not prof_name:
+        return None
+    profile = profiles_mod.load_profile(prof_name)
+    if profile is None:
+        return profiles_mod.unknown(prof_name)
+    return profiles_mod.completeness(
+        profile, documents, str(anchor.frontmatter.get("status", "")))
+
+
+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
+    out = []
+    for p in projects_mod.load_projects(documents_dir):
+        comp = build_status(documents_dir, project=p["id"]).get("completeness")
+        if comp:
+            out.append({"id": p["id"], "name": p["name"], "lifecycle": p["status"], **comp})
+    return out
+
+
+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
+    cards = []
+    for p in projects_mod.load_projects(documents_dir):
+        m = build_status(documents_dir, project=p["id"])
+        cards.append({
+            "id": p["id"], "code": p["code"], "name": p["name"],
+            "sponsor": p["sponsor"], "lifecycle": p["status"],
+            "rag": m["rag"],
+            "total": m["counts"]["total"],
+            "failing": m["counts"]["failing"],
+            "risks": len(m["risks"]),
+            "coverage_gaps": sum(len(c["gaps"]) for c in m["coverage"]),
+            "broken": len(m["broken_references"]),
+            "completeness": m.get("completeness"),
+        })
+    return {"projects": cards, "overall": build_status(documents_dir)}
+
+
+def derive_rag(model) -> str:
+    """Red = something is objectively broken. Amber = carrying risk or
+    incompleteness. Green = clean."""
+    comp = model.get("completeness")
+    approved_failing = any(not d["passing"] for d in model["documents"]
+                           if d["status"] in APPROVED)
+    if approved_failing or model["broken_references"] or (comp and comp["blocks"]):
+        return "red"
+    coverage_gap = any(c["gaps"] for c in model["coverage"])
+    reported = (model["latest_report"] or {}).get("rag")
+    completeness_gap = bool(comp and (comp["missing_required"] or comp["incomplete_required"]
+                                      or comp["recommended_gaps"] or comp.get("unknown")))
+    if coverage_gap or model["risks"] or reported in {"amber", "red"} or completeness_gap:
+        return "amber"
+    return "green"
+
+
+# ── renderers ───────────────────────────────────────────────────────────────

docassert-0.7.0/docassert/status.py → docassert-0.7.1/docassert/status/render.py

@@ -1,237 +1,18 @@
-"""Derive a project status view from the documents.
+"""Render a status/index model as Markdown, JSON, HTML, or a shields badge.
 
-Nothing here is authored: every number comes from the actual files and the
-traceability graph. This is "derived status over self-reported status" — the
-page computes its own RAG from real signals rather than trusting a typed field.
+Each function takes an already-built model dict (see docassert.status.derive)
+and returns a string; none touch the document graph.
 """
 from __future__ import annotations
 
+import html as _h
 import json
-from pathlib import Path
-
-from . import config as config_mod
-from . import profiles as profiles_mod
-from .graph import build_graph
-from .loader import load
-from .structural import _field_value, run_structural
-
-DOCUMENTS_DIR = Path("documents")
-APPROVED = {"approved", "baselined"}
-_SEVERITY = {"low": 1, "medium": 2, "high": 3, "critical": 4}
-
-
-# ── per-document validity (blocking structural checks only) ─────────────────
-def _doc_passes(doc, id_index) -> bool:
-    kind = doc.kind or ""
-    if not config_mod.criteria_exists(kind):
-        return True
-    criteria = config_mod.read_criteria(kind)
-    try:
-        schema = config_mod.read_schema(kind)
-    except FileNotFoundError:
-        schema = {}
-    ctx = {
-        "schema": schema,
-        "required_sections": criteria.get("required_sections", []),
-        "item_sections": criteria.get("item_sections", []),
-        "steps_sections": criteria.get("steps_sections", []),
-        "measurable_sections": criteria.get("measurable_sections", []),
-        "id_index": id_index,
-    }
-    for spec in criteria.get("checks", []):
-        if spec.get("type") == "structural":
-            if run_structural(doc, spec, ctx).is_blocking_failure:
-                return False
-    return True
-
-
-# ── signal extractors ───────────────────────────────────────────────────────
-# `code` optionally scopes a signal to one project (by item project code, e.g.
-# "AUR"). The graph itself stays global so cross-project link targets resolve.
-def _coverage(graph, config, code=None):
-    out = []
-    for rule in config.get("coverage", []):
-        parent_prefix, relation = rule["parent"], rule["relation"]
-        by_prefix = rule.get("by_prefix")
-        parents = graph.by_type.get(parent_prefix, [])
-        if code:
-            parents = [p for p in parents if p.project == code]
-        covered = [p for p in parents if graph.children(p.id, relation, by_prefix)]
-        out.append({
-            "label": rule.get("label", f"{parent_prefix} → {by_prefix}"),
-            "covered": len(covered),
-            "total": len(parents),
-            "gaps": [p.id for p in parents if p not in covered],
-        })
-    return out
-
-
-def _risks(graph, code=None):
-    risks = []
-    for item in graph.by_type.get("RISK", []):
-        if code and item.project != code:
-            continue
-        prob = (_field_value(item.text, "probability") or "").lower()
-        impact = (_field_value(item.text, "impact") or "").lower()
-        risks.append({
-            "id": item.id,
-            "probability": prob or "?",
-            "impact": impact or "?",
-            "owner": _field_value(item.text, "owner") or "?",
-            "score": _SEVERITY.get(prob, 0) * _SEVERITY.get(impact, 0),
-        })
-    return sorted(risks, key=lambda r: -r["score"])
-
-
-def _broken_references(graph, code=None):
-    broken = []
-    for item in graph.all_items():
-        if code and item.project != code:
-            continue
-        for relation, targets in item.links.items():
-            for target in targets:
-                if not graph.exists(target):
-                    broken.append(f"{item.id} —{relation}→ {target}")
-    return broken
-
-
-def _latest_report(docs):
-    reports = [d for d in docs if d.kind == "status-report"]
-    if not reports:
-        return None
-    reports.sort(key=lambda d: str(d.frontmatter.get("period", "")), reverse=True)
-    top = reports[0]
-    return {
-        "id": top.id,
-        "period": str(top.frontmatter.get("period", "")),
-        "rag": str(top.frontmatter.get("rag", "")).lower(),
-    }
-
-
-# ── the model + derived RAG ─────────────────────────────────────────────────
-def build_status(documents_dir=DOCUMENTS_DIR, project: str | None = 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()
-
-    code = project.split("-")[-1] if project else None
-    if project:
-        docs = [d for d in all_docs
-                if d.frontmatter.get("project") == project
-                or (d.kind == "project" and d.id == project)]
-    else:
-        docs = all_docs
-
-    id_index: dict[str, list[str]] = {}
-    for d in all_docs:                       # uniqueness is always global
-        id_index.setdefault(d.id or "", []).append(d.path)
-
-    documents = [{
-        "kind": d.kind,
-        "id": d.id,
-        "title": d.frontmatter.get("title", d.id),
-        "status": str(d.frontmatter.get("status", "draft")),
-        "passing": _doc_passes(d, id_index),
-    } for d in docs]
-
-    completeness = None
-    if project:
-        anchor = next((d for d in docs if d.kind == "project"), None)
-        title = str(anchor.frontmatter.get("name", project)) if anchor else project
-        if anchor is not None:
-            completeness = _completeness_for(anchor, documents)
-    else:
-        title = "Project Status"
-
-    model = {
-        "project": project,
-        "title": title,
-        "documents": documents,
-        "counts": {
-            "total": len(documents),
-            "kinds": len({d["kind"] for d in documents}),
-            "approved": sum(1 for d in documents if d["status"] in APPROVED),
-            "failing": sum(1 for d in documents if not d["passing"]),
-        },
-        "coverage": _coverage(graph, cfg, code),
-        "risks": _risks(graph, code),
-        "broken_references": _broken_references(graph, code),
-        "latest_report": _latest_report(docs),
-        "completeness": completeness,
-    }
-    model["rag"] = derive_rag(model)
-    return model
-
-
-def _completeness_for(anchor, documents: list[dict]) -> dict | None:
-    """Assess a project's documents against the profile its anchor declares."""
-    prof_name = anchor.frontmatter.get("profile")
-    if not prof_name:
-        return None
-    profile = profiles_mod.load_profile(prof_name)
-    if profile is None:
-        return profiles_mod.unknown(prof_name)
-    return profiles_mod.completeness(
-        profile, documents, str(anchor.frontmatter.get("status", "")))
-
-
-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
-    out = []
-    for p in projects_mod.load_projects(documents_dir):
-        comp = build_status(documents_dir, project=p["id"]).get("completeness")
-        if comp:
-            out.append({"id": p["id"], "name": p["name"], "lifecycle": p["status"], **comp})
-    return out
-
-
-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
-    cards = []
-    for p in projects_mod.load_projects(documents_dir):
-        m = build_status(documents_dir, project=p["id"])
-        cards.append({
-            "id": p["id"], "code": p["code"], "name": p["name"],
-            "sponsor": p["sponsor"], "lifecycle": p["status"],
-            "rag": m["rag"],
-            "total": m["counts"]["total"],
-            "failing": m["counts"]["failing"],
-            "risks": len(m["risks"]),
-            "coverage_gaps": sum(len(c["gaps"]) for c in m["coverage"]),
-            "broken": len(m["broken_references"]),
-            "completeness": m.get("completeness"),
-        })
-    return {"projects": cards, "overall": build_status(documents_dir)}
-
-
-def derive_rag(model) -> str:
-    """Red = something is objectively broken. Amber = carrying risk or
-    incompleteness. Green = clean."""
-    comp = model.get("completeness")
-    approved_failing = any(not d["passing"] for d in model["documents"]
-                           if d["status"] in APPROVED)
-    if approved_failing or model["broken_references"] or (comp and comp["blocks"]):
-        return "red"
-    coverage_gap = any(c["gaps"] for c in model["coverage"])
-    reported = (model["latest_report"] or {}).get("rag")
-    completeness_gap = bool(comp and (comp["missing_required"] or comp["incomplete_required"]
-                                      or comp["recommended_gaps"] or comp.get("unknown")))
-    if coverage_gap or model["risks"] or reported in {"amber", "red"} or completeness_gap:
-        return "amber"
-    return "green"
-
-
-# ── renderers ───────────────────────────────────────────────────────────────
+
+
+def esc(s):
+    return _h.escape(str(s))
+
+
 _EMOJI = {"green": "🟢", "amber": "🟠", "red": "🔴"}
 
 
@@ -348,13 +129,10 @@ _INDEX_CSS = """
 
 def render_html(model) -> str:
     import datetime
-    import html as _h
     rag = model["rag"]
     c = model["counts"]
     color = {"green": "var(--ok)", "amber": "var(--amber)", "red": "var(--bad)"}[rag]
     bar_color = {"green": "var(--ok)", "amber": "var(--amber)", "red": "var(--bad)"}[rag]
-    def esc(s):
-        return _h.escape(str(s))
 
     coverage = "".join(
         f'<div class="sig"><div class="sig-h"><span>{esc(cov["label"])}</span>'
@@ -518,9 +296,6 @@ def render_index_markdown(index) -> str:
 def render_index_html(index) -> str:
     """The multi-project landing page: one linked RAG card per project."""
     import datetime
-    import html as _h
-    def esc(s):
-        return _h.escape(str(s))
 
     overall = index["overall"]["rag"]
     ocolor = _RAG_COLOR[overall]

{docassert-0.7.0 → docassert-0.7.1/docassert.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassert
-Version: 0.7.0
+Version: 0.7.1
 Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
 Author: C4G Enterprises Inc.
 License: Apache-2.0
@@ -44,6 +44,8 @@ Dynamic: license-file
 [![Python](https://img.shields.io/pypi/pyversions/docassert)](https://pypi.org/project/docassert/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
 
+![docassert demo — a weak charter is blocked, fixed, and cleared](https://raw.githubusercontent.com/c4g-john/docassert/main/docs/demo.svg)
+
 **Unit testing for business documents.** Validate structured Markdown documents
 (charters, BRDs, PRDs, risk registers, …) against a configurable audit standard:
 deterministic structural checks that gate a merge, plus optional AI-graded
@@ -52,7 +54,7 @@ derived from the documents rather than self-reported.
 
 docassert is the reference implementation of **[PMO as Code](https://c4g-john.github.io/pmo-as-code/)** —
 a vendor-neutral standard for running a PMO from version-controlled, declarative
-files. It implements the [PMO as Code specification](https://github.com/c4g-john/pmo-as-code-spec) **v0.1**.
+files. It implements the [PMO as Code specification](https://github.com/c4g-john/pmo-as-code-spec) **v0.2**.
 
 ## Install
 

{docassert-0.7.0 → docassert-0.7.1}/docassert.egg-info/SOURCES.txt

@@ -17,7 +17,6 @@ docassert/report.py
 docassert/rtm.py
 docassert/scaffold.py
 docassert/semantic.py
-docassert/status.py
 docassert/structural.py
 docassert.egg-info/PKG-INFO
 docassert.egg-info/SOURCES.txt
@@ -90,6 +89,9 @@ docassert/_data/templates/runbook.template.md
 docassert/_data/templates/status-report.template.md
 docassert/_data/templates/test-cases.template.md
 docassert/_data/templates/user-story.template.md
+docassert/status/__init__.py
+docassert/status/derive.py
+docassert/status/render.py
 tests/test_badge.py
 tests/test_config.py
 tests/test_consistency.py

{docassert-0.7.0 → docassert-0.7.1}/pyproject.toml

@@ -43,8 +43,8 @@ docassert = "docassert.cli:main"
 requires = ["setuptools>=68"]
 build-backend = "setuptools.build_meta"
 
-[tool.setuptools]
-packages = ["docassert"]
+[tool.setuptools.packages.find]
+include = ["docassert*"]   # auto-discover subpackages (docassert, docassert.status, …)
 
 [tool.setuptools.package-data]
 # Ship the default criteria/schema/profiles/templates/consistency.yaml so