Skip to content

alexgreensh/repo-forensics / skills/repo-forensics

repo-forensics

Flagged

Security forensics for git repos, AI skills, and MCP servers. Audits dependencies, detects prompt injection, credential theft, runtime dynamism, manifest drift, known CVEs, CISA KEV (actively exploited) vulns, and 2026 attack patterns. Not for fixing vulnerabilities or pentesting.

FileKindSize
.gitignoreother193 B
SKILL.mdskill md43.4 KB
checksums.jsonconfig10.8 KB
checksums.json.sigother64 B
data/README.mdmarkdown1.3 KB
data/compromised_versions.jsonconfig188.3 KB
data/rule_ids.csvother35.3 KB
data/rulepacks/.gitkeepother221 B
data/rulepacks/dead_anchors.jsonconfig9.0 KB
data/rulepacks/mcp_security.jsonconfig31.2 KB
data/rulepacks/runtime_dynamism.jsonconfig46.7 KB
data/rulepacks/sast.jsonconfig107.6 KB
data/rulepacks/secrets.jsonconfig30.4 KB
data/rulepacks/shared.jsonconfig4.4 KB
data/rulepacks/skill_threats.jsonconfig95.4 KB
data/runtime_floors.jsonconfig2.3 KB
data/yara/cryptominers.yarother1.8 KB
data/yara/hacktools.yarother2.2 KB
data/yara/malware.yarother2.2 KB
data/yara/manifest.jsonconfig8.0 KB
data/yara/webshells.yarother2.5 KB
references/cursor-hook-contract.mdmarkdown5.6 KB
references/kernel_privesc_sandbox_pack.mdmarkdown5.0 KB
references/mcp-attack-patterns.mdmarkdown8.7 KB
references/research_sources.mdmarkdown8.0 KB
references/threat_patterns.mdmarkdown20.3 KB
scripts/_context_gate.pyscript21.7 KB
scripts/_ed25519.pyscript5.1 KB
scripts/_pyc_unmarshal.pyscript17.1 KB
scripts/_shared_patterns.pyscript4.8 KB
scripts/adjudication.pyscript16.4 KB
scripts/adjudication_bridge.pyscript1.0 KB
scripts/aggregate_json.pyscript69.2 KB
scripts/auto_scan.pyexecutablescript152.1 KB
scripts/corpus_sync.pyscript10.0 KB
scripts/cursor_pre_scan.pyscript22.5 KB
scripts/dast_sandbox.sbother1.6 KB
scripts/dead_anchors_extract.pyscript14.8 KB
scripts/dead_anchors_probe.pyscript27.1 KB
scripts/forensics_core.pyscript176.5 KB
scripts/gen_rule_ids.pyscript8.6 KB
scripts/hook_adapter.pyscript19.4 KB
scripts/ioc_manager.pyscript49.6 KB
scripts/parse_pnpm_lock.pyscript7.9 KB
scripts/pre_scan.pyscript143.5 KB
scripts/pypi_pins.pyscript8.1 KB
scripts/refresh_controller.pyexecutablescript48.4 KB
scripts/refresh_threat_dbs.pyexecutablescript19.4 KB
scripts/rule_loader.pyscript44.8 KB
scripts/rulepack_feed.pyscript26.4 KB
scripts/run_forensics.shexecutablescript20.3 KB
scripts/sarif_export.pyscript18.6 KB
scripts/scan_agent_skills.pyscript33.2 KB
scripts/scan_archive.pyscript29.1 KB
scripts/scan_ast.pyscript44.9 KB
scripts/scan_binary.pyscript10.9 KB
scripts/scan_bytecode.pyscript28.2 KB
scripts/scan_dast.pyscript28.8 KB
scripts/scan_dataflow.pyscript15.4 KB
scripts/scan_dead_anchors.pyscript15.9 KB
scripts/scan_decode.pyscript37.5 KB
scripts/scan_dependencies.pyscript124.5 KB
scripts/scan_devcontainer.pyscript8.5 KB
scripts/scan_entropy.pyscript15.6 KB
scripts/scan_entrypoint.pyscript34.3 KB
scripts/scan_git_config.pyscript96.3 KB
scripts/scan_git_forensics.pyscript24.1 KB
scripts/scan_history.pyscript14.5 KB
scripts/scan_infra.pyscript54.3 KB
scripts/scan_integrity.pyscript41.0 KB
scripts/scan_lifecycle.pyscript65.1 KB
scripts/scan_manifest_drift.pyscript47.0 KB
scripts/scan_mcp_security.pyscript42.3 KB
scripts/scan_oversize.pyscript11.7 KB
scripts/scan_post_incident.pyscript36.9 KB
scripts/scan_provenance.pyscript19.4 KB
scripts/scan_runtime_dynamism.pyscript23.5 KB
scripts/scan_runtime_floors.pyscript33.5 KB
scripts/scan_sast.pyscript59.1 KB
scripts/scan_secrets.pyscript11.9 KB
scripts/scan_skill_threats.pyscript102.4 KB
scripts/scan_splitstream.pyscript29.5 KB
scripts/scan_yara.pyscript19.7 KB
scripts/session_scan.pyscript54.1 KB
scripts/suppressions.pyscript15.4 KB
scripts/validate_manifests.pyscript13.7 KB
scripts/verify_install.pyscript26.2 KB
scripts/vuln_feed.pyscript31.1 KB
tests/conftest.pyscript13.4 KB
tests/corpus/DEAD_ANCHORS_CORPUS.mdmarkdown2.3 KB
tests/corpus/budgets.jsonconfig5.6 KB
tests/cursor_helpers.pyscript12.6 KB
tests/fixtures/legacy_main_blocks.jsonconfig10.3 KB
tests/fixtures/powershell_verdict_corpus.jsonconfig114.9 KB
tests/golden/parity_mcp_security.jsonconfig17.5 KB
tests/golden/parity_runtime_dynamism.jsonconfig31.7 KB
tests/golden/parity_sast.jsonconfig59.8 KB
tests/golden/parity_secrets.jsonconfig18.8 KB
tests/golden/parity_skill_threats.jsonconfig48.8 KB
tests/parity_corpus.pyscript6.3 KB
tests/powershell_hook.pyscript8.2 KB
tests/report_builders.pyscript5.0 KB
tests/schemas/sarif-schema-2.1.0.jsonconfig109.1 KB
tests/shell_compat.pyscript2.2 KB
tests/test_adjudication_bridge.pyscript832 B
tests/test_adjudication_containment.pyscript1.4 KB
tests/test_adjudication_output.pyscript20.0 KB
tests/test_adjudication_suppressions.pyscript18.7 KB
tests/test_advisory_adjudication.pyscript1.3 KB
tests/test_agent_relay_rules.pyscript7.8 KB
tests/test_aggregate_json.pyscript10.0 KB
tests/test_auto_scan_patterns.pyscript10.5 KB
tests/test_benign_corpus.pyscript16.4 KB
tests/test_benign_new_scanners.pyscript6.1 KB
tests/test_build_output_skip.pyscript10.6 KB
tests/test_capability_ledger.pyscript18.8 KB
tests/test_codex_install.pyscript10.0 KB
tests/test_codex_marketplace.pyscript3.3 KB
tests/test_comment_false_positives.pyscript2.2 KB
tests/test_composer_dependencies.pyscript4.0 KB
tests/test_compromised_versions.pyscript51.2 KB
tests/test_context_gate.pyscript32.4 KB
tests/test_coverage_status.pyscript7.6 KB
tests/test_css_compounding_shrink.pyscript20.8 KB
tests/test_cursor_adapter.pyscript7.8 KB
tests/test_cursor_benign.pyscript3.4 KB
tests/test_cursor_degrade.pyscript12.7 KB
tests/test_cursor_install.pyscript17.1 KB
tests/test_cursor_latency.pyscript7.2 KB
tests/test_cursor_parity.pyscript5.8 KB
tests/test_cursor_redteam_fn.pyscript4.9 KB
tests/test_cursor_tamper_modify.pyscript14.2 KB
tests/test_cursor_wiring.pyscript32.3 KB
tests/test_d1_yara_correlation.pyscript9.2 KB
tests/test_dead_anchors_extract.pyscript7.6 KB
tests/test_dead_anchors_probe.pyscript19.7 KB
tests/test_evidence_engine_parity.pyscript8.1 KB
tests/test_evidence_model.pyscript11.4 KB
tests/test_forensics_core.pyscript79.2 KB
tests/test_fp_hardening_r3.pyscript9.7 KB
tests/test_fp_hardening_r4.pyscript18.8 KB
tests/test_fp_regression_pairs.pyscript62.5 KB
tests/test_fp_structural.pyscript21.2 KB
tests/test_freshness.pyscript6.2 KB
tests/test_frontmatter_validity.pyscript7.0 KB
tests/test_gpg_rce_hotfix.pyscript4.8 KB
tests/test_hook_inert_data.pyscript6.1 KB
tests/test_hook_scripts.pyscript14.0 KB
tests/test_inspection_cpu_budget.pyscript11.6 KB
tests/test_ioc_manager.pyscript55.4 KB
tests/test_kernel_privesc_rules.pyscript27.8 KB
tests/test_legit_precision_regressions.pyscript6.8 KB
tests/test_lethal_trifecta.pyscript20.7 KB
tests/test_manifest_signature.pyscript1.5 KB
tests/test_manifest_validity.pyscript2.9 KB
tests/test_monotonic_trust_e2e.pyscript4.4 KB
tests/test_non_breaking_contract.pyscript22.7 KB
tests/test_openclaw_install.pyscript6.6 KB
tests/test_pack_parity.pyscript24.8 KB
tests/test_parse_pnpm_lock.pyscript10.7 KB
tests/test_plugin_checkout_provenance.pyscript11.1 KB
tests/test_powershell_hook_wire.pyscript10.6 KB
tests/test_powershell_verdict_corpus.pyscript6.2 KB
tests/test_pr44_hardening.pyscript6.5 KB
tests/test_pre_scan.pyscript19.6 KB
tests/test_pre_scan_composer.pyscript7.4 KB
tests/test_precondition_fields.pyscript4.6 KB
tests/test_provenance_offline.pyscript2.5 KB
tests/test_published_rulepack_feed_current.pyscript1.4 KB
tests/test_py38_compat.pyscript3.3 KB
tests/test_pypi_pinned_versions.pyscript19.3 KB
tests/test_pyproject_string_forms.pyscript2.2 KB
tests/test_redteam_fn_regression.pyscript32.5 KB
tests/test_reflective_fetch_execute.pyscript23.5 KB
tests/test_reflective_review_fixes.pyscript17.8 KB
tests/test_refresh_controller.pyscript19.9 KB
tests/test_refresh_rulepacks.pyscript12.4 KB
tests/test_review_gate_regressions.pyscript9.3 KB
tests/test_rule_loader.pyscript23.2 KB
tests/test_rulepack_feed.pyscript38.1 KB
tests/test_run_forensics_json.pyscript1012 B
tests/test_run_scanner_fail_loud.pyscript6.5 KB
tests/test_runtime_floors.pyscript19.8 KB
tests/test_sandbox_probing_rules.pyscript9.6 KB
tests/test_sarif_export.pyscript19.9 KB
tests/test_scan_agent_skills.pyscript31.3 KB
tests/test_scan_archive.pyscript11.6 KB
tests/test_scan_ast.pyscript12.8 KB
tests/test_scan_binary.pyscript15.3 KB
tests/test_scan_bytecode.pyscript21.5 KB
tests/test_scan_dast.pyscript32.1 KB
tests/test_scan_dataflow.pyscript7.1 KB
tests/test_scan_dead_anchors.pyscript11.5 KB
tests/test_scan_decode.pyscript28.0 KB
tests/test_scan_dependencies.pyscript37.8 KB
tests/test_scan_devcontainer.pyscript8.5 KB
tests/test_scan_entropy.pyscript11.2 KB
tests/test_scan_entrypoint.pyscript19.5 KB
tests/test_scan_git_config.pyscript58.5 KB
tests/test_scan_git_config_review_fixes.pyscript33.3 KB

scripts/scan_history.py

View on GitHub
#!/usr/bin/env python3
"""Content-addressed scan attestations and deferred enrichment state."""

from __future__ import annotations

import hashlib
import json
import os
import platform
import re
import sqlite3
import sys
import time
from pathlib import Path


SCHEMA = """
CREATE TABLE IF NOT EXISTS attestations (
    id INTEGER PRIMARY KEY,
    run_ts REAL NOT NULL,
    tree_hash TEXT NOT NULL,
    rulepack_digest TEXT NOT NULL,
    scanner_versions TEXT NOT NULL,
    env_fingerprint TEXT NOT NULL,
    core_verdict TEXT NOT NULL,
    coverage_status TEXT NOT NULL,
    enrichment_status TEXT NOT NULL,
    evidence_hashes TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS attestations_tree_idx ON attestations(tree_hash);
CREATE TABLE IF NOT EXISTS tree_files (
    tree_hash TEXT NOT NULL,
    path TEXT NOT NULL,
    content_hash TEXT NOT NULL,
    PRIMARY KEY (tree_hash, path)
);
CREATE TABLE IF NOT EXISTS evidence_state (
    evidence_key TEXT PRIMARY KEY,
    evidence_type TEXT NOT NULL,
    status TEXT NOT NULL,
    checked_at REAL NOT NULL,
    ttl_seconds REAL NOT NULL,
    details TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS suppressions (
    fingerprint TEXT PRIMARY KEY,
    rule_id TEXT NOT NULL,
    relpath TEXT NOT NULL,
    file_hash TEXT NOT NULL,
    reason TEXT NOT NULL,
    created_at REAL NOT NULL
);
CREATE TABLE IF NOT EXISTS retry_queue (
    id INTEGER PRIMARY KEY,
    source_attestation_id INTEGER,
    capability TEXT NOT NULL,
    reason TEXT NOT NULL,
    queued_at REAL NOT NULL,
    completed_attestation_id INTEGER
);
"""


def default_db_path() -> str:
    return os.path.join(os.path.expanduser("~"), ".cache", "repo-forensics", "history.db")


def _canonical(value) -> str:
    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)


def _digest(value) -> str:
    return hashlib.sha256(_canonical(value).encode("utf-8")).hexdigest()


def tree_manifest(repo_path: str) -> dict[str, str]:
    """Return stable relative-path to content-hash entries for regular files."""
    root = Path(repo_path).resolve()
    manifest = {}
    for path in sorted(root.rglob("*")):
        if not path.is_file() or ".git" in path.parts:
            continue
        rel = path.relative_to(root).as_posix()
        try:
            manifest[rel] = hashlib.sha256(path.read_bytes()).hexdigest()
        except OSError:
            continue
    return manifest


def compute_tree_hash(repo_path: str) -> tuple[str, dict[str, str]]:
    manifest = tree_manifest(repo_path)
    return _digest(manifest), manifest


def environment_fingerprint() -> str:
    return _digest({
        "platform": platform.platform(),
        "python": platform.python_version(),
        "implementation": platform.python_implementation(),
    })


def compute_rulepack_digest(base_dir: str | None = None) -> str:
    """Hash shipped rule data without loading executable scanner modules."""
    root = Path(base_dir) if base_dir else Path(__file__).resolve().parent.parent / "data" / "rulepacks"
    entries = {}
    try:
        for path in sorted(root.glob("*.json")):
            entries[path.name] = hashlib.sha256(path.read_bytes()).hexdigest()
    except OSError:
        return "unavailable"
    return _digest(entries)


def scanner_versions(scanners: list[dict]) -> dict[str, str]:
    return {
        str(item.get("name", "unknown")): str(item.get("version", "unknown"))
        for item in scanners
    }


def evidence_hashes(findings: list[dict]) -> list[str]:
    return sorted(_digest(item) for item in findings)


class HistoryStore:
    def __init__(self, path: str | None = None):
        self.path = path or default_db_path()

    def connect(self):
        parent = os.path.dirname(self.path)
        os.makedirs(parent, mode=0o700, exist_ok=True)
        connection = sqlite3.connect(self.path)
        try:
            os.chmod(self.path, 0o600)
            connection.executescript(SCHEMA)
            connection.commit()
        except Exception:
            connection.close()
            raise
        return connection

    def record(self, repo_path: str, report: dict, rulepack_digest: str | None = None) -> dict:
        tree_hash, manifest = compute_tree_hash(repo_path)
        rulepack_digest = rulepack_digest or compute_rulepack_digest()
        versions = scanner_versions(report.get("scanners", []))
        env = environment_fingerprint()
        evidence = evidence_hashes(report.get("findings", []))
        fields = (
            time.time(), tree_hash, rulepack_digest, _canonical(versions), env,
            _canonical(report.get("core_verdict", {})),
            _canonical(report.get("coverage_status", {})),
            _canonical(report.get("enrichment_status", {})), _canonical(evidence),
        )
        with self.connect() as db:
            cursor = db.execute(
                "INSERT INTO attestations (run_ts, tree_hash, rulepack_digest, "
                "scanner_versions, env_fingerprint, core_verdict, coverage_status, "
                "enrichment_status, evidence_hashes) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                fields,
            )
            db.executemany(
                "INSERT OR IGNORE INTO tree_files (tree_hash, path, content_hash) VALUES (?, ?, ?)",
                [(tree_hash, path, digest) for path, digest in manifest.items()],
            )
            attestation_id = cursor.lastrowid
        return {
            "id": attestation_id,
            "tree_hash": tree_hash,
            "rulepack_digest": rulepack_digest,
            "scanner_versions": versions,
            "env_fingerprint": env,
            "evidence_hashes": evidence,
        }

    def get(self, attestation_id: int) -> dict | None:
        with self.connect() as db:
            db.row_factory = sqlite3.Row
            row = db.execute("SELECT * FROM attestations WHERE id = ?", (attestation_id,)).fetchone()
        return dict(row) if row else None

    def diff(self, tree_hash_a: str, tree_hash_b: str) -> dict:
        with self.connect() as db:
            rows = db.execute(
                "SELECT tree_hash, path, content_hash FROM tree_files WHERE tree_hash IN (?, ?)",
                (tree_hash_a, tree_hash_b),
            ).fetchall()
        left = {path: digest for tree, path, digest in rows if tree == tree_hash_a}
        right = {path: digest for tree, path, digest in rows if tree == tree_hash_b}
        return {
            "added": sorted(right.keys() - left.keys()),
            "removed": sorted(left.keys() - right.keys()),
            "changed": sorted(path for path in left.keys() & right.keys() if left[path] != right[path]),
        }

    def put_evidence_state(self, key: str, evidence_type: str, status: str,
                           checked_at: float, ttl_seconds: float, details=None):
        with self.connect() as db:
            db.execute(
                "INSERT OR REPLACE INTO evidence_state VALUES (?, ?, ?, ?, ?, ?)",
                (key, evidence_type, status, checked_at, ttl_seconds, _canonical(details or {})),
            )

    def evidence_freshness(self, now: float | None = None) -> list[dict]:
        now = time.time() if now is None else now
        with self.connect() as db:
            rows = db.execute(
                "SELECT evidence_key, evidence_type, status, checked_at, ttl_seconds, details "
                "FROM evidence_state"
            ).fetchall()
        result = []
        for key, kind, status, checked, ttl, details in rows:
            stale = now - checked > ttl
            result.append({
                "key": key, "type": kind,
                "status": "RECHECK_REQUIRED" if stale and kind == "dead_anchor" else "STALE" if stale else status,
                "checked_at": checked, "ttl_seconds": ttl, "details": json.loads(details),
            })
        return result

    def enqueue_retry(self, capability: str, reason: str, source_attestation_id=None) -> int:
        with self.connect() as db:
            cursor = db.execute(
                "INSERT INTO retry_queue (source_attestation_id, capability, reason, queued_at) "
                "VALUES (?, ?, ?, ?)",
                (source_attestation_id, capability, reason, time.time()),
            )
            return cursor.lastrowid

    def complete_retry(self, retry_id: int, new_attestation_id: int):
        with self.connect() as db:
            db.execute(
                "UPDATE retry_queue SET completed_attestation_id = ? WHERE id = ?",
                (new_attestation_id, retry_id),
            )

    def add_suppression(self, fingerprint: str, rule_id: str, relpath: str,
                        file_hash: str, reason: str, created_at: float | None = None):
        """Persist (or refresh) a WARN-tier adjudication downgrade."""
        with self.connect() as db:
            db.execute(
                "INSERT OR REPLACE INTO suppressions "
                "(fingerprint, rule_id, relpath, file_hash, reason, created_at) "
                "VALUES (?, ?, ?, ?, ?, ?)",
                (fingerprint, rule_id, relpath, file_hash, reason,
                 time.time() if created_at is None else created_at),
            )

    def list_suppressions(self) -> list[dict]:
        with self.connect() as db:
            db.row_factory = sqlite3.Row
            rows = db.execute(
                "SELECT fingerprint, rule_id, relpath, file_hash, reason, created_at "
                "FROM suppressions ORDER BY created_at"
            ).fetchall()
        return [dict(row) for row in rows]

    def revoke_suppression(self, prefix: str) -> int:
        """Revoke by exact fingerprint or unique prefix.

        Returns the number of records removed. Raises ValueError when the
        prefix matches more than one record (ambiguous) so the caller can
        refuse rather than delete the wrong suppression.
        """
        if not isinstance(prefix, str) or not re.fullmatch(r"[0-9a-f]{4,64}", prefix):
            raise ValueError("fingerprint must be 4 to 64 lowercase hex characters")
        with self.connect() as db:
            rows = db.execute(
                "SELECT fingerprint FROM suppressions "
                "WHERE substr(fingerprint, 1, length(?)) = ?",
                (prefix, prefix),
            ).fetchall()
            matches = [row[0] for row in rows]
            if len(matches) > 1:
                raise ValueError(
                    f"ambiguous fingerprint prefix {prefix!r}: matches {len(matches)} records"
                )
            if not matches:
                return 0
            db.execute("DELETE FROM suppressions WHERE fingerprint = ?", (matches[0],))
            return 1

    def clear_suppressions(self) -> int:
        with self.connect() as db:
            cursor = db.execute("DELETE FROM suppressions")
            return cursor.rowcount


def record_report_safely(repo_path: str, report: dict, db_path: str | None = None,
                         rulepack_digest: str | None = None) -> dict | None:
    """Persist an attestation without allowing storage failure onto the scan path."""
    try:
        return HistoryStore(db_path).record(repo_path, report, rulepack_digest)
    except (OSError, sqlite3.Error, ValueError, TypeError) as exc:
        print(f"[!] Scan history unavailable: {exc}", file=sys.stderr)
        return None


def evidence_history_enabled() -> bool:
    """Evidence freshness is opt-in, gated by the same HISTORY flag as attestations."""
    return os.environ.get("REPO_FORENSICS_HISTORY") == "1"


def evidence_db_path() -> str | None:
    """Return an explicit DB path if one is configured, otherwise None for the default."""
    if not evidence_history_enabled():
        return None
    return os.environ.get("REPO_FORENSICS_HISTORY_DB") or None


def put_evidence_state_safely(key: str, evidence_type: str, status: str,
                              checked_at: float, ttl_seconds: float,
                              details=None,
                              db_path: str | None = None) -> dict | None:
    """Persist per-anchor evidence state without allowing DB failures to crash a scan."""
    if db_path is None:
        db_path = evidence_db_path()
    if db_path is None:
        return None
    try:
        HistoryStore(db_path).put_evidence_state(
            key, evidence_type, status, checked_at, ttl_seconds, details
        )
    except (OSError, sqlite3.Error, ValueError, TypeError) as exc:
        print(f"[!] Evidence state unavailable: {exc}", file=sys.stderr)
        return None
    return {"key": key, "status": status}


def evidence_freshness_safely(db_path: str | None = None, now: float | None = None) -> list[dict]:
    """Read evidence freshness without allowing DB failures to block a scan."""
    if db_path is None:
        db_path = evidence_db_path()
    if db_path is None:
        return []
    try:
        return HistoryStore(db_path).evidence_freshness(now)
    except (OSError, sqlite3.Error, ValueError, TypeError) as exc:
        print(f"[!] Evidence freshness unavailable: {exc}", file=sys.stderr)
        return []


def suppressions_db_path() -> str:
    """Suppressions share the history DB file. REPO_FORENSICS_HISTORY_DB
    overrides the location (used by tests and power users); unlike the
    attestations feature, suppressions are NOT gated on REPO_FORENSICS_HISTORY
    — a recorded downgrade must apply on every scan, history or not."""
    return os.environ.get("REPO_FORENSICS_HISTORY_DB") or default_db_path()


def load_suppressions_safely(db_path: str | None = None) -> list[dict]:
    """Read active suppression records without ever affecting the scan path.

    Returns [] on any failure, and — unlike attestation reads — never creates
    the DB: a scan on a machine with no recorded downgrades must not write to
    disk just to discover that.
    """
    path = db_path or suppressions_db_path()
    try:
        if not os.path.isfile(path):
            return []
        return HistoryStore(path).list_suppressions()
    except (OSError, sqlite3.Error, ValueError, TypeError) as exc:
        print(f"[!] Adjudication suppressions unavailable: {exc}", file=sys.stderr)
        return []


def add_suppression_safely(fingerprint: str, rule_id: str, relpath: str,
                           file_hash: str, reason: str,
                           db_path: str | None = None) -> dict | None:
    try:
        HistoryStore(db_path or suppressions_db_path()).add_suppression(
            fingerprint, rule_id, relpath, file_hash, reason
        )
    except (OSError, sqlite3.Error, ValueError, TypeError) as exc:
        print(f"[!] Could not persist suppression: {exc}", file=sys.stderr)
        return None
    return {"fingerprint": fingerprint, "rule_id": rule_id, "relpath": relpath}
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall