vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/agent-firewall/enforcement/verdict-v2.js

@@ -0,0 +1,333 @@
+/**
+ * Verdict System v2 - Deterministic Enforcement Verdicts
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * AGENT FIREWALL™ - VERDICT SYSTEM
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * Every Agent Firewall run MUST end in exactly one verdict:
+ * - PASS (intent + proof satisfied)
+ * - BLOCK (default on any violation)
+ * 
+ * NO "partial success".
+ * NO "best effort".
+ * NO "WARN" as a final state in ENFORCE mode.
+ * 
+ * Verdicts are:
+ * - Deterministic
+ * - Signed/hashed
+ * - Stored for reuse
+ * 
+ * @module enforcement/verdict-v2
+ * @version 2.0.0
+ */
+
+"use strict";
+
+const crypto = require("crypto");
+
+/**
+ * Verdict decisions - only two options
+ */
+const VERDICT = {
+  PASS: "PASS",
+  BLOCK: "BLOCK",
+};
+
+/**
+ * Observation decision (for OBSERVE mode only)
+ */
+const OBSERVATION = {
+  WOULD_PASS: "WOULD_PASS",
+  WOULD_BLOCK: "WOULD_BLOCK",
+};
+
+/**
+ * Firewall modes
+ */
+const MODE = {
+  ENFORCE: "ENFORCE",  // Default: block on violation
+  OBSERVE: "OBSERVE",  // Log + warn only (returns WOULD_* verdicts)
+  CI: "CI",            // Fail pipeline on BLOCK
+  IDE: "IDE",          // Real-time interception, block writes
+};
+
+/**
+ * Verdict object structure
+ * @typedef {Object} Verdict
+ * @property {string} decision - PASS or BLOCK
+ * @property {string} mode - Mode used for evaluation
+ * @property {Object[]} violations - All violations found
+ * @property {Object[]} proofs - All proofs collected
+ * @property {string} intent_hash - Hash of intent used
+ * @property {string} verdict_hash - Hash of entire verdict for signing
+ * @property {string} timestamp - ISO timestamp
+ * @property {string} id - Unique verdict ID
+ */
+
+/**
+ * Generate verdict ID
+ * @returns {string} Unique verdict ID
+ */
+function generateVerdictId() {
+  return `vrd-${Date.now().toString(36)}-${crypto.randomBytes(4).toString("hex")}`;
+}
+
+/**
+ * Compute verdict hash for integrity/signing
+ * @param {Object} verdict - Verdict object (without hash)
+ * @returns {string} SHA-256 hash
+ */
+function computeVerdictHash(verdict) {
+  const content = JSON.stringify({
+    decision: verdict.decision,
+    mode: verdict.mode,
+    violations: verdict.violations.map(v => ({
+      code: v.code,
+      resource: v.resource,
+    })),
+    proofs: verdict.proofs.map(p => ({
+      id: p.id,
+      status: p.status,
+    })),
+    intent_hash: verdict.intent_hash,
+    timestamp: verdict.timestamp,
+  });
+  
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Generate deterministic verdict from alignment and proof results
+ * 
+ * RULES:
+ * - If ANY violation exists → BLOCK
+ * - If ANY required proof failed → BLOCK
+ * - If intent is missing → BLOCK
+ * - Only if ALL checks pass → PASS
+ * 
+ * @param {Object} params - Verdict parameters
+ * @param {Object} params.alignmentResult - Result from alignment engine
+ * @param {Object[]} params.proofs - Array of proof artifacts
+ * @param {string} params.mode - Firewall mode
+ * @param {string} params.intent_hash - Hash of intent used
+ * @returns {Verdict} Final verdict
+ */
+function generateVerdict({ alignmentResult, proofs = [], mode = MODE.ENFORCE, intent_hash = null }) {
+  const timestamp = new Date().toISOString();
+  const id = generateVerdictId();
+  
+  // Collect all violations
+  const violations = alignmentResult?.violations || [];
+  
+  // Check for failed proofs
+  const failedProofs = proofs.filter(p => p.status === "failed" || p.status === "unverified");
+  for (const proof of failedProofs) {
+    violations.push({
+      code: "PROOF_FAILED",
+      rule: `proof_${proof.type}`,
+      message: `Required proof failed: ${proof.type} - ${proof.id}`,
+      resource: proof.target || "unknown",
+      intent_ref: "reality_proof",
+      severity: "block",
+    });
+  }
+  
+  // Determine decision
+  // In ENFORCE/CI mode: any violation = BLOCK
+  // In OBSERVE mode: violations generate WOULD_BLOCK but don't actually block
+  let decision;
+  
+  if (mode === MODE.OBSERVE) {
+    decision = violations.length > 0 ? OBSERVATION.WOULD_BLOCK : OBSERVATION.WOULD_PASS;
+  } else {
+    // ENFORCE, CI, IDE - strict enforcement
+    decision = violations.length > 0 ? VERDICT.BLOCK : VERDICT.PASS;
+  }
+  
+  const verdict = {
+    id,
+    decision,
+    mode,
+    violations,
+    proofs: proofs.map(p => ({
+      id: p.id,
+      type: p.type,
+      status: p.status,
+      trace: p.trace,
+    })),
+    intent_hash,
+    timestamp,
+    verdict_hash: "", // Will be computed
+    
+    // Summary for humans
+    summary: generateSummary(decision, violations, proofs),
+    
+    // Machine-readable status
+    passed: decision === VERDICT.PASS || decision === OBSERVATION.WOULD_PASS,
+    blocked: decision === VERDICT.BLOCK || decision === OBSERVATION.WOULD_BLOCK,
+    violation_count: violations.length,
+    proof_count: proofs.length,
+    failed_proof_count: failedProofs.length,
+  };
+  
+  // Compute and set hash
+  verdict.verdict_hash = computeVerdictHash(verdict);
+  
+  return verdict;
+}
+
+/**
+ * Generate human-readable summary
+ * @param {string} decision - Verdict decision
+ * @param {Object[]} violations - Violations array
+ * @param {Object[]} proofs - Proofs array
+ * @returns {string} Summary text
+ */
+function generateSummary(decision, violations, proofs) {
+  if (decision === VERDICT.PASS || decision === OBSERVATION.WOULD_PASS) {
+    return `All checks passed. Intent aligned, ${proofs.length} proofs verified.`;
+  }
+  
+  const violationSummary = violations.slice(0, 3)
+    .map(v => v.message)
+    .join("; ");
+  
+  const extra = violations.length > 3 ? ` (+${violations.length - 3} more)` : "";
+  
+  return `BLOCKED: ${violations.length} violation(s). ${violationSummary}${extra}`;
+}
+
+/**
+ * Generate block message with exact reason and reference
+ * @param {Object[]} violations - Violations array
+ * @returns {string} Formatted block message
+ */
+function formatBlockMessage(violations) {
+  if (violations.length === 0) {
+    return "BLOCKED_BY_AGENT_FIREWALL: Unknown reason";
+  }
+  
+  const lines = ["BLOCKED_BY_AGENT_FIREWALL:"];
+  
+  for (const violation of violations) {
+    lines.push(`- reason: ${violation.code}`);
+    lines.push(`  resource: ${violation.resource}`);
+    lines.push(`  intent_ref: ${violation.intent_ref}`);
+    if (violation.message) {
+      lines.push(`  message: ${violation.message}`);
+    }
+    lines.push("");
+  }
+  
+  return lines.join("\n");
+}
+
+/**
+ * Verify verdict integrity
+ * @param {Object} verdict - Verdict to verify
+ * @returns {Object} Verification result
+ */
+function verifyVerdictIntegrity(verdict) {
+  if (!verdict || !verdict.verdict_hash) {
+    return {
+      valid: false,
+      reason: "MISSING_HASH",
+    };
+  }
+  
+  const computed = computeVerdictHash(verdict);
+  
+  return {
+    valid: computed === verdict.verdict_hash,
+    reason: computed === verdict.verdict_hash ? "VERIFIED" : "HASH_MISMATCH",
+    computed_hash: computed,
+    stored_hash: verdict.verdict_hash,
+  };
+}
+
+/**
+ * Convert legacy verdict (ALLOW/WARN/BLOCK) to v2 format
+ * @param {Object} legacyVerdict - Legacy verdict object
+ * @param {string} mode - Firewall mode
+ * @returns {Verdict} V2 verdict
+ */
+function convertLegacyVerdict(legacyVerdict, mode = MODE.ENFORCE) {
+  const violations = (legacyVerdict.violations || []).map(v => ({
+    code: v.rule?.toUpperCase().replace(/-/g, "_") || "UNKNOWN",
+    rule: v.rule || "unknown",
+    message: v.message || "No message",
+    resource: v.claimId || v.file || "unknown",
+    intent_ref: "legacy",
+    severity: v.severity || "block",
+  }));
+  
+  // In v2, WARN becomes BLOCK in ENFORCE mode
+  let decision;
+  if (mode === MODE.OBSERVE) {
+    decision = legacyVerdict.decision === "ALLOW" 
+      ? OBSERVATION.WOULD_PASS 
+      : OBSERVATION.WOULD_BLOCK;
+  } else {
+    // ALLOW stays PASS, WARN and BLOCK become BLOCK
+    decision = legacyVerdict.decision === "ALLOW" ? VERDICT.PASS : VERDICT.BLOCK;
+  }
+  
+  return generateVerdict({
+    alignmentResult: { violations },
+    proofs: [],
+    mode,
+    intent_hash: null,
+  });
+}
+
+/**
+ * Create verdict manifest for artifact storage
+ * @param {Object} verdict - Verdict object
+ * @param {Object} metadata - Additional metadata
+ * @returns {Object} Manifest object
+ */
+function createVerdictManifest(verdict, metadata = {}) {
+  return {
+    schema_version: "2.0.0",
+    verdict: {
+      id: verdict.id,
+      decision: verdict.decision,
+      hash: verdict.verdict_hash,
+      timestamp: verdict.timestamp,
+    },
+    intent: {
+      hash: verdict.intent_hash,
+    },
+    violations: verdict.violations.map(v => ({
+      code: v.code,
+      resource: v.resource,
+      intent_ref: v.intent_ref,
+    })),
+    proofs: verdict.proofs.map(p => ({
+      id: p.id,
+      type: p.type,
+      status: p.status,
+    })),
+    summary: verdict.summary,
+    metadata: {
+      mode: verdict.mode,
+      ...metadata,
+    },
+    created_at: new Date().toISOString(),
+  };
+}
+
+module.exports = {
+  VERDICT,
+  OBSERVATION,
+  MODE,
+  generateVerdict,
+  generateVerdictId,
+  computeVerdictHash,
+  verifyVerdictIntegrity,
+  formatBlockMessage,
+  generateSummary,
+  convertLegacyVerdict,
+  createVerdictManifest,
+};

package/bin/runners/lib/agent-firewall/evidence/auth-evidence.js

@@ -0,0 +1,88 @@
+/**
+ * Auth Evidence Resolver
+ * 
+ * Resolves auth claims against truthpack.auth.json
+ * Checks for auth drift (claimed restriction not enforced).
+ */
+
+"use strict";
+
+const { getAuthRules } = require("../truthpack");
+
+/**
+ * Resolve auth claim evidence
+ * @param {string} projectRoot - Project root directory
+ * @param {object} claim - Auth claim
+ * @returns {object} Evidence result
+ */
+function resolve(projectRoot, claim) {
+  const authData = getAuthRules(projectRoot);
+  
+  // Extract auth keywords from claim value
+  const claimText = claim.value.toLowerCase();
+  const hasAuthKeywords = /\b(admin|owner|staff|role|scope|permission|auth|authorize|rbac)\b/i.test(claimText);
+  
+  if (!hasAuthKeywords) {
+    // Not an auth-related claim
+    return {
+      result: "PROVEN",
+      sources: [],
+      reason: "No auth keywords detected in claim"
+    };
+  }
+  
+  // Check if auth middleware exists
+  const nextMiddleware = authData.nextMiddleware || [];
+  const fastifyHooks = authData.fastify?.hooks || [];
+  
+  if (nextMiddleware.length > 0 || fastifyHooks.length > 0) {
+    // Auth infrastructure exists
+    // Check if claim matches protected patterns
+    const matcherPatterns = authData.nextMatcherPatterns || [];
+    const claimFile = claim.file || "";
+    
+    // Check if file is in protected path
+    const isProtected = matcherPatterns.some(pattern => {
+      // Simple pattern matching
+      if (pattern.includes("*")) {
+        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+        return regex.test(claimFile);
+      }
+      return claimFile.includes(pattern);
+    });
+    
+    if (isProtected) {
+      return {
+        result: "PROVEN",
+        sources: [{
+          type: "truthpack.auth",
+          pointer: claim.pointer,
+          confidence: 0.8
+        }],
+        reason: "Auth claim matches protected route pattern"
+      };
+    } else {
+      // Auth keywords present but route not protected - potential drift
+      return {
+        result: "CONTRADICTS",
+        sources: [{
+          type: "truthpack.auth",
+          pointer: claim.pointer,
+          confidence: 0.7
+        }],
+        reason: "Auth keywords present but route not in protected patterns (auth drift)"
+      };
+    }
+  } else {
+    // No auth infrastructure - cannot verify
+    return {
+      result: "UNPROVEN",
+      sources: [],
+      reason: "No auth middleware found in truthpack"
+    };
+  }
+}
+
+module.exports = {
+  resolve
+};

package/bin/runners/lib/agent-firewall/evidence/contract-evidence.js

@@ -0,0 +1,75 @@
+/**
+ * Contract Evidence Resolver
+ * 
+ * Resolves contract claims against truthpack.contracts.json
+ * Checks for contract drift (API shape mismatch).
+ */
+
+"use strict";
+
+const { getContracts } = require("../truthpack");
+
+/**
+ * Resolve contract claim evidence
+ * @param {string} projectRoot - Project root directory
+ * @param {object} claim - Contract claim
+ * @returns {object} Evidence result
+ */
+function resolve(projectRoot, claim) {
+  const contracts = getContracts(projectRoot);
+  
+  // Extract contract identifier from claim
+  // Contract claims might reference API endpoints, types, or schemas
+  const claimValue = claim.value.toLowerCase();
+  
+  // Check if contracts exist
+  if (!contracts || Object.keys(contracts).length === 0) {
+    return {
+      result: "UNPROVEN",
+      sources: [],
+      reason: "No contracts found in truthpack"
+    };
+  }
+  
+  // Try to match claim against contract definitions
+  // This is a simplified check - full implementation would parse contract schemas
+  const contractKeys = Object.keys(contracts);
+  const matchingContract = contractKeys.find(key => 
+    key.toLowerCase().includes(claimValue) || 
+    claimValue.includes(key.toLowerCase())
+  );
+  
+  if (matchingContract) {
+    return {
+      result: "PROVEN",
+      sources: [{
+        type: "truthpack.contracts",
+        pointer: claim.pointer,
+        confidence: 0.8
+      }],
+      reason: `Contract ${matchingContract} found in truthpack`
+    };
+  }
+  
+  // Check for contract drift by examining the claim context
+  // If claim references an API endpoint, check if contract exists for that endpoint
+  if (claimValue.includes("api") || claimValue.includes("endpoint")) {
+    // Potential contract drift - endpoint referenced but contract not found
+    return {
+      result: "CONTRADICTS",
+      sources: [],
+      reason: "API endpoint referenced but contract not found in truthpack (contract drift)"
+    };
+  }
+  
+  // Cannot verify contract
+  return {
+    result: "UNPROVEN",
+    sources: [],
+    reason: "Contract not found in truthpack"
+  };
+}
+
+module.exports = {
+  resolve
+};

package/bin/runners/lib/agent-firewall/evidence/env-evidence.js

@@ -0,0 +1,127 @@
+/**
+ * Environment Variable Evidence Resolver
+ * 
+ * Resolves env var claims against truthpack.env.json
+ * Checks for ghost env vars (used but not declared).
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { getEnvVars } = require("../truthpack");
+
+/**
+ * Resolve env var claim evidence
+ * @param {string} projectRoot - Project root directory
+ * @param {object} claim - Env var claim
+ * @returns {object} Evidence result
+ */
+function resolve(projectRoot, claim) {
+  const envData = getEnvVars(projectRoot);
+  
+  // Check declared env vars
+  const declared = envData.declared || [];
+  const declaredSet = new Set(declared.map(v => v.name || v));
+  
+  // Check declared sources (env.schema.ts, .env.example, etc.)
+  const declaredSources = envData.declaredSources || [];
+  
+  const envVarName = claim.value;
+  
+  // Check if env var is declared
+  if (declaredSet.has(envVarName)) {
+    // Find source file
+    const source = declaredSources.find(s => 
+      s.vars && s.vars.includes(envVarName)
+    );
+    
+    return {
+      result: "PROVEN",
+      sources: [{
+        type: "truthpack.env",
+        pointer: source ? source.file : claim.pointer,
+        confidence: 0.9
+      }],
+      reason: `Environment variable ${envVarName} found in truthpack`
+    };
+  }
+  
+  // Check if env var exists in .env.example or schema files
+  // Check multiple possible locations for .env.example
+  const envExamplePaths = [
+    path.join(projectRoot, ".env.example"),
+    path.join(projectRoot, "apps", "web-ui", ".env.example"),
+    path.join(projectRoot, "apps", "api", ".env.example")
+  ];
+  
+  for (const envExamplePath of envExamplePaths) {
+    if (fs.existsSync(envExamplePath)) {
+      const envExample = fs.readFileSync(envExamplePath, "utf8");
+      if (envExample.includes(envVarName)) {
+        const relativePath = path.relative(projectRoot, envExamplePath).replace(/\\/g, "/");
+        return {
+          result: "PROVEN",
+          sources: [{
+            type: "repo.search",
+            pointer: relativePath,
+            confidence: 0.7
+          }],
+          reason: `Environment variable ${envVarName} found in ${relativePath}`
+        };
+      }
+    }
+  }
+  
+  const envSchemaPath = findEnvSchemaFile(projectRoot);
+  
+  if (envSchemaPath && fs.existsSync(envSchemaPath)) {
+    const envSchema = fs.readFileSync(envSchemaPath, "utf8");
+    if (envSchema.includes(envVarName)) {
+      return {
+        result: "PROVEN",
+        sources: [{
+          type: "repo.search",
+          pointer: envSchemaPath,
+          confidence: 0.8
+        }],
+        reason: `Environment variable ${envVarName} found in env schema`
+      };
+    }
+  }
+  
+  // Not found - ghost env var
+  return {
+    result: "UNPROVEN",
+    sources: [],
+    reason: `Environment variable ${envVarName} not declared (ghost env var)`
+  };
+}
+
+/**
+ * Find env schema file (env.schema.ts, env.ts, etc.)
+ * @param {string} projectRoot - Project root directory
+ * @returns {string|null} Path to schema file or null
+ */
+function findEnvSchemaFile(projectRoot) {
+  const candidates = [
+    "apps/api/src/config/env.schema.ts",
+    "apps/api/src/env.schema.ts",
+    "src/config/env.schema.ts",
+    "src/env.schema.ts",
+    "env.schema.ts"
+  ];
+  
+  for (const candidate of candidates) {
+    const fullPath = path.join(projectRoot, candidate);
+    if (fs.existsSync(fullPath)) {
+      return candidate;
+    }
+  }
+  
+  return null;
+}
+
+module.exports = {
+  resolve
+};