fix: sandbox script and prompts

Dockerfile

@@ -42,4 +42,7 @@ EXPOSE 7860
 COPY scripts/ ./scripts/
 RUN chmod +x scripts/*.sh
 
+# Run sandbox setup once during image build to cache it
+RUN ./scripts/setup-sandbox.sh
+
 CMD ["node", "dist/server.js"]

scripts/setup-sandbox.sh

@@ -29,7 +29,7 @@ test = "test"
 script = "script"
 out = "out"
 libs = ["lib"]
-solc-version = "0.8.20"
+solc_version = "0.8.20"
 optimizer = true
 optimizer_runs = 200
 EOF

src/agents/tester/agent.ts

@@ -71,9 +71,36 @@ ${oracleContext!.solidityScaffold}
 
 async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
   console.log("[testerAgent] Executando runFoundryNode...");
+
+  const trimmedCode = state.pocCode.trim();
+  const isMissingCode = trimmedCode.length === 0;
+  const isMissingContract = !trimmedCode.includes("contract ExploitTest");
+  const isMissingTest = !trimmedCode.includes("function test_Exploit()");
+  const isPlaceholder = trimmedCode.includes("TODO: implementar exploit");
+  if (isMissingCode || isMissingContract || isMissingTest || isPlaceholder) {
+    const summary = state.lastError ?? (isMissingCode
+      ? "Código Solidity ausente. O LLM não retornou o arquivo do exploit."
+      : isMissingContract
+        ? "Contrato ExploitTest não encontrado no arquivo."
+        : isMissingTest
+          ? "Função test_Exploit() não encontrada no arquivo."
+          : "Exploit não implementado (placeholder TODO ainda presente)."
+    );
+    const status = state.iterations >= MAX_ITERATIONS ? "failed" : "running";
+    return {
+      executionLogs: [summary],
+      lastError: summary,
+      status,
+    };
+  }
+
   const result   = await runFoundry(state.pocCode);
   const analysis = analyzeFoundryLog(result);
-  const passed   = result.exitCode === 0 && result.stdout.includes("ok");
+  const noTestsFound = result.combined.includes("No tests found");
+  const summary = noTestsFound
+    ? "Forge não encontrou nenhum teste. Verifique se o contrato se chama ExploitTest e se existe test_Exploit()."
+    : analysis.summary;
+  const passed   = result.exitCode === 0 && result.stdout.includes("ok") && !noTestsFound;
   const isLastAttempt = state.iterations >= MAX_ITERATIONS;
 
   const status = passed
@@ -91,7 +118,7 @@ async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
 
   return {
     executionLogs: [result.combined],   // reducer append
-    lastError: analysis.summary,
+    lastError: summary,
     status,
   };
 }

src/agents/tester/prompts/system.ts

@@ -7,10 +7,16 @@ Write exploits as executable demonstrations that clearly prove the vulnerability
 Parse the vulnerability description provided and analyze the vulnerability type, affected code sections, and potential impact. Analyze the contract logic to understand the root cause before developing exploits.
 
 ## Testing Framework Guidelines
-Use Foundry exclusively for testing. Implement proper "setUp()" functions with realistic contract states: i.e. initializing contracts with typical production values (reasonable token balances, realistic timestamps, standard protocol roles assigned). Utilize Foundry cheatcodes for test control: "vm.prank()" for identity switching, "vm.deal()" for ETH funding, "vm.warp()" for time manipulation, "vm.expectRevert()" for failure testing.
+Use Foundry exclusively for testing. Utilize Foundry cheatcodes for test control: "vm.prank()" for identity switching, "vm.deal()" for ETH funding, "vm.warp()" for time manipulation, "vm.expectRevert()" for failure testing.
+
+## Scaffold Strict Compliance
+- The target contract's full source code is ALREADY included at the top of the scaffold. You can and MUST call its functions directly (e.g., \`target.deposit()\`). Do NOT create fake interfaces or use low-level \`.call(abi.encodeWithSignature(...))\`.
+- YOU MUST RETURN THE ENTIRE FILE PROVIDED IN THE SCAFFOLD. Do not omit the \`setUp()\` function or the original contract source code. Your output will overwrite the file directly.
+- DO NOT rename \`test_Exploit()\`. You MUST implement your exploit inside \`function test_Exploit() public\`.
+- DO NOT use characters with accents (like ã, ç, é, etc.) in string literals (e.g., inside \`assertEq\` or \`require\`). Use ONLY plain ASCII, or prefix with \`unicode"..."\` to avoid Solc compiler errors.
 
 ## PoC Executability
-Ensure all generated code compiles successfully. Write ONLY the test file code (helper contracts + ExploitTest). Do NOT modify or re-include the original contract source code provided in the scaffold. Resolve all compilation errors and logic reverts while preserving original contract logic.
+Ensure all generated code compiles successfully. Write ONLY the test file code (helper contracts + ExploitTest). Resolve all compilation errors and logic reverts while preserving original contract logic.
 
 ## Iterative Refinement
 Debug compilation errors and test failures systematically using Forge output. If stuck on the same issue for >3 attempts, shift to a minimal working demonstration—proving the vulnerability exists matters more than setup complexity.
@@ -19,11 +25,72 @@ Debug compilation errors and test failures systematically using Forge output. If
 The assertion in your test MUST prove the vulnerability. For example, if funds are stolen, assert that the vault balance decreased and the attacker balance increased.
 
 ## Output Format
-Return ONLY a code block with the helper attacker contract (if needed) and the ExploitTest contract:
+Return ONLY a code block with the full ExploitTest contract and any helper attacker contracts. Do not include markdown outside the code block.
+
+## Examples (Few-Shot)
+
+**Input Example:**
+Vulnerability: Reentrancy in withdraw() allows draining the contract.
+Scaffold:
+\`\`\`solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+import "forge-std/Test.sol";
+contract Target { function withdraw(uint256) public {} } // Source code
+contract ExploitTest is Test {
+    Target target;
+    function setUp() public { target = new Target(); }
+    function test_Exploit() public {
+        // TODO: implementar exploit aqui
+    }
+}
+\`\`\`
+
+**Expected Output:**
 \`\`\`solidity
-// Attacker helpers here...
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+import "forge-std/Test.sol";
+contract Target { function withdraw(uint256) public {} } // Source code
+
+// We can define helper contracts outside the main test contract
+contract Attacker {
+    Target target;
+    constructor(address _target) {
+        target = Target(_target);
+    }
+    fallback() external payable {
+        if (address(target).balance >= 1 ether) {
+            target.withdraw(1 ether);
+        }
+    }
+    function attack() external {
+        target.withdraw(1 ether);
+    }
+}
+
 contract ExploitTest is Test {
-    // ...
+    Target target;
+    
+    // IMPORTANT: We include the EXACT setUp() provided in the scaffold.
+    function setUp() public { 
+        target = new Target(); 
+    }
+
+    function test_Exploit() public {
+        vm.startPrank(address(0xBEEF));
+        
+        // 1. Deploy malicious contract
+        Attacker attacker = new Attacker(address(target));
+        
+        // 2. Exploit the vulnerability using direct function calls
+        attacker.attack();
+        
+        // 3. Verify the exploit succeeded (no special characters in assertion strings)
+        assertEq(address(target).balance, 0, "Target contract should be drained");
+        
+        vm.stopPrank();
+    }
 }
 \`\`\`
 `.trim();

src/agents/tester/tools/foundryRunner.ts

@@ -4,7 +4,7 @@ import { writeFile, access } from "fs/promises";
 import { join } from "path";
 
 const execAsync  = promisify(exec);
-const SANDBOX    = "/tmp/poc-sandbox";
+const SANDBOX = process.env.SANDBOX_DIR || "/tmp/poc-sandbox";
 const TIMEOUT_MS = 60_000;
 
 export interface FoundryResult {

src/config/llm.ts

@@ -6,7 +6,7 @@ import type { BaseChatModel } from "@langchain/core/language_models/chat_models"
 export type LLMProvider = "google" | "openrouter" | "anthropic";
 
 export function createLLM(overrideProvider?: LLMProvider): BaseChatModel {
-  const provider = overrideProvider || (process.env.LLM_PROVIDER as LLMProvider) || "google";
+  const provider = overrideProvider || (process.env.LLM_PROVIDER as LLMProvider) || "openrouter";
 
   switch (provider) {
     case "openrouter":