@securecode-ai/mcp 0.5.4 → 0.5.6

package/dist/attack/scanState.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Authoritative scan state — the single source of truth for a scan run's
+ * phase, budget, recovery, and lifecycle.
+ *
+ * The MCP owns this state. The model proposes actions; the MCP validates
+ * them against this state and owns all transitions.
+ *
+ * This replaces scattered booleans, counters, and checklist sets with a
+ * serializable state object that can be snapshotted for tracing and audit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScanRunState = createScanRunState;
+exports.transitionScanPhase = transitionScanPhase;
+exports.terminateScan = terminateScan;
+exports.isScanTerminal = isScanTerminal;
+exports.hasBudgetRemaining = hasBudgetRemaining;
+exports.hasWallClockRemaining = hasWallClockRemaining;
+exports.canExecuteWork = canExecuteWork;
+exports.snapshotState = snapshotState;
+const VALID_TRANSITIONS = {
+    planning: ['surveying', 'terminated'],
+    surveying: ['tracing', 'terminated'],
+    tracing: ['candidate_investigation', 'finish_review', 'terminated'],
+    candidate_investigation: ['finish_review', 'tracing', 'terminated'],
+    finish_review: ['verifying', 'evidence_recovery', 'surveying', 'tracing', 'terminated'],
+    verifying: ['evidence_recovery', 'finalizing', 'terminated'],
+    evidence_recovery: ['verifying', 'tracing', 'candidate_investigation', 'terminated'],
+    finalizing: ['completed', 'terminated'],
+    completed: [],
+    terminated: [],
+};
+function createScanRunState(runId, target, budget) {
+    return {
+        runId,
+        phase: 'planning',
+        target,
+        transcript: [],
+        budget: {
+            stepsUsed: 0,
+            stepsRemaining: budget.stepsRemaining,
+            stepsGranted: budget.stepsGranted,
+            hardMaxSteps: budget.hardMaxSteps,
+            extensionsGranted: budget.extensionsGranted,
+            costSpentUsd: 0,
+            costCapUsd: budget.costCapUsd,
+            startedAt: Date.now(),
+            wallClockMs: 720_000,
+        },
+        recovery: {
+            consecutiveBlockedActions: 0,
+            totalBlockedActions: 0,
+            recoveryAttempts: 0,
+            meaningfulProgressSinceRecovery: true,
+        },
+        finishAttempts: 0,
+        verificationCycles: 0,
+    };
+}
+function transitionScanPhase(state, next, reason) {
+    const allowed = VALID_TRANSITIONS[state.phase];
+    if (!allowed.includes(next)) {
+        throw new Error(`Invalid scan phase transition: ${state.phase} -> ${next} (${reason}). ` +
+            `Valid transitions: ${allowed.join(', ')}`);
+    }
+    state.phase = next;
+}
+function terminateScan(state, reason, summary) {
+    state.termination = {
+        reason,
+        phase: state.phase,
+        timestamp: Date.now(),
+        summary,
+    };
+    state.phase = 'terminated';
+}
+function isScanTerminal(state) {
+    return state.phase === 'completed' || state.phase === 'terminated';
+}
+function hasBudgetRemaining(state) {
+    return state.budget.stepsRemaining > 0 &&
+        state.budget.costSpentUsd < state.budget.costCapUsd;
+}
+function hasWallClockRemaining(state) {
+    return Date.now() - state.budget.startedAt < state.budget.wallClockMs;
+}
+function canExecuteWork(state) {
+    return hasBudgetRemaining(state) && hasWallClockRemaining(state) && !isScanTerminal(state);
+}
+function snapshotState(state) {
+    return JSON.stringify({
+        runId: state.runId,
+        phase: state.phase,
+        stepsUsed: state.budget.stepsUsed,
+        stepsRemaining: state.budget.stepsRemaining,
+        costSpentUsd: state.budget.costSpentUsd,
+        finishAttempts: state.finishAttempts,
+        totalBlockedActions: state.recovery.totalBlockedActions,
+        termination: state.termination,
+    });
+}
+//# sourceMappingURL=scanState.js.map

package/dist/attack/scanState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanState.js","sourceRoot":"","sources":["../../src/attack/scanState.ts"],"names":[],"mappings":"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"}

package/dist/attack/searchIntent.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Search intent normalization — detects when two search_code calls are
+ * semantically equivalent even if their patterns differ in ordering or
+ * formatting.
+ *
+ * Without this, the agent can call:
+ *   search_code("requireOwner|CurrentWsSessionRole")
+ *   search_code("CurrentWsSessionRole|requireOwner")
+ *   search_code("requireOwner|CurrentWsSessionRole|isLoopbackHost")
+ * ...and each is treated as a "new" search because the raw strings differ.
+ *
+ * This module normalizes patterns into a canonical form and provides
+ * overlap detection so the loop can block equivalent searches.
+ */
+export declare function normalizeSearchPattern(pattern: string): string;
+export declare function isEquivalentSearchIntent(previous: string, current: string): boolean;

package/dist/attack/searchIntent.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Search intent normalization — detects when two search_code calls are
+ * semantically equivalent even if their patterns differ in ordering or
+ * formatting.
+ *
+ * Without this, the agent can call:
+ *   search_code("requireOwner|CurrentWsSessionRole")
+ *   search_code("CurrentWsSessionRole|requireOwner")
+ *   search_code("requireOwner|CurrentWsSessionRole|isLoopbackHost")
+ * ...and each is treated as a "new" search because the raw strings differ.
+ *
+ * This module normalizes patterns into a canonical form and provides
+ * overlap detection so the loop can block equivalent searches.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSearchPattern = normalizeSearchPattern;
+exports.isEquivalentSearchIntent = isEquivalentSearchIntent;
+function normalizeSearchPattern(pattern) {
+    let p = pattern.trim();
+    // Remove common regex wrappers that don't change intent
+    p = p.replace(/^\(\?:|\)\$$/g, '');
+    // Split on | (alternation) into alternatives
+    const alternatives = p
+        .split('|')
+        .map(a => a.trim())
+        .filter(a => a.length > 0);
+    if (alternatives.length <= 1) {
+        return p.toLowerCase();
+    }
+    // Sort alternatives alphabetically, deduplicate, lowercase
+    const unique = [...new Set(alternatives.map(a => a.toLowerCase()))];
+    unique.sort();
+    return unique.join('|');
+}
+function isEquivalentSearchIntent(previous, current) {
+    const prevNorm = normalizeSearchPattern(previous);
+    const currNorm = normalizeSearchPattern(current);
+    if (prevNorm === currNorm)
+        return true;
+    // Check if one is a subset of the other (all alternatives of the
+    // smaller pattern are present in the larger one)
+    const prevTerms = prevNorm.split('|').filter(t => t.length > 0);
+    const currTerms = currNorm.split('|').filter(t => t.length > 0);
+    const prevSet = new Set(prevTerms);
+    const currSet = new Set(currTerms);
+    // If current is a subset of previous, it's equivalent (already searched)
+    const currSubsetOfPrev = [...currSet].every(t => prevSet.has(t));
+    if (currSubsetOfPrev)
+        return true;
+    // If previous is a subset of current, the current adds nothing new
+    const prevSubsetOfCurr = [...prevSet].every(t => currSet.has(t));
+    if (prevSubsetOfCurr)
+        return true;
+    return false;
+}
+//# sourceMappingURL=searchIntent.js.map

package/dist/attack/searchIntent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchIntent.js","sourceRoot":"","sources":["../../src/attack/searchIntent.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;AAEH,wDAoBC;AAED,4DAuBC;AA7CD,SAAgB,sBAAsB,CAAC,OAAe;IAClD,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAEvB,wDAAwD;IACxD,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;IAEnC,6CAA6C;IAC7C,MAAM,YAAY,GAAG,CAAC;SACjB,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SAClB,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE/B,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IAED,2DAA2D;IAC3D,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;IACpE,MAAM,CAAC,IAAI,EAAE,CAAC;IACd,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC;AAED,SAAgB,wBAAwB,CAAC,QAAgB,EAAE,OAAe;IACtE,MAAM,QAAQ,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;IAClD,MAAM,QAAQ,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAEjD,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAEvC,iEAAiE;IACjE,iDAAiD;IACjD,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChE,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAEhE,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IACnC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IAEnC,yEAAyE;IACzE,MAAM,gBAAgB,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,IAAI,gBAAgB;QAAE,OAAO,IAAI,CAAC;IAElC,mEAAmE;IACnE,MAAM,gBAAgB,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,IAAI,gBAAgB;QAAE,OAAO,IAAI,CAAC;IAElC,OAAO,KAAK,CAAC;AACjB,CAAC"}

package/dist/attack/verifyLoop.d.ts

@@ -1,4 +1,5 @@
 import type { ApiClient } from '../api/client';
+import { VerifyBudgetTracker, defaultVerifyBudget, type VerifyBudget } from './agentScanProtocol';
 export interface VerifyFinding {
     type: string;
     line: number;
@@ -20,6 +21,17 @@ export interface VerifyLoopOptions {
     language: string;
     client: ApiClient;
     onProgress?: (round: number, maxRounds: number, message: string) => void;
+    /** Aggregate budget tracker shared across all findings in one scan. */
+    budgetTracker?: VerifyBudgetTracker;
+    /** AbortSignal — aborts the loop and any running test. */
+    signal?: AbortSignal;
+    /**
+     * Distinguishes initial vulnerability verification from fix re-verification.
+     * - 'original' (default): verifying the original code for a vulnerability.
+     * - 'fix': re-verifying the proposed fixed code to see if the exploit still works.
+     * Passed to the API so the verifier prompt can be adjusted accordingly.
+     */
+    verificationPhase?: 'original' | 'fix';
 }
 export interface VerifyLoopResult {
     verdict: 'PROVEN' | 'UNPROVEN' | 'INCONCLUSIVE';
@@ -27,5 +39,36 @@ export interface VerifyLoopResult {
     roundsUsed: number;
     testScript: string;
     testOutput: string;
+    /** Why the loop stopped early, when verdict is INCONCLUSIVE due to budget. */
+    budgetExhaustedReason?: string;
+    /** Backend that executed the test (docker, deno, etc.). Empty when none ran. */
+    backend?: string;
+    /** Structured proof evidence from the proof marker, if present. */
+    proofEvidence?: import('./proofTypes').ProofEvidence;
+    /** Result of the deterministic proof gate evaluation. */
+    proofGateResult?: import('./proofTypes').ProofGateResult;
+    /** Proof-specific sub-verdict for strict gate failures. */
+    proofSubVerdict?: import('./proofTypes').ProofSubVerdict;
+    /**
+     * Machine-readable sub-verdict so callers (toolAgentScan) can detect the
+     * INCONCLUSIVE reason without string-matching `reason`. Distinct from
+     * `verdict` because all of these collapse to INCONCLUSIVE at the top
+     * level — the difference is what the user should do about it.
+     *
+     *   - 'analyzed'         : the analyze LLM ran and returned INCONCLUSIVE
+     *                          (couldn't decide after exhausting rounds).
+     *   - 'cannot-test'       : /verify/generate returned canTest:false — the
+     *                          vuln type/framework can't be tested locally.
+     *   - 'sandbox-unavailable': no Docker/Deno on the user's machine. The
+     *                          caller should surface an install hint.
+     *   - 'blocked'           : the static safety check rejected the script.
+     *   - 'budget-exhausted'  : the aggregate VerifyBudget ran out.
+     *   - 'aborted'           : the AbortSignal fired.
+     *   - 'cancelled'         : the user cancelled the scan mid-test.
+     *   - 'runtime-blocked'   : detectRuntime said canRunLocally:false.
+     *   - undefined           : PROVEN or UNPROVEN (no sub-verdict needed).
+     */
+    subVerdict?: 'analyzed' | 'cannot-test' | 'sandbox-unavailable' | 'blocked' | 'budget-exhausted' | 'aborted' | 'cancelled' | 'runtime-blocked';
 }
 export declare function runVerifyLoop(opts: VerifyLoopOptions): Promise<VerifyLoopResult>;
+export { VerifyBudgetTracker, defaultVerifyBudget, type VerifyBudget };

package/dist/attack/verifyLoop.js

@@ -33,24 +33,88 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultVerifyBudget = exports.VerifyBudgetTracker = void 0;
 exports.runVerifyLoop = runVerifyLoop;
 const path = __importStar(require("path"));
 const localTestRunner_1 = require("../utils/localTestRunner");
 const runtimeDetect_1 = require("../utils/runtimeDetect");
-const MAX_ROUNDS = 8;
+const agentScanProtocol_1 = require("./agentScanProtocol");
+Object.defineProperty(exports, "VerifyBudgetTracker", { enumerable: true, get: function () { return agentScanProtocol_1.VerifyBudgetTracker; } });
+Object.defineProperty(exports, "defaultVerifyBudget", { enumerable: true, get: function () { return agentScanProtocol_1.defaultVerifyBudget; } });
+const protocolValidator_1 = require("./protocolValidator");
+const proofTypes_1 = require("./proofTypes");
+const proofGate_1 = require("./proofGate");
+const mutationTest_1 = require("./mutationTest");
+const PER_FINDING_MAX_ROUNDS = 12;
 async function runVerifyLoop(opts) {
     const { finding, filePath, code, relatedFiles, workspaceRoot, language, client, onProgress } = opts;
+    const tracker = opts.budgetTracker;
+    const verificationPhase = opts.verificationPhase ?? 'original';
     const previousErrors = [];
     let lastTestScript = '';
     let lastTestOutput = '';
-    const runtimeInfo = (0, runtimeDetect_1.detectRuntime)(workspaceRoot);
+    // Per-finding round cap = min(per-finding default, budget's per-finding cap).
+    const maxRounds = tracker
+        ? Math.min(PER_FINDING_MAX_ROUNDS, tracker.budget.maxRoundsPerFinding)
+        : PER_FINDING_MAX_ROUNDS;
+    const runtimeInfo = (0, runtimeDetect_1.detectRuntime)(workspaceRoot, filePath || undefined);
     const testFileDir = path.join(workspaceRoot, '.securecode');
     const relativeImportPath = filePath
         ? (0, runtimeDetect_1.computeRelativeImportPath)(testFileDir, path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath))
         : '';
-    for (let round = 1; round <= MAX_ROUNDS; round++) {
-        onProgress?.(round, MAX_ROUNDS, `Round ${round}: generating test...`);
-        const genResp = await client.postJson('/verify/generate', {
+    if (!runtimeInfo.canRunLocally) {
+        return {
+            verdict: 'INCONCLUSIVE',
+            reason: runtimeInfo.skipReason || 'Detected framework cannot run a local exploit test.',
+            roundsUsed: 0,
+            testScript: '',
+            testOutput: '',
+            subVerdict: 'runtime-blocked',
+        };
+    }
+    // Pre-flight: if the aggregate budget is already exhausted at finding entry,
+    // skip without spending any LLM calls. The caller (toolAgentScan) should
+    // also check this before calling, but we double-enforce here.
+    if (tracker && !tracker.canAttemptFinding()) {
+        return {
+            verdict: 'INCONCLUSIVE',
+            reason: `Verification budget exhausted before this finding (findings=${tracker.findingsAttempted}/${tracker.budget.maxFindings}, llmCalls=${tracker.llmCallsUsed}/${tracker.budget.maxLlmCalls}, wallClock=${tracker.wallClockElapsedMs}ms/${tracker.budget.maxWallClockMs}ms).`,
+            roundsUsed: 0,
+            testScript: '',
+            testOutput: '',
+            budgetExhaustedReason: 'aggregate',
+            subVerdict: 'budget-exhausted',
+        };
+    }
+    if (tracker)
+        tracker.findingsAttempted += 1;
+    for (let round = 1; round <= maxRounds; round++) {
+        // Per-round budget check (need at least generate + analyze = 2 calls).
+        if (tracker && !tracker.canAttemptRound()) {
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: `Verification budget exhausted mid-finding (llmCalls=${tracker.llmCallsUsed}/${tracker.budget.maxLlmCalls}, wallClock=${tracker.wallClockElapsedMs}ms/${tracker.budget.maxWallClockMs}ms).`,
+                roundsUsed: round - 1,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                budgetExhaustedReason: 'aggregate',
+                subVerdict: 'budget-exhausted',
+            };
+        }
+        if (tracker)
+            tracker.roundsUsed += 1;
+        if (opts.signal?.aborted) {
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: 'Cancelled by user.',
+                roundsUsed: round - 1,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                subVerdict: 'aborted',
+            };
+        }
+        onProgress?.(round, maxRounds, `Round ${round}: generating test...`);
+        const genRespRaw = await client.postJson('/verify/generate', {
             code,
             language,
             vulnerabilityType: finding.type,
@@ -63,9 +127,29 @@ async function runVerifyLoop(opts) {
             previousErrors: previousErrors.length > 0 ? previousErrors : undefined,
             projectRuntime: runtimeInfo.runtime,
             suggestedRunner: runtimeInfo.runner,
+            framework: runtimeInfo.framework,
+            frameworkVersion: runtimeInfo.frameworkVersion,
+            testabilityTier: runtimeInfo.testabilityTier,
+            packageManager: runtimeInfo.packageManager,
             testFileDir: '.securecode',
             relativeImportPath,
+            depsInstalled: runtimeInfo.depsInstalled,
+            verificationPhase,
         });
+        if (tracker)
+            tracker.recordLlmCall(genRespRaw.costUsd ?? 0);
+        const genValidation = (0, protocolValidator_1.validateVerifyGenerateResponse)(genRespRaw);
+        if (!genValidation.ok) {
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: `API returned a malformed verify/generate response: ${genValidation.error}`,
+                roundsUsed: round,
+                testScript: '',
+                testOutput: '',
+                subVerdict: 'analyzed',
+            };
+        }
+        const genResp = genValidation.value;
         if (!genResp.canTest || !genResp.testScript) {
             return {
                 verdict: 'INCONCLUSIVE',
@@ -73,15 +157,80 @@ async function runVerifyLoop(opts) {
                 roundsUsed: round,
                 testScript: '',
                 testOutput: '',
+                subVerdict: 'cannot-test',
             };
         }
         lastTestScript = genResp.testScript;
         const runner = genResp.runner || runtimeInfo.runner || (language === 'typescript' ? 'tsx' : 'node');
-        onProgress?.(round, MAX_ROUNDS, `Round ${round}: running test...`);
-        const testResult = await (0, localTestRunner_1.runLocalTest)(genResp.testScript, runner, workspaceRoot);
+        onProgress?.(round, maxRounds, `Round ${round}: running test...`);
+        // Cap the local test timeout at the remaining verify-budget wall-clock.
+        const testTimeoutMs = tracker
+            ? Math.min(30_000, tracker.remainingWallClockMs())
+            : 30_000;
+        const testResult = await (0, localTestRunner_1.runLocalTest)(genResp.testScript, runner, workspaceRoot, {
+            setupScript: genResp.setupScript || null,
+            timeoutMs: testTimeoutMs,
+            signal: opts.signal,
+        });
         lastTestOutput = testResult.output;
-        onProgress?.(round, MAX_ROUNDS, `Round ${round}: analyzing result...`);
-        const analyzeResp = await client.postJson('/verify/analyze', {
+        // Handle non-LLM-judged verdicts that should short-circuit the loop.
+        if (testResult.verdict === 'sandbox-unavailable') {
+            // No isolation backend on the user's machine. We must NOT run
+            // the script with host privileges — return INCONCLUSIVE so the
+            // finding keeps its non-PROVEN status but isn't buried as UNPROVEN.
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: testResult.output,
+                roundsUsed: round,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                backend: testResult.backend || '',
+                subVerdict: 'sandbox-unavailable',
+            };
+        }
+        if (testResult.verdict === 'blocked') {
+            // Static safety check rejected the script. Don't retry — the
+            // LLM would have to emit a less dangerous script, but anything
+            // that trips the blocklist is almost certainly trying to do
+            // something we don't want.
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: `Test script rejected by safety check: ${testResult.output}`,
+                roundsUsed: round,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                subVerdict: 'blocked',
+            };
+        }
+        if (testResult.verdict === 'cancelled') {
+            // User aborted the scan. Do NOT retry — return immediately so the
+            // cancellation propagates up to toolAgentScan, which stops the loop.
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: `Verification cancelled by user at round ${round}.`,
+                roundsUsed: round,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                subVerdict: 'cancelled',
+            };
+        }
+        if (testResult.verdict === 'timeout') {
+            // Treat as a retryable error — feed it back to the LLM.
+            previousErrors.push(`Round ${round}: timed out — ${testResult.output.slice(0, 500)}`);
+            if (round >= maxRounds) {
+                return {
+                    verdict: 'INCONCLUSIVE',
+                    reason: `Test timed out after ${round} round(s).`,
+                    roundsUsed: round,
+                    testScript: lastTestScript,
+                    testOutput: lastTestOutput,
+                    subVerdict: 'analyzed',
+                };
+            }
+            continue;
+        }
+        onProgress?.(round, maxRounds, `Round ${round}: analyzing result...`);
+        const analyzeRespRaw = await client.postJson('/verify/analyze', {
             vulnerabilityType: finding.type,
             line: finding.line,
             evidence: finding.evidence,
@@ -91,19 +240,184 @@ async function runVerifyLoop(opts) {
             stderr: '',
             exitCode: testResult.exitCode,
             round,
-            maxRounds: MAX_ROUNDS,
+            maxRounds,
+            verificationPhase,
         });
+        if (tracker)
+            tracker.recordLlmCall(analyzeRespRaw.costUsd ?? 0);
+        const analyzeValidation = (0, protocolValidator_1.validateVerifyAnalyzeResponse)(analyzeRespRaw);
+        if (!analyzeValidation.ok) {
+            return {
+                verdict: 'INCONCLUSIVE',
+                reason: `API returned a malformed verify/analyze response: ${analyzeValidation.error}`,
+                roundsUsed: round,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                backend: testResult.backend || '',
+                subVerdict: 'analyzed',
+            };
+        }
+        const analyzeResp = analyzeValidation.value;
+        const proofMarker = (0, proofTypes_1.parseProofMarker)(lastTestOutput);
+        const gateResult = (0, proofGate_1.evaluateProofGate)(proofMarker, {
+            sandboxBackend: testResult.backend || 'unknown',
+            targetFile: filePath || '',
+            targetLine: finding.line,
+            repeatedRuns: 1,
+            repeatPasses: proofMarker.found && proofMarker.exploit === 'pass' ? 1 : 0,
+            llmVerdict: analyzeResp.verdict,
+            sourceMode: proofMarker.sourceMode,
+            minimumRepeatRuns: 1,
+        });
+        const proofEvidence = proofMarker.found
+            ? (0, proofGate_1.buildProofEvidence)(proofMarker, {
+                sandboxBackend: testResult.backend || 'unknown',
+                targetFile: filePath || '',
+                targetLine: finding.line,
+                repeatedRuns: 1,
+                repeatPasses: proofMarker.found && proofMarker.exploit === 'pass' ? 1 : 0,
+            })
+            : undefined;
         if (analyzeResp.verdict === 'PROVEN') {
-            return { verdict: 'PROVEN', reason: analyzeResp.reason, roundsUsed: round, testScript: lastTestScript, testOutput: lastTestOutput };
+            if (gateResult.eligibleForProven) {
+                const REPEAT_RUNS = 3;
+                const runResults = [];
+                // First run already done — validate it independently
+                runResults.push({
+                    runIndex: 1,
+                    verdict: testResult.verdict,
+                    markerValid: proofMarker.found,
+                    targetReached: proofMarker.targetReached === true,
+                    impactObserved: proofMarker.impact === 'observed',
+                    baselineResult: proofMarker.baseline,
+                    exploitResult: proofMarker.exploit,
+                });
+                let lastRepOutput = lastTestOutput;
+                let lastRepMarker = proofMarker;
+                for (let rep = 2; rep <= REPEAT_RUNS; rep++) {
+                    if (opts.signal?.aborted)
+                        break;
+                    if (tracker && !tracker.canAttemptRound())
+                        break;
+                    onProgress?.(round, maxRounds, `Round ${round}: repeatability run ${rep}/${REPEAT_RUNS}...`);
+                    const repResult = await (0, localTestRunner_1.runLocalTest)(genResp.testScript, runner, opts.workspaceRoot, { setupScript: genResp.setupScript || null, timeoutMs: tracker ? Math.min(30_000, tracker.remainingWallClockMs()) : 30_000, signal: opts.signal });
+                    lastRepOutput = repResult.output;
+                    const repMarker = (0, proofTypes_1.parseProofMarker)(repResult.output);
+                    lastRepMarker = repMarker;
+                    runResults.push({
+                        runIndex: rep,
+                        verdict: repResult.verdict,
+                        markerValid: repMarker.found,
+                        targetReached: repMarker.targetReached === true,
+                        impactObserved: repMarker.impact === 'observed',
+                        baselineResult: repMarker.baseline,
+                        exploitResult: repMarker.exploit,
+                    });
+                }
+                // A run only counts as "passed" if ALL proof properties are valid.
+                // Do not count a run as passed solely because verdict === 'pass'.
+                const totalPasses = runResults.filter(r => r.verdict === 'pass' &&
+                    r.markerValid &&
+                    r.targetReached &&
+                    r.impactObserved).length;
+                const repGateResult = (0, proofGate_1.evaluateProofGate)(lastRepMarker, {
+                    sandboxBackend: testResult.backend || 'unknown',
+                    targetFile: filePath || '',
+                    targetLine: finding.line,
+                    repeatedRuns: runResults.length,
+                    repeatPasses: totalPasses,
+                    llmVerdict: 'PROVEN',
+                    sourceMode: lastRepMarker.sourceMode,
+                });
+                if (!repGateResult.eligibleForProven) {
+                    console.warn(`[Verify Loop] Repeatability check failed: ${totalPasses}/${runResults.length} runs passed`);
+                    const repEvidence = lastRepMarker.found
+                        ? (0, proofGate_1.buildProofEvidence)(lastRepMarker, {
+                            sandboxBackend: testResult.backend || 'unknown',
+                            targetFile: filePath || '',
+                            targetLine: finding.line,
+                            repeatedRuns: runResults.length,
+                            repeatPasses: totalPasses,
+                        })
+                        : proofEvidence;
+                    return {
+                        verdict: 'INCONCLUSIVE',
+                        reason: `Repeatability check failed: ${totalPasses}/${runResults.length} runs passed. ${repGateResult.warnings.join(' ')}`,
+                        roundsUsed: round,
+                        testScript: lastTestScript,
+                        testOutput: lastTestOutput,
+                        backend: testResult.backend || '',
+                        proofEvidence: repEvidence,
+                        proofGateResult: repGateResult,
+                        proofSubVerdict: 'gate-rejected',
+                        subVerdict: 'analyzed',
+                    };
+                }
+                if (proofEvidence) {
+                    proofEvidence.repeatedRuns = REPEAT_RUNS;
+                    proofEvidence.repeatPasses = totalPasses;
+                }
+                const mutationResult = await (0, mutationTest_1.runMutationTest)({
+                    vulnerableCode: code,
+                    testScript: lastTestScript,
+                    runner: genResp.runner || runtimeInfo.runner || 'node',
+                    workspaceRoot: opts.workspaceRoot,
+                    filePath: filePath || '',
+                    vulnerabilityType: finding.type,
+                    line: finding.line,
+                });
+                if (!mutationResult.discriminating) {
+                    console.warn(`[Verify Loop] Mutation test non-discriminating: ${mutationResult.reason}`);
+                    if (proofEvidence) {
+                        proofEvidence.assumptions.push(`mutation-test: ${mutationResult.reason}`);
+                    }
+                    return {
+                        verdict: 'INCONCLUSIVE',
+                        reason: `Proof gate passed but mutation test was non-discriminating: ${mutationResult.reason}`,
+                        roundsUsed: round,
+                        testScript: lastTestScript,
+                        testOutput: lastTestOutput,
+                        backend: testResult.backend || '',
+                        proofEvidence,
+                        proofGateResult: { ...gateResult, failedGates: [...gateResult.failedGates, 'mutation-non-discriminating'] },
+                        proofSubVerdict: 'gate-rejected',
+                        subVerdict: 'analyzed',
+                    };
+                }
+                return {
+                    verdict: 'PROVEN',
+                    reason: `${analyzeResp.reason} [mutation: ${mutationResult.reason}]`,
+                    roundsUsed: round,
+                    testScript: lastTestScript,
+                    testOutput: lastTestOutput,
+                    backend: testResult.backend || '',
+                    proofEvidence,
+                    proofGateResult: gateResult,
+                    proofSubVerdict: 'gate-passed',
+                };
+            }
+            console.warn(`[Verify Loop] LLM said PROVEN but proof gate rejected: ${gateResult.failedGates.join(', ')}`);
+            return {
+                verdict: gateResult.downgradedVerdict === 'UNPROVEN' ? 'UNPROVEN' : 'INCONCLUSIVE',
+                reason: `Proof gate rejected: ${gateResult.failedGates.join(', ')}. ${gateResult.warnings.join(' ')}. LLM reason: ${analyzeResp.reason}`,
+                roundsUsed: round,
+                testScript: lastTestScript,
+                testOutput: lastTestOutput,
+                backend: testResult.backend || '',
+                proofEvidence,
+                proofGateResult: gateResult,
+                proofSubVerdict: 'gate-rejected',
+                subVerdict: gateResult.downgradedVerdict === 'UNPROVEN' ? undefined : 'analyzed',
+            };
         }
         if (analyzeResp.verdict === 'UNPROVEN') {
-            return { verdict: 'UNPROVEN', reason: analyzeResp.reason, roundsUsed: round, testScript: lastTestScript, testOutput: lastTestOutput };
+            return { verdict: 'UNPROVEN', reason: analyzeResp.reason, roundsUsed: round, testScript: lastTestScript, testOutput: lastTestOutput, backend: testResult.backend || '', proofEvidence, proofGateResult: gateResult };
         }
-        if (!analyzeResp.shouldRetry || round >= MAX_ROUNDS) {
-            return { verdict: 'INCONCLUSIVE', reason: analyzeResp.reason || `Could not verify after ${round} round(s).`, roundsUsed: round, testScript: lastTestScript, testOutput: lastTestOutput };
+        if (!analyzeResp.shouldRetry || round >= maxRounds) {
+            return { verdict: 'INCONCLUSIVE', reason: analyzeResp.reason || `Could not verify after ${round} round(s).`, roundsUsed: round, testScript: lastTestScript, testOutput: lastTestOutput, backend: testResult.backend || '', subVerdict: 'analyzed', proofEvidence, proofGateResult: gateResult };
         }
         previousErrors.push(`Round ${round}: ${testResult.verdict} — ${testResult.output.slice(0, 500)}`);
     }
-    return { verdict: 'INCONCLUSIVE', reason: `Exhausted all ${MAX_ROUNDS} rounds.`, roundsUsed: MAX_ROUNDS, testScript: lastTestScript, testOutput: lastTestOutput };
+    return { verdict: 'INCONCLUSIVE', reason: `Exhausted all ${maxRounds} rounds.`, roundsUsed: maxRounds, testScript: lastTestScript, testOutput: lastTestOutput, subVerdict: 'analyzed' };
 }
 //# sourceMappingURL=verifyLoop.js.map