agentic-project-kit 1.0.1__py3-none-any.whl

agentic_project_kit/chat_bootloader.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from agentic_project_kit.operational_handoff_projection import render_current_operational_handoff_state
+from agentic_project_kit.workspace import LEGACY_DEFAULTS, load_workspace
+
+DEFAULT_BOOTSTRAP_PATH = Path(LEGACY_DEFAULTS.handoff_root) / "NEXT_CHAT_BOOTSTRAP.md"
+START_PROMPT_PATH = "docs/handoff/START_NEW_CHAT_PROMPT.md"
+CLOSEOUT_PROMPT_PATH = "docs/handoff/CLOSEOUT_BEFORE_CHAT_SWITCH_PROMPT.md"
+BOOT_REPORT_PATH = Path(LEGACY_DEFAULTS.handoff_root) / "BOOT_REPORT.md"
+
+MANDATORY_BOOT_SOURCES = (
+    ".agentic/compiled_agent_context.yaml",
+    ".agentic/handoff_state.yaml",
+    ".agentic/operational_handoff_state.yaml",
+    ".agentic/rule_mechanism_inventory.yaml",
+    ".agentic/rule_migrations.yaml",
+    ".agentic/rule_preservation.yaml",
+    "docs/STATUS.md",
+    "docs/handoff/CURRENT_HANDOFF.md",
+    "docs/handoff/START_NEW_CHAT_PROMPT.md",
+    "docs/handoff/CLOSEOUT_BEFORE_CHAT_SWITCH_PROMPT.md",
+    "docs/governance/FINAL_SUMMARY_CONTRACT.md",
+    "docs/governance/CHAT_COMMUNICATION_CONTRACT.md",
+    "docs/governance/PORTABLE_CHAT_EXECUTION_CONTRACT.md",
+    "docs/governance/CHAT_BOOTSTRAP_AND_DRIFT_CONTRACT.md",
+    "docs/DOCUMENTATION_REGISTRY.yaml",
+    "docs/planning/PROJECT_DIRECTION.yaml",
+)
+
+BOOTLOADER_RULES = (
+    "Start from repository artifacts instead of chat memory.",
+    "Read mandatory boot sources before repository changes.",
+    "Prefer Python runners for local workflow execution; shell remains a thin adapter.",
+    "Use run_summary_renderer for final summaries in evidence-bearing workflows.",
+    "Evidence-bearing local workflow finalization must use `agentic-kit evidence finalize-log` or a stricter successor. Freehand final PASS footers are not valid closeout evidence.",
+    "Treat d, f, and w as communication signals rather than evidence.",
+    "Run `agentic-kit evidence inspect --require-summary` or inspect equivalent remote/repo evidence before continuing after chat control signals.",
+    "Inspect repo or remote evidence before requesting pasted terminal output.",
+    (
+        "Use the supported protected-change planning route before protected YAML, JSON, "
+        "or Markdown control changes: `./ns protected-change-plan --diff-file <file>` "
+        "or `python -m agentic_project_kit.protected_change_planner --diff-file <file>`. "
+        "Do not use `agentic-kit protected-change-plan`; that package CLI command is not "
+        "registered."
+    ),
+    "Before a chat switch, run the closeout prompt and check whether START_NEW_CHAT_PROMPT.md, CLOSEOUT_BEFORE_CHAT_SWITCH_PROMPT.md, and NEXT_CHAT_BOOTSTRAP.md all need updates.",
+)
+
+def current_operational_handoff_state(root: Path | str = ".") -> tuple[str, ...]:
+    return render_current_operational_handoff_state(root)
+
+NEXT_WORK_ITEMS = (
+    "Finish local sync after the bootloader/summary-runner merge and verify boot write/check plus targeted tests.",
+    "Use boot write to refresh docs/handoff/NEXT_CHAT_BOOTSTRAP.md before chat changes.",
+    "Harden no-op/PASS_ALREADY_DONE handling for already satisfied target states.",
+    "Use `agentic-kit evidence inspect --require-summary` after chat control signals so d/f/w do not rely on chat memory.",
+    "Use `agentic-kit evidence finalize-log` for evidence-bearing local workflow closeout so invalid summary fields cannot still end in a freehand final PASS.",
+    "Automate red CI failed-log diagnosis in the repo workflow path.",
+    "Resume Rule Registry Phase A only in small PRs: typed schema, generated projections, stronger assertions, query/impact analysis, and documentation integration.",
+    "Continue the document-management projection system: move operative truth into machine-readable sources and keep Markdown as generated or verified projection where possible.",
+    "Postpone GUI work until the workflow kernel, no-op handling, evidence inspection, and red-CI diagnosis are stable.",
+)
+
+
+@dataclass(frozen=True)
+class BootCheckResult:
+    source: str
+    exists: bool
+
+
+def _run_git(args: list[str], root: Path) -> str:
+    completed = subprocess.run(["git", *args], cwd=root, text=True, capture_output=True, check=False)
+    return completed.stdout.strip() if completed.returncode == 0 else "UNKNOWN"
+
+
+def current_git_head(root: Path | str = ".") -> str:
+    return _run_git(["rev-parse", "HEAD"], Path(root))
+
+
+def current_git_branch(root: Path | str = ".") -> str:
+    return _run_git(["branch", "--show-current"], Path(root))
+
+
+def check_boot_sources(root: Path | str = ".") -> tuple[BootCheckResult, ...]:
+    root_path = Path(root)
+    return tuple(BootCheckResult(source, (root_path / source).exists()) for source in MANDATORY_BOOT_SOURCES)
+
+
+def render_bootloader(root: Path | str = ".") -> str:
+    checks = check_boot_sources(root)
+    lines = [
+        "CHAT_BOOTLOADER",
+        "",
+        "Purpose: bootstrap a successor chat from repository truth.",
+        "",
+        "Mandatory boot sources:",
+    ]
+    for check in checks:
+        state = "present" if check.exists else "missing"
+        lines.append(f"- [{state}] {check.source}")
+    lines.extend(["", "Mandatory workflow rules:"])
+    for rule in BOOTLOADER_RULES:
+        lines.append(f"- {rule}")
+    lines.extend(
+        [
+            "",
+            "Required first action in a successor chat:",
+            "- Read these sources and verify main, open PRs, CI, STATUS, handoff, rule registry, and final-summary contracts before repository changes.",
+            "- If continuing after a chat control signal, run `agentic-kit evidence inspect --require-summary` or inspect equivalent remote/repo evidence first.",
+            "",
+            "### RESULT: PASS ###",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def render_next_chat_bootstrap(root: Path | str = ".", *, include_state: bool = False) -> str:
+    """Render the deterministic successor handoff bootstrap projection.
+
+    Prefer the committed latest successor package when present. This makes
+    bootstrap validation stable in CI merge-checkout contexts. The
+    chat-switch-complete command remains responsible for refreshing the package
+    from live local state.
+    """
+    package_context = Path(root) / "docs/reports/handoff-packages/latest/successor_context.yaml"
+    if package_context.exists():
+        from agentic_project_kit.successor_handoff_package import (
+            load_successor_context,
+            render_next_chat_bootstrap_from_context,
+        )
+
+        return render_next_chat_bootstrap_from_context(load_successor_context(package_context))
+
+    from agentic_project_kit.successor_handoff_package import build_successor_handoff_package
+
+    result = build_successor_handoff_package(root)
+    return result.next_chat_bootstrap
+
+
+
+def write_next_chat_bootstrap(
+    path: Path | str = DEFAULT_BOOTSTRAP_PATH,
+    root: Path | str = ".",
+    *,
+    include_state: bool = False,
+) -> Path:
+    output_path = Path(path)
+    if output_path == DEFAULT_BOOTSTRAP_PATH:
+        output_path = load_workspace(Path(root)).handoff_file("NEXT_CHAT_BOOTSTRAP.md")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(render_next_chat_bootstrap(root, include_state=include_state), encoding="utf-8")
+    return output_path
+
+
+def validate_generated_bootstrap(path: Path | str = DEFAULT_BOOTSTRAP_PATH, root: Path | str = ".") -> list[str]:
+    output_path = Path(path)
+    if output_path == DEFAULT_BOOTSTRAP_PATH:
+        output_path = load_workspace(Path(root)).handoff_file("NEXT_CHAT_BOOTSTRAP.md")
+    elif not output_path.is_absolute():
+        output_path = Path(root) / output_path
+    if not output_path.exists():
+        return [f"missing bootstrap file: {path}"]
+    expected = render_next_chat_bootstrap(root)
+    actual = output_path.read_text(encoding="utf-8")
+    if actual != expected:
+        return ["bootstrap file is not generated from chat_bootloader.py"]
+    return []
+
+
+def render_boot_report(root: Path | str = ".") -> str:
+    checks = check_boot_sources(root)
+    missing = [item.source for item in checks if not item.exists]
+    drift = validate_generated_bootstrap(root=root)
+    lines = [
+        "BOOT_REPORT",
+        "",
+        f"branch: {current_git_branch(root)}",
+        f"head: {current_git_head(root)}",
+        f"mandatory_sources_total: {len(checks)}",
+        f"mandatory_sources_missing: {len(missing)}",
+        "sources_read_required: yes",
+        "open_prs: inspect_remote_github_before_mutation",
+        "ci: inspect_remote_github_before_mutation",
+        "drift_findings:",
+    ]
+    lines.extend(f"- {finding}" for finding in drift) if drift else lines.append("- none")
+    lines.extend(
+        [
+            "next_safe_slice: verify remote PRs/CI, then continue with no-op/PASS_ALREADY_DONE hardening",
+            "### RESULT: PASS ###" if not missing and not drift else "### RESULT: FAIL ###",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def write_boot_report(path: Path | str = BOOT_REPORT_PATH, root: Path | str = ".") -> Path:
+    output_path = Path(path)
+    if output_path == BOOT_REPORT_PATH:
+        output_path = load_workspace(Path(root)).handoff_file("BOOT_REPORT.md")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(render_boot_report(root), encoding="utf-8")
+    return output_path
+
+
+def run_chat_switch_closeout(root: Path | str = ".") -> list[str]:
+    findings: list[str] = []
+    findings.extend(validate_generated_bootstrap(root=root))
+    missing = [item.source for item in check_boot_sources(root) if not item.exists]
+    findings.extend(f"missing mandatory boot source: {source}" for source in missing)
+    return findings
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="chat-bootloader")
+    parser.add_argument("--root", default=".")
+    parser.add_argument("--check", action="store_true")
+    parser.add_argument("--write", action="store_true")
+    parser.add_argument("--path", default=str(DEFAULT_BOOTSTRAP_PATH))
+    parser.add_argument("--include-state", action="store_true")
+    parser.add_argument("--report", action="store_true")
+    parser.add_argument("--closeout", action="store_true")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    status = 0
+    if args.write:
+        output_path = write_next_chat_bootstrap(args.path, args.root, include_state=args.include_state)
+        print(f"WROTE {output_path}")
+    elif args.report:
+        print(render_boot_report(args.root))
+    elif args.closeout:
+        findings = run_chat_switch_closeout(args.root)
+        if findings:
+            print("CHAT_SWITCH_CLOSEOUT: FAIL")
+            for finding in findings:
+                print(f"- {finding}")
+            status = 1
+        else:
+            print("CHAT_SWITCH_CLOSEOUT: PASS")
+    else:
+        print(render_bootloader(args.root))
+    if args.check:
+        missing = [item.source for item in check_boot_sources(args.root) if not item.exists]
+        if missing:
+            status = 1
+    return status
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agentic_project_kit/chat_entrypoint_contract.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import hashlib
+import re
+from typing import Any
+
+COMMAND_REFERENCE_JSON = "docs/reference/agentic-kit-commands.json"
+COMMAND_REFERENCE_MARKDOWN = "docs/reference/AGENTIC_KIT_COMMANDS.md"
+ENTRYPOINT_START = "<!-- command-manifest-entrypoint:start -->"
+ENTRYPOINT_END = "<!-- command-manifest-entrypoint:end -->"
+ENTRYPOINT_SOURCE_PATHS = (
+    "AGENTS.md",
+    "src/agentic_project_kit/workspace_init.py",
+    "src/agentic_project_kit/gui_task_editor.py",
+)
+CHAT_MODES = ("copy-paste", "remote", "file-transfer")
+_SHA_REFERENCE_RE = re.compile(
+    r"(?:manifest_sha:\s*|COMMAND_MANIFEST_ACK\s+)(?P<sha>[0-9a-f]{12}|stale|UNKNOWN)"
+)
+
+
+def load_command_manifest(root: Path | str = ".") -> dict[str, Any]:
+    path = Path(root) / COMMAND_REFERENCE_JSON
+    if not path.exists():
+        return {"meta": {"manifest_sha": "UNKNOWN"}, "commands": []}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {"meta": {"manifest_sha": "UNKNOWN"}, "commands": []}
+
+
+def command_manifest_sha(manifest: dict[str, Any]) -> str:
+    meta = manifest.get("meta") if isinstance(manifest.get("meta"), dict) else {}
+    return str(meta.get("manifest_sha") or "UNKNOWN")
+
+
+def computed_command_manifest_sha(manifest: dict[str, Any]) -> str:
+    commands = manifest.get("commands")
+    if not isinstance(commands, list):
+        return command_manifest_sha(manifest)
+    canonical = json.dumps(commands, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha256(canonical).hexdigest()[:12]
+
+
+def command_manifest_ack_line(manifest: dict[str, Any]) -> str:
+    return f"COMMAND_MANIFEST_ACK {command_manifest_sha(manifest)}"
+
+
+def mandatory_entrypoint_line(manifest: dict[str, Any]) -> str:
+    sha = command_manifest_sha(manifest)
+    return (
+        f"MANDATORY FIRST READ: {COMMAND_REFERENCE_JSON} (manifest_sha: {sha}). "
+        "Every reply containing commands MUST start with: "
+        f"COMMAND_MANIFEST_ACK {sha}. Consult `agentic-kit command-for` before proposing commands "
+        "and choose the most specific available Kit workflow command."
+    )
+
+
+def mandatory_entrypoint_block(manifest: dict[str, Any]) -> str:
+    return "\n".join((ENTRYPOINT_START, mandatory_entrypoint_line(manifest), ENTRYPOINT_END))
+
+
+def chat_refresher_lines(mode: str, manifest: dict[str, Any]) -> tuple[str, ...]:
+    normalized_mode = _normalize_chat_mode(mode)
+    sha = command_manifest_sha(manifest)
+    mode_lines = {
+        "copy-paste": "Mode copy-paste: your reply will be linted before execution.",
+        "remote": "Mode remote: read the manifest file first, it is the single source.",
+        "file-transfer": "Mode file-transfer: the carrier header pins the manifest sha.",
+    }
+    return (
+        command_manifest_ack_line(manifest),
+        f"Manifest: {COMMAND_REFERENCE_JSON} (manifest_sha: {sha}).",
+        "Before proposing ANY command run/consult `agentic-kit command-for` and choose the most specific available Kit workflow command.",
+        "raw git/gh commands with a mapped wrapper are rejected by instruction lint.",
+        mode_lines[normalized_mode],
+        f"Readable reference: {COMMAND_REFERENCE_MARKDOWN}.",
+    )
+
+
+def render_chat_refresher(mode: str = "copy-paste", root: Path | str = ".") -> str:
+    return "\n".join(chat_refresher_lines(mode, load_command_manifest(root))) + "\n"
+
+
+def render_chat_session_start(mode: str = "copy-paste", root: Path | str = ".") -> str:
+    manifest = load_command_manifest(root)
+    lines = [*chat_refresher_lines(mode, manifest), "", "Command manifest inline list:"]
+    for command in manifest.get("commands") or []:
+        if not isinstance(command, dict):
+            continue
+        lines.append(
+            f"{command.get('qualified_name', '')} · {command.get('safety', '')} · "
+            f"{command.get('when_to_use', '')}"
+        )
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _normalize_chat_mode(mode: str) -> str:
+    normalized = str(mode or "").strip().lower().replace("_", "-")
+    if normalized not in CHAT_MODES:
+        raise ValueError(f"unsupported chat mode: {mode}")
+    return normalized
+
+
+def command_reference_contract(
+    root: Path | str = ".",
+    *,
+    manifest: dict[str, Any] | None = None,
+    source_texts: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    repo_root = Path(root)
+    manifest = manifest or load_command_manifest(repo_root)
+    source_hashes: dict[str, str] = {}
+    for rel in (COMMAND_REFERENCE_JSON, COMMAND_REFERENCE_MARKDOWN):
+        if source_texts is not None and rel in source_texts:
+            source_hashes[rel] = hashlib.sha256(source_texts[rel].encode("utf-8")).hexdigest()
+        elif (path := repo_root / rel).exists():
+            source_hashes[rel] = hashlib.sha256(path.read_bytes()).hexdigest()
+
+    return {
+        "json": COMMAND_REFERENCE_JSON,
+        "markdown": COMMAND_REFERENCE_MARKDOWN,
+        "manifest_sha": command_manifest_sha(manifest),
+        "ack": command_manifest_ack_line(manifest),
+        "must_not_reconstruct_commands_from_memory": True,
+        "source_hashes": source_hashes,
+    }
+
+
+def command_reference_prompt_block(
+    root: Path | str = ".",
+    *,
+    manifest: dict[str, Any] | None = None,
+    source_texts: dict[str, str] | None = None,
+) -> str:
+    contract = command_reference_contract(root, manifest=manifest, source_texts=source_texts)
+    manifest = manifest or load_command_manifest(root)
+    hashes = contract["source_hashes"]
+    hash_lines = "\n".join(f"- {path}: {digest}" for path, digest in sorted(hashes.items()))
+    if not hash_lines:
+        hash_lines = "- source_hashes: unavailable; regenerate from repository root"
+
+    return (
+        "Command manifest entrypoint:\n"
+        f"- {mandatory_entrypoint_line(manifest)}\n"
+        f"- {chat_refresher_lines('remote', manifest)[2]}\n"
+        f"- {chat_refresher_lines('remote', manifest)[3]}\n\n"
+        "Command reference contract:\n"
+        f"- Read `{COMMAND_REFERENCE_JSON}` before composing agentic-kit commands.\n"
+        f"- Read `{COMMAND_REFERENCE_MARKDOWN}` before composing agentic-kit commands.\n"
+        "- `must_not_reconstruct_commands_from_memory: true`.\n"
+        "- Treat `source_hashes` as freshness evidence.\n"
+        "source_hashes:\n"
+        f"{hash_lines}"
+    )
+
+
+def ensure_command_reference_in_prompt(
+    prompt_text: str,
+    root: Path | str = ".",
+    *,
+    manifest: dict[str, Any] | None = None,
+    source_texts: dict[str, str] | None = None,
+) -> str:
+    manifest = manifest or load_command_manifest(root)
+    if (
+        COMMAND_REFERENCE_JSON in prompt_text
+        and command_manifest_ack_line(manifest) in prompt_text
+        and "must_not_reconstruct_commands_from_memory" in prompt_text
+    ):
+        return prompt_text
+    return (
+        prompt_text.rstrip()
+        + "\n\n"
+        + command_reference_prompt_block(root, manifest=manifest, source_texts=source_texts)
+        + "\n"
+    )
+
+
+_COMMAND_REFERENCE_PROMPT_BLOCK_RE = re.compile(
+    r"(?:\n\n)?Command manifest entrypoint:\n"
+    r".*?"
+    r"source_hashes:\n"
+    r"(?:- [^\n]+\n?)+",
+    re.DOTALL,
+)
+
+
+def upsert_command_reference_prompt_block(
+    prompt_text: str,
+    root: Path | str = ".",
+    *,
+    manifest: dict[str, Any] | None = None,
+    source_texts: dict[str, str] | None = None,
+) -> str:
+    block = command_reference_prompt_block(root, manifest=manifest, source_texts=source_texts)
+    if "Command manifest entrypoint:" in prompt_text and "Command reference contract:" in prompt_text:
+        updated = _COMMAND_REFERENCE_PROMPT_BLOCK_RE.sub("\n\n" + block + "\n", prompt_text, count=1)
+        if updated != prompt_text:
+            return updated.lstrip("\n")
+    return ensure_command_reference_in_prompt(prompt_text, root, manifest=manifest, source_texts=source_texts)
+
+
+def upsert_mandatory_entrypoint_block(text: str, manifest: dict[str, Any]) -> str:
+    block = mandatory_entrypoint_block(manifest)
+    if ENTRYPOINT_START in text and ENTRYPOINT_END in text:
+        pattern = re.compile(
+            re.escape(ENTRYPOINT_START) + r".*?" + re.escape(ENTRYPOINT_END),
+            re.DOTALL,
+        )
+        return pattern.sub(block, text, count=1)
+    heading = "# Agent Instructions"
+    if heading in text:
+        return text.replace(heading, heading + "\n\n" + block, 1)
+    return block + "\n\n" + text
+
+
+def sync_entrypoint_files(
+    root: Path | str,
+    *,
+    manifest: dict[str, Any],
+    markdown: str,
+    execute: bool = False,
+) -> dict[str, Any]:
+    repo_root = Path(root)
+    reference_targets: dict[str, str] = {
+        COMMAND_REFERENCE_JSON: json.dumps(manifest, indent=2, sort_keys=True) + "\n",
+        COMMAND_REFERENCE_MARKDOWN: markdown,
+    }
+    targets: dict[str, str] = dict(reference_targets)
+    agents_path = repo_root / "AGENTS.md"
+    if agents_path.exists():
+        targets["AGENTS.md"] = upsert_mandatory_entrypoint_block(
+            agents_path.read_text(encoding="utf-8"),
+            manifest,
+        )
+    start_prompt_path = repo_root / "docs/handoff/START_NEW_CHAT_PROMPT.md"
+    if start_prompt_path.exists():
+        targets["docs/handoff/START_NEW_CHAT_PROMPT.md"] = upsert_command_reference_prompt_block(
+            start_prompt_path.read_text(encoding="utf-8"),
+            repo_root,
+            manifest=manifest,
+            source_texts=reference_targets,
+        )
+
+    changed_paths: list[str] = []
+    for relative, desired in targets.items():
+        path = repo_root / relative
+        current = path.read_text(encoding="utf-8") if path.exists() else ""
+        if current != desired:
+            changed_paths.append(relative)
+            if execute:
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text(desired, encoding="utf-8")
+
+    return {
+        "schema_version": 1,
+        "kind": "commands_sync_entrypoints_result",
+        "result_status": "PASS",
+        "manifest_sha": command_manifest_sha(manifest),
+        "changed": bool(changed_paths),
+        "execute": execute,
+        "changed_paths": changed_paths,
+    }
+
+
+def audit_entrypoint_manifest_references(
+    root: Path | str,
+    manifest: dict[str, Any],
+) -> list[dict[str, str]]:
+    repo_root = Path(root)
+    expected_sha = computed_command_manifest_sha(manifest)
+    findings: list[dict[str, str]] = []
+    for relative in ENTRYPOINT_SOURCE_PATHS:
+        path = repo_root / relative
+        if not path.exists():
+            continue
+        text = path.read_text(encoding="utf-8")
+        if relative == "AGENTS.md" and mandatory_entrypoint_line(manifest) not in text:
+            findings.append(
+                {
+                    "code": "ENTRYPOINT_MANIFEST_BLOCK_MISSING",
+                    "message": f"{relative}: missing current command manifest entrypoint block",
+                }
+            )
+        for match in _SHA_REFERENCE_RE.finditer(text):
+            found = match.group("sha")
+            if found != expected_sha:
+                findings.append(
+                    {
+                        "code": "ENTRYPOINT_MANIFEST_SHA_MISMATCH",
+                        "message": f"{relative}: expected {expected_sha}, found {found}",
+                    }
+                )
+    return findings