refactor: remove old files

src/agents/tester/README.md

@@ -1,109 +1,60 @@
-# Agente Gerador de PoCs (Tester)
+# PoCo Agent (Proof-of-Concept Agent)
 
-Este agente é responsável por validar vulnerabilidades identificadas pelo **Agente Auditor** através da geração automática de exploits em Solidity (*Proof of Concepts* - PoCs) e execução em um ambiente sandbox utilizando **Foundry**.
+Este diretório contém a implementação principal do **Agente PoCo**, uma arquitetura autônoma baseada no framework **LangGraph**, desenvolvida para atuar como um auditor de segurança e desenvolvedor de exploits (Proof of Concepts) em Smart Contracts.
 
 ## 1. Visão Geral
 
-O agente implementa um **loop ReAct** (Gerar → Executar → Refletir) orquestrado via **LangGraph**. Diferente de abordagens tradicionais, ele utiliza um componente **Oracle** para preparar o scaffold do teste, permitindo que o LLM foque exclusivamente na lógica do exploit.
+O Agente recebe como entrada um relatório de vulnerabilidade (escrito por um auditor humano) e o código-fonte do contrato afetado. O objetivo do agente é explorar iterativamente o ambiente local usando o framework **Foundry** até conseguir escrever um arquivo `Exploit.t.sol` que prove matematicamente que a vulnerabilidade descrita é explorável (roubando fundos, burlando acessos, etc).
 
-### Fluxo Multi-agente
-```mermaid
-graph LR
-    Coder[Agente Gerador] -- "Código Fonte" --> Auditor
-    Auditor[Agente Auditor] -- "Findings (JSON)" --> Tester
-    Tester[Agente de PoCs] -- "PoCResult (Verificado)" --> Final[Projeto Validado]
-```
-
-### Principais Funcionalidades:
-- **Sandbox Autônomo:** O agente detecta e inicializa o ambiente Foundry (`/tmp/poc-sandbox`) automaticamente no primeiro uso.
-- **Scaffold Automático:** Gera o arquivo `Exploit.t.sol` com o contrato vítima já instanciado e financiado.
-- **Loop de Auto-correção:** Se o exploit falhar, o agente analisa os logs e tenta corrigir o código por até 5 iterações.
-- **Integração com DeepSeek:** Utiliza o modelo `deepseek-v4-pro` via OpenRouter.
+Diferente de scripts sequenciais convencionais, este agente emprega um **Loop ReAct** (Raciocínio e Ação) iterativo:
+1. **Lê e entende** o contexto.
+2. **Planeja** uma estratégia de ataque em múltiplos passos.
+3. **Escreve** o código no disco.
+4. **Compila e testa** localmente via terminal.
+5. **Analisa o erro** de compilação ou de lógica e auto-corrige o exploit na próxima iteração.
 
-## 2. Arquitetura
+## 2. Componentes da Arquitetura
 
-O fluxo de execução segue o grafo definido em `agent.ts`:
+O sistema é orquestrado através de uma Máquina de Estados Finita (Graph) no `graph.ts`, composta por 5 nós fundamentais:
 
-1.  **Oracle Node:** Recebe o relatório de vulnerabilidade e gera o scaffold Solidity inicial.
-2.  **Generate PoC Node:** O LLM completa a função `test_Exploit()` com base no scaffold e na descrição da falha.
-3.  **Run Foundry Node:** Escreve o código no sandbox e executa `forge test`.
-4.  **Reflect Node:** Em caso de falha, analisa o output do Forge, classifica o erro e fornece feedback para o próximo ciclo de geração.
+*   **`contextNode`**: Nó de entrada. Carrega o relatório original do auditor e injeta no estado global do agente.
+*   **`routerNode`**: Formata as restrições do ambiente e monta o `System Prompt` que define a persona do LLM.
+*   **`pocoAgentNode`**: O motor cognitivo. Utiliza o modelo de linguagem avançado (ex: Claude 3.5 Sonnet) para raciocinar sobre as falhas e escolher qual ferramenta invocar.
+*   **`pocoToolsNode`**: O executor mecânico das ferramentas. Acessa o FileSystem (`read_file`, `write_file`) e o terminal (`smart_contract_test`, `smart_contract_compile`).
+*   **`trackToolCallsNode`**: Intercepta a saída do teste. Se o teste passar (`Test Passed Successfully!`), ele interrompe o grafo prematuramente definindo o status de `success`. Se falhar, devolve o feedback de erro para o `pocoAgentNode` tentar novamente, até o limite de 30 iterações.
 
-## 3. Estrutura de Arquivos
+## 3. Estrutura de Diretórios
 
-```
+```text
 src/agents/tester/
-├── agent.ts           # Definição do grafo LangGraph e lógica dos nodes
-├── state.ts           # Estado interno do agente (PoCStateAnnotation)
-├── types.ts           # Interfaces de entrada (Finding) e saída (PoCResult)
-├── index.ts           # Entry point público (runPoCGenerator)
-│
-├── tools/
-│   ├── scaffoldGenerator.ts  # Gerador de boilerplate Foundry
-│   └── foundryRunner.ts      # Executor de comandos shell (forge)
-│
-├── prompts/
-│   └── system.ts             # Instruções especializadas para o LLM
-│
-└── utils/
-    ├── extractSolidity.ts    # Parser de blocos de código
-    └── logAnalyzer.ts        # Classificador de erros de execução
+├── index.ts           # Entrypoint da biblioteca, orquestra e dispara o grafo LangGraph.
+├── agent.ts           # Definição e wrapper do agente para integração externa.
+├── graph.ts           # A topologia da rede ReAct (nodes e edges).
+├── state.ts           # Interface de Estado global que trafega entre os nós do grafo.
+├── types.ts           # Tipagens TypeScript (Report, Vulnerability, etc).
+├── tools/             # (Depreciado) Ferramentas antigas de suporte.
+├── utils/             # Scripts utilitários e stubs de dependências.
+└── nodes/
+    ├── context.ts     # Setup inicial e parser do contexto.
+    ├── router.ts      # Montagem do prompt base.
+    └── pocoAgent.ts   # Chamada direta à API do LLM com as Tools associadas.
 ```
 
-## 4. Integração e Uso
+## 4. Como Executar
 
-### Fluxo de Dados (Input/Output)
-
-O agente recebe um objeto `VulnerabilityReport`. Como o **Agente Auditor** gera objetos do tipo `Finding`, é necessário realizar um mapeamento (veja `src/index.ts` para o adapter).
-
-#### Estrutura de Entrada (`VulnerabilityReport`)
-```typescript
-interface VulnerabilityReport {
-  id: string;               // Identificador único do report
-  severity: string;         // "high", "medium", "low"
-  title: string;            // Título curto da falha
-  description: string;      // Descrição técnica detalhada
-  affectedContract: {
-    name: string;           // Nome da classe do contrato
-    sourceCode: string;     // Código-fonte completo (Solidity)
-  };
-  attackVector: string;     // Descrição do caminho de ataque
-  exploitablePaths?: string[]; // (Opcional) Passos detalhados
-}
-```
+O agente não é chamado isoladamente pelo usuário, mas sim invocado pelo orquestrador principal de Benchmark ou pela CLI da ferramenta. Para avaliar a eficácia do agente, recomenda-se executar os scripts do Benchmark na raiz do projeto:
 
-#### Estrutura de Saída (`PoCResult`)
-```typescript
-interface PoCResult {
-  reportId: string;
-  status: "success" | "failed" | "timeout";
-  solidityCode: string;    // Conteúdo final do Exploit.t.sol
-  executionLogs: string[]; // Logs brutos de todas as iterações
-  iterations: number;      // Total de tentativas realizadas
-}
+```bash
+# Executa a avaliação em cima do dataset Hard (Proof-of-Patch)
+DEBUG_CONTEXT=true FORCE_RERUN=true npx tsx src/benchmark/runTesterBenchmark.ts 100
 ```
 
-### Exemplo de Integração
-```typescript
-import { runPoCGenerator } from "./src/agents/tester";
-
-// O orquestrador mapeia o Finding + Código Fonte para o Report
-const result = await runPoCGenerator(report);
-```
-
-### Pré-requisitos
-- **Foundry:** `forge` deve estar instalado e acessível. O agente busca em `~/.foundry/bin` e no PATH padrão.
-- **API Key:** `OPENROUTER_API_KEY` deve estar configurada no arquivo `.env`.
-
-## 5. Avaliação de Resultados
-
-O `PoCResult` retorna um status que indica a validade da vulnerabilidade ou a eficácia de um patch:
+## 5. Ferramentas (Tools)
 
-| Status | Significado | Ação Recomendada |
-| :--- | :--- | :--- |
-| **`success`** | Exploit executou e passou na assertion. | Vulnerabilidade confirmada. |
-| **`failed`** | Exploit falhou após 5 tentativas. | Verificar `executionLogs` para erro de lógica ou compilação. |
-| **`timeout`** | Forge excedeu 60 segundos. | Possível loop infinito no contrato ou exploit. |
+A maestria do agente vem de seu arsenal de ferramentas (`tools.ts`), que operam com alta precisão cirúrgica para economizar tokens:
+*   `read_file`, `list_dir`: Explorar a árvore de contratos vulneráveis.
+*   `todo_planner`: Criar uma lista de tarefas persistente para orientar a memória de longo prazo durante as 30 iterações.
+*   `write_file`, `edit_file`: Gerar ou alterar partes específicas do exploit de forma isolada.
+*   `smart_contract_compile`, `smart_contract_test`: Interagir diretamente com a CLI do `forge` para compilar ou rodar os testes, com os logs canalizados de volta para o agente.
 
-## 6. Base Acadêmica
-A implementação deste agente foi inspirada no framework **PoCo** (Bergman et al., KTH 2025), adaptada para execução local determinística e suporte multi-agente.
+> **Nota Metodológica:** O agente assume que está operando em um repositório configurado e funcional. Se as dependências do repositório alvo (ex: submódulos do foundry) estiverem quebradas ou faltantes fisicamente no disco, o agente tentará alucinar "Mocks" arquiteturais para forçar o projeto a compilar, o que foge do escopo do teste da vulnerabilidade. Sempre garanta que o projeto alvo passa por um `forge build` limpo antes de submetê-lo à auditoria.

src/agents/tester/graph.ts

@@ -1,8 +1,7 @@
 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 { contextNode } from "./nodes/context.js";
 import { pocoAgentNode } from "./nodes/pocoAgent.js";
 import { pocoTools } from "./tools.js";
 
@@ -54,15 +53,13 @@ function routeAfterTools(state: PoCState): "pocoAgentNode" | typeof END {
 }
 
 const graphBuilder = new StateGraph(PoCStateAnnotation)
-  .addNode("oracleNode", oracleNode)
-  .addNode("routerNode", routerNode)
+  .addNode("contextNode", contextNode)
   .addNode("pocoAgentNode", pocoAgentNode)
   .addNode("pocoToolsNode", pocoToolsNode)
   .addNode("trackToolCallsNode", trackToolCallsNode)
   
-  .addEdge(START, "oracleNode")
-  .addEdge("oracleNode", "routerNode")
-  .addEdge("routerNode", "pocoAgentNode")
+  .addEdge(START, "contextNode")
+  .addEdge("contextNode", "pocoAgentNode")
   
   // ReAct Loop Routing
   .addConditionalEdges("pocoAgentNode", routeAfterAgent, {

src/agents/tester/nodes/context.ts

@@ -0,0 +1,32 @@
+import fs from "fs/promises";
+import path from "path";
+import { PoCState } from "../state.js";
+
+export async function contextNode(state: PoCState): Promise<Partial<PoCState>> {
+  console.log("[contextNode] Preparando ambiente de testes para:", state.report.title);
+
+  if (state.report.customSandboxDir) {
+    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(`[contextNode] Limpos ${removed} arquivos de teste antigos.`);
+      }
+    } catch (e) {
+      console.warn("[contextNode] falha na limpeza do diretório de testes:", (e as Error).message);
+    }
+  }
+
+  return { 
+    templateCode: "", 
+    pocCode: "", 
+    infrastructurePhase: false
+  };
+}

src/agents/tester/nodes/oracle.ts

@@ -1,72 +0,0 @@
-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 { 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);
-    }
-  }
-
-  const oracleContext: OracleContext = { 
-    solidityScaffold,
-    constructorInfo: constructorInfo?.parameters,
-    targetContractAPI,
-    referenceTestHelpers,
-    projectRemappings,
-    projectTestImports,
-    projectTestFilePath,
-  };
-
-  // No longer generating static template. We leave it to the agent to build the setup.
-  console.log("[oracleNode] scaffold generation skipped. Context built.");
-  return { 
-    oracleContext, 
-    templateCode: "", 
-    pocCode: "", 
-    infrastructurePhase: false
-  };
-}

src/agents/tester/nodes/router.ts

@@ -1,32 +0,0 @@
-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/state.ts

@@ -1,15 +1,10 @@
 import { Annotation } from "@langchain/langgraph";
 import { BaseMessage } from "@langchain/core/messages";
-import { VulnerabilityReport, OracleContext } from "./types.js";
+import { VulnerabilityReport } from "./types.js";
 
 export const PoCStateAnnotation = Annotation.Root({
   report: Annotation<VulnerabilityReport>(),
 
-  oracleContext: Annotation<OracleContext | null>({
-    default: () => null,
-    reducer: (_, y) => y,           // overwrite — filled once by oracleNode
-  }),
-
   pocCode: Annotation<string>({
     default: () => "",
     reducer: (_, y) => y,           // overwrite — full combined file
@@ -25,11 +20,6 @@ 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

src/agents/tester/tools/scaffoldGenerator.ts

@@ -1,50 +0,0 @@
-import { VulnerabilityReport } from "../types.js";
-
-export function generateLocalScaffold(report: VulnerabilityReport): string {
-  const cheatcodes = report.suggestedCheatcodes?.join(", ") ?? "vm.deal, vm.prank, vm.warp";
-
-  // Extrair pragma do código original para evitar conflitos de versão
-  const pragmaMatch = report.affectedContract.sourceCode.match(/pragma solidity ([^;]+);/);
-  const pragma = pragmaMatch ? pragmaMatch[0] : "pragma solidity ^0.8.20;";
-
-  let contractSetup = "";
-  if (report.affectedContract.sourceFilePath) {
-    // Se temos o caminho do arquivo, importamos ao invés de colar
-    contractSetup = `import { ${report.affectedContract.name} } from "../${report.affectedContract.sourceFilePath}";`;
-  } else {
-    // Fallback: colar o código (pode falhar por causa de imports ausentes no sandbox)
-    contractSetup = `// ── Código-fonte do contrato vulnerável ──────────────────────────────────────\n${report.affectedContract.sourceCode}\n// ─────────────────────────────────────────────────────────────────────────────`;
-  }
-
-  return `// SPDX-License-Identifier: UNLICENSED
-${pragma}
-
-import "forge-std/Test.sol";
-import "forge-std/console.sol";
-
-${contractSetup}
-
-contract ExploitTest is Test {
-    ${report.affectedContract.name} target;
-    address constant ATTACKER = address(0xBEEF);
-
-    // setUp() - O Oracle tentou gerar um básico, mas sinta-se à vontade para ajustar se o contrato for complexo
-    function setUp() public virtual {
-        // target = new ${report.affectedContract.name}(...); // TODO: ajustar se necessário
-        vm.deal(ATTACKER, 100 ether);
-    }
-
-    // Vulnerabilidade: ${report.title}
-    // Tipo: ${report.type}
-    // Vetor: ${report.attackVector}
-    ${report.exploitablePaths ? `// Caminhos de Exploração:\n    // - ${report.exploitablePaths.join("\n    // - ")}` : ""}
-    // Cheatcodes sugeridos: ${cheatcodes}
-    //
-    // Implemente test_Exploit() e ajuste o setUp() se o contrato exigir argumentos no constructor.
-    function test_Exploit() public {
-        vm.startPrank(ATTACKER);
-        // TODO: implementar exploit aqui
-        vm.stopPrank();
-    }
-}`.trim();
-}

src/agents/tester/types.ts

@@ -34,15 +34,7 @@ export interface VulnerabilityReport {
   patchDiff?: string; // Unified diff of the patch (vulnerable vs patched) for specificity guidance
 }
 
-export interface OracleContext {
-  solidityScaffold: string;  // Exploit.t.sol parcial com setUp() pronto
-  constructorInfo?: string;  // Assinatura do constructor para ajudar no deploy
-  targetContractAPI?: string;  // Resumo dos métodos e variáveis do contrato alvo
-  referenceTestHelpers?: string; // Resumo das funções auxiliares disponíveis no ambiente de teste
-  projectRemappings?: string; // Content of remappings.txt for correct import paths
-  projectTestImports?: string; // Import lines from an existing test file in the project
-  projectTestFilePath?: string | null; // Path to the reference test file used
-}
+
 
 export interface PoCResult {
   reportId: string;

src/agents/tester/utils/dependencyStubber.ts

@@ -1,85 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-
-const execAsync = promisify(exec);
-
-/**
- * Runs a minimal forge build probe to detect missing source files,
- * then creates minimal stub contracts at those exact paths.
- * This unblocks projects that use deep submodule dependencies (e.g. lib/caviar/lib/oracle/...)
- * or node_modules imports that are not present in the sandbox.
- */
-export async function createMissingDependencyStubs(sandboxDir: string): Promise<void> {
-  // Run forge build on just the project (no test files), capture errors
-  let combined = "";
-  try {
-    const { stdout, stderr } = await execAsync(
-      `cd "${sandboxDir}" && forge build --no-cache 2>&1 || true`,
-      { 
-        timeout: 60_000,
-        env: { ...process.env, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` }
-      }
-    );
-    combined = stdout + stderr;
-  } catch (e: any) {
-    combined = e.stdout || e.stderr || e.message || "";
-  }
-
-  // Extract all "Source X not found" paths
-  const missingPaths: string[] = [];
-  const sourceNotFoundRegex = /Source "([^"]+)" not found/g;
-  let match: RegExpExecArray | null;
-  while ((match = sourceNotFoundRegex.exec(combined)) !== null) {
-    const missing = match[1];
-    if (!missingPaths.includes(missing)) {
-      missingPaths.push(missing);
-    }
-  }
-
-  if (missingPaths.length === 0) return;
-
-  console.log(`[oracleNode] Detected ${missingPaths.length} missing dependencies, creating stubs...`);
-
-  // Detect Solidity version used in the project (for the stub pragma)
-  let pragmaVersion = "^0.8.0";
-  try {
-    const toml = await fs.readFile(path.join(sandboxDir, "foundry.toml"), "utf-8");
-    const vMatch = toml.match(/solc[_-]?version\s*=\s*"([^"]+)"/);
-    if (vMatch) pragmaVersion = vMatch[1];
-  } catch { /* use default */ }
-
-  for (const missing of missingPaths) {
-    // Build the stub path inside the sandbox
-    const stubPath = path.join(sandboxDir, missing);
-    
-    // Skip if file already exists
-    try {
-      await fs.access(stubPath);
-      continue; // already exists
-    } catch { /* doesn't exist, create it */ }
-
-    // Skip forge-std — it should always be available
-    if (missing.startsWith("forge-std/") || missing.startsWith("lib/forge-std/")) continue;
-
-    try {
-      await fs.mkdir(path.dirname(stubPath), { recursive: true });
-      
-      // Generate a minimal stub that satisfies the import
-      const contractName = path.basename(missing, ".sol");
-      const stubContent = `// SPDX-License-Identifier: MIT
-// AUTO-GENERATED STUB — replaces missing dependency: ${missing}
-pragma solidity ${pragmaVersion};
-
-// Minimal stub to satisfy missing import
-contract ${contractName} {}
-interface I${contractName} {}
-`;
-      await fs.writeFile(stubPath, stubContent);
-      console.log(`  [stub] Created: ${missing}`);
-    } catch (e) {
-      console.warn(`  [stub] Failed to create ${missing}:`, (e as Error).message);
-    }
-  }
-}

src/agents/tester/utils/projectContextExtractor.ts

@@ -1,156 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-
-export interface ProjectContext {
-  remappings: string;       // Content of remappings.txt or foundry.toml [profile.default.remappings]
-  existingTestImports: string; // First few import lines from an existing test file
-  foundryTomlProfile: string; // Relevant foundry.toml settings (src, libs)
-  existingTestFilePath: string | null; // Relative path to an existing test file for reference
-}
-
-/**
- * Extracts project-level context needed for correct import paths in PoC tests.
- * Reads remappings.txt, foundry.toml, and the first existing test file in the project.
- */
-export async function extractProjectContext(sandboxDir: string): Promise<ProjectContext> {
-  let remappings = "";
-  let foundryTomlProfile = "";
-  let existingTestImports = "";
-  let existingTestFilePath: string | null = null;
-
-  // 1. Read remappings.txt
-  try {
-    const remappingsPath = path.join(sandboxDir, "remappings.txt");
-    remappings = await fs.readFile(remappingsPath, "utf-8");
-  } catch {
-    // fallback: try to extract from foundry.toml
-  }
-
-  // 2. Read foundry.toml for additional context
-  try {
-    const foundryTomlPath = path.join(sandboxDir, "foundry.toml");
-    const tomlContent = await fs.readFile(foundryTomlPath, "utf-8");
-    // Extract relevant lines (src, libs, remappings)
-    const relevantLines = tomlContent
-      .split("\n")
-      .filter(l =>
-        l.includes("src") ||
-        l.includes("libs") ||
-        l.includes("remapping") ||
-        l.includes("[profile")
-      )
-      .slice(0, 20)
-      .join("\n");
-    foundryTomlProfile = relevantLines;
-
-    // If no remappings.txt, try to extract from foundry.toml remappings array
-    if (!remappings) {
-      const remappingMatch = tomlContent.match(/remappings\s*=\s*\[([\s\S]*?)\]/);
-      if (remappingMatch) {
-        remappings = remappingMatch[1]
-          .split(",")
-          .map(s => s.trim().replace(/^["']|["']$/g, ""))
-          .filter(Boolean)
-          .join("\n");
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  // 3. Find an existing test file to use as import reference
-  try {
-    const testDir = path.join(sandboxDir, "test");
-    const testFile = await findFirstTestFile(testDir);
-    if (testFile) {
-      existingTestFilePath = path.relative(sandboxDir, testFile);
-      const testContent = await fs.readFile(testFile, "utf-8");
-      // Extract the first 20 lines which typically contain imports
-      existingTestImports = testContent
-        .split("\n")
-        .slice(0, 25)
-        .filter(l => l.startsWith("import") || l.startsWith("pragma") || l.startsWith("//") || l.startsWith("contract") || l.startsWith("abstract"))
-        .join("\n");
-    }
-  } catch {
-    // ignore
-  }
-
-  return { remappings, existingTestImports, foundryTomlProfile, existingTestFilePath };
-}
-
-/**
- * Recursively finds the best reference test file in the test directory.
- * Strategy:
- *  1. Collect ALL .t.sol files (excluding Exploit.t.sol) across all subdirs (BFS)
- *  2. Pick the one with the most import lines (most context-rich)
- *  3. Fallback to .sol files that have "import" statements (e.g. BaseTest.sol, Fixture.sol)
- *  4. Skip pure mock contracts (files in "mock" directories or named *Mock.sol)
- */
-async function findFirstTestFile(dir: string): Promise<string | null> {
-  const tSolFiles: string[] = [];
-  const solFiles: string[] = [];
-
-  // BFS collect all files
-  const queue = [dir];
-  let depth = 0;
-  while (queue.length > 0 && depth < 4) {
-    const currentDepth: string[] = [...queue];
-    queue.length = 0;
-    depth++;
-    for (const currentDir of currentDepth) {
-      let entries: import('fs').Dirent[];
-      try {
-        entries = await fs.readdir(currentDir, { withFileTypes: true }) as import('fs').Dirent[];
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        const fullPath = path.join(currentDir, entry.name);
-        const name = entry.name as string;
-        if (entry.isFile()) {
-          if (name === "Exploit.t.sol") continue; // skip our own file
-          if (name.endsWith(".t.sol")) {
-            tSolFiles.push(fullPath);
-          } else if (name.endsWith(".sol")) {
-            // Skip mock contracts
-            const isMock = name.toLowerCase().includes("mock") || currentDir.toLowerCase().includes("mock");
-            if (!isMock) {
-              solFiles.push(fullPath);
-            }
-          }
-        } else if (entry.isDirectory()) {
-          queue.push(fullPath);
-        }
-      }
-    }
-  }
-
-  // Pick the .t.sol file with the most import lines (richest context)
-  if (tSolFiles.length > 0) {
-    let bestFile = tSolFiles[0];
-    let bestImportCount = 0;
-    for (const f of tSolFiles.slice(0, 10)) { // check up to 10
-      try {
-        const content = await fs.readFile(f, "utf-8");
-        const importCount = (content.match(/^import/gm) ?? []).length;
-        if (importCount > bestImportCount) {
-          bestImportCount = importCount;
-          bestFile = f;
-        }
-      } catch { /* skip */ }
-    }
-    return bestFile;
-  }
-
-  // Fallback: .sol files that have import statements (like BaseTest.sol, Fixture.sol)
-  for (const f of solFiles.slice(0, 10)) {
-    try {
-      const content = await fs.readFile(f, "utf-8");
-      if (content.includes("import ")) return f;
-    } catch { /* skip */ }
-  }
-
-  return null;
-}
-

src/benchmark/runTesterBenchmark.ts

@@ -206,8 +206,8 @@ async function main() {
       continue;
     }
 
-    const allowedIds = ["008", "020", "041", "054", "070", "077"];
-    if (!allowedIds.includes(id)) {
+    const targetIds = ["020"];
+    if (!targetIds.includes(id)) {
       continue;
     }