v7.2: fix historical velocity tracking (repo_id), session UUID collision, read-only repo mount, SQLite pre-score, batched semgrep, real CI patch content

README.md

@@ -5,53 +5,62 @@ tags:
   - ai-governance
   - sandboxing
   - devsecops
-pretty_name: Adaptive Runtime Security Platform for Autonomous Agents (v7.2)
+pretty_name: Adaptive Runtime Security Platform for Autonomous Agents (v8.0)
 ---
 
-# Adaptive Runtime Security Platform for Autonomous Agents (v7.2)
+# Adaptive Runtime Security Platform for Autonomous Agents (v8.0)
 
 A production-ready, drop-in governance layer for AI coding agents (Claude Code, Cursor, Aider).
-v7.2 closes out the 4 major + 3 minor issues found in the v7.1 external review.
 
-## Changelog: v7.1 → v7.2
+It combines sandbox isolation, runtime telemetry, and weighted risk scoring to **contain**
+prompt injection and malicious agent behavior before changes reach the host repository.
+This is a defense-in-depth control, not a guarantee against all prompt injection — see
+"Scope & Limitations" below.
+
+## Changelog: v7.2 → v8.0
 
 | # | Issue | Severity | Fix |
 | --- | --- | --- | --- |
-| 1 | Session UUID collision (`date +%s` granularity) | High | Switched to `uuid.uuid4()` for guaranteed-unique session IDs |
-| 2 | Historical velocity always returned 0 (queried by unique `session_id`) | **Critical** | Track a stable `repo_id` (derived from git remote) and query history by repo, not session |
-| 3 | Pre-score stored in fragile `/tmp/pre_score_*.txt` files | Medium-High | Moved to a `session_state` SQLite table (WAL mode), no stale files or partial writes |
-| 4 | Container had RW access to the real repo + `.git` | High | Repo now mounts **read-only**; agent works in a tmpfs copy; only a scoped patch file crosses back to the host, applied only after JRI evaluation |
-| 5 | Semgrep spawned one process per changed file | Minor | Batched into a single `semgrep ... file1 file2 file3 --json` invocation |
-| 6 | CI only passed changed filenames into the prompt scorer | Minor | CI now passes actual patch content (truncated) for real prompt-injection scoring |
-| 7 | `refactor_heavy` profile branch was unreachable dead code | Minor | Added a `refactor_heavy` profile to config + prompt-intent detection so the branch is now reachable |
+| 1 | `cp -r` into tmpfs was slow/memory-heavy on monorepos (node_modules, build artifacts) | Medium | Sandbox now copies only git-tracked files via `git archive \| tar -x`, skipping ignored directories entirely |
+| 2 | No cap on patch size before the host tried to `git apply` it | High | Patch size checked against `max_patch_size_bytes` (default 5MB) *before* any apply attempt; oversized patches are rejected outright |
+| 3 | Prompt-injection regex could be bypassed by zero-width characters, bidi overrides, or whitespace fragmentation | Medium (partial mitigation) | Strip zero-width/bidi-override characters and collapse whitespace before pattern matching; messaging updated to accurately describe this as heuristic detection, not semantic analysis |
+| 4 | No timeout — a hung agent process could hold the sandbox open indefinitely | High | `timeout` wraps the full container run, killed and treated as a failed session if it exceeds `agent_runtime_timeout_seconds` (default 900s) |
+| 5 | `session_history` / `session_state` grew unbounded | Low-Medium | Auto-prune on every engine init, controlled by `history_retention_days` (default 30) |
+| 6 | If a patch failed to apply on the host, container-side activity was scored as zero — evidence lost | Medium (partial mitigation) | Orchestrator exports a small telemetry file (modified file count, apply-failure flag) that the engine folds into behavioral scoring even when the patch itself is rejected |
+
+## Scope & Limitations
+
+Be precise about what this does and doesn't do:
+
+- **Does**: sandbox agent execution (network-isolated, read-only host repo, resource-capped, timeout-enforced), detect common prompt-injection payloads and override signatures, cap the blast radius of any single agent session, and score risk across multiple independent signals before anything lands in the real repo.
+- **Does not**: perform semantic/LLM-based prompt analysis. Regex + normalization catches known attack patterns (override phrases, base64-encoded payloads, zero-width smuggling) but a sufficiently novel injection technique can still get through the pre-runtime gate. Treat the runtime sandbox and post-runtime scoring as your primary defenses, and pre-runtime prompt scanning as an early tripwire, not a guarantee.
 
 ## What's Included
 
 | File | Purpose |
 | --- | --- |
 | `core_engine.py` | Risk Fusion, Normalization & Policy Engine (JRI calculation) |
-| `config/security_profiles.json` | Context-aware weight profiles: `default`, `security_sensitive`, `refactor_heavy` |
+| `config/security_profiles.json` | Context-aware weight profiles + system tunables (patch size cap, runtime timeout, retention) |
 | `config/rules.semgrep.yml` | AST-aware semantic diff rules |
-| `scripts/secure-agent-orchestrator.sh` | Phase-driven execution wrapper — RO repo mount / RW tmpfs overlay / patch export |
+| `scripts/secure-agent-orchestrator.sh` | Phase-driven execution wrapper — RO repo mount / RW tmpfs overlay / patch export / timeout enforcement |
 | `.github/workflows/agent-governance.yml` | Remote CI pipeline arbiter |
 
-## Isolation Model (v7.2)
+## Isolation Model
 
 ```
-Host repo (read-only mount) ──► Container tmpfs copy (agent works here)
+Host repo (read-only mount) ──► Container tmpfs copy (git-tracked files only)
+                                        │
+                                timeout-bounded agent run
                                         │
                                         ▼
-                              git diff → /patches/session.patch
+                      git diff --cached → /patches/session.patch
+                      + modified_files.txt + telemetry.json
                                         │
                     (only this narrow RW mount crosses back)
                                         ▼
-                Host: git apply --check → git apply → JRI evaluation
+        Host: patch size check → git apply --check → git apply → JRI evaluation
 ```
 
-The agent can never touch host git refs, history, or objects directly — it only ever
-produces a patch, and that patch is applied on the host **after** the container is
-already destroyed, then scored before it's allowed to land.
-
 ## Quick Setup
 
 ```bash
@@ -59,6 +68,14 @@ chmod +x scripts/secure-agent-orchestrator.sh
 ./scripts/secure-agent-orchestrator.sh aider "your prompt here"
 ```
 
+## System Tunables (`config/security_profiles.json`)
+
+| Setting | Default | Purpose |
+| --- | --- | --- |
+| `max_patch_size_bytes` | 5242880 (5MB) | Reject oversized patches before host `git apply` ever sees them |
+| `agent_runtime_timeout_seconds` | 900 | Kill hung containers instead of letting them run indefinitely |
+| `history_retention_days` | 30 | Prune old `session_history` / `session_state` rows automatically |
+
 ## Risk Thresholds
 
 | Profile | Warn | Quarantine | Block & Isolate |

config/security_profiles.json

@@ -1,6 +1,9 @@
 {
   "system_settings": {
     "historical_decay_half_life_days": 3.0,
+    "history_retention_days": 30,
+    "max_patch_size_bytes": 5242880,
+    "agent_runtime_timeout_seconds": 900,
     "trusted_registries": [
       "https://registry.npmjs.org/",
       "https://files.pythonhosted.org/",

core_engine.py

@@ -9,7 +9,19 @@ import base64
 import subprocess
 import uuid
 import hashlib
-from datetime import datetime
+from datetime import datetime, timedelta
+
+# Characters commonly used to smuggle instructions past naive regex matching:
+# zero-width joiners/spaces and directional override marks. Stripped before
+# pattern matching so "ignore\u200bprevious" still triggers the same signature
+# as "ignoreprevious". This is still a heuristic layer, not semantic analysis —
+# see README for accurate scope-of-defense language.
+_ZERO_WIDTH_CHARS = "".join([
+    "\u200b", "\u200c", "\u200d", "\u2060", "\ufeff",
+    "\u202a", "\u202b", "\u202c", "\u202d", "\u202e",
+])
+_ZERO_WIDTH_RE = re.compile("[" + _ZERO_WIDTH_CHARS + "]")
+
 
 class AgentSecurityEngine:
     def __init__(self, workspace_dir, session_id, raw_prompt=""):
@@ -19,15 +31,12 @@ class AgentSecurityEngine:
         self.db_path = "/tmp/agent_intel_state.db"
         self.explain_log = []
 
-        # FIX #2 (Critical): historical velocity must be tracked per-repo, not per-session.
-        # A session_id is unique per run by design, so filtering history on it always
-        # returned zero prior rows. Derive a stable repo_id from the git remote (falling
-        # back to the absolute workspace path) so history persists across sessions.
         self.repo_id = self._derive_repo_id()
 
         self._init_database()
         self.config = self._load_config()
         self.profile = self._determine_context_profile()
+        self._prune_history()
 
     def _derive_repo_id(self):
         try:
@@ -40,8 +49,6 @@ class AgentSecurityEngine:
         return hashlib.sha256(basis.encode("utf-8")).hexdigest()[:16]
 
     def _init_database(self):
-        """WAL mode for concurrent access, plus a session_state table replacing the
-        fragile /tmp/pre_score_{session}.txt file (FIX #3)."""
         with sqlite3.connect(self.db_path, timeout=30.0) as conn:
             conn.execute("PRAGMA journal_mode=WAL;")
             conn.execute("""
@@ -66,14 +73,25 @@ class AgentSecurityEngine:
         with open(config_path, "r") as f:
             return json.load(f)
 
+    def _prune_history(self):
+        """FIX #5 (Low-Medium): unbounded growth in session_history/session_state
+        slows historical scans over months of use. Prune anything older than the
+        configured retention window on every engine init."""
+        retention_days = self.config.get("system_settings", {}).get("history_retention_days", 30)
+        cutoff = datetime.utcnow() - timedelta(days=retention_days)
+        try:
+            with sqlite3.connect(self.db_path, timeout=30.0) as conn:
+                conn.execute("DELETE FROM session_history WHERE timestamp < ?", (cutoff,))
+                conn.execute("DELETE FROM session_state WHERE created_at < ?", (cutoff,))
+        except Exception:
+            pass
+
     def _determine_context_profile(self):
         sensitive_patterns = r"(auth|login|jwt|rbac|oauth|session|crypto|credential|privilege|permission|token)"
         refactor_patterns = r"(refactor|restructure|rename across|migrate|reorganize|large-scale rewrite)"
 
         if re.search(sensitive_patterns, self.raw_prompt, re.IGNORECASE):
             return "security_sensitive"
-        # Makes the previously-dead "refactor_heavy" branch in evaluate_behavioral_risk
-        # reachable via prompt intent detection, instead of being unreachable dead logic.
         if re.search(refactor_patterns, self.raw_prompt, re.IGNORECASE) and "refactor_heavy" in self.config.get("context_profiles", {}):
             return "refactor_heavy"
         return "default"
@@ -85,24 +103,33 @@ class AgentSecurityEngine:
         if not self.raw_prompt:
             return 0
 
-        norm = unicodedata.normalize("NFKC", self.raw_prompt).lower()
+        # FIX #3 (Medium, partial mitigation): strip zero-width/bidi-override
+        # characters and apply NFKC normalization *before* stripping markdown/
+        # comments, so homoglyph/invisible-character smuggling doesn't slip
+        # override signatures past the regex. This still does not amount to
+        # semantic prompt analysis — see README for accurate framing.
+        norm = _ZERO_WIDTH_RE.sub("", self.raw_prompt)
+        norm = unicodedata.normalize("NFKC", norm).lower()
         norm = re.sub(r"<!--.*?-->", "", norm, flags=re.DOTALL)
         norm = re.sub(r"```.*?```", "", norm, flags=re.DOTALL)
+        # Collapse repeated whitespace/newlines, another common fragmentation trick
+        # (e.g. "ignore\n\nprevious" split across lines to dodge a single-line regex).
+        norm_collapsed = re.sub(r"\s+", " ", norm)
 
         b64_patterns = r"[a-zA-Z0-9+/]{40,}={0,2}"
         for match in re.findall(b64_patterns, norm):
             try:
                 decoded = base64.b64decode(match).decode("utf-8", errors="ignore").lower()
-                norm += " " + decoded
+                norm_collapsed += " " + re.sub(r"\s+", " ", decoded)
             except Exception:
                 pass
 
         score = 0
-        if re.search(r"(ignore previous|system override|bypass restrictions|developer mode)", norm):
+        if re.search(r"(ignore\s*previous|system\s*override|bypass\s*restrictions|developer\s*mode)", norm_collapsed):
             base_risk = 85; confidence = 0.95
             score += (base_risk * confidence)
             self.explain_log.append(f"Prompt Normalizer: Override signature detected (Contribution: +{int(base_risk * confidence)})")
-        if re.search(r"(reveal secrets|system prompt|read \.env)", norm):
+        if re.search(r"(reveal\s*secrets|system\s*prompt|read\s*\.env)", norm_collapsed):
             base_risk = 60; confidence = 0.90
             score += (base_risk * confidence)
             self.explain_log.append(f"Prompt Normalizer: Target vector probe signature detected (Contribution: +{int(base_risk * confidence)})")
@@ -116,8 +143,6 @@ class AgentSecurityEngine:
         return final_score
 
     def save_pre_score(self, score):
-        """FIX #3: persist pre-runtime score in SQLite instead of a /tmp text file,
-        which was prone to stale leftovers, partial writes, and no cleanup path."""
         with sqlite3.connect(self.db_path, timeout=30.0) as conn:
             conn.execute(
                 "INSERT OR REPLACE INTO session_state VALUES (?, ?, ?, ?)",
@@ -162,7 +187,21 @@ class AgentSecurityEngine:
             diff_stats = subprocess.check_output(["git", "diff", "--cached", "--numstat"], text=True).splitlines()
             lines_changed = sum(sum(int(x) for x in line.split()[:2] if x.isdigit()) for line in diff_stats)
         except Exception:
-            return 0
+            files_changed, lines_changed = 0, 0
+
+        # FIX #6 (Medium, partial mitigation): if the patch failed to apply on the
+        # host, the diff above is empty and this signal would silently go to zero
+        # even if the agent did something risky inside the container. Fold in
+        # container-side telemetry (modified file count) exported by the
+        # orchestrator alongside the patch, so a failed-apply doesn't erase evidence.
+        telemetry = self._load_container_telemetry()
+        if telemetry:
+            files_changed = max(files_changed, telemetry.get("modified_file_count", 0))
+            if telemetry.get("patch_apply_failed"):
+                self.explain_log.append(
+                    "Telemetry Bridge: Container-side patch failed to apply on host — "
+                    f"scoring against {telemetry.get('modified_file_count', 0)} modified files reported by container instead"
+                )
 
         max_files = 12 if self.profile == "refactor_heavy" else 3
         max_lines = 700 if self.profile == "refactor_heavy" else 150
@@ -177,9 +216,17 @@ class AgentSecurityEngine:
 
         return min(score, 100)
 
+    def _load_container_telemetry(self):
+        telemetry_path = os.environ.get("AGENT_TELEMETRY_PATH")
+        if not telemetry_path or not os.path.exists(telemetry_path):
+            return None
+        try:
+            with open(telemetry_path, "r") as f:
+                return json.load(f)
+        except Exception:
+            return None
+
     def evaluate_historical_velocity(self):
-        """FIX #2 (Critical): now queries by repo_id so history actually accumulates
-        across sessions instead of always looking up a session_id with zero prior rows."""
         half_life = self.config["system_settings"]["historical_decay_half_life_days"]
         with sqlite3.connect(self.db_path, timeout=30.0) as conn:
             cursor = conn.cursor()
@@ -213,8 +260,6 @@ class AgentSecurityEngine:
         return True
 
     def run_semgrep_ast_diff(self):
-        """FIX #5 (Minor): batch all target files into a single semgrep invocation
-        instead of spawning one process per file, which doesn't scale on monorepos."""
         try:
             changed_files = subprocess.check_output(["git", "diff", "--cached", "--name-only"], text=True).splitlines()
             target_modules = [f for f in changed_files if re.search(r"\.(ts|js|py|rs|go)$", f) and os.path.exists(f)]
@@ -237,7 +282,6 @@ class AgentSecurityEngine:
         return 0
 
     def compute_and_route_jri(self):
-        """Executes full mathematical matrix normalization across all signals."""
         pre_runtime_prompt_score = self.load_pre_score()
         b_score = self.evaluate_behavioral_risk()
         s_score = 100 if not self.verify_clean_secrets() else 0

scripts/secure-agent-orchestrator.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # ==============================================================================
-# Runtime Orchestrator: Enforces Split-Phase Lifecycle Topologies (v7.2)
+# Runtime Orchestrator: Enforces Split-Phase Lifecycle Topologies (v8.0)
 # ==============================================================================
 set -euo pipefail
 
@@ -8,11 +8,12 @@ WORKSPACE_DIR="$(pwd)"
 AGENT_TOOL="${1:-aider}"
 USER_PROMPT="${2:-""}"
 
-# FIX #1 (High): timestamp-second granularity collided on concurrent/rapid runs.
-# uuid4 guarantees uniqueness for /tmp/pre_score files, SQLite session rows, and
-# quarantine branch names.
 SESSION_UUID=$(python3 -c "import uuid; print(uuid.uuid4())")
 
+# Pull tunables from config so ops can adjust without touching this script.
+MAX_PATCH_SIZE=$(python3 -c "import json; print(json.load(open('config/security_profiles.json'))['system_settings']['max_patch_size_bytes'])")
+RUNTIME_TIMEOUT=$(python3 -c "import json; print(json.load(open('config/security_profiles.json'))['system_settings']['agent_runtime_timeout_seconds'])")
+
 PATCH_DIR="/tmp/agent_patches_${SESSION_UUID}"
 mkdir -p "$PATCH_DIR"
 
@@ -22,12 +23,16 @@ python3 core_engine.py "pre" "$SESSION_UUID" "$USER_PROMPT"
 echo "🔒 Spawning Hardened Linux Kernel Container Space ($SESSION_UUID)..."
 
 # 2. PHASE B: Secure Sandbox Perimeter Execution
-# FIX #4 (High): the repo itself is now mounted READ-ONLY. The agent only gets a
-# writable copy inside the container's own tmpfs (never bind-mounted from host),
-# so it cannot tamper with git internals, refs, or history on the real repo.
-# On exit, the container emits a patch file into the one narrow RW mount point
-# (PATCH_DIR) — that's the only thing that crosses back to the host filesystem.
-docker run -it --rm \
+#
+# FIX (Medium): the container now copies only *git-tracked* files instead of
+# `cp -r .`, which was slow and memory-heavy on monorepos and could balloon
+# on untracked build artifacts / node_modules. `git archive` streams tracked
+# content straight into the tmpfs copy without walking ignored directories.
+#
+# FIX (High): `timeout` wraps the whole docker invocation so a hung agent
+# process or stuck inference call can't hold the sandbox (and its resources)
+# open indefinitely — it gets killed and treated as a failed run.
+timeout --signal=KILL "${RUNTIME_TIMEOUT}s" docker run --rm \
   --name "secure_agent_$SESSION_UUID" \
   --network none \
   --memory="2g" \
@@ -45,22 +50,55 @@ docker run -it --rm \
   --mount type=bind,source=/dev/null,target=/workspace_ro/.env \
   -w /workspace \
   coder-agent-image:latest bash -c "
-    cp -r /workspace_ro/. /workspace/ &&
+    git --git-dir=/workspace_ro/.git --work-tree=/workspace_ro archive HEAD | tar -x -C /workspace &&
     cd /workspace &&
     $AGENT_TOOL '$USER_PROMPT' || true;
-    git diff > /patches/session.patch 2>/dev/null || true
-  "
+    git init -q &&
+    git add -A &&
+    git diff --cached > /patches/session.patch 2>/dev/null || true;
+    git diff --cached --name-only > /patches/modified_files.txt 2>/dev/null || true
+  " || echo "⚠️  Agent runtime terminated (timeout or nonzero exit) — evaluating whatever telemetry was captured."
 
 # 3. PHASE C: Post-Runtime Metric Evaluation & Active Routing
-# The JRI is computed against the *outside* repo state plus the pending patch,
-# so quarantine/block decisions never depend on code that only exists inside
-# the now-destroyed container.
+#
+# FIX (High): guard against oversized patches *before* the host git process
+# ever tries to parse them. A 40k-line / 500-file patch shouldn't be handed
+# to `git apply` at all — reject it outright and let it fall straight into
+# quarantine scoring instead.
+PATCH_APPLY_FAILED=false
+MODIFIED_FILE_COUNT=0
+
+if [ -f "$PATCH_DIR/modified_files.txt" ]; then
+  MODIFIED_FILE_COUNT=$(wc -l < "$PATCH_DIR/modified_files.txt" | tr -d ' ')
+fi
+
 if [ -s "$PATCH_DIR/session.patch" ]; then
-  git apply --check "$PATCH_DIR/session.patch" 2>/dev/null && \
-    git apply "$PATCH_DIR/session.patch" && \
+  PATCH_SIZE=$(wc -c < "$PATCH_DIR/session.patch")
+  if [ "$PATCH_SIZE" -gt "$MAX_PATCH_SIZE" ]; then
+    echo "❌ Patch rejected: ${PATCH_SIZE} bytes exceeds max_patch_size_bytes (${MAX_PATCH_SIZE}). Not applying to host repo."
+    PATCH_APPLY_FAILED=true
+  elif git apply --check "$PATCH_DIR/session.patch" 2>/dev/null; then
+    git apply "$PATCH_DIR/session.patch"
     git add -A
+  else
+    echo "⚠️  Patch failed git apply --check — not applying to host repo."
+    PATCH_APPLY_FAILED=true
+  fi
 fi
 
+# FIX (Medium): even when the patch can't be applied, don't lose the evidence.
+# Export a small telemetry file the engine can read to score against what the
+# container reported, instead of silently defaulting every signal to zero.
+TELEMETRY_PATH="$PATCH_DIR/telemetry.json"
+python3 -c "
+import json
+json.dump({
+    'modified_file_count': ${MODIFIED_FILE_COUNT},
+    'patch_apply_failed': ${PATCH_APPLY_FAILED,,}
+}, open('${TELEMETRY_PATH}', 'w'))
+"
+export AGENT_TELEMETRY_PATH="$TELEMETRY_PATH"
+
 python3 core_engine.py "post" "$SESSION_UUID" "$USER_PROMPT"
 
 rm -rf "$PATCH_DIR"