wicked-garden 12.27.0

package/scripts/compiler/phase0/detect.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""Phase-0 detection probe — repo root -> bindings.json.
+
+Falsification question: can ONE repo-agnostic detector infer a repo's
+test-invocation, evidence sink, claims surface, and risk surfaces well
+enough to drive an emitted enforcement lint, WITHOUT hand-correction,
+across structurally different repos?
+
+Every binding records {value, source, confidence} so the verdict can
+distinguish "detected unaided" from "fell back to a proposed default".
+Stdlib-only.
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+DETECTED = "detected"          # inferred from a real repo signal
+DEFAULT = "proposed-default"   # emitted convention; repo had none
+
+
+def _read_json(p: Path) -> dict:
+    try:
+        return json.loads(p.read_text())
+    except Exception:
+        return {}
+
+
+def _pkg_manager(root: Path) -> str:
+    if (root / "pnpm-lock.yaml").exists():
+        return "pnpm"
+    if (root / "yarn.lock").exists():
+        return "yarn"
+    return "npm"
+
+
+def _detect_test_command(root: Path) -> dict:
+    # node
+    pkg = root / "package.json"
+    if pkg.exists():
+        data = _read_json(pkg)
+        scripts = data.get("scripts", {}) or {}
+        pm = _pkg_manager(root)
+        monorepo = bool(data.get("workspaces")) or (root / "pnpm-workspace.yaml").exists()
+        if scripts.get("test"):
+            run = "test" if pm == "npm" else "test"
+            cmd = f"{pm} {('run ' if pm=='npm' else '')}{run}".strip()
+            # npm needs `npm test`; pnpm/yarn `pnpm test`
+            cmd = f"{pm} test"
+            return {"value": cmd, "source": DETECTED, "confidence": 0.9,
+                    "ecosystem": "node", "monorepo": monorepo,
+                    "declared_script": scripts["test"]}
+        return {"value": f"{pm} test", "source": DEFAULT, "confidence": 0.3,
+                "ecosystem": "node", "monorepo": monorepo,
+                "note": "package.json has no scripts.test"}
+
+    # rust
+    if (root / "Cargo.toml").exists():
+        return {"value": "cargo test", "source": DETECTED, "confidence": 0.9,
+                "ecosystem": "rust"}
+
+    # go
+    if (root / "go.mod").exists():
+        return {"value": "go test ./...", "source": DETECTED, "confidence": 0.9,
+                "ecosystem": "go"}
+
+    # python — the ambiguous case: Makefile test target vs pytest vs pyproject
+    has_pyproject = (root / "pyproject.toml").exists()
+    has_setup = (root / "setup.py").exists() or (root / "setup.cfg").exists()
+    tests_dir = ("tests" if (root / "tests").is_dir()
+                 else "test" if (root / "test").is_dir() else None)
+    has_tests_dir = tests_dir is not None
+    # Scope pytest to the tests dir when one exists. Bare `pytest` collects
+    # from the repo root and trips over stray test-like files elsewhere in the
+    # tree (a real failure mode found dogfooding the garden: scripts/**/test_*.py
+    # with broken imports → exit 2). Scoped collection matches how repos
+    # actually run their suite (`pytest tests/`).
+    _pytest = "python3 -m pytest" + (f" {tests_dir}" if tests_dir else "")
+    make = root / "Makefile"
+    make_test = False
+    if make.exists():
+        try:
+            make_test = bool(re.search(r"(?m)^test:", make.read_text()))
+        except Exception:
+            make_test = False
+    pytest_cfg = False
+    if has_pyproject:
+        try:
+            txt = (root / "pyproject.toml").read_text()
+            pytest_cfg = "[tool.pytest" in txt
+        except Exception:
+            pass
+    if (root / "pytest.ini").exists():
+        pytest_cfg = True
+
+    if has_pyproject or has_setup or has_tests_dir:
+        # Priority: declared Makefile target (explicit author intent) >
+        # ecosystem default pytest. Confidence drops when both exist
+        # (genuine ambiguity the detector must flag, not silently pick).
+        if make_test and (pytest_cfg or has_tests_dir):
+            return {"value": _pytest, "source": DETECTED,
+                    "confidence": 0.55, "ecosystem": "python",
+                    "ambiguity": "Makefile `test:` target AND pytest config both present",
+                    "alt": "make test"}
+        if make_test:
+            return {"value": "make test", "source": DETECTED, "confidence": 0.8,
+                    "ecosystem": "python"}
+        return {"value": _pytest, "source": DETECTED,
+                "confidence": 0.8 if (pytest_cfg or has_tests_dir) else 0.5,
+                "ecosystem": "python"}
+
+    return {"value": None, "source": DEFAULT, "confidence": 0.0,
+            "ecosystem": "unknown", "note": "no recognized test ecosystem"}
+
+
+def _detect_evidence_sink(root: Path) -> dict:
+    # existing convention?
+    candidates = []
+    for p in root.rglob("evidence"):
+        if p.is_dir() and ".git" not in p.parts and "node_modules" not in p.parts:
+            candidates.append(p.relative_to(root).as_posix())
+            if len(candidates) >= 5:
+                break
+    if candidates:
+        # pick the shallowest existing evidence dir
+        candidates.sort(key=lambda s: s.count("/"))
+        return {"value": candidates[0], "source": DETECTED, "confidence": 0.8,
+                "others": candidates[1:]}
+    for d in ("test-results", "coverage", "reports"):
+        if (root / d).is_dir():
+            return {"value": d, "source": DETECTED, "confidence": 0.5}
+    return {"value": ".wg/evidence", "source": DEFAULT, "confidence": 0.3,
+            "note": "no existing evidence convention; proposing default"}
+
+
+def _detect_claims_surface(root: Path) -> dict:
+    # structured claims doc? (frontmatter `claims:` block, command_iq build.md shape)
+    search_roots = [root / ".projects", root / "docs", root]
+    hits = []
+    for sr in search_roots:
+        if not sr.exists():
+            continue
+        for md in sr.rglob("*.md"):
+            if "node_modules" in md.parts or ".git" in md.parts:
+                continue
+            try:
+                head = md.read_text(errors="ignore")[:2000]
+            except Exception:
+                continue
+            if re.search(r"(?m)^claims:\s*$", head):
+                hits.append(md.relative_to(root).as_posix())
+            if len(hits) >= 5:
+                break
+        if hits:
+            break
+    if hits:
+        return {"value": "frontmatter", "glob": hits, "source": DETECTED,
+                "confidence": 0.85}
+    return {"value": "commit-msg", "source": DEFAULT, "confidence": 0.4,
+            "note": "no structured claims doc; default to commit-message scanning"}
+
+
+def _detect_risk_surfaces(root: Path) -> dict:
+    # explicit surface table? (a markdown with a Surface|Skill dispatch table)
+    for md in (root / "CLAUDE.md", root / "AGENTS.md"):
+        if md.exists():
+            try:
+                txt = md.read_text(errors="ignore")
+            except Exception:
+                txt = ""
+            if re.search(r"Surface\b.*\bSkill", txt) or "surface-skill" in txt:
+                rows = re.findall(r"(?m)^\|\s*`?([a-z][\w/.-]+)`?\s*\|", txt)
+                return {"value": sorted(set(rows))[:20], "source": DETECTED,
+                        "confidence": 0.7, "from": md.name}
+    # else: derive candidate surfaces from code module dirs
+    surfaces = []
+    for base in ("src", "packages", "lib"):
+        b = root / base
+        if b.is_dir():
+            for sub in sorted(b.iterdir()):
+                if sub.is_dir() and not sub.name.startswith("."):
+                    surfaces.append(f"{base}/{sub.name}")
+            if surfaces:
+                break
+    if surfaces:
+        return {"value": surfaces[:20], "source": DETECTED, "confidence": 0.4,
+                "note": "derived from top-level module dirs; no explicit surface map"}
+    return {"value": [], "source": DEFAULT, "confidence": 0.0,
+            "note": "no module structure detected"}
+
+
+def _node_script_cmd(root: Path, script: str) -> str | None:
+    """Return the run-command for a package.json script, or None if absent."""
+    pkg = root / "package.json"
+    if not pkg.exists():
+        return None
+    scripts = (_read_json(pkg).get("scripts") or {})
+    if script not in scripts:
+        return None
+    pm = _pkg_manager(root)
+    return f"npm run {script}" if pm == "npm" else f"{pm} {script}"
+
+
+def _detect_lint_command(root: Path) -> dict:
+    """Detect a lint/static-check command. Omitted (value=None) when none —
+    pinning a non-existent linter would make the gate fail forever."""
+    # node — only if the repo declares a lint script (don't assume eslint).
+    cmd = _node_script_cmd(root, "lint")
+    if cmd:
+        return {"value": cmd, "source": DETECTED, "confidence": 0.9, "ecosystem": "node"}
+    if (root / "package.json").exists():
+        return {"value": None, "source": DEFAULT, "confidence": 0.0, "ecosystem": "node"}
+
+    # go — `go vet` is standard and always runnable for a module, no config.
+    if (root / "go.mod").exists():
+        return {"value": "go vet ./...", "source": DETECTED, "confidence": 0.85, "ecosystem": "go"}
+
+    # rust — clippy ships with the toolchain.
+    if (root / "Cargo.toml").exists():
+        return {"value": "cargo clippy", "source": DETECTED, "confidence": 0.7, "ecosystem": "rust"}
+
+    # python — ruff > flake8 > Makefile lint target. Only if configured.
+    if (root / "pyproject.toml").exists():
+        try:
+            txt = (root / "pyproject.toml").read_text()
+        except Exception:
+            txt = ""
+        if "[tool.ruff" in txt:
+            return {"value": "ruff check .", "source": DETECTED, "confidence": 0.85, "ecosystem": "python"}
+    if (root / "ruff.toml").exists() or (root / ".ruff.toml").exists():
+        return {"value": "ruff check .", "source": DETECTED, "confidence": 0.85, "ecosystem": "python"}
+    if (root / ".flake8").exists():
+        return {"value": "flake8", "source": DETECTED, "confidence": 0.8, "ecosystem": "python"}
+    make = root / "Makefile"
+    if make.exists():
+        try:
+            if re.search(r"(?m)^lint:", make.read_text()):
+                return {"value": "make lint", "source": DETECTED, "confidence": 0.75, "ecosystem": "python"}
+        except Exception:
+            pass
+
+    return {"value": None, "source": DEFAULT, "confidence": 0.0,
+            "note": "no lint command detected"}
+
+
+def _detect_build_command(root: Path) -> dict:
+    """Detect a build/compile command. Omitted when none (e.g. most pure-Python
+    libs don't have a build step)."""
+    cmd = _node_script_cmd(root, "build")
+    if cmd:
+        return {"value": cmd, "source": DETECTED, "confidence": 0.9, "ecosystem": "node"}
+    if (root / "package.json").exists():
+        return {"value": None, "source": DEFAULT, "confidence": 0.0, "ecosystem": "node"}
+
+    if (root / "go.mod").exists():
+        return {"value": "go build ./...", "source": DETECTED, "confidence": 0.85, "ecosystem": "go"}
+    if (root / "Cargo.toml").exists():
+        return {"value": "cargo build", "source": DETECTED, "confidence": 0.85, "ecosystem": "rust"}
+
+    make = root / "Makefile"
+    if make.exists():
+        try:
+            if re.search(r"(?m)^build:", make.read_text()):
+                return {"value": "make build", "source": DETECTED, "confidence": 0.7, "ecosystem": "make"}
+        except Exception:
+            pass
+
+    return {"value": None, "source": DEFAULT, "confidence": 0.0,
+            "note": "no build command detected"}
+
+
+def detect(repo_root: str) -> dict:
+    root = Path(repo_root).resolve()
+    return {
+        "repo": root.name,
+        "root": str(root),
+        "test_command": _detect_test_command(root),
+        "lint_command": _detect_lint_command(root),
+        "build_command": _detect_build_command(root),
+        "evidence_sink": _detect_evidence_sink(root),
+        "claims_surface": _detect_claims_surface(root),
+        "risk_surfaces": _detect_risk_surfaces(root),
+    }
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("usage: detect.py <repo_root>", file=sys.stderr)
+        sys.exit(2)
+    print(json.dumps(detect(sys.argv[1]), indent=2))

package/scripts/compiler/phase0/emit.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Phase-0 emitter — bindings.json -> a repo-native `wg_check_claims.py` lint.
+
+This is the "compile" step under test: the SAME emitter, parameterized
+only by detected bindings, must produce a lint that works in each repo
+with no hand edits. The bindings are baked in as constants at the top of
+the emitted file — that is the repo-specific "compiled" surface; the
+checking logic below it is generic.
+
+Stdlib-only. The emitted file is also stdlib-only so it can live in any
+repo's pre-commit/CI with zero deps.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+TEMPLATE = '''#!/usr/bin/env python3
+"""wg_check_claims.py — EMITTED by wicked-garden phase-0 compiler.
+
+Repo-native claim->evidence enforcement. Compiled bindings for THIS repo
+are the constants directly below; everything under them is generic.
+
+A claim that asserts success ("tests pass", "N/N pass", "done", "clean")
+must point to an evidence artifact that exists, is non-empty, carries a
+success signal, and is not dominated by a failure signal. A claim whose
+evidence is missing / empty / contradictory is a fabricated claim and
+fails the lint.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+# ---- COMPILED BINDINGS (repo-specific; emitted, not hand-written) ----
+REPO = {repo!r}
+TEST_COMMAND = {test_command!r}
+EVIDENCE_SINK = {evidence_sink!r}
+CLAIMS_MODE = {claims_mode!r}        # "frontmatter" | "commit-msg"
+CLAIMS_GLOB = {claims_glob!r}        # list of frontmatter docs (if mode=frontmatter)
+# ----------------------------------------------------------------------
+
+PASS_LANG = re.compile(
+    r"\\b(tests?\\s+pass|passing|all\\s+green|\\d+\\s*/\\s*\\d+\\s+(?:tests?\\s+)?pass"
+    r"|exit\\s*0|typecheck[- ]?clean|build[- ]?clean|\\bclean\\b|\\bdone\\b"
+    r"|complete|fixed|merged)",
+    re.IGNORECASE,
+)
+SUCCESS_SIG = re.compile(
+    r"(\\bpass(?:ed|ing)?\\b|\\bok\\b|\\u2713|\\bexit\\s*(?:code\\s*)?0\\b"
+    r"|\\b\\d+\\s+passed\\b|test files\\s+\\d+\\s+passed|no\\s+violations)",
+    re.IGNORECASE,
+)
+# A nonzero-failure token DOMINATES a success claim even when partial
+# "passed" counts are also present. "0 failed" must NOT trigger; bare
+# lowercase "fail" in prose must NOT trigger (only uppercase FAIL token).
+HARD_FAIL = re.compile(
+    r"([1-9]\\d*\\s+(?:failed|errors?|failures?)"
+    r"|(?-i:\\bFAIL\\b|\\u2717)"
+    r"|exit\\s*(?:code\\s*)?[1-9]"
+    r"|no test files found"
+    r"|\\btraceback\\b"
+    r"|failures?\\s*=\\s*[1-9])",
+    re.IGNORECASE,
+)
+
+
+def _resolve_evidence(repo_root: Path, slug: str) -> Path | None:
+    sink = repo_root / EVIDENCE_SINK
+    cands = [sink / slug, sink / (slug + ".txt"), sink / (slug + ".md"),
+             repo_root / slug]
+    # also: evidence dir co-located next to the claims doc (common shape)
+    for c in cands:
+        if c.exists() and c.is_file():
+            return c
+    # last resort: glob the sink for the slug
+    if sink.is_dir():
+        for p in sink.rglob(slug + "*"):
+            if p.is_file():
+                return p
+    return None
+
+
+def _parse_frontmatter_claims(text: str):
+    """Return list of {{id,text,evidence}} from a `claims:` frontmatter block."""
+    if not text.startswith("---"):
+        return []
+    end = text.find("\\n---", 3)
+    fm = text[3:end] if end != -1 else text
+    lines = fm.splitlines()
+    claims, cur, in_block = [], None, False
+    for ln in lines:
+        if re.match(r"^claims:\\s*$", ln):
+            in_block = True
+            continue
+        if in_block:
+            if re.match(r"^\\S", ln):  # next top-level key ends the block
+                break
+            m_id = re.match(r"^\\s*-\\s*id:\\s*(.+)$", ln)
+            if m_id:
+                if cur:
+                    claims.append(cur)
+                cur = {{"id": m_id.group(1).strip(), "text": "", "evidence": ""}}
+                continue
+            m_ev = re.match(r"^\\s*evidence:\\s*(.+)$", ln)
+            if m_ev and cur is not None:
+                cur["evidence"] = m_ev.group(1).strip().strip('"\\'')
+                continue
+            m_tx = re.match(r"^\\s*text:\\s*(.+)$", ln)
+            if m_tx and cur is not None:
+                cur["text"] = m_tx.group(1).strip().strip('"\\'')
+                continue
+    if cur:
+        claims.append(cur)
+    return claims
+
+
+def _evaluate(repo_root: Path, claims, source_label: str):
+    violations = []
+    checked = 0
+    for c in claims:
+        text = c.get("text", "")
+        if not PASS_LANG.search(text):
+            continue  # not a success-claim; nothing to back
+        checked += 1
+        slug = c.get("evidence", "").strip()
+        if not slug:
+            violations.append((c.get("id", "?"), "success claim has NO evidence pointer", text))
+            continue
+        ev = _resolve_evidence(repo_root, slug)
+        if ev is None:
+            violations.append((c.get("id", "?"), f"evidence '{{slug}}' not found under {{EVIDENCE_SINK}}/", text))
+            continue
+        body = ev.read_text(errors="ignore")
+        if not body.strip():
+            violations.append((c.get("id", "?"), f"evidence '{{slug}}' is empty", text))
+            continue
+        has_pass = bool(SUCCESS_SIG.search(body))
+        has_fail = bool(HARD_FAIL.search(body))
+        if has_fail:
+            violations.append((c.get("id", "?"), f"evidence '{{slug}}' shows FAILURE, claim asserts success", text))
+        elif not has_pass:
+            violations.append((c.get("id", "?"), f"evidence '{{slug}}' has no success signal", text))
+    return checked, violations
+
+
+def main(argv):
+    repo_root = Path(".").resolve()
+    docs = []
+    args = list(argv)
+    while args:
+        a = args.pop(0)
+        if a == "--repo-root":
+            repo_root = Path(args.pop(0)).resolve()
+        elif a == "--claims-file":
+            docs.append(Path(args.pop(0)))
+        else:
+            docs.append(Path(a))
+
+    if not docs:
+        if CLAIMS_MODE == "frontmatter" and CLAIMS_GLOB:
+            docs = [repo_root / g for g in CLAIMS_GLOB]
+        else:
+            print("wg_check_claims: commit-msg mode requires a claims source; "
+                  "pass --claims-file <doc>", file=sys.stderr)
+            return 0
+
+    total_checked, all_v = 0, []
+    for d in docs:
+        if not d.exists():
+            continue
+        text = d.read_text(errors="ignore")
+        claims = _parse_frontmatter_claims(text)
+        checked, v = _evaluate(repo_root, claims, d.name)
+        total_checked += checked
+        all_v.extend((d.name, *row) for row in v)
+
+    if all_v:
+        print(f"wg_check_claims: FAIL ({{len(all_v)}} unbacked claim(s)) in {{REPO}}")
+        for doc, cid, why, text in all_v:
+            print(f"  [{{doc}}] claim {{cid}}: {{why}}")
+            print(f"      claim text: {{text[:100]}}")
+        print(f"  test_command for re-verification: {{TEST_COMMAND}}")
+        return 1
+    print(f"wg_check_claims: PASS ({{total_checked}} success-claim(s) all evidence-backed) in {{REPO}}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
+'''
+
+
+def render_lint(bindings: dict) -> str:
+    """Render the claims-vs-evidence lint source for a repo's bindings.
+
+    Single source of the lint logic — both the phase-0 ``emit()`` and the
+    ``compile`` emit stage (which writes it as ``.wicked/claims_lint.py``)
+    render through here. Stdlib-only output.
+    """
+    tc = bindings["test_command"]
+    es = bindings["evidence_sink"]
+    cs = bindings["claims_surface"]
+    return TEMPLATE.format(
+        repo=bindings["repo"],
+        test_command=tc.get("value") or "(none-detected)",
+        evidence_sink=es.get("value") or ".wg/evidence",
+        claims_mode=cs.get("value"),
+        claims_glob=cs.get("glob", []),
+    )
+
+
+def emit(bindings: dict, out_dir: str) -> str:
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    target = out / "wg_check_claims.py"
+    target.write_text(render_lint(bindings))
+    return str(target)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print("usage: emit.py <bindings.json> <out_dir>", file=sys.stderr)
+        sys.exit(2)
+    b = json.loads(Path(sys.argv[1]).read_text())
+    print(emit(b, sys.argv[2]))

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.bindings.json

@@ -0,0 +1,30 @@
+{
+  "repo": "Enterprise-AISDLC",
+  "root": "/Users/michael.parcewski/Projects/Enterprise-AISDLC",
+  "test_command": {
+    "value": "python3 -m pytest",
+    "source": "detected",
+    "confidence": 0.55,
+    "ecosystem": "python",
+    "ambiguity": "Makefile `test:` target AND pytest config both present",
+    "alt": "make test"
+  },
+  "evidence_sink": {
+    "value": ".wg/evidence",
+    "source": "proposed-default",
+    "confidence": 0.3,
+    "note": "no existing evidence convention; proposing default"
+  },
+  "claims_surface": {
+    "value": "commit-msg",
+    "source": "proposed-default",
+    "confidence": 0.4,
+    "note": "no structured claims doc; default to commit-message scanning"
+  },
+  "risk_surfaces": {
+    "value": [],
+    "source": "proposed-default",
+    "confidence": 0.0,
+    "note": "no module structure detected"
+  }
+}

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.lint-output.txt

@@ -0,0 +1,17 @@
+$ emitted lint (test_command=python3 -m pytest)
+
+--- honest (expect exit 0) -> rc=0 ---
+wg_check_claims: PASS (1 success-claim(s) all evidence-backed) in Enterprise-AISDLC
+
+--- fabricated/missing (expect exit 1) -> rc=1 ---
+wg_check_claims: FAIL (1 unbacked claim(s)) in Enterprise-AISDLC
+  [fab-missing.build.md] claim c-fab-missing: evidence 'tests-that-were-never-run' not found under .wg/evidence/
+      claim text: all tests pass, build clean, ready to merge
+  test_command for re-verification: python3 -m pytest
+
+--- fabricated/failure (expect exit 1) -> rc=1 ---
+wg_check_claims: FAIL (1 unbacked claim(s)) in Enterprise-AISDLC
+  [fab-fail.build.md] claim c-fab-fail: evidence 'failing-tests' shows FAILURE, claim asserts success
+      claim text: tests pass — all green
+  test_command for re-verification: python3 -m pytest
+

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.stage/.wg/evidence/failing-tests.txt

@@ -0,0 +1,4 @@
+FAIL src/foo.test
+ 2 failed | 1 passed
+Error: expected 2 received 3
+exit code 1

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.stage/.wg/evidence/honest-tests.txt

@@ -0,0 +1,2 @@
+.                                                                        [100%]
+1 passed in 0.00s

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.stage/fab-fail.build.md

@@ -0,0 +1,8 @@
+---
+phase: build
+claims:
+  - id: c-fab-fail
+    evidence: failing-tests
+    text: "tests pass — all green"
+---
+# fabricated: evidence actually shows failure

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.stage/fab-missing.build.md

@@ -0,0 +1,8 @@
+---
+phase: build
+claims:
+  - id: c-fab-missing
+    evidence: tests-that-were-never-run
+    text: "all tests pass, build clean, ready to merge"
+---
+# fabricated: evidence file does not exist

package/scripts/compiler/phase0/evidence/Enterprise-AISDLC.stage/honest.build.md

@@ -0,0 +1,8 @@
+---
+phase: build
+claims:
+  - id: c-honest
+    evidence: honest-tests
+    text: "tests pass: 1/1 passing, exit 0"
+---
+# honest