thumbgate 1.34.3 → 1.37.1

package/scripts/gurobi_optimizer.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python3
+"""
+Gurobi Optimization Engine for ThumbGate
+
+Formulates and solves MILP (Mixed-Integer Linear Programming) problems for:
+1. Model Tier & Provider Routing under Cost & Latency Constraints
+2. Active Prevention Rule Knapsack Selection under Latency & Token Budgets
+
+Uses gurobipy (v13+) with deterministic fallback logic.
+
+Security: --input accepts only inline JSON (no filesystem open). The Node bridge
+always passes JSON.stringify(payload); agentic path injection is impossible.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Dict, List
+
+try:
+    import gurobipy as gp
+    from gurobipy import GRB
+    GUROBI_AVAILABLE = True
+except ImportError:
+    gp = None  # type: ignore
+    GRB = None  # type: ignore
+    GUROBI_AVAILABLE = False
+
+
+def extract_iis(model: Any) -> List[str]:
+    """Return IIS constraint names. Empty when computeIIS is unavailable."""
+    if not GUROBI_AVAILABLE or model is None:
+        return []
+    try:
+        model.computeIIS()
+        return [c.ConstrName for c in model.getConstrs() if bool(getattr(c, "IISConstr", 0))]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def stamp_receipt(result: Dict[str, Any], *, model: Any = None) -> Dict[str, Any]:
+    """Pulse steal: proof, not plausible. Never mark a heuristic as certified."""
+    out = dict(result)
+    solver = str(out.get("solver") or "")
+    status = str(out.get("status") or "")
+    certified = solver == "gurobi" and status == "OPTIMAL" and out.get("success") is True
+    out["certified"] = certified
+    out["capturedRevenueUsd"] = 0
+    if certified:
+        out.setdefault("proof", "gurobi-optimal")
+        if model is not None:
+            try:
+                out["objBound"] = float(model.ObjBound)
+            except Exception:  # noqa: BLE001
+                pass
+            try:
+                out["mipGap"] = float(model.MIPGap)
+            except Exception:  # noqa: BLE001
+                pass
+    elif status.startswith("INFEASIBLE"):
+        out.setdefault("proof", "infeasible-iis")
+        if "iis" not in out and model is not None:
+            out["iis"] = extract_iis(model)
+    elif "heuristic" in solver or solver.endswith("-fallback") or "fallback" in solver:
+        out.setdefault("proof", "heuristic")
+    else:
+        out.setdefault("proof", "unproven")
+    return out
+
+
+def load_input_payload(raw: str) -> Dict[str, Any]:
+    """Parse --input as inline JSON only (no filesystem access)."""
+    text = (raw or "").strip()
+    if not text:
+        raise ValueError("empty input")
+    if not (text.startswith("{") or text.startswith("[")):
+        raise ValueError(
+            "input must be an inline JSON object (filesystem paths are not accepted)"
+        )
+    parsed = json.loads(text)
+    if not isinstance(parsed, dict):
+        raise ValueError("inline JSON input must be an object")
+    return parsed
+
+
+def create_gurobi_model(name: str):
+    """Creates a Gurobi model with OutputFlag=0 to prevent stdout license spam."""
+    env = gp.Env(empty=True)
+    env.setParam("OutputFlag", 0)
+    env.start()
+    return gp.Model(name, env=env)
+
+
+def solve_model_routing(
+    candidates: List[Dict[str, Any]],
+    max_budget_usd: float,
+    max_latency_ms: float,
+) -> Dict[str, Any]:
+    """Select one model candidate maximizing score under budget and latency."""
+    if not candidates:
+        return {"success": False, "selected": None, "reason": "No candidates provided"}
+
+    if not GUROBI_AVAILABLE:
+        valid = [
+            c
+            for c in candidates
+            if c.get("cost", 0) <= max_budget_usd and c.get("latency_ms", 0) <= max_latency_ms
+        ]
+        if not valid:
+            return stamp_receipt(
+                {
+                    "success": False,
+                    "selected": None,
+                    "solver": "heuristic-fallback",
+                    "objective": None,
+                    "status": "INFEASIBLE",
+                    "iis": ["BudgetLimit", "LatencyLimit"],
+                    "reason": "no candidate satisfies budget and latency",
+                }
+            )
+        best = max(valid, key=lambda c: c.get("score", 0))
+        return stamp_receipt(
+            {
+                "success": True,
+                "selected": best["id"],
+                "solver": "heuristic-fallback",
+                "objective": float(best.get("score", 0)),
+                "status": "HEURISTIC",
+            }
+        )
+
+    try:
+        model = create_gurobi_model("ModelRouting")
+        x = {}
+        for i, cand in enumerate(candidates):
+            cid = cand.get("id", f"c_{i}")
+            x[cid] = model.addVar(vtype=GRB.BINARY, name=f"x_{cid}")
+        model.update()
+        model.setObjective(
+            gp.quicksum(
+                x[cand.get("id", f"c_{i}")] * cand.get("score", 0.0)
+                for i, cand in enumerate(candidates)
+            ),
+            GRB.MAXIMIZE,
+        )
+        model.addConstr(
+            gp.quicksum(x[cand.get("id", f"c_{i}")] for i, cand in enumerate(candidates)) == 1,
+            "SelectOne",
+        )
+        model.addConstr(
+            gp.quicksum(
+                x[cand.get("id", f"c_{i}")] * cand.get("cost", 0.0)
+                for i, cand in enumerate(candidates)
+            )
+            <= max_budget_usd,
+            "BudgetLimit",
+        )
+        model.addConstr(
+            gp.quicksum(
+                x[cand.get("id", f"c_{i}")] * cand.get("latency_ms", 0.0)
+                for i, cand in enumerate(candidates)
+            )
+            <= max_latency_ms,
+            "LatencyLimit",
+        )
+        model.optimize()
+        if model.status == GRB.OPTIMAL:
+            selected_id = next((cid for cid, var in x.items() if var.X > 0.5), None)
+            return stamp_receipt(
+                {
+                    "success": True,
+                    "selected": selected_id,
+                    "solver": "gurobi",
+                    "objective": float(model.ObjVal),
+                    "status": "OPTIMAL",
+                },
+                model=model,
+            )
+        iis = extract_iis(model)
+        return stamp_receipt(
+            {
+                "success": False,
+                "selected": None,
+                "solver": "gurobi",
+                "objective": None,
+                "status": "INFEASIBLE",
+                "iis": iis,
+                "reason": "no feasible candidate under budget and latency",
+            },
+            model=model,
+        )
+    except Exception as exc:  # noqa: BLE001 — fail-open to heuristic for CI
+        valid = [
+            c
+            for c in candidates
+            if c.get("cost", 0) <= max_budget_usd and c.get("latency_ms", 0) <= max_latency_ms
+        ]
+        if not valid:
+            return stamp_receipt(
+                {
+                    "success": False,
+                    "selected": None,
+                    "solver": f"gurobi-error-fallback: {exc}",
+                    "objective": None,
+                    "status": "INFEASIBLE",
+                    "reason": str(exc),
+                }
+            )
+        best = max(valid, key=lambda c: c.get("score", 0))
+        return stamp_receipt(
+            {
+                "success": True,
+                "selected": best["id"],
+                "solver": f"gurobi-error-fallback: {exc}",
+                "objective": float(best.get("score", 0)),
+                "status": "HEURISTIC",
+            }
+        )
+
+
+def fallback_rule_selection(
+    rules: List[Dict[str, Any]],
+    max_eval_time_ms: float,
+    max_token_footprint: int,
+) -> Dict[str, Any]:
+    sorted_rules = sorted(
+        rules,
+        key=lambda r: float(r.get("risk_mitigation", 0))
+        / max(float(r.get("eval_time_ms", 0.1)), 0.1),
+        reverse=True,
+    )
+    selected = []
+    total_time = 0.0
+    total_tokens = 0
+    total_risk = 0.0
+    for rule in sorted_rules:
+        r_time = float(rule.get("eval_time_ms", 0.0))
+        r_tokens = int(rule.get("token_footprint", 0))
+        if total_time + r_time <= max_eval_time_ms and total_tokens + r_tokens <= max_token_footprint:
+            selected.append(rule.get("id"))
+            total_time += r_time
+            total_tokens += r_tokens
+            total_risk += float(rule.get("risk_mitigation", 0.0))
+    return stamp_receipt(
+        {
+            "success": True,
+            "selected_rules": selected,
+            "solver": "heuristic-knapsack",
+            "objective": total_risk,
+            "used_time_ms": total_time,
+            "used_tokens": total_tokens,
+            "status": "HEURISTIC",
+        }
+    )
+
+
+def solve_rule_selection(
+    rules: List[Dict[str, Any]],
+    max_eval_time_ms: float,
+    max_token_footprint: int,
+) -> Dict[str, Any]:
+    """0-1 knapsack over prevention rules under time and token budgets."""
+    if not rules:
+        return {"success": False, "selected_rules": [], "reason": "No rules provided"}
+
+    if not GUROBI_AVAILABLE:
+        return fallback_rule_selection(rules, max_eval_time_ms, max_token_footprint)
+
+    try:
+        model = create_gurobi_model("RuleKnapsackSelection")
+        y = {}
+        for i, rule in enumerate(rules):
+            rid = rule.get("id", f"r_{i}")
+            y[rid] = model.addVar(vtype=GRB.BINARY, name=f"rule_{rid}")
+        model.setObjective(
+            gp.quicksum(
+                y[rule.get("id", f"r_{i}")] * rule.get("risk_mitigation", 0.0)
+                for i, rule in enumerate(rules)
+            ),
+            GRB.MAXIMIZE,
+        )
+        model.addConstr(
+            gp.quicksum(
+                y[rule.get("id", f"r_{i}")] * rule.get("eval_time_ms", 0.0)
+                for i, rule in enumerate(rules)
+            )
+            <= max_eval_time_ms,
+            "EvalTimeLimit",
+        )
+        model.addConstr(
+            gp.quicksum(
+                y[rule.get("id", f"r_{i}")] * rule.get("token_footprint", 0)
+                for i, rule in enumerate(rules)
+            )
+            <= max_token_footprint,
+            "TokenFootprintLimit",
+        )
+        model.optimize()
+        if model.status == GRB.OPTIMAL:
+            selected_ids = [rid for rid, var in y.items() if var.X > 0.5]
+            used_time = sum(
+                r.get("eval_time_ms", 0.0) for r in rules if r.get("id") in selected_ids
+            )
+            used_tokens = sum(
+                r.get("token_footprint", 0) for r in rules if r.get("id") in selected_ids
+            )
+            return stamp_receipt(
+                {
+                    "success": True,
+                    "selected_rules": selected_ids,
+                    "solver": "gurobi",
+                    "objective": float(model.ObjVal),
+                    "used_time_ms": used_time,
+                    "used_tokens": used_tokens,
+                    "status": "OPTIMAL",
+                },
+                model=model,
+            )
+        return stamp_receipt(
+            {
+                "success": False,
+                "selected_rules": [],
+                "solver": "gurobi",
+                "objective": None,
+                "status": "INFEASIBLE",
+                "iis": extract_iis(model),
+                "reason": "rule knapsack infeasible",
+            },
+            model=model,
+        )
+    except Exception as exc:  # noqa: BLE001
+        res = fallback_rule_selection(rules, max_eval_time_ms, max_token_footprint)
+        res["solver"] = f"gurobi-error-fallback: {exc}"
+        return stamp_receipt(res)
+
+
+def solve_fleet_dispatch(
+    jobs: List[Dict[str, Any]],
+    max_ram_mb: int = 32768,
+    max_cpu_cores: int = 10,
+    max_concurrency: int = 4,
+) -> Dict[str, Any]:
+    """MILP Job-Shop / Machine-Scheduling to maximize dispatched priority while preventing starvation."""
+    if not jobs:
+        return {"success": False, "selected_jobs": [], "reason": "No jobs provided"}
+
+    if not GUROBI_AVAILABLE:
+        valid_jobs = []
+        cur_ram, cur_cpu = 0, 0
+        for j in sorted(jobs, key=lambda x: x.get("priority", 1), reverse=True):
+            r = j.get("ram_mb", 1024)
+            c = j.get("cpu_cores", 1)
+            if len(valid_jobs) < max_concurrency and cur_ram + r <= max_ram_mb and cur_cpu + c <= max_cpu_cores:
+                valid_jobs.append(j.get("id"))
+                cur_ram += r
+                cur_cpu += c
+        return {
+            "success": True,
+            "selected_jobs": valid_jobs,
+            "solver": "heuristic-fallback",
+            "allocated_ram_mb": cur_ram,
+            "allocated_cpu_cores": cur_cpu,
+            "status": "HEURISTIC",
+        }
+
+    try:
+        model = create_gurobi_model("FleetDispatch")
+        z = {}
+        for i, j in enumerate(jobs):
+            jid = j.get("id", f"j_{i}")
+            z[jid] = model.addVar(vtype=GRB.BINARY, name=f"job_{jid}")
+        model.setObjective(
+            gp.quicksum(
+                z[j.get("id", f"j_{i}")] * j.get("priority", 1.0)
+                for i, j in enumerate(jobs)
+            ),
+            GRB.MAXIMIZE,
+        )
+        model.addConstr(
+            gp.quicksum(z[j.get("id", f"j_{i}")] for i, j in enumerate(jobs)) <= max_concurrency,
+            "MaxConcurrency",
+        )
+        model.addConstr(
+            gp.quicksum(
+                z[j.get("id", f"j_{i}")] * j.get("ram_mb", 1024)
+                for i, j in enumerate(jobs)
+            )
+            <= max_ram_mb,
+            "MaxRAM",
+        )
+        model.addConstr(
+            gp.quicksum(
+                z[j.get("id", f"j_{i}")] * j.get("cpu_cores", 1)
+                for i, j in enumerate(jobs)
+            )
+            <= max_cpu_cores,
+            "MaxCPU",
+        )
+        model.optimize()
+        if model.status == GRB.OPTIMAL:
+            selected = [jid for jid, var in z.items() if var.X > 0.5]
+            used_ram = sum(j.get("ram_mb", 1024) for j in jobs if j.get("id") in selected)
+            used_cpu = sum(j.get("cpu_cores", 1) for j in jobs if j.get("id") in selected)
+            return {
+                "success": True,
+                "selected_jobs": selected,
+                "solver": "gurobi",
+                "objective": float(model.ObjVal),
+                "allocated_ram_mb": used_ram,
+                "allocated_cpu_cores": used_cpu,
+                "status": "OPTIMAL",
+                "optimality_gap": 0.0,
+            }
+        return {"success": False, "selected_jobs": [], "status": f"INFEASIBLE_{model.status}"}
+    except Exception as exc:  # noqa: BLE001
+        return {"success": False, "selected_jobs": [], "error": str(exc)}
+
+def stamp_decision_governance(result: Dict[str, Any]) -> Dict[str, Any]:
+    """Action layer stays human-oversight. A solve is not a PreToolUse apply."""
+    body = dict(result or {})
+    solver = str(body.get("solver") or "")
+    status = str(body.get("status") or "")
+    repeatable = solver == "gurobi" and status == "OPTIMAL"
+    body["autoApply"] = False
+    body["humanOversightRequired"] = True
+    body["capturedRevenueUsd"] = 0
+    body["repeatable"] = repeatable
+    body["plausibleOnly"] = not repeatable
+    return body
+
+
+def run_mode(mode: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    if mode == "routing":
+        return stamp_decision_governance(
+            solve_model_routing(
+                candidates=payload.get("candidates", []),
+                max_budget_usd=float(payload.get("max_budget_usd", 1.0)),
+                max_latency_ms=float(payload.get("max_latency_ms", 5000.0)),
+            )
+        )
+    if mode == "rules":
+        return stamp_decision_governance(
+            solve_rule_selection(
+                rules=payload.get("rules", []),
+                max_eval_time_ms=float(payload.get("max_eval_time_ms", 50.0)),
+                max_token_footprint=int(payload.get("max_token_footprint", 1000)),
+            )
+        )
+    if mode == "dispatch":
+        return stamp_decision_governance(
+            solve_fleet_dispatch(
+                jobs=payload.get("jobs", []),
+                max_ram_mb=int(payload.get("max_ram_mb", 32768)),
+                max_cpu_cores=int(payload.get("max_cpu_cores", 10)),
+                max_concurrency=int(payload.get("max_concurrency", 4)),
+            )
+        )
+    return stamp_decision_governance({"success": False, "error": f"Unknown mode: {mode}"})
+
+
+def main(argv: List[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Gurobi Optimization Engine for ThumbGate")
+    parser.add_argument("--mode", choices=["routing", "rules", "dispatch"], required=True)
+    parser.add_argument(
+        "--input",
+        required=True,
+        help="Inline JSON object only (no filesystem paths; agent-safe)",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        payload = load_input_payload(args.input)
+        result = run_mode(args.mode, payload)
+    except Exception as err:  # noqa: BLE001 — CLI always emits JSON
+        print(json.dumps(stamp_decision_governance({"success": False, "error": f"Failed to parse input: {err}"})))
+        return 1
+
+    print(json.dumps(result, indent=2))
+    return 0 if result.get("success") else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/harness-selector.js

@@ -26,12 +26,35 @@ const HARNESSES = Object.freeze({
   'code-edit': path.join(HARNESS_DIR, 'code-edit.json'),
   'db-write': path.join(HARNESS_DIR, 'db-write.json'),
   routine: path.join(HARNESS_DIR, 'routine.json'),
+  'actor-critic-audit': path.join(HARNESS_DIR, 'actor-critic-audit.json'),
+  'future-agi-guardrails': path.join(HARNESS_DIR, 'future-agi-guardrails.json'),
+  'five-walls-governance': path.join(HARNESS_DIR, 'five-walls-governance.json'),
+  'simatree-data-governance': path.join(HARNESS_DIR, 'simatree-data-governance.json'),
+  'radware-threat-defense': path.join(HARNESS_DIR, 'radware-threat-defense-2026.json'),
 });
 
 // ---------------------------------------------------------------------------
 // Detection patterns
 // ---------------------------------------------------------------------------
 
+const SIMATREE_PATTERNS = [
+  /\b(simatree|data_lifecycle|why_before_how|pmo_transformation|bayesian_uncertainty|lakehouse_governance)\b/i,
+];
+
+const FIVE_WALLS_PATTERNS = [
+  /\b(five_walls|five-walls|action_safety|hard_deny|preconditions|index_and_leaf|identity_propagation)\b/i,
+];
+
+const FUTURE_AGI_PATTERNS = [
+  /\b(future-agi|futureagi|agentcc|traceai|self_healing|adversarial_simulation|simulate_agent)\b/i,
+  /\b(prompt_injection|jailbreak|eval_rubric|guardrail_scanner)\b/i,
+];
+
+const ACTOR_CRITIC_PATTERNS = [
+  /\b(publish_causal_report|causal_inference|target_trial|target-trial|actor-critic|actor_critic|process_audit)\b/i,
+  /\b(placebo_test|counterfactual|propensity_score|double_ml)\b/i,
+];
+
 const DEPLOY_PATTERNS = [
   /\brailway\s+(deploy|up|run)\b/i,
   /\bdocker\s+(push|build)\b/i,
@@ -73,6 +96,24 @@ const CODE_EDIT_TOOL_NAMES = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdi
  * @param {object|string} toolInput - raw tool input object or string
  * @returns {string|null} absolute path to harness JSON, or null
  */
+/**
+ * Full-payload text for pattern scanning. extractCommandText short-circuits on
+ * file_path for Edit/Write, which never carries an injection string — the
+ * content/new_string fields do.
+ *
+ * @param {object|string} toolInput
+ * @returns {string}
+ */
+function extractPayloadText(toolInput) {
+  if (!toolInput) return '';
+  if (typeof toolInput === 'string') return toolInput;
+  try {
+    return JSON.stringify(toolInput);
+  } catch {
+    return extractCommandText(toolInput);
+  }
+}
+
 function selectHarness(toolName, toolInput) {
   // 1. Explicit override
   if (process.env.THUMBGATE_HARNESS) {
@@ -82,8 +123,31 @@ function selectHarness(toolName, toolInput) {
     if (path.isAbsolute(override)) return override;
   }
 
-  // 2. Edit/Write tools always get code-edit harness
+  // 1b. Radware / Bot Manager threat defense — auto-select when evaluateThreat or rate burst
+  //     flags ShadowLeak, ZombieAgent, suspicious-bot challenge, or rate burst.
+  //     Without this branch the registry entry is inert for normal PreToolUse.
+  try {
+    const { evaluateThreat } = require('./radware-threat-defense.js');
+    const payloadText = extractPayloadText(toolInput) || extractCommandText(toolInput) || String(toolName || '');
+    // Content threats only here. Rate-burst is enforced structurally in gates-engine
+    // (persisted history) so selector probes cannot false-select this harness.
+    const threat = evaluateThreat(payloadText);
+    if (threat.blocked || threat.challenged || threat.severity !== 'none') {
+      return HARNESSES['radware-threat-defense'];
+    }
+  } catch {
+    // Fail open on selector errors; gates still apply when harness forced via env.
+  }
+
+  // 2. Edit/Write tools get the code-edit harness, UNLESS the payload itself
+  //    trips a Future AGI pattern. Returning code-edit unconditionally meant
+  //    the prompt-injection gates declared for Edit/Write were never active
+  //    under automatic selection, since only the selected harness is loaded.
   if (CODE_EDIT_TOOL_NAMES.has(toolName)) {
+    const payloadText = extractPayloadText(toolInput);
+    if (payloadText && FUTURE_AGI_PATTERNS.some((p) => p.test(payloadText))) {
+      return HARNESSES['future-agi-guardrails'];
+    }
     return HARNESSES['code-edit'];
   }
 
@@ -93,6 +157,18 @@ function selectHarness(toolName, toolInput) {
     if (DB_WRITE_PATTERNS.some((p) => p.test(commandText))) {
       return HARNESSES['db-write'];
     }
+    if (ACTOR_CRITIC_PATTERNS.some((p) => p.test(commandText))) {
+      return HARNESSES['actor-critic-audit'];
+    }
+    if (FUTURE_AGI_PATTERNS.some((p) => p.test(commandText))) {
+      return HARNESSES['future-agi-guardrails'];
+    }
+    if (FIVE_WALLS_PATTERNS.some((p) => p.test(commandText))) {
+      return HARNESSES['five-walls-governance'];
+    }
+    if (SIMATREE_PATTERNS.some((p) => p.test(commandText))) {
+      return HARNESSES['simatree-data-governance'];
+    }
     if (ROUTINE_PATTERNS.some((p) => p.test(commandText))) {
       return HARNESSES.routine;
     }
@@ -459,6 +535,8 @@ function extractCommandText(toolInput) {
   return '';
 }
 
+const { evaluateThreat, evaluatePretoolDefense, checkRateBurst } = require('./radware-threat-defense.js');
+
 module.exports = {
   selectHarness,
   selectHarnessName,
@@ -473,6 +551,9 @@ module.exports = {
   buildSolverWorkflowGovernance,
   formatSolverWorkflowGovernance,
   extractCommandText,
+  evaluateThreat,
+  evaluatePretoolDefense,
+  checkRateBurst,
   HARNESSES,
   DEPLOY_PATTERNS,
   DB_WRITE_PATTERNS,