phase-loop-runtime 0.2.0__py3-none-any.whl

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/borderline/borderline-threshold-edge/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "borderline-threshold-edge",
+  "category": "borderline",
+  "expected_verdict_class": "uncertain",
+  "expected_confidence": 0.84,
+  "expected_artifact_characteristics": "Ambiguous evidence near the default confidence threshold.",
+  "sample_artifact_paths": ["edge.txt"],
+  "rationale": "Confidence just below 0.85 should not become a hard real or fake assertion.",
+  "tier2_signal_summary": {
+    "kind": "calibration_borderline",
+    "signals": ["near threshold", "plausible evidence", "insufficient corroboration"]
+  },
+  "estimated_input_tokens": 660,
+  "estimated_output_tokens": 205,
+  "estimated_cost_usd": 0.0069
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-duplicate-png/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "fake-duplicate-png",
+  "category": "known-fake",
+  "expected_verdict_class": "fake",
+  "expected_confidence": 0.96,
+  "expected_artifact_characteristics": "Suspicious evidence where multiple claimed screenshots share identical placeholder bytes.",
+  "sample_artifact_paths": ["shot-a.txt", "shot-b.txt", "shot-c.txt"],
+  "rationale": "Covers the obvious duplicate-artifact fake evidence pattern.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_fake",
+    "signals": ["duplicate artifact content", "claimed distinct screenshots", "same byte length"]
+  },
+  "estimated_input_tokens": 680,
+  "estimated_output_tokens": 210,
+  "estimated_cost_usd": 0.0072
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-duplicate-png/shot-a.txt

@@ -0,0 +1 @@
+placeholder screenshot bytes 8d7f1750 repeated for every viewport

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-duplicate-png/shot-b.txt

@@ -0,0 +1 @@
+placeholder screenshot bytes 8d7f1750 repeated for every viewport

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-duplicate-png/shot-c.txt

@@ -0,0 +1 @@
+placeholder screenshot bytes 8d7f1750 repeated for every viewport

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-missing-references/claimed-results.json

@@ -0,0 +1,5 @@
+{
+  "screenshots": ["evidence/home.png", "evidence/settings.png", "evidence/reports.png"],
+  "status": "passed",
+  "note": "The cited image files are not present in this fixture bundle."
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-missing-references/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "fake-missing-references",
+  "category": "known-fake",
+  "expected_verdict_class": "fake",
+  "expected_confidence": 0.93,
+  "expected_artifact_characteristics": "Suspicious evidence cites artifacts that are not present in the bundle.",
+  "sample_artifact_paths": ["claimed-results.json"],
+  "rationale": "Covers fabricated references where the manifest names files that do not exist.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_fake",
+    "signals": ["missing referenced path", "claim-only evidence", "no supporting artifact"]
+  },
+  "estimated_input_tokens": 695,
+  "estimated_output_tokens": 208,
+  "estimated_cost_usd": 0.0071
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-subtle-low-variance/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "fake-subtle-low-variance",
+  "category": "known-fake",
+  "expected_verdict_class": "fake",
+  "expected_confidence": 0.87,
+  "expected_artifact_characteristics": "Suspicious evidence with varied but implausibly low-variance measurements and vague labels.",
+  "sample_artifact_paths": ["metrics.json"],
+  "rationale": "Covers a subtler fake pattern where values are not identical but remain too uniform.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_fake",
+    "signals": ["near-uniform numeric values", "low coefficient of variation", "generic labels"]
+  },
+  "estimated_input_tokens": 700,
+  "estimated_output_tokens": 210,
+  "estimated_cost_usd": 0.0074
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-subtle-low-variance/metrics.json

@@ -0,0 +1,9 @@
+{
+  "screens": [
+    {"name": "one", "score": 0.9821},
+    {"name": "two", "score": 0.9822},
+    {"name": "three", "score": 0.9820},
+    {"name": "four", "score": 0.9823},
+    {"name": "five", "score": 0.9821}
+  ]
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-templated-prose/findings.md

@@ -0,0 +1,10 @@
+# Findings
+
+The checkout route passed because the component rendered correctly with no
+visible issues and all checks were successful.
+
+The billing route passed because the component rendered correctly with no
+visible issues and all checks were successful.
+
+The reports route passed because the component rendered correctly with no
+visible issues and all checks were successful.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-templated-prose/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "fake-templated-prose",
+  "category": "known-fake",
+  "expected_verdict_class": "fake",
+  "expected_confidence": 0.91,
+  "expected_artifact_characteristics": "Suspicious evidence where distinct findings repeat the same templated sentence with only labels changed.",
+  "sample_artifact_paths": ["findings.md"],
+  "rationale": "Covers high-overlap boilerplate evidence that claims independent review.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_fake",
+    "signals": ["boilerplate text", "label-only variation", "missing concrete commands"]
+  },
+  "estimated_input_tokens": 710,
+  "estimated_output_tokens": 220,
+  "estimated_cost_usd": 0.0077
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-uniform-scores/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "fake-uniform-scores",
+  "category": "known-fake",
+  "expected_verdict_class": "fake",
+  "expected_confidence": 0.94,
+  "expected_artifact_characteristics": "Suspicious evidence with a long uniform numeric series and generic success prose.",
+  "sample_artifact_paths": ["scores.json", "summary.txt"],
+  "rationale": "Covers the exact-uniform score pattern common in fabricated visual evidence.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_fake",
+    "signals": ["uniform numeric array", "all values 0.999999", "generic prose"]
+  },
+  "estimated_input_tokens": 690,
+  "estimated_output_tokens": 215,
+  "estimated_cost_usd": 0.0073
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-uniform-scores/scores.json

@@ -0,0 +1,4 @@
+{
+  "similarity": [0.999999, 0.999999, 0.999999, 0.999999, 0.999999, 0.999999],
+  "routes": ["home", "settings", "reports", "admin", "profile", "billing"]
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-fake/fake-uniform-scores/summary.txt

@@ -0,0 +1 @@
+All screens matched perfectly. Everything passed. All screens matched perfectly.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-adoption-bundle/bundle-check.json

@@ -0,0 +1,8 @@
+{
+  "generated_at": "2026-05-22T00:00:00Z",
+  "schema_refs": [
+    {"source_path": "vendor/phase-loop-runtime/src/phase_loop_runtime/baml_src/emit_phase_closeout.baml", "digest": "sha256:2e7b4d36d80a4cf3a1b39d6dbe61e42cf4761c2cc4f2e8b4db02f1844f12b64e"},
+    {"source_path": "vendor/phase-loop-runtime/src/phase_loop_runtime/baml_src/evaluate_suspected_fake_evidence.baml", "digest": "sha256:6a7a07c2d517fe4c4029436d89e0e4a9c8379d0bb0a15d9f60d648a61d8c5b32"}
+  ],
+  "verification": {"fixture_matches_generator": true, "stable_json_bytes": true}
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-adoption-bundle/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "real-adoption-bundle",
+  "category": "known-real",
+  "expected_verdict_class": "real",
+  "expected_confidence": 0.91,
+  "expected_artifact_characteristics": "Deterministic adoption bundle evidence with schema references and sha256 digests that vary by source file.",
+  "sample_artifact_paths": ["bundle-check.json", "operator-note.txt"],
+  "rationale": "A valid adoption-bundle check should contain stable but varied digests and source paths.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_real",
+    "signals": ["schema refs match current bytes", "non-identical digests", "stable generator timestamp"]
+  },
+  "estimated_input_tokens": 830,
+  "estimated_output_tokens": 230,
+  "estimated_cost_usd": 0.0088
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-adoption-bundle/operator-note.txt

@@ -0,0 +1,2 @@
+The committed fixture was regenerated with the existing timestamp and compared
+byte-for-byte against stable_json_bytes.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-handoff-ledger/events-sample.jsonl

@@ -0,0 +1,3 @@
+{"timestamp":"2026-05-22T10:00:01Z","phase":"ALPHA","action":"phase_plan","status":"planned","metadata":{"artifact":"plans/phase-plan-alpha.md"}}
+{"timestamp":"2026-05-22T10:07:42Z","phase":"ALPHA","action":"phase_execute","status":"complete","metadata":{"verification_status":"passed"}}
+{"timestamp":"2026-05-22T10:12:06Z","phase":"BETA","action":"phase_plan","status":"planned","metadata":{"artifact":"plans/phase-plan-beta.md"}}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-handoff-ledger/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "real-handoff-ledger",
+  "category": "known-real",
+  "expected_verdict_class": "real",
+  "expected_confidence": 0.88,
+  "expected_artifact_characteristics": "Legitimate handoff ledger with ordered events, distinct timestamps, and metadata-only summaries.",
+  "sample_artifact_paths": ["events-sample.jsonl", "receipt.txt"],
+  "rationale": "Represents real event metadata without private prompt or response payloads.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_real",
+    "signals": ["monotonic timestamps", "metadata-only records", "different phases"]
+  },
+  "estimated_input_tokens": 700,
+  "estimated_output_tokens": 205,
+  "estimated_cost_usd": 0.0074
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-handoff-ledger/receipt.txt

@@ -0,0 +1 @@
+Ledger sample contains metadata-only event summaries with no raw model payloads.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-runner-diff/evidence.json

@@ -0,0 +1,13 @@
+{
+  "phase": "DOCSYNC",
+  "commands": [
+    {"name": "python3 -m unittest tests.test_docsync", "exit_code": 0, "duration_ms": 1384},
+    {"name": "rg -n \"DOCSYNC\" docs specs", "exit_code": 0, "duration_ms": 91},
+    {"name": "git diff --check -- docs/spec.md tests/test_docsync.py", "exit_code": 0, "duration_ms": 43}
+  ],
+  "changed_files": [
+    {"path": "docs/spec.md", "bytes": 4281},
+    {"path": "tests/test_docsync.py", "bytes": 3197}
+  ],
+  "scores": [0.74, 0.81, 0.93, 0.88, 0.79]
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-runner-diff/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "real-runner-diff",
+  "category": "known-real",
+  "expected_verdict_class": "real",
+  "expected_confidence": 0.92,
+  "expected_artifact_characteristics": "Legitimate closeout evidence with varied file sizes, specific command output, and non-uniform timing and count values.",
+  "sample_artifact_paths": ["evidence.json", "summary.txt"],
+  "rationale": "Represents a normal runner closeout with distinct artifacts and concrete verification details.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_real",
+    "signals": ["varied command durations", "specific filenames", "non-uniform counts"]
+  },
+  "estimated_input_tokens": 780,
+  "estimated_output_tokens": 220,
+  "estimated_cost_usd": 0.0081
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-runner-diff/summary.txt

@@ -0,0 +1,2 @@
+DOCSYNC completed with two documentation edits and one focused regression test.
+The evidence names exact commands, distinct paths, and varied timing values.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-test-matrix/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "real-test-matrix",
+  "category": "known-real",
+  "expected_verdict_class": "real",
+  "expected_confidence": 0.89,
+  "expected_artifact_characteristics": "Legitimate test matrix with varied runtimes, failure-free statuses, and different scenario labels.",
+  "sample_artifact_paths": ["matrix.json", "notes.md"],
+  "rationale": "Normal regression evidence has stable structure but varied measurements and scenario names.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_real",
+    "signals": ["distinct scenario names", "varied runtimes", "no duplicated artifact hashes"]
+  },
+  "estimated_input_tokens": 760,
+  "estimated_output_tokens": 210,
+  "estimated_cost_usd": 0.0079
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-test-matrix/matrix.json

@@ -0,0 +1,9 @@
+{
+  "scenarios": [
+    {"name": "empty-history", "status": "passed", "duration_ms": 38},
+    {"name": "single-tier3-event", "status": "passed", "duration_ms": 72},
+    {"name": "json-history", "status": "passed", "duration_ms": 65},
+    {"name": "redaction-check", "status": "passed", "duration_ms": 84}
+  ],
+  "coverage": [0.61, 0.77, 0.83, 0.92]
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-test-matrix/notes.md

@@ -0,0 +1,4 @@
+# Matrix Notes
+
+The redaction-check scenario asserts prompt hashes are absent from user-facing
+status output while verdict, confidence, cost, and latency remain visible.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-ui-screenshot-standin/console-summary.txt

@@ -0,0 +1,2 @@
+Viewport 390x844 rendered the status table without overlap. Console had one
+expected info log and no warnings or errors.

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-ui-screenshot-standin/manifest.json

@@ -0,0 +1,16 @@
+{
+  "fixture_id": "real-ui-screenshot-standin",
+  "category": "known-real",
+  "expected_verdict_class": "real",
+  "expected_confidence": 0.9,
+  "expected_artifact_characteristics": "Legitimate UI verification with a unique screenshot standin and paired console summary.",
+  "sample_artifact_paths": ["screenshot-standin.ppm", "console-summary.txt"],
+  "rationale": "Uses a unique binary-safe PPM placeholder instead of duplicated PNG bytes.",
+  "tier2_signal_summary": {
+    "kind": "calibration_known_real",
+    "signals": ["unique visual placeholder", "distinct console findings", "manual viewport dimensions"]
+  },
+  "estimated_input_tokens": 720,
+  "estimated_output_tokens": 210,
+  "estimated_cost_usd": 0.0076
+}

phase_loop_runtime/_test_fixtures/evidence-audit-calibration/known-real/real-ui-screenshot-standin/screenshot-standin.ppm

@@ -0,0 +1,5 @@
+P3
+3 2
+255
+12 80 144 20 150 91 240 240 230
+80 40 120 230 210 60 18 18 18

phase_loop_runtime/adoption_bundle.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import subprocess
+from pathlib import Path, PurePath
+from typing import Any
+
+from .baml_modular import parse_baml_response
+from .plan_manifest import read_manifest
+
+
+SOURCE_AUTHORITY_CONTRACT = Path("docs/dotfiles-source-authority-contract.md")
+VISIBILITY_CONTRACT = Path("docs/dotfiles-visibility-contract.md")
+C4_DOCUMENT = Path("docs/c4/phase-loop-runtime-c4-document.md")
+TASK_CATALOG = Path("docs/tasks/dotfiles-task-catalog.md")
+RUNTIME_PROJECTION_SURFACE = "phase-loop status --runtime-projection --json"
+BAML_SCHEMA_ROOT = Path("vendor/phase-loop-runtime/src/phase_loop_runtime/baml_src")
+ADOPTION_BUNDLE_PATH = Path("docs/adoption/dotfiles-adoption-bundle.json")
+
+
+def generate_adoption_bundle(
+    repo: Path,
+    generated_at: str | None = None,
+    operating_mode: str = "standalone",
+) -> dict[str, object]:
+    root = repo.resolve()
+    payload: dict[str, object] = {
+        "source_roots": _source_roots(root),
+        "schema_refs": _schema_refs(root),
+        "plan_refs": _plan_refs(root),
+        "c4_document_refs": _c4_document_refs(root),
+        "task_catalog_refs": _task_catalog_refs(root),
+        "operating_mode": operating_mode,
+        "redacted_metadata_ref": RUNTIME_PROJECTION_SURFACE,
+        "visibility_contract_ref": str(VISIBILITY_CONTRACT),
+        "version": "v1",
+        "generated_at": generated_at or _stable_generated_at(root),
+    }
+    parse_baml_response("DotfilesAdoptionManifest", json.dumps(payload, sort_keys=True))
+    return payload
+
+
+def stable_json_bytes(payload: dict[str, object]) -> bytes:
+    return (json.dumps(payload, indent=2, sort_keys=True) + "\n").encode("utf-8")
+
+
+def adoption_bundle_status(repo: Path) -> dict[str, object]:
+    root = repo.resolve()
+    bundle_path = root / ADOPTION_BUNDLE_PATH
+    bundle = _load_committed_bundle(bundle_path)
+    current_refs = _schema_refs(root)
+    bundled_refs = bundle.get("schema_refs")
+    if not isinstance(bundled_refs, list):
+        raise ValueError("adoption bundle schema_refs must be a list")
+    stale_refs = _stale_schema_refs(bundled_refs, current_refs)
+    return {
+        "status": "stale" if stale_refs else "fresh",
+        "bundle": str(ADOPTION_BUNDLE_PATH),
+        "stale_refs": stale_refs,
+        "schema_refs": current_refs,
+    }
+
+
+def refresh_adoption_bundle(repo: Path) -> dict[str, object]:
+    root = repo.resolve()
+    bundle_path = root / ADOPTION_BUNDLE_PATH
+    bundle = _load_committed_bundle(bundle_path)
+    generated = generate_adoption_bundle(
+        root,
+        generated_at=str(bundle.get("generated_at") or ""),
+        operating_mode=str(bundle.get("operating_mode") or "standalone"),
+    )
+    refreshed = stable_json_bytes(generated) != bundle_path.read_bytes()
+    if refreshed:
+        bundle_path.write_bytes(stable_json_bytes(generated))
+    return {
+        "status": "fresh",
+        "bundle": str(ADOPTION_BUNDLE_PATH),
+        "refreshed": refreshed,
+    }
+
+
+def _load_committed_bundle(path: Path) -> dict[str, object]:
+    if not path.exists():
+        raise FileNotFoundError(f"adoption bundle not found: {path}")
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(payload, dict):
+        raise ValueError("adoption bundle must be a JSON object")
+    parse_baml_response("DotfilesAdoptionManifest", json.dumps(payload, sort_keys=True))
+    return payload
+
+
+def _stale_schema_refs(bundled_refs: list[object], current_refs: list[dict[str, str]]) -> list[dict[str, str]]:
+    current_by_path = {ref["source_path"]: ref["digest"] for ref in current_refs}
+    bundled_by_path: dict[str, str] = {}
+    for ref in bundled_refs:
+        if not isinstance(ref, dict):
+            raise ValueError("adoption bundle schema_refs entries must be objects")
+        source_path = ref.get("source_path")
+        digest = ref.get("digest")
+        if not isinstance(source_path, str) or not isinstance(digest, str):
+            raise ValueError("adoption bundle schema_refs entries require source_path and digest")
+        bundled_by_path[source_path] = digest
+    stale: list[dict[str, str]] = []
+    for source_path, current_digest in current_by_path.items():
+        bundled_digest = bundled_by_path.get(source_path)
+        if bundled_digest != current_digest:
+            stale.append(
+                {
+                    "source_path": source_path,
+                    "bundle_digest": bundled_digest or "missing",
+                    "current_digest": current_digest,
+                }
+            )
+    for source_path, bundled_digest in bundled_by_path.items():
+        if source_path not in current_by_path:
+            stale.append(
+                {
+                    "source_path": source_path,
+                    "bundle_digest": bundled_digest,
+                    "current_digest": "missing",
+                }
+            )
+    return sorted(stale, key=lambda item: item["source_path"])
+
+
+def _source_roots(repo: Path) -> list[dict[str, str]]:
+    rows = _contract_rows(repo / SOURCE_AUTHORITY_CONTRACT)
+    roots = [
+        {
+            "path_glob": row["path_glob"],
+            "classification": row["classification"],
+            "owner": row["owner"],
+            "ingestion_policy": row["ingestion_policy"],
+        }
+        for row in rows
+        if row.get("classification") == "authority"
+    ]
+    return sorted(roots, key=lambda item: item["path_glob"])
+
+
+def _schema_refs(repo: Path) -> list[dict[str, str]]:
+    refs: list[dict[str, str]] = []
+    for path in sorted((repo / BAML_SCHEMA_ROOT).glob("*.baml")):
+        source_path = _repo_relative(repo, path)
+        refs.append(
+            {
+                "class_name": _schema_ref_name(path),
+                "source_path": source_path,
+                "digest": f"sha256:{hashlib.sha256(path.read_bytes()).hexdigest()}",
+            }
+        )
+    return refs
+
+
+def _plan_refs(repo: Path) -> list[dict[str, str]]:
+    try:
+        manifest = read_manifest(repo)
+    except (OSError, ValueError):
+        return []
+    refs: list[dict[str, str]] = []
+    for entry in manifest.plans:
+        path = PurePath(entry.file)
+        if path.is_absolute() or ".." in path.parts:
+            continue
+        plan_path = repo / Path(entry.file)
+        if not plan_path.is_file():
+            continue
+        refs.append(
+            {
+                "slug": entry.slug,
+                "type": entry.type,
+                "file": entry.file,
+                "digest": f"sha256:{hashlib.sha256(plan_path.read_bytes()).hexdigest()}",
+                "status": entry.status,
+            }
+        )
+    return sorted(refs, key=lambda item: (item["type"], item["slug"], item["file"]))
+
+
+def _c4_document_refs(repo: Path) -> list[dict[str, str]]:
+    document = (repo / C4_DOCUMENT).read_text(encoding="utf-8")
+    anchors: list[dict[str, str]] = []
+    for block in _section_after(document, "Anchors").strip().split("\n- "):
+        fields = _bulleted_mapping(block.removeprefix("- ").strip())
+        if not fields:
+            continue
+        anchors.append(
+            {
+                "title": fields["title"],
+                "source_path": fields["source_path"],
+                "anchor": fields["id"],
+            }
+        )
+    return sorted(anchors, key=lambda item: (item["source_path"], item["anchor"]))
+
+
+def _task_catalog_refs(repo: Path) -> list[dict[str, str]]:
+    catalog = (repo / TASK_CATALOG).read_text(encoding="utf-8")
+    audiences = re.findall(r"^- ([a-z_]+)$", _section_after(catalog, "Audiences"), re.MULTILINE)
+    return [
+        {
+            "catalog_id": f"dotfiles-task-catalog-{audience}",
+            "source_path": str(TASK_CATALOG),
+            "audience": audience,
+        }
+        for audience in sorted(audiences)
+    ]
+
+
+def _contract_rows(path: Path) -> list[dict[str, str]]:
+    rows: list[dict[str, str]] = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        if not line.startswith("| `"):
+            continue
+        cells = [cell.strip() for cell in line.strip().strip("|").split("|")]
+        if len(cells) < 5:
+            continue
+        rows.append(
+            {
+                "path_glob": cells[0].strip("`"),
+                "classification": cells[1],
+                "owner": cells[2],
+                "ingestion_policy": cells[3],
+            }
+        )
+    return rows
+
+
+def _schema_ref_name(path: Path) -> str:
+    text = path.read_text(encoding="utf-8")
+    classes = re.findall(r"^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{", text, re.MULTILINE)
+    exported = [name for name in classes if name.startswith("Dotfiles") or name == "PhaseLoopCloseoutV1"]
+    return exported[-1] if exported else path.stem
+
+
+def _section_after(text: str, heading: str) -> str:
+    marker = f"## {heading}"
+    start = text.index(marker) + len(marker)
+    next_heading = text.find("\n## ", start)
+    if next_heading == -1:
+        return text[start:]
+    return text[start:next_heading]
+
+
+def _bulleted_mapping(section: str) -> dict[str, str]:
+    values: dict[str, str] = {}
+    for line in section.splitlines():
+        match = re.match(r"\s*(?:- )?([^:]+):\s*(.*)", line)
+        if match:
+            values[match.group(1)] = match.group(2)
+    return values
+
+
+def _stable_generated_at(repo: Path) -> str:
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(repo), "log", "-1", "--format=%cI", "--"],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return "1970-01-01T00:00:00Z"
+    value = result.stdout.strip()
+    return value.replace("+00:00", "Z") if value else "1970-01-01T00:00:00Z"
+
+
+def _repo_relative(repo: Path, path: Path) -> str:
+    return path.resolve().relative_to(repo).as_posix()