feat(agent): cache control embedding index + auto-wire semantic pass (gated)

Item 2 of the semantic-mapping follow-ups.

Caching (2a): ControlIndex::load_or_build persists the embedded corpus to
snapshot_dir keyed by a corpus hash (control ids + requirement text). A later
scan reuses the embeddings unless the catalog changed, turning the per-scan
re-embed of the ~13.6k master-control corpus into a one-time cost. Atomic
write (temp + rename); self-invalidates on catalog change. ControlCheckSpec
gains Serialize/Deserialize to persist.

Auto-wire (2b): orchestrator Stage 5c runs semantic_stamp_findings after control
triage, gated on breakpilot.semantic_mapping (env BREAKPILOT_SEMANTIC_MAPPING,
default off). Stays off until verified live against a deployed master-controls
catalog; safe no-op meanwhile (the endpoint 400s pre-deploy and the pass warns +
returns 0).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.gitea/workflows/ci.yml

@@ -206,13 +206,11 @@ jobs:
           apk add --no-cache git curl openssl
           git init && git remote add origin "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
           git fetch --depth=1 origin "${GITHUB_SHA}" && git checkout FETCH_HEAD
-          IMAGE=repo.meghsakha.com/certifai/compliance-agent
-          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login repo.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
+          IMAGE=registry.meghsakha.com/compliance-agent
+          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login registry.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
           DOCKER_BUILDKIT=1 docker build --secret id=tramiton_token,env=TRAMITON_FETCH_TOKEN \
             -f Dockerfile.agent -t "$IMAGE:latest" -t "$IMAGE:${GITHUB_SHA}" .
           docker push "$IMAGE:latest" && docker push "$IMAGE:${GITHUB_SHA}"
-          command -v cosign >/dev/null 2>&1 || { curl -sSfLo /usr/local/bin/cosign https://github.com/sigstore/cosign/releases/download/v2.4.3/cosign-linux-amd64 && chmod +x /usr/local/bin/cosign; }
-          cosign sign --yes --key env://COSIGN_KEY "$IMAGE:latest" || echo "::warning::cosign failed"
           PAYLOAD=$(printf '{"ref":"refs/heads/main","repository":{"full_name":"sharang/compliance-scanner-agent"},"head_commit":{"id":"%s","message":"deploy agent"}}' "${GITHUB_SHA}")
           SIG=$(printf '%s' "$PAYLOAD" | openssl dgst -sha256 -hmac "${{ secrets.ORCA_WEBHOOK_SECRET }}" | awk '{print $2}')
           RESP=$(curl -fsS -w "\nHTTP %{http_code}" -X POST "http://46.225.100.82:6880/api/v1/webhooks/github" -H "Content-Type: application/json" -H "X-Hub-Signature-256: sha256=$SIG" -d "$PAYLOAD"); echo "$RESP"
@@ -232,13 +230,11 @@ jobs:
           apk add --no-cache git curl openssl
           git init && git remote add origin "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
           git fetch --depth=1 origin "${GITHUB_SHA}" && git checkout FETCH_HEAD
-          IMAGE=repo.meghsakha.com/certifai/compliance-dashboard
-          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login repo.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
+          IMAGE=registry.meghsakha.com/compliance-dashboard
+          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login registry.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
           DOCKER_BUILDKIT=1 docker build --secret id=tramiton_token,env=TRAMITON_FETCH_TOKEN \
             -f Dockerfile.dashboard -t "$IMAGE:latest" -t "$IMAGE:${GITHUB_SHA}" .
           docker push "$IMAGE:latest" && docker push "$IMAGE:${GITHUB_SHA}"
-          command -v cosign >/dev/null 2>&1 || { curl -sSfLo /usr/local/bin/cosign https://github.com/sigstore/cosign/releases/download/v2.4.3/cosign-linux-amd64 && chmod +x /usr/local/bin/cosign; }
-          cosign sign --yes --key env://COSIGN_KEY "$IMAGE:latest" || echo "::warning::cosign failed"
           PAYLOAD=$(printf '{"ref":"refs/heads/main","repository":{"full_name":"sharang/compliance-scanner-agent"},"head_commit":{"id":"%s","message":"deploy dashboard"}}' "${GITHUB_SHA}")
           SIG=$(printf '%s' "$PAYLOAD" | openssl dgst -sha256 -hmac "${{ secrets.ORCA_WEBHOOK_SECRET }}" | awk '{print $2}')
           RESP=$(curl -fsS -w "\nHTTP %{http_code}" -X POST "http://46.225.100.82:6880/api/v1/webhooks/github" -H "Content-Type: application/json" -H "X-Hub-Signature-256: sha256=$SIG" -d "$PAYLOAD"); echo "$RESP"
@@ -256,12 +252,10 @@ jobs:
           apk add --no-cache git curl openssl
           git init && git remote add origin "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
           git fetch --depth=1 origin "${GITHUB_SHA}" && git checkout FETCH_HEAD
-          IMAGE=repo.meghsakha.com/certifai/compliance-docs
-          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login repo.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
+          IMAGE=registry.meghsakha.com/compliance-docs
+          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login registry.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
           docker build -f Dockerfile.docs -t "$IMAGE:latest" -t "$IMAGE:${GITHUB_SHA}" .
           docker push "$IMAGE:latest" && docker push "$IMAGE:${GITHUB_SHA}"
-          command -v cosign >/dev/null 2>&1 || { curl -sSfLo /usr/local/bin/cosign https://github.com/sigstore/cosign/releases/download/v2.4.3/cosign-linux-amd64 && chmod +x /usr/local/bin/cosign; }
-          cosign sign --yes --key env://COSIGN_KEY "$IMAGE:latest" || echo "::warning::cosign failed"
           PAYLOAD=$(printf '{"ref":"refs/heads/main","repository":{"full_name":"sharang/compliance-scanner-agent"},"head_commit":{"id":"%s","message":"deploy docs"}}' "${GITHUB_SHA}")
           SIG=$(printf '%s' "$PAYLOAD" | openssl dgst -sha256 -hmac "${{ secrets.ORCA_WEBHOOK_SECRET }}" | awk '{print $2}')
           RESP=$(curl -fsS -w "\nHTTP %{http_code}" -X POST "http://46.225.100.82:6880/api/v1/webhooks/github" -H "Content-Type: application/json" -H "X-Hub-Signature-256: sha256=$SIG" -d "$PAYLOAD"); echo "$RESP"
@@ -281,13 +275,11 @@ jobs:
           apk add --no-cache git curl openssl
           git init && git remote add origin "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
           git fetch --depth=1 origin "${GITHUB_SHA}" && git checkout FETCH_HEAD
-          IMAGE=repo.meghsakha.com/certifai/compliance-mcp
-          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login repo.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
+          IMAGE=registry.meghsakha.com/compliance-mcp
+          echo "${{ secrets.REGISTRY_PASSWORD }}" | docker login registry.meghsakha.com -u "${{ secrets.REGISTRY_USERNAME }}" --password-stdin
           DOCKER_BUILDKIT=1 docker build --secret id=tramiton_token,env=TRAMITON_FETCH_TOKEN \
             -f Dockerfile.mcp -t "$IMAGE:latest" -t "$IMAGE:${GITHUB_SHA}" .
           docker push "$IMAGE:latest" && docker push "$IMAGE:${GITHUB_SHA}"
-          command -v cosign >/dev/null 2>&1 || { curl -sSfLo /usr/local/bin/cosign https://github.com/sigstore/cosign/releases/download/v2.4.3/cosign-linux-amd64 && chmod +x /usr/local/bin/cosign; }
-          cosign sign --yes --key env://COSIGN_KEY "$IMAGE:latest" || echo "::warning::cosign failed"
           PAYLOAD=$(printf '{"ref":"refs/heads/main","repository":{"full_name":"sharang/compliance-scanner-agent"},"head_commit":{"id":"%s","message":"deploy mcp"}}' "${GITHUB_SHA}")
           SIG=$(printf '%s' "$PAYLOAD" | openssl dgst -sha256 -hmac "${{ secrets.ORCA_WEBHOOK_SECRET }}" | awk '{print $2}')
           RESP=$(curl -fsS -w "\nHTTP %{http_code}" -X POST "http://46.225.100.82:6880/api/v1/webhooks/github" -H "Content-Type: application/json" -H "X-Hub-Signature-256: sha256=$SIG" -d "$PAYLOAD"); echo "$RESP"

compliance-agent/rules/cra_semgrep.yaml

@@ -1,117 +0,0 @@
-# Custom semgrep rules for CRA controls that no off-the-shelf ruleset digs out.
-# Each rule id is `cra-ai-<n>-<slug>` and is keyed back to its control via the
-# `control-map` LUT (by rule-id suffix, so semgrep's path prefix on check_id does
-# not matter). Detection here is deterministic; the grounded LLM judge downstream
-# only confirms/refutes — it never detects. Keep patterns tight: a false positive
-# that the judge refutes marks the whole finding a false positive.
-rules:
-  # --- cra-ai-1: Secure-by-Default-Konfiguration -------------------------------
-  - id: cra-ai-1-flask-debug-enabled
-    languages: [python]
-    severity: WARNING
-    message: Flask app started with debug=True — ships an interactive debugger / code execution in production (secure-by-default violation).
-    metadata:
-      cwe: ["CWE-489: Active Debug Code"]
-      control: cra-ai-1
-    patterns:
-      - pattern: '$APP.run(..., debug=True, ...)'
-
-  - id: cra-ai-1-django-debug-true
-    languages: [python]
-    severity: WARNING
-    message: Django DEBUG = True — leaks stack traces / settings in production (secure-by-default violation).
-    metadata:
-      cwe: ["CWE-489: Active Debug Code"]
-      control: cra-ai-1
-    patterns:
-      - pattern: 'DEBUG = True'
-
-  - id: cra-ai-1-tls-verify-disabled
-    languages: [python]
-    severity: ERROR
-    message: TLS certificate verification disabled (verify=False) — defeats transport security by default.
-    metadata:
-      cwe: ["CWE-295: Improper Certificate Validation"]
-      control: cra-ai-1
-    patterns:
-      - pattern: 'requests.$M(..., verify=False, ...)'
-
-  - id: cra-ai-1-cors-wildcard
-    languages: [javascript, typescript]
-    severity: WARNING
-    message: CORS Access-Control-Allow-Origin set to "*" — opens the API to any origin by default.
-    metadata:
-      cwe: ["CWE-942: Permissive Cross-domain Policy with Untrusted Domains"]
-      control: cra-ai-1
-    patterns:
-      - pattern-either:
-          - pattern: '$RES.header("Access-Control-Allow-Origin", "*")'
-          - pattern: '$RES.setHeader("Access-Control-Allow-Origin", "*")'
-
-  # --- cra-ai-7: Starke Authentifizierung (weak password hashing) --------------
-  - id: cra-ai-7-weak-password-hash
-    languages: [python]
-    severity: ERROR
-    message: Password/secret hashed with a fast, broken digest (md5/sha1) — use a password KDF (bcrypt/scrypt/argon2).
-    metadata:
-      cwe: ["CWE-916: Use of Password Hash With Insufficient Computational Effort"]
-      control: cra-ai-7
-    patterns:
-      - pattern-either:
-          - pattern: 'hashlib.md5($PW)'
-          - pattern: 'hashlib.sha1($PW)'
-      - metavariable-regex:
-          metavariable: $PW
-          regex: '(?i).*(pass|pwd|secret|cred|token).*'
-
-  # --- cra-ai-10: Sitzungsmanagement (insecure session cookies) ----------------
-  - id: cra-ai-10-session-cookie-insecure
-    languages: [python]
-    severity: ERROR
-    message: Session cookie hardened flag explicitly disabled (Secure/HttpOnly = False) — session token exposed to theft.
-    metadata:
-      cwe: ["CWE-614: Sensitive Cookie in HTTPS Session Without 'Secure' Attribute"]
-      control: cra-ai-10
-    patterns:
-      - pattern-either:
-          - pattern: 'SESSION_COOKIE_SECURE = False'
-          - pattern: 'SESSION_COOKIE_HTTPONLY = False'
-
-  - id: cra-ai-10-express-cookie-insecure
-    languages: [javascript, typescript]
-    severity: ERROR
-    message: Express cookie set with secure/httpOnly = false — session token exposed to interception / XSS theft.
-    metadata:
-      cwe: ["CWE-614: Sensitive Cookie in HTTPS Session Without 'Secure' Attribute"]
-      control: cra-ai-10
-    patterns:
-      - pattern-either:
-          - pattern: '$RES.cookie($NAME, $VAL, {..., secure: false, ...})'
-          - pattern: '$RES.cookie($NAME, $VAL, {..., httpOnly: false, ...})'
-
-  # --- cra-ai-14: Speicher-Schutz / Data at Rest (weak cipher) -----------------
-  - id: cra-ai-14-python-weak-cipher
-    languages: [python]
-    severity: ERROR
-    message: Data-at-rest encrypted with a broken cipher/mode (ECB, DES, 3DES) — provides no real confidentiality.
-    metadata:
-      cwe: ["CWE-327: Use of a Broken or Risky Cryptographic Algorithm"]
-      control: cra-ai-14
-    patterns:
-      - pattern-either:
-          - pattern: 'AES.new($K, AES.MODE_ECB, ...)'
-          - pattern: 'DES.new(...)'
-          - pattern: 'DES3.new(...)'
-
-  - id: cra-ai-14-node-weak-cipher
-    languages: [javascript, typescript]
-    severity: ERROR
-    message: Data-at-rest encrypted with a broken cipher (DES / deprecated createCipher) — provides no real confidentiality.
-    metadata:
-      cwe: ["CWE-327: Use of a Broken or Risky Cryptographic Algorithm"]
-      control: cra-ai-14
-    patterns:
-      - pattern-either:
-          - pattern: 'crypto.createCipheriv("des-ecb", ...)'
-          - pattern: 'crypto.createCipheriv("des", ...)'
-          - pattern: 'crypto.createCipher(...)'

compliance-agent/src/config.rs

@@ -103,8 +103,5 @@ fn load_breakpilot_config() -> BreakpilotConfig {
         semantic_mapping: env_var_opt("BREAKPILOT_SEMANTIC_MAPPING")
             .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
             .unwrap_or(d.semantic_mapping),
-        grounded_control_checks: env_var_opt("BREAKPILOT_GROUNDED_CHECKS")
-            .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
-            .unwrap_or(d.grounded_control_checks),
     }
 }

compliance-agent/src/controls/mod.rs

@@ -11,13 +11,12 @@ mod judge;
 mod oscal_provider;
 mod scan_triage;
 mod semantic;
-mod surface;
 mod triage;
 
 pub use checker::GroundedControlChecker;
 pub use index::ControlIndex;
 pub use judge::{ControlJudge, LlmControlJudge, PROMPT_VERSION};
 pub use oscal_provider::OscalControlsProvider;
-pub use scan_triage::{grounded_surface_findings, semantic_stamp_findings, triage_repo_findings};
+pub use scan_triage::{semantic_stamp_findings, triage_repo_findings};
 pub use semantic::SemanticControlChecker;
 pub use triage::{ControlTriage, TriageOutcome};

compliance-agent/src/controls/scan_triage.rs

@@ -16,10 +16,9 @@ use compliance_core::models::onboarding::ComplianceFramework;
 use compliance_core::AgentConfig;
 use control_map::ControlMap;
 
-use super::surface;
 use super::{
-    ControlIndex, ControlTriage, GroundedControlChecker, LlmControlJudge, OscalControlsProvider,
-    SemanticControlChecker, TriageOutcome,
+    ControlIndex, ControlTriage, LlmControlJudge, OscalControlsProvider, SemanticControlChecker,
+    TriageOutcome,
 };
 use crate::llm::LlmClient;
 
@@ -106,50 +105,6 @@ async fn build_specs(provider: &OscalControlsProvider) -> HashMap<String, Contro
     specs
 }
 
-/// Absence-based control pass (the grounded half of the hybrid coverage): for each
-/// control with a [`surface`] definition, deterministically retrieve the code
-/// surfaces it governs (login routes, logging setup, update/download code) and have
-/// the grounded judge decide whether the control holds there. Returns net-new
-/// findings, each already tagged with its control and grounded to a real snippet.
-///
-/// Gated: the orchestrator runs this only when `breakpilot.grounded_control_checks`
-/// is set. Absence detection is the least deterministic path (the judge decides
-/// presence/absence, not a syntactic pattern), so it stays off until tuned live.
-pub async fn grounded_surface_findings(
-    config: &AgentConfig,
-    llm: Arc<LlmClient>,
-    repo_path: &Path,
-    repo_id: &str,
-) -> Vec<Finding> {
-    let Some(base_url) = config.breakpilot.base_url.clone() else {
-        return Vec::new();
-    };
-    let provider = OscalControlsProvider::new(
-        reqwest::Client::new(),
-        base_url,
-        config.breakpilot.token.clone(),
-        &config.breakpilot.snapshot_dir,
-    );
-    let specs = build_specs(&provider).await;
-    if specs.is_empty() {
-        return Vec::new();
-    }
-    let checker = GroundedControlChecker::new(LlmControlJudge::new(llm));
-
-    let mut out = Vec::new();
-    for surf in surface::SURFACES {
-        let Some(spec) = specs.get(surf.control_id) else {
-            continue; // catalog doesn't carry this control
-        };
-        let regions = surface::retrieve(repo_path, surf.terms);
-        if regions.is_empty() {
-            continue;
-        }
-        out.extend(checker.check(spec, &regions, repo_id).await);
-    }
-    out
-}
-
 /// Read a window of lines around `line` (1-based) from `repo_path/file`.
 fn fetch_region(repo_path: &Path, file: &str, line: u32) -> Option<CandidateRegion> {
     let content = std::fs::read_to_string(repo_path.join(file)).ok()?;

compliance-agent/src/controls/surface.rs

@@ -1,246 +0,0 @@
-//! Surface retrieval for absence-based controls.
-//!
-//! Some CRA controls are violated by an *absence* — no rate limiting on login, no
-//! security logging, no signature check on an update — so there's no offending
-//! pattern for semgrep to match. Instead we deterministically locate the code
-//! *surface* the control governs (a login route, a logging setup, update/download
-//! code) by identifier/route terms, then hand each surface region to the grounded
-//! judge, which decides whether the control is satisfied there. The resulting
-//! finding grounds to the surface snippet, so nothing fabricated survives.
-//!
-//! Retrieval is intentionally cheap and bounded: keyword match + a fixed window,
-//! capped per control to keep the downstream LLM cost predictable.
-
-use std::path::Path;
-
-use compliance_core::control_check::CandidateRegion;
-
-/// An absence-based control and the case-insensitive terms that mark the code
-/// surface it governs.
-pub struct Surface {
-    pub control_id: &'static str,
-    pub terms: &'static [&'static str],
-}
-
-/// The absence-based CRA controls we retrieve surfaces for — the grounded half of
-/// the hybrid coverage (the pattern-expressible half is custom semgrep rules).
-pub const SURFACES: &[Surface] = &[
-    Surface {
-        control_id: "cra-ai-6", // Integritaetspruefung
-        terms: &[
-            "checksum",
-            "sha256",
-            "signature",
-            "hmac",
-            "integrity",
-            "verify",
-        ],
-    },
-    Surface {
-        control_id: "cra-ai-11", // Brute-Force-Schutz
-        terms: &[
-            "login",
-            "signin",
-            "authenticate",
-            "/auth",
-            "password",
-            "ratelimit",
-        ],
-    },
-    Surface {
-        control_id: "cra-ai-24", // Security-Logging
-        terms: &["login", "authorize", "permission", "role", "admin", "audit"],
-    },
-    Surface {
-        control_id: "cra-ai-27", // Log-Integritaet und -Aufbewahrung
-        terms: &["logging", "logger", "getlogger", "audit_log"],
-    },
-    Surface {
-        control_id: "cra-ai-28", // Sichere Update-Mechanismen
-        terms: &["update", "upgrade", "download", "firmware"],
-    },
-    Surface {
-        control_id: "cra-ai-29", // Update-Authentizitaet
-        terms: &["update", "signature", "verify", "pubkey", "certificate"],
-    },
-    Surface {
-        control_id: "cra-ai-30", // Update-Integritaet
-        terms: &["update", "checksum", "digest", "integrity", "verify"],
-    },
-];
-
-/// Source file extensions worth reading (skip binaries/assets/lockfiles).
-const CODE_EXTS: &[&str] = &[
-    "py", "js", "ts", "tsx", "jsx", "go", "java", "rb", "php", "rs", "cs", "kt",
-];
-/// Directories never worth walking.
-const SKIP_DIRS: &[&str] = &[
-    ".git",
-    "node_modules",
-    "target",
-    "vendor",
-    ".venv",
-    "__pycache__",
-    "dist",
-    "build",
-];
-/// Lines of context on each side of a hit.
-const WINDOW: usize = 6;
-/// Cap on regions per control, to bound downstream LLM calls.
-const MAX_REGIONS_PER_CONTROL: usize = 8;
-/// Skip files larger than this (generated/minified).
-const MAX_FILE_BYTES: u64 = 512 * 1024;
-
-/// Deterministically retrieve up to [`MAX_REGIONS_PER_CONTROL`] code regions in
-/// `repo_path` whose lines mention any of `terms`. Hits close together within a
-/// file are merged into one region; results are capped to bound LLM cost.
-pub fn retrieve(repo_path: &Path, terms: &[&str]) -> Vec<CandidateRegion> {
-    let lowered: Vec<String> = terms.iter().map(|t| t.to_lowercase()).collect();
-    let mut regions = Vec::new();
-    for entry in walk(repo_path) {
-        if regions.len() >= MAX_REGIONS_PER_CONTROL {
-            break;
-        }
-        let path = entry.path();
-        if !has_code_ext(path) {
-            continue;
-        }
-        let Ok(meta) = entry.metadata() else { continue };
-        if !meta.is_file() || meta.len() > MAX_FILE_BYTES {
-            continue;
-        }
-        let Ok(content) = std::fs::read_to_string(path) else {
-            continue;
-        };
-        let rel = path
-            .strip_prefix(repo_path)
-            .unwrap_or(path)
-            .to_string_lossy()
-            .to_string();
-        let lines: Vec<&str> = content.lines().collect();
-        let hits: Vec<usize> = lines
-            .iter()
-            .enumerate()
-            .filter(|(_, line)| {
-                let ll = line.to_lowercase();
-                lowered.iter().any(|t| ll.contains(t.as_str()))
-            })
-            .map(|(i, _)| i)
-            .collect();
-        for center in merge_centers(&hits) {
-            if regions.len() >= MAX_REGIONS_PER_CONTROL {
-                break;
-            }
-            let start = center.saturating_sub(WINDOW);
-            let end = (center + WINDOW + 1).min(lines.len());
-            regions.push(CandidateRegion {
-                file: rel.clone(),
-                start_line: (start as u32) + 1,
-                content: lines[start..end].join("\n"),
-            });
-        }
-    }
-    regions
-}
-
-/// Collapse ascending hit indices that fall within one window into a single
-/// representative center, so overlapping regions aren't judged repeatedly.
-fn merge_centers(hits: &[usize]) -> Vec<usize> {
-    let mut out: Vec<usize> = Vec::new();
-    for &h in hits {
-        match out.last() {
-            Some(&last) if h.saturating_sub(last) <= WINDOW => {}
-            _ => out.push(h),
-        }
-    }
-    out
-}
-
-fn has_code_ext(path: &Path) -> bool {
-    path.extension()
-        .and_then(|e| e.to_str())
-        .is_some_and(|e| CODE_EXTS.contains(&e))
-}
-
-fn walk(root: &Path) -> Vec<walkdir::DirEntry> {
-    walkdir::WalkDir::new(root)
-        .into_iter()
-        .filter_entry(|e| {
-            let name = e.file_name().to_string_lossy();
-            !SKIP_DIRS.contains(&name.as_ref())
-        })
-        .filter_map(|e| e.ok())
-        .collect()
-}
-
-#[cfg(test)]
-#[allow(clippy::unwrap_used)]
-mod tests {
-    use super::*;
-
-    fn write(dir: &Path, rel: &str, body: &str) {
-        let p = dir.join(rel);
-        if let Some(parent) = p.parent() {
-            std::fs::create_dir_all(parent).unwrap();
-        }
-        std::fs::write(p, body).unwrap();
-    }
-
-    fn terms_for(control_id: &str) -> &'static [&'static str] {
-        SURFACES
-            .iter()
-            .find(|s| s.control_id == control_id)
-            .unwrap()
-            .terms
-    }
-
-    #[test]
-    fn surfaces_cover_the_absence_based_controls() {
-        assert_eq!(SURFACES.len(), 7);
-        for id in [
-            "cra-ai-6",
-            "cra-ai-11",
-            "cra-ai-24",
-            "cra-ai-27",
-            "cra-ai-28",
-            "cra-ai-29",
-            "cra-ai-30",
-        ] {
-            assert!(SURFACES.iter().any(|s| s.control_id == id), "{id} missing");
-        }
-    }
-
-    #[test]
-    fn retrieves_matching_region_with_context() {
-        let dir = std::env::temp_dir().join(format!("surface-{}", uuid::Uuid::new_v4()));
-        std::fs::create_dir_all(&dir).unwrap();
-        write(
-            &dir,
-            "app/auth.py",
-            "import x\n\n\n\n\n\n\ndef login(u, p):\n    return check(u, p)\n",
-        );
-        let regions = retrieve(&dir, terms_for("cra-ai-11"));
-        assert_eq!(regions.len(), 1);
-        assert!(regions[0].content.contains("def login"));
-        assert_eq!(regions[0].file, "app/auth.py");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn skips_non_code_and_vendored() {
-        let dir = std::env::temp_dir().join(format!("surface-{}", uuid::Uuid::new_v4()));
-        std::fs::create_dir_all(&dir).unwrap();
-        write(&dir, "README.md", "login and password and audit\n"); // not code ext
-        write(&dir, "node_modules/pkg/index.js", "function login() {}\n"); // vendored
-        assert!(retrieve(&dir, terms_for("cra-ai-11")).is_empty());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn merges_adjacent_hits_into_one_region() {
-        // Two hits one line apart collapse to a single center/region.
-        assert_eq!(merge_centers(&[10, 11, 30]), vec![10, 30]);
-        assert_eq!(merge_centers(&[]), Vec::<usize>::new());
-        assert_eq!(merge_centers(&[5]), vec![5]);
-    }
-}

compliance-agent/src/controls/triage.rs

@@ -44,14 +44,10 @@ impl<J: ControlJudge> ControlTriage<J> {
     /// Triage one tool finding. `region` is the code around the finding, used as
     /// the grounding evidence for the judge.
     pub async fn triage(&self, finding: &Finding, region: &CandidateRegion) -> TriageOutcome {
-        // Match by CWE (off-the-shelf findings) and/or rule id (our custom
-        // detectors, which carry no LUT-bound CWE). A finding with neither is
-        // simply unmapped.
-        let mapped = self.map.controls_for_finding(
-            &finding.scanner,
-            finding.cwe.as_deref(),
-            finding.rule_id.as_deref(),
-        );
+        let Some(cwe) = finding.cwe.as_deref() else {
+            return TriageOutcome::Unmapped;
+        };
+        let mapped = self.map.controls_for(&finding.scanner, cwe);
         if mapped.is_empty() {
             return TriageOutcome::Unmapped;
         }
@@ -166,52 +162,6 @@ mod tests {
         assert_eq!(out, TriageOutcome::FalsePositive);
     }
 
-    #[tokio::test]
-    async fn custom_rule_finding_without_cwe_is_confirmed() {
-        // A custom detector finding carries a rule id but no LUT-bound CWE; it must
-        // still map (by rule id) and confirm.
-        let mut specs = specs();
-        specs.insert(
-            "cra-ai-1".to_string(),
-            ControlCheckSpec {
-                control_id: "cra-ai-1".into(),
-                title: "Secure-by-Default".into(),
-                requirement: "Ship secure defaults".into(),
-                default_cwe: None,
-                severity: Severity::Medium,
-            },
-        );
-        let triage = ControlTriage::new(
-            StubJudge {
-                verdict: LlmVerdict {
-                    violates: true,
-                    snippet: "app.run(debug=True)".into(),
-                    cwe: None,
-                    confidence: 0.9,
-                },
-            },
-            ControlMap::cra().unwrap(),
-            specs,
-        );
-        let mut f = Finding::new(
-            "repo".into(),
-            "fp".into(),
-            "semgrep".into(),
-            ScanType::Sast,
-            "flask debug".into(),
-            "desc".into(),
-            Severity::Medium,
-        );
-        f.rule_id = Some("tmp.x.cra-ai-1-flask-debug-enabled".into()); // no cwe
-        let region = CandidateRegion {
-            file: "app.py".into(),
-            start_line: 1,
-            content: "app.run(debug=True)\n".into(),
-        };
-        let out = triage.triage(&f, &region).await;
-        assert_eq!(out, TriageOutcome::Confirmed(vec!["cra-ai-1".to_string()]));
-    }
-
     #[tokio::test]
     async fn unmapped_cwe_is_left_untagged() {
         let triage = ControlTriage::new(

compliance-agent/src/pipeline/orchestrator.rs

@@ -252,31 +252,6 @@ impl PipelineOrchestrator {
             }
         }
 
-        // Stage 5d: grounded surface checks — the absence-based controls (no
-        // rate limiting, no security logging, no update-signature check) have no
-        // syntactic pattern to match, so we retrieve the code surface each governs
-        // and let the grounded judge decide whether it holds, producing net-new
-        // findings already tagged + grounded. Gated (default off): absence
-        // detection is the least deterministic path, kept off until tuned live.
-        if self.config.breakpilot.grounded_control_checks {
-            self.update_phase(scan_run_id, "grounded_control_checks")
-                .await;
-            let grounded = crate::controls::grounded_surface_findings(
-                &self.config,
-                self.llm.clone(),
-                &repo_path,
-                &repo_id,
-            )
-            .await;
-            if !grounded.is_empty() {
-                tracing::info!(
-                    "[{repo_id}] Grounded surface checks raised {} control findings",
-                    grounded.len()
-                );
-                all_findings.extend(grounded);
-            }
-        }
-
         // Dedup against existing findings and insert new ones
         let mut new_count = 0u32;
         let mut new_findings: Vec<Finding> = Vec::new();

compliance-agent/src/pipeline/semgrep.rs

@@ -1,4 +1,4 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use compliance_core::models::{Finding, ScanType, Severity};
 use compliance_core::traits::{ScanOutput, Scanner};
@@ -6,30 +6,6 @@ use compliance_core::CoreError;
 
 use crate::pipeline::dedup;
 
-/// Custom CRA-control detectors bundled into the binary and staged to a temp file
-/// at scan time so semgrep can `--config` them alongside the auto ruleset. These
-/// cover controls no off-the-shelf rule digs out (secure defaults, weak password
-/// hashing, insecure session cookies, weak data-at-rest ciphers); each rule id is
-/// keyed back to its control by the `control-map` LUT.
-const CRA_RULES: &str = include_str!("../../rules/cra_semgrep.yaml");
-
-/// Write the bundled CRA rules to a stable temp path (atomic: unique tmp +
-/// rename). Returns `None` on failure — the scan then runs with auto rules only.
-async fn stage_cra_rules() -> Option<PathBuf> {
-    let dir = std::env::temp_dir();
-    let path = dir.join("compliance-cra-semgrep.yaml");
-    let tmp = dir.join(format!("compliance-cra-semgrep.{}.tmp", std::process::id()));
-    if let Err(e) = tokio::fs::write(&tmp, CRA_RULES).await {
-        tracing::warn!(error = %e, "failed to stage custom CRA semgrep rules; using auto rules only");
-        return None;
-    }
-    if let Err(e) = tokio::fs::rename(&tmp, &path).await {
-        tracing::warn!(error = %e, "failed to stage custom CRA semgrep rules; using auto rules only");
-        return None;
-    }
-    Some(path)
-}
-
 pub struct SemgrepScanner;
 
 impl Scanner for SemgrepScanner {
@@ -43,26 +19,30 @@ impl Scanner for SemgrepScanner {
 
     #[tracing::instrument(skip_all)]
     async fn scan(&self, repo_path: &Path, repo_id: &str) -> Result<ScanOutput, CoreError> {
-        let cra_rules = stage_cra_rules().await;
-        let mut command = tokio::process::Command::new("semgrep");
-        command.arg("--config=auto");
-        if let Some(path) = &cra_rules {
-            command.arg(format!("--config={}", path.display()));
-        }
-        command
-            .args(["--json", "--quiet", "--max-memory", "500", "--jobs", "1"])
-            .arg(repo_path);
-
-        let output = tokio::time::timeout(std::time::Duration::from_secs(600), command.output())
-            .await
-            .map_err(|_| CoreError::Scanner {
-                scanner: "semgrep".to_string(),
-                source: "timed out after 10 minutes".into(),
-            })?
-            .map_err(|e| CoreError::Scanner {
-                scanner: "semgrep".to_string(),
-                source: Box::new(e),
-            })?;
+        let output = tokio::time::timeout(
+            std::time::Duration::from_secs(600),
+            tokio::process::Command::new("semgrep")
+                .args([
+                    "--config=auto",
+                    "--json",
+                    "--quiet",
+                    "--max-memory",
+                    "500",
+                    "--jobs",
+                    "1",
+                ])
+                .arg(repo_path)
+                .output(),
+        )
+        .await
+        .map_err(|_| CoreError::Scanner {
+            scanner: "semgrep".to_string(),
+            source: "timed out after 10 minutes".into(),
+        })?
+        .map_err(|e| CoreError::Scanner {
+            scanner: "semgrep".to_string(),
+            source: Box::new(e),
+        })?;
 
         if !output.status.success() && output.stdout.is_empty() {
             let stderr = String::from_utf8_lossy(&output.stderr);

compliance-core/src/config.rs

@@ -80,11 +80,6 @@ pub struct BreakpilotConfig {
     /// scale path and stays gated until verified live against a deployed
     /// master-controls catalog.
     pub semantic_mapping: bool,
-    /// Enable the **grounded surface** pass for absence-based controls (retrieve
-    /// the code surface a control governs, judge whether it holds). Off by
-    /// default: absence detection is the least deterministic path and stays gated
-    /// until tuned against live scans.
-    pub grounded_control_checks: bool,
 }
 
 impl Default for BreakpilotConfig {
@@ -94,7 +89,6 @@ impl Default for BreakpilotConfig {
             token: None,
             snapshot_dir: "/data/compliance-scanner/oscal".to_string(),
             semantic_mapping: false,
-            grounded_control_checks: false,
         }
     }
 }

control-map/data/cra_control_map.json

@@ -5,21 +5,9 @@
     {
       "control": "cra-ai-1",
       "title": "Secure-by-Default-Konfiguration",
-      "scans": [
-        {
-          "tool": "semgrep",
-          "scan_type": "sast",
-          "cwe": [],
-          "rules": [
-            "cra-ai-1-flask-debug-enabled",
-            "cra-ai-1-django-debug-true",
-            "cra-ai-1-tls-verify-disabled",
-            "cra-ai-1-cors-wildcard"
-          ]
-        }
-      ],
-      "note": null,
-      "status": "covered"
+      "scans": [],
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
+      "status": "needs_tooling"
     },
     {
       "control": "cra-ai-2",
@@ -53,24 +41,15 @@
       "control": "cra-ai-6",
       "title": "Integritaetspruefung",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {
       "control": "cra-ai-7",
       "title": "Starke Authentifizierung",
-      "scans": [
-        {
-          "tool": "semgrep",
-          "scan_type": "sast",
-          "cwe": [],
-          "rules": [
-            "cra-ai-7-weak-password-hash"
-          ]
-        }
-      ],
-      "note": null,
-      "status": "covered"
+      "scans": [],
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
+      "status": "needs_tooling"
     },
     {
       "control": "cra-ai-8",
@@ -121,25 +100,15 @@
     {
       "control": "cra-ai-10",
       "title": "Sitzungsmanagement",
-      "scans": [
-        {
-          "tool": "semgrep",
-          "scan_type": "sast",
-          "cwe": [],
-          "rules": [
-            "cra-ai-10-session-cookie-insecure",
-            "cra-ai-10-express-cookie-insecure"
-          ]
-        }
-      ],
-      "note": null,
-      "status": "covered"
+      "scans": [],
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
+      "status": "needs_tooling"
     },
     {
       "control": "cra-ai-11",
       "title": "Brute-Force-Schutz",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {
@@ -169,19 +138,9 @@
     {
       "control": "cra-ai-14",
       "title": "Speicher-Schutz (Data at Rest)",
-      "scans": [
-        {
-          "tool": "semgrep",
-          "scan_type": "sast",
-          "cwe": [],
-          "rules": [
-            "cra-ai-14-python-weak-cipher",
-            "cra-ai-14-node-weak-cipher"
-          ]
-        }
-      ],
-      "note": null,
-      "status": "covered"
+      "scans": [],
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
+      "status": "needs_tooling"
     },
     {
       "control": "cra-ai-15",
@@ -308,7 +267,7 @@
       "control": "cra-ai-24",
       "title": "Security-Logging",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {
@@ -329,28 +288,28 @@
       "control": "cra-ai-27",
       "title": "Log-Integritaet und -Aufbewahrung",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {
       "control": "cra-ai-28",
       "title": "Sichere Update-Mechanismen",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {
       "control": "cra-ai-29",
       "title": "Update-Authentizitaet",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {
       "control": "cra-ai-30",
       "title": "Update-Integritaet",
       "scans": [],
-      "note": "absence-based — no syntactic pattern; covered by the grounded surface check (retrieve surface + LLM judge), gated (BREAKPILOT_GROUNDED_CHECKS) pending live tuning",
+      "note": "code-checkable but no off-the-shelf tool digs it out — author a detector (custom semgrep rule / check)",
       "status": "needs_tooling"
     },
     {

control-map/src/lib.rs

@@ -66,14 +66,6 @@ pub struct ControlMap {
 
 const CRA_MAP_JSON: &str = include_str!("../data/cra_control_map.json");
 
-/// Whether an authored rule id `bound` matches a scanner's emitted rule id
-/// `actual`. semgrep prefixes local-rule check_ids with a path
-/// (`tmp.compliance-cra-semgrep.cra-ai-1-flask-debug-enabled`), so match the final
-/// id segment rather than requiring exact equality.
-fn rule_id_matches(bound: &str, actual: &str) -> bool {
-    actual == bound || actual.ends_with(&format!(".{bound}"))
-}
-
 impl ControlMap {
     /// Load the built-in CRA control map (the embedded, authored LUT).
     pub fn cra() -> Result<Self, MapError> {
@@ -88,28 +80,12 @@ impl ControlMap {
     /// Controls whose bindings include the given `tool` + `cwe` — used to attach a
     /// raw tool finding back to the control(s) it's evidence for.
     pub fn controls_for(&self, tool: &str, cwe: &str) -> Vec<&ControlEntry> {
-        self.controls_for_finding(tool, Some(cwe), None)
-    }
-
-    /// Controls a tool finding is evidence for, matched by CWE and/or the specific
-    /// rule id that fired. Off-the-shelf findings bind by CWE; our custom detectors
-    /// bind by rule id (precise — a broad CWE would over-attribute and then the
-    /// grounded judge could drop a genuine finding as a control false positive).
-    pub fn controls_for_finding(
-        &self,
-        tool: &str,
-        cwe: Option<&str>,
-        rule_id: Option<&str>,
-    ) -> Vec<&ControlEntry> {
         self.controls
             .iter()
             .filter(|c| {
-                c.scans.iter().any(|s| {
-                    s.tool == tool
-                        && (cwe.is_some_and(|w| s.cwe.iter().any(|x| x == w))
-                            || rule_id
-                                .is_some_and(|r| s.rules.iter().any(|b| rule_id_matches(b, r))))
-                })
+                c.scans
+                    .iter()
+                    .any(|s| s.tool == tool && s.cwe.iter().any(|w| w == cwe))
             })
             .collect()
     }
@@ -184,46 +160,4 @@ mod tests {
         assert!(s.needs_tooling > 0);
         assert!(s.not_code_checkable > 0);
     }
-
-    #[test]
-    fn rule_id_matching_handles_semgrep_path_prefix() {
-        let bound = "cra-ai-1-flask-debug-enabled";
-        assert!(rule_id_matches(bound, bound)); // exact
-        assert!(rule_id_matches(
-            bound,
-            "tmp.compliance-cra-semgrep.cra-ai-1-flask-debug-enabled"
-        )); // semgrep path prefix
-        assert!(!rule_id_matches(
-            bound,
-            "cra-ai-1-flask-debug-enabled-extra"
-        )); // not a suffix segment
-        assert!(!rule_id_matches(
-            bound,
-            "python.lang.security.exec-detected"
-        )); // unrelated
-    }
-
-    #[test]
-    fn custom_rule_finding_attaches_to_control_by_rule_id() {
-        let map = ControlMap::cra().unwrap();
-        // cra-ai-1 is now tool-covered by custom rules.
-        assert_eq!(map.coverage("cra-ai-1").unwrap().status, Coverage::Covered);
-        // A prefixed check_id still maps back to cra-ai-1 by rule id.
-        let hits =
-            map.controls_for_finding("semgrep", None, Some("tmp.x.cra-ai-1-tls-verify-disabled"));
-        assert!(hits.iter().any(|c| c.control == "cra-ai-1"));
-    }
-
-    #[test]
-    fn custom_rule_controls_do_not_bind_by_broad_cwe() {
-        let map = ControlMap::cra().unwrap();
-        // cra-ai-1 rules emit CWE-489 in metadata, but the LUT binds by rule id
-        // only (cwe: []) — so a stray CWE-489 finding must NOT attach to it.
-        assert!(map.controls_for("semgrep", "CWE-489").is_empty());
-        // The CWE path for off-the-shelf findings is unchanged.
-        assert!(map
-            .controls_for("semgrep", "CWE-798")
-            .iter()
-            .any(|c| c.control == "cra-ai-8"));
-    }
 }