Spaces:

TALP-Project
/

multi-agent-smart-contracts

Runtime error

App Files Files Community

Uanderson Ricardo commited on Jun 17

Commit

5cf0f74

2 Parent(s): 3ada692 42ebf1f

Merge pull request #8 from uandersonricardo/unify-logs

Browse files

Files changed (14) hide show

frontend/index.html +21 -1
frontend/src/App.tsx +125 -362
frontend/src/components/ArtifactPanel.tsx +523 -0
frontend/src/components/ControlPanel.tsx +443 -0
frontend/src/types.ts +48 -0
frontend/src/utils/diff.ts +54 -0
frontend/src/utils/status.ts +100 -0
src/agents/auditor/agent.ts +44 -22
src/agents/coder/agent.ts +14 -1
src/agents/tester/agent.ts +42 -33
src/agents/tester/index.ts +0 -27
src/agents/tester/tools/foundryRunner.ts +13 -12
src/logger.ts +50 -0
src/server.ts +18 -13

frontend/index.html CHANGED Viewed

@@ -3,7 +3,27 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Multi-Agent Smart Contracts</title>
   </head>
   <body>
     <div id="root"></div>

   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>TALP1 — Smart Contract Agents</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:ital,wght@0,400;0,500;0,600;0,700;1,400&display=swap" rel="stylesheet" />
+    <style>
+      *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+      html, body { height: 100%; }
+      body { overflow: hidden; background: #070c10; font-family: 'JetBrains Mono', 'Fira Code', monospace; }
+      #root { height: 100%; }
+      ::-webkit-scrollbar { width: 5px; height: 5px; }
+      ::-webkit-scrollbar-track { background: transparent; }
+      ::-webkit-scrollbar-thumb { background: #21262d; border-radius: 3px; }
+      ::-webkit-scrollbar-thumb:hover { background: #30363d; }
+      * { scrollbar-width: thin; scrollbar-color: #21262d transparent; }
+      @keyframes spin { to { transform: rotate(360deg); } }
+      @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.3; } }
+      @keyframes fadein { from { opacity: 0; transform: translateY(3px); } to { opacity: 1; transform: translateY(0); } }
+      @keyframes blink { 0%, 100% { opacity: 1; } 50% { opacity: 0; } }
+    </style>
   </head>
   <body>
     <div id="root"></div>

frontend/src/App.tsx CHANGED Viewed

@@ -1,56 +1,46 @@
 import { useState, useRef, useCallback } from "react";
-interface Finding {
-  title: string;
-  description: string;
-  recommendation: string;
-  severity: "high" | "medium" | "low";
-  codeSnippet: string;
-  location: string;
-  path: string;
-  judgeReview: {
-    review: string;
-    confidence: number;
-    exploitablePaths: string[];
-  };
-}
-interface AgentResult {
-  contract?: string;
-  compilationErrors?: string[];
-  reviewSummary?: string;
-  findings?: Finding[];
-  // Tester fields
-  status?: string;
-  pocCode?: string;
-  executionLogs?: string[];
-  iterations?: number;
-}
 export function App() {
   const [requirements, setRequirements] = useState("");
-  const [logs, setLogs] = useState<string[]>([]);
-  const [coderResult, setCoderResult] = useState<AgentResult | null>(null);
-  const [auditorResult, setAuditorResult] = useState<AgentResult | null>(null);
-  const [testerResult, setTesterResult] = useState<AgentResult | null>(null);
   const [running, setRunning] = useState(false);
-  const logsEndRef = useRef<HTMLDivElement>(null);
   const appendLog = useCallback((msg: string) => {
     setLogs((prev) => [...prev, msg]);
-    setTimeout(() => logsEndRef.current?.scrollIntoView({ behavior: "smooth" }), 50);
   }, []);
-  const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
     if (!requirements.trim() || running) return;
     setRunning(true);
     setLogs([]);
-    setCoderResult(null);
-    setAuditorResult(null);
-    setTesterResult(null);
-    appendLog("Iniciando pipeline...");
     try {
       const res = await fetch("/api/run", {
@@ -72,30 +62,88 @@ export function App() {
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
         for (const line of lines) {
           if (line.startsWith("event:")) {
             currentEvent = line.slice(6).trim();
-            console.log("event", currentEvent);
           } else if (line.startsWith("data:")) {
             const data = line.slice(5).trim();
-            console.log("data", data);
             switch (currentEvent) {
               case "log":
                 appendLog(data);
                 break;
-              case "coder":
-                setCoderResult(JSON.parse(data));
                 break;
-              case "auditor":
-                setAuditorResult(JSON.parse(data));
                 break;
-              case "tester":
-                setTesterResult(JSON.parse(data));
                 break;
               case "error":
-                appendLog(`❌ ERRO: ${data}`);
                 break;
             }
             currentEvent = "";
@@ -103,328 +151,43 @@ export function App() {
         }
       }
     } catch (err) {
-      appendLog(`❌ Erro de conexão: ${err instanceof Error ? err.message : String(err)}`);
     } finally {
       setRunning(false);
     }
   };
-  return (
-    <div style={styles.container}>
-      <header style={styles.header}>
-        <h1 style={styles.title}>Multi-Agent: Geração, Auditoria e Teste de Smart Contracts</h1>
-        <p style={styles.subtitle}>
-          Descreva um cenário ou requisito cuja solução seja um smart contract em Solidity. O sistema irá gerar,
-          compilar, auditar e testar o contrato automaticamente.
-        </p>
-      </header>
-      <form onSubmit={handleSubmit} style={styles.form}>
-        <textarea
-          value={requirements}
-          onChange={(e) => setRequirements(e.target.value)}
-          placeholder={
-            "Ex: Crie um token ERC20 com as seguintes características:\n- Nome: MeuToken, Símbolo: MTK\n- Supply inicial de 1.000.000 tokens\n- Funções de mint (apenas owner) e burn\n- Pausável pelo owner"
-          }
-          style={styles.textarea}
-          rows={6}
-          disabled={running}
-        />
-        <button
-          type="submit"
-          disabled={running || !requirements.trim()}
-          style={{
-            ...styles.button,
-            opacity: running || !requirements.trim() ? 0.5 : 1,
-          }}
-        >
-          {running ? "Executando pipeline..." : "Executar Pipeline"}
-        </button>
-      </form>
-      {/* Logs */}
-      {logs.length > 0 && (
-        <section style={styles.section}>
-          <h2 style={styles.sectionTitle}>📋 Log de Execução</h2>
-          <div style={styles.logBox}>
-            {logs.map((log, i) => (
-              <div key={i} style={styles.logLine}>
-                {log}
-              </div>
-            ))}
-            <div ref={logsEndRef} />
-          </div>
-        </section>
-      )}
-      {/* Coder */}
-      {coderResult && (
-        <section style={styles.section}>
-          <h2 style={styles.sectionTitle}>🔨 Agente Coder</h2>
-          <h3 style={styles.subTitle}>Contrato Gerado</h3>
-          <div style={styles.codeBox}>
-            <pre style={styles.code}>{coderResult.contract}</pre>
-          </div>
-          {coderResult.compilationErrors && coderResult.compilationErrors.length > 0 && (
-            <>
-              <h3 style={{ ...styles.subTitle, color: "#ef4444" }}>Erros de Compilação</h3>
-              <div style={{ ...styles.codeBox, borderColor: "#ef4444" }}>
-                <pre style={styles.code}>{coderResult.compilationErrors.join("\n")}</pre>
-              </div>
-            </>
-          )}
-          {coderResult.reviewSummary && (
-            <>
-              <h3 style={styles.subTitle}>Revisão de Segurança</h3>
-              <div style={styles.resultBox}>
-                <p style={styles.resultText}>{coderResult.reviewSummary}</p>
-              </div>
-            </>
-          )}
-        </section>
-      )}
-      {/* Auditor */}
-      {auditorResult && (
-        <section style={styles.section}>
-          <h2 style={styles.sectionTitle}>🔍 Agente Auditor</h2>
-          {auditorResult.findings && auditorResult.findings.length > 0 ? (
-            auditorResult.findings.map((f, i) => (
-              <div key={i} style={{ ...styles.findingCard, borderColor: severityColor(f.severity) }}>
-                <div style={styles.findingHeader}>
-                  <span style={{ ...styles.severityBadge, background: severityColor(f.severity) }}>
-                    {f.severity.toUpperCase()}
-                  </span>
-                  <span style={styles.findingTitle}>{f.title}</span>
-                </div>
-                <p style={styles.findingText}>{f.description}</p>
-                <p style={{ ...styles.findingText, color: "#94a3b8" }}>
-                  <strong>Localização:</strong> {f.location ?? "-"}
-                </p>
-                {f.codeSnippet && <pre style={styles.code}>{f.codeSnippet}</pre>}
-                <p style={{ ...styles.findingText, color: "#94a3b8" }}>
-                  <strong>Recomendação:</strong> {f.recommendation}
-                </p>
-                <p style={{ ...styles.findingText, color: "#64748b", fontSize: 12 }}>
-                  Confiança: {Math.round(f.judgeReview.confidence)}% — {f.judgeReview.review}
-                </p>
-              </div>
-            ))
-          ) : (
-            <div style={styles.resultBox}>
-              <p style={styles.resultText}>Nenhuma vulnerabilidade encontrada.</p>
-            </div>
-          )}
-        </section>
-      )}
-      {/* Tester */}
-      {testerResult && (
-        <section style={styles.section}>
-          <h2 style={styles.sectionTitle}>🧪 Agente Tester</h2>
-          <div style={styles.resultBox}>
-            <p style={styles.resultText}>
-              <strong>Status:</strong>{" "}
-              <span style={{ color: testerResult.status === "success" ? "#22c55e" : "#ef4444" }}>
-                {testerResult.status?.toUpperCase()}
-              </span>
-              <br />
-              <strong>Iterações:</strong> {testerResult.iterations}
-            </p>
-          </div>
-          {testerResult.pocCode && (
-            <>
-              <h3 style={styles.subTitle}>Proof of Concept (Exploit)</h3>
-              <div style={styles.codeBox}>
-                <pre style={styles.code}>{testerResult.pocCode}</pre>
-              </div>
-            </>
-          )}
-          {testerResult.executionLogs && testerResult.executionLogs.length > 0 && (
-            <>
-              <h3 style={styles.subTitle}>Logs de Execução (Foundry)</h3>
-              <div style={styles.logBox}>
-                {testerResult.executionLogs.map((log, i) => (
-                  <div key={i} style={styles.logLine}>
-                    {log}
-                  </div>
-                ))}
-              </div>
-            </>
-          )}
-        </section>
-      )}
     </div>
   );
 }
-const severityColor = (severity: string) => {
-  switch (severity) {
-    case "high":
-      return "#ef4444";
-    case "medium":
-      return "#f97316";
-    case "low":
-      return "#eab308";
-    default:
-      return "#64748b";
-  }
-};
-const styles: Record<string, React.CSSProperties> = {
-  container: {
-    maxWidth: 900,
-    margin: "0 auto",
-    padding: "32px 20px",
-    fontFamily: "'Segoe UI', system-ui, -apple-system, sans-serif",
-    color: "#e2e8f0",
-    background: "#0f172a",
-    minHeight: "100vh",
-  },
-  header: {
-    textAlign: "center",
-    marginBottom: 32,
-  },
-  title: {
-    fontSize: 28,
-    fontWeight: 700,
-    color: "#f8fafc",
-    margin: "0 0 12px",
-    lineHeight: 1.3,
-  },
-  subtitle: {
-    fontSize: 15,
-    color: "#94a3b8",
-    margin: 0,
-    lineHeight: 1.6,
-  },
-  form: {
-    display: "flex",
-    flexDirection: "column",
-    gap: 12,
-    marginBottom: 32,
-  },
-  textarea: {
-    width: "100%",
-    padding: 16,
-    fontSize: 14,
-    fontFamily: "inherit",
-    borderRadius: 8,
-    border: "1px solid #334155",
-    background: "#1e293b",
-    color: "#e2e8f0",
-    resize: "vertical",
-    outline: "none",
-    boxSizing: "border-box",
-    lineHeight: 1.6,
-  },
-  button: {
-    padding: "12px 24px",
-    fontSize: 15,
-    fontWeight: 600,
-    borderRadius: 8,
-    border: "none",
-    background: "#3b82f6",
-    color: "#fff",
-    cursor: "pointer",
-    transition: "background 0.2s",
-  },
-  section: {
-    marginBottom: 28,
-  },
-  sectionTitle: {
-    fontSize: 18,
-    fontWeight: 600,
-    color: "#f8fafc",
-    marginBottom: 10,
-  },
-  subTitle: {
-    fontSize: 14,
-    fontWeight: 600,
-    color: "#94a3b8",
-    marginTop: 14,
-    marginBottom: 6,
-  },
-  logBox: {
-    background: "#1e293b",
-    border: "1px solid #334155",
-    borderRadius: 8,
-    padding: 16,
-    maxHeight: 220,
-    overflowY: "auto",
-    fontSize: 13,
-    fontFamily: "'JetBrains Mono', 'Fira Code', monospace",
-  },
-  logLine: {
-    padding: "2px 0",
-    color: "#a5f3fc",
-    whiteSpace: "pre-wrap",
-    wordBreak: "break-word",
-  },
-  codeBox: {
-    background: "#1e293b",
-    border: "1px solid #334155",
-    borderRadius: 8,
-    padding: 16,
-    maxHeight: 400,
-    overflowY: "auto",
-  },
-  code: {
-    margin: 0,
-    fontSize: 13,
-    fontFamily: "'JetBrains Mono', 'Fira Code', monospace",
-    color: "#a5f3fc",
-    whiteSpace: "pre-wrap",
-    wordBreak: "break-word",
-  },
-  resultBox: {
-    background: "#1e293b",
-    border: "1px solid #334155",
-    borderRadius: 8,
-    padding: 16,
-  },
-  resultText: {
-    margin: 0,
-    fontSize: 14,
-    lineHeight: 1.6,
-    color: "#cbd5e1",
-    whiteSpace: "pre-wrap",
-  },
-  findingCard: {
-    background: "#1e293b",
-    border: "1px solid",
-    borderRadius: 8,
-    padding: 16,
-    marginBottom: 12,
-  },
-  findingHeader: {
-    display: "flex",
-    alignItems: "center",
-    gap: 10,
-    marginBottom: 8,
-  },
-  severityBadge: {
-    fontSize: 11,
-    fontWeight: 700,
-    color: "#fff",
-    padding: "2px 8px",
-    borderRadius: 4,
-    letterSpacing: "0.05em",
-  },
-  findingTitle: {
-    fontSize: 15,
-    fontWeight: 600,
-    color: "#f8fafc",
-  },
-  findingText: {
-    margin: "4px 0",
-    fontSize: 13,
-    lineHeight: 1.6,
-    color: "#cbd5e1",
-  },
-};

 import { useState, useRef, useCallback } from "react";
+import type { CoderResult, AuditorResult, TesterResult, AgentState } from "./types";
+import { computeDiff, type DiffLine } from "./utils/diff";
+import { INITIAL_AGENT_STATES, applyStepEvent, type StepEvent } from "./utils/status";
+import { ArtifactPanel } from "./components/ArtifactPanel";
+import { ControlPanel } from "./components/ControlPanel";
+export type ArtifactTab = "contract" | "findings" | "poc";
 export function App() {
   const [requirements, setRequirements] = useState("");
   const [running, setRunning] = useState(false);
+  const [logs, setLogs] = useState<string[]>([]);
+  const [coder, setCoder] = useState<CoderResult | null>(null);
+  const [auditor, setAuditor] = useState<AuditorResult | null>(null);
+  const [tester, setTester] = useState<TesterResult | null>(null);
+  const [agentStates, setAgentStates] = useState<AgentState[]>(INITIAL_AGENT_STATES);
+  const [selectedTab, setSelectedTab] = useState<ArtifactTab>("contract");
+  const [contractDiff, setContractDiff] = useState<DiffLine[] | null>(null);
+  const [pocDiff, setPocDiff] = useState<DiffLine[] | null>(null);
+  const [diffMode, setDiffMode] = useState<Record<string, boolean>>({});
+  const prevContract = useRef<string | null>(null);
+  const prevPoc = useRef<string | null>(null);
   const appendLog = useCallback((msg: string) => {
     setLogs((prev) => [...prev, msg]);
   }, []);
+  const handleRun = async (e: React.FormEvent) => {
     e.preventDefault();
     if (!requirements.trim() || running) return;
     setRunning(true);
     setLogs([]);
+    setCoder(null);
+    setAuditor(null);
+    setTester(null);
+    setAgentStates(INITIAL_AGENT_STATES);
+    setContractDiff(null);
+    setPocDiff(null);
+    setSelectedTab("contract");
     try {
       const res = await fetch("/api/run", {
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
         for (const line of lines) {
           if (line.startsWith("event:")) {
             currentEvent = line.slice(6).trim();
           } else if (line.startsWith("data:")) {
             const data = line.slice(5).trim();
             switch (currentEvent) {
               case "log":
                 appendLog(data);
                 break;
+              case "step": {
+                const event: StepEvent = JSON.parse(data);
+                setAgentStates((prev) => applyStepEvent(prev, event));
                 break;
+              }
+              case "coder": {
+                const result: CoderResult = JSON.parse(data);
+                const hasPrev = prevContract.current !== null;
+                const diff = computeDiff(prevContract.current, result.contract);
+                prevContract.current = result.contract;
+                setContractDiff(diff);
+                setDiffMode((prev) => ({ ...prev, contract: hasPrev }));
+                setCoder(result);
+                setSelectedTab("contract");
+                setAgentStates((prev) => {
+                  const s = prev.map((a) => ({ ...a, steps: a.steps.map((st) => ({ ...st })) }));
+                  const a = s.find((x) => x.id === "coder")!;
+                  a.status = "done";
+                  a.steps.forEach((st) => {
+                    if (st.status !== "error") st.status = "done";
+                  });
+                  return s;
+                });
                 break;
+              }
+              case "auditor": {
+                const result: AuditorResult = JSON.parse(data);
+                setAuditor(result);
+                if (result.findings.length > 0) setSelectedTab("findings");
+                setAgentStates((prev) => {
+                  const s = prev.map((a) => ({ ...a, steps: a.steps.map((st) => ({ ...st })) }));
+                  const a = s.find((x) => x.id === "auditor")!;
+                  a.status = "done";
+                  a.steps.forEach((st) => {
+                    if (st.status !== "error") st.status = "done";
+                  });
+                  return s;
+                });
                 break;
+              }
+              case "tester": {
+                const result: TesterResult = JSON.parse(data);
+                if (result.pocCode) {
+                  const hasPrev = prevPoc.current !== null;
+                  const diff = computeDiff(prevPoc.current, result.pocCode);
+                  prevPoc.current = result.pocCode;
+                  setPocDiff(diff);
+                  setDiffMode((prev) => ({ ...prev, poc: hasPrev }));
+                  setSelectedTab("poc");
+                }
+                setTester(result);
+                setAgentStates((prev) => {
+                  const s = prev.map((a) => ({ ...a, steps: a.steps.map((st) => ({ ...st })) }));
+                  const a = s.find((x) => x.id === "tester")!;
+                  if (result.status === "skipped") {
+                    a.status = "skipped";
+                    a.steps.forEach((st) => {
+                      st.status = "skipped";
+                    });
+                  } else {
+                    a.status = result.status === "success" ? "done" : "error";
+                    a.steps.forEach((st) => {
+                      if (st.status !== "error") st.status = "done";
+                    });
+                  }
+                  return s;
+                });
+                break;
+              }
               case "error":
+                appendLog(`[ERRO] ${data}`);
                 break;
             }
             currentEvent = "";
         }
       }
     } catch (err) {
+      appendLog(`[ERRO] ${err instanceof Error ? err.message : String(err)}`);
     } finally {
       setRunning(false);
     }
   };
+  const toggleDiffMode = (key: string) => setDiffMode((prev) => ({ ...prev, [key]: !prev[key] }));
+  return (
+    <div
+      style={{
+        display: "flex",
+        height: "100vh",
+        background: "#070c10",
+        overflow: "hidden",
+        color: "#c9d1d9",
+      }}
+    >
+      <ControlPanel
+        requirements={requirements}
+        onRequirementsChange={setRequirements}
+        onRun={handleRun}
+        running={running}
+        agentStates={agentStates}
+        logs={logs}
+      />
+      <ArtifactPanel
+        coder={coder}
+        auditor={auditor}
+        tester={tester}
+        contractDiff={contractDiff}
+        pocDiff={pocDiff}
+        selectedTab={selectedTab}
+        onSelectTab={setSelectedTab}
+        diffMode={diffMode}
+        onToggleDiff={toggleDiffMode}
+      />
     </div>
   );
 }

frontend/src/components/ArtifactPanel.tsx ADDED Viewed

	@@ -0,0 +1,523 @@

+import type { CoderResult, AuditorResult, TesterResult, Finding } from "../types";
+import type { DiffLine } from "../utils/diff";
+import type { ArtifactTab } from "../App";
+const C = {
+  bg: "#0d1117",
+  surface: "#161b22",
+  border: "#21262d",
+  text: "#c9d1d9",
+  muted: "#8b949e",
+  dim: "#484f58",
+  accent: "#58a6ff",
+  green: "#3fb950",
+  red: "#f85149",
+  yellow: "#d29922",
+  orange: "#db6d28",
+  addedBg: "rgba(46, 160, 67, 0.1)",
+  removedBg: "rgba(248, 81, 73, 0.09)",
+};
+const SEVERITY_COLOR: Record<string, string> = {
+  high: C.red,
+  medium: C.yellow,
+  low: "#58a6ff",
+};
+interface Props {
+  coder: CoderResult | null;
+  auditor: AuditorResult | null;
+  tester: TesterResult | null;
+  contractDiff: DiffLine[] | null;
+  pocDiff: DiffLine[] | null;
+  selectedTab: ArtifactTab;
+  onSelectTab: (tab: ArtifactTab) => void;
+  diffMode: Record<string, boolean>;
+  onToggleDiff: (key: string) => void;
+}
+export function ArtifactPanel({
+  coder,
+  auditor,
+  tester,
+  contractDiff,
+  pocDiff,
+  selectedTab,
+  onSelectTab,
+  diffMode,
+  onToggleDiff,
+}: Props) {
+  const findingCount = auditor?.findings?.length ?? 0;
+  const hasPoc = !!tester?.pocCode;
+  const treeItems: {
+    id: ArtifactTab;
+    icon: string;
+    name: string;
+    badge?: string;
+    badgeColor?: string;
+    available: boolean;
+  }[] = [
+    {
+      id: "contract",
+      icon: "◈",
+      name: "Contract.sol",
+      badge: coder ? "sol" : undefined,
+      badgeColor: C.accent,
+      available: !!coder,
+    },
+    {
+      id: "findings",
+      icon: "⚑",
+      name: "findings/",
+      badge: auditor ? (findingCount > 0 ? `${findingCount} issue${findingCount > 1 ? "s" : ""}` : "clean") : undefined,
+      badgeColor: auditor ? (findingCount > 0 ? C.red : C.green) : C.dim,
+      available: !!auditor,
+    },
+    {
+      id: "poc",
+      icon: "◈",
+      name: "ExploitTest.t.sol",
+      badge: tester ? tester.status : undefined,
+      badgeColor: tester?.status === "success" ? C.green : tester?.status === "failed" ? C.red : C.yellow,
+      available: hasPoc,
+    },
+  ];
+  return (
+    <div
+      style={{
+        flex: 1,
+        minWidth: 0,
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden",
+        borderLeft: `1px solid ${C.border}`,
+        background: C.bg,
+      }}
+    >
+      {/* Panel titlebar */}
+      <div
+        style={{
+          height: 38,
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+          padding: "0 16px",
+          borderBottom: `1px solid ${C.border}`,
+          flexShrink: 0,
+        }}
+      >
+        <span style={{ fontSize: 10, color: C.dim, letterSpacing: "0.12em", textTransform: "uppercase" }}>
+          explorer
+        </span>
+      </div>
+      {/* File tree */}
+      <div
+        style={{
+          flexShrink: 0,
+          borderBottom: `1px solid ${C.border}`,
+          padding: "6px 0",
+        }}
+      >
+        <div style={{ padding: "3px 16px 4px", display: "flex", alignItems: "center", gap: 6 }}>
+          <span style={{ fontSize: 10, color: C.dim, letterSpacing: "0.08em" }}>▾</span>
+          <span style={{ fontSize: 11, color: C.muted, letterSpacing: "0.05em" }}>artifacts</span>
+        </div>
+        {treeItems.map((item) => {
+          const selected = selectedTab === item.id;
+          return (
+            <button
+              key={item.id}
+              onClick={() => item.available && onSelectTab(item.id)}
+              disabled={!item.available}
+              style={{
+                display: "flex",
+                alignItems: "center",
+                gap: 8,
+                width: "100%",
+                padding: "4px 16px 4px 28px",
+                background: selected ? "rgba(88, 166, 255, 0.08)" : "transparent",
+                border: "none",
+                borderLeft: selected ? `2px solid ${C.accent}` : "2px solid transparent",
+                cursor: item.available ? "pointer" : "default",
+                textAlign: "left",
+                color: selected ? C.text : item.available ? C.muted : C.dim,
+                fontSize: 13,
+                transition: "background 0.1s",
+              }}
+            >
+              <span style={{ fontSize: 10, color: selected ? C.accent : item.available ? C.dim : "#2d333b" }}>
+                {item.icon}
+              </span>
+              <span style={{ flex: 1 }}>{item.name}</span>
+              {item.badge && (
+                <span
+                  style={{
+                    fontSize: 10,
+                    color: item.badgeColor,
+                    padding: "1px 5px",
+                    borderRadius: 3,
+                    border: `1px solid ${item.badgeColor}30`,
+                    background: `${item.badgeColor}12`,
+                  }}
+                >
+                  {item.badge}
+                </span>
+              )}
+            </button>
+          );
+        })}
+      </div>
+      {/* Content area */}
+      <div style={{ flex: 1, overflow: "hidden", display: "flex", flexDirection: "column" }}>
+        {selectedTab === "contract" && coder && contractDiff ? (
+          <CodeViewer
+            title="Contract.sol"
+            diff={contractDiff}
+            showDiff={diffMode["contract"] ?? false}
+            onToggleDiff={() => onToggleDiff("contract")}
+          />
+        ) : selectedTab === "findings" && auditor ? (
+          <FindingsViewer findings={auditor.findings} reviewSummary={coder?.reviewSummary} />
+        ) : selectedTab === "poc" && tester?.pocCode && pocDiff ? (
+          <CodeViewer
+            title="ExploitTest.t.sol"
+            diff={pocDiff}
+            showDiff={diffMode["poc"] ?? false}
+            onToggleDiff={() => onToggleDiff("poc")}
+            status={tester.status}
+            iterations={tester.iterations}
+          />
+        ) : (
+          <EmptyState />
+        )}
+      </div>
+    </div>
+  );
+}
+function CodeViewer({
+  title,
+  diff,
+  showDiff,
+  onToggleDiff,
+  status,
+  iterations,
+}: {
+  title: string;
+  diff: DiffLine[];
+  showDiff: boolean;
+  onToggleDiff: () => void;
+  status?: string;
+  iterations?: number;
+}) {
+  const addedCount = diff.filter((l) => l.type === "added").length;
+  const removedCount = diff.filter((l) => l.type === "removed").length;
+  const totalLines = diff.filter((l) => l.type !== "removed").length;
+  const hasDiff = addedCount > 0 || removedCount > 0;
+  const hasChanges =
+    diff.some((l) => l.type === "removed") ||
+    diff.some((l) => l.type === "added" && diff.some((x) => x.type === "unchanged"));
+  return (
+    <div style={{ display: "flex", flexDirection: "column", height: "100%", overflow: "hidden" }}>
+      {/* Toolbar */}
+      <div
+        style={{
+          height: 36,
+          display: "flex",
+          alignItems: "center",
+          padding: "0 16px",
+          borderBottom: `1px solid ${C.border}`,
+          gap: 10,
+          flexShrink: 0,
+          background: C.bg,
+        }}
+      >
+        <span style={{ fontSize: 12, color: C.muted }}>{title}</span>
+        {status && (
+          <span
+            style={{
+              fontSize: 10,
+              color: status === "success" ? C.green : status === "failed" ? C.red : C.yellow,
+              padding: "1px 6px",
+              border: `1px solid currentColor`,
+              borderRadius: 3,
+              opacity: 0.8,
+            }}
+          >
+            {status}
+          </span>
+        )}
+        {iterations !== undefined && iterations > 0 && (
+          <span style={{ fontSize: 10, color: C.dim }}>{iterations} iter</span>
+        )}
+        <span style={{ flex: 1 }} />
+        {hasDiff && (
+          <>
+            {hasChanges && (
+              <span style={{ fontSize: 10, color: C.dim }}>
+                <span style={{ color: C.green }}>+{addedCount}</span>{" "}
+                <span style={{ color: C.red }}>-{removedCount}</span>
+              </span>
+            )}
+            <button
+              onClick={onToggleDiff}
+              style={{
+                padding: "2px 8px",
+                fontSize: 11,
+                background: showDiff ? "rgba(88, 166, 255, 0.12)" : "transparent",
+                border: `1px solid ${showDiff ? C.accent : C.border}`,
+                color: showDiff ? C.accent : C.muted,
+                cursor: "pointer",
+                borderRadius: 3,
+                fontFamily: "inherit",
+              }}
+            >
+              diff
+            </button>
+          </>
+        )}
+        <span style={{ fontSize: 10, color: C.dim }}>{totalLines}L</span>
+      </div>
+      {/* Code */}
+      <div style={{ flex: 1, overflow: "auto", background: "#0a0e14" }}>
+        <table
+          style={{
+            width: "100%",
+            borderCollapse: "collapse",
+            fontSize: 12.5,
+            lineHeight: 1.65,
+          }}
+        >
+          <tbody>
+            {diff.map((dl, idx) => {
+              if (!showDiff && dl.type === "removed") return null;
+              const isAdded = showDiff && dl.type === "added";
+              const isRemoved = showDiff && dl.type === "removed";
+              return (
+                <tr
+                  key={idx}
+                  style={{
+                    background: isAdded ? C.addedBg : isRemoved ? C.removedBg : "transparent",
+                  }}
+                >
+                  {showDiff && (
+                    <td
+                      style={{
+                        width: 18,
+                        textAlign: "center",
+                        color: isAdded ? C.green : isRemoved ? C.red : "transparent",
+                        fontSize: 11,
+                        userSelect: "none",
+                        paddingLeft: 8,
+                        paddingRight: 4,
+                      }}
+                    >
+                      {isAdded ? "+" : isRemoved ? "−" : " "}
+                    </td>
+                  )}
+                  <td
+                    style={{
+                      width: 44,
+                      textAlign: "right",
+                      paddingRight: 14,
+                      paddingLeft: 8,
+                      color: isRemoved ? "#5e3535" : C.dim,
+                      userSelect: "none",
+                      fontSize: 11,
+                    }}
+                  >
+                    {dl.lineNo > 0 ? dl.lineNo : ""}
+                  </td>
+                  <td
+                    style={{
+                      padding: "0 16px 0 0",
+                      color: isAdded ? "#b5e3b5" : isRemoved ? "#e5a0a0" : C.text,
+                      whiteSpace: "pre",
+                      fontFamily: "inherit",
+                    }}
+                  >
+                    {dl.line}
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+}
+function FindingsViewer({ findings, reviewSummary }: { findings: Finding[]; reviewSummary?: string }) {
+  return (
+    <div style={{ flex: 1, overflow: "auto", padding: 20 }}>
+      {/* Review summary */}
+      {reviewSummary && (
+        <div style={{ marginBottom: 20 }}>
+          <div
+            style={{
+              fontSize: 10,
+              color: C.dim,
+              letterSpacing: "0.1em",
+              textTransform: "uppercase",
+              marginBottom: 8,
+            }}
+          >
+            coder / security-review
+          </div>
+          <div
+            style={{
+              background: C.surface,
+              border: `1px solid ${C.border}`,
+              borderRadius: 6,
+              padding: 14,
+              fontSize: 12.5,
+              color: C.muted,
+              lineHeight: 1.7,
+              whiteSpace: "pre-wrap",
+            }}
+          >
+            {reviewSummary}
+          </div>
+        </div>
+      )}
+      {/* Findings */}
+      <div
+        style={{
+          fontSize: 10,
+          color: C.dim,
+          letterSpacing: "0.1em",
+          textTransform: "uppercase",
+          marginBottom: 8,
+        }}
+      >
+        auditor / findings — {findings.length} issue{findings.length !== 1 ? "s" : ""}
+      </div>
+      {findings.length === 0 ? (
+        <div
+          style={{
+            background: C.surface,
+            border: `1px solid ${C.border}`,
+            borderRadius: 6,
+            padding: 16,
+            color: C.green,
+            fontSize: 13,
+          }}
+        >
+          ✓ Nenhuma vulnerabilidade encontrada.
+        </div>
+      ) : (
+        findings.map((f, i) => <FindingCard key={i} finding={f} index={i} />)
+      )}
+    </div>
+  );
+}
+function FindingCard({ finding, index }: { finding: Finding; index: number }) {
+  const color = SEVERITY_COLOR[finding.severity] ?? C.muted;
+  return (
+    <div
+      style={{
+        background: C.surface,
+        border: `1px solid ${C.border}`,
+        borderLeft: `3px solid ${color}`,
+        borderRadius: 6,
+        marginBottom: 12,
+        overflow: "hidden",
+        animation: "fadein 0.2s ease",
+      }}
+    >
+      {/* Header */}
+      <div
+        style={{
+          display: "flex",
+          alignItems: "center",
+          gap: 10,
+          padding: "10px 14px",
+          borderBottom: `1px solid ${C.border}`,
+        }}
+      >
+        <span
+          style={{
+            fontSize: 9,
+            fontWeight: 700,
+            color: color,
+            padding: "2px 6px",
+            border: `1px solid ${color}`,
+            borderRadius: 3,
+            letterSpacing: "0.1em",
+            background: `${color}15`,
+          }}
+        >
+          {finding.severity.toUpperCase()}
+        </span>
+        <span style={{ fontSize: 13, color: C.text, fontWeight: 600 }}>
+          [{index + 1}] {finding.title}
+        </span>
+        {finding.location && <span style={{ marginLeft: "auto", fontSize: 10, color: C.dim }}>{finding.location}</span>}
+      </div>
+      {/* Body */}
+      <div style={{ padding: 14 }}>
+        <p style={{ fontSize: 12.5, color: C.muted, lineHeight: 1.7, marginBottom: 10 }}>{finding.description}</p>
+        {finding.codeSnippet && (
+          <div
+            style={{
+              background: "#0a0e14",
+              border: `1px solid ${C.border}`,
+              borderRadius: 4,
+              padding: "8px 12px",
+              marginBottom: 10,
+              fontSize: 12,
+              color: "#b5c0cc",
+              whiteSpace: "pre",
+              overflow: "auto",
+              maxHeight: 140,
+              fontFamily: "inherit",
+            }}
+          >
+            {finding.codeSnippet}
+          </div>
+        )}
+        <div style={{ fontSize: 12, color: C.muted, marginBottom: 6 }}>
+          <span style={{ color: C.dim }}>recomendação: </span>
+          {finding.recommendation}
+        </div>
+        <div style={{ fontSize: 11, color: C.dim, marginTop: 8 }}>
+          confiança: {Math.round(finding.judgeReview.confidence)}% — {finding.judgeReview.review}
+        </div>
+      </div>
+    </div>
+  );
+}
+function EmptyState() {
+  return (
+    <div
+      style={{
+        flex: 1,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        color: C.dim,
+        gap: 12,
+      }}
+    >
+      <div style={{ fontSize: 28, opacity: 0.3 }}>◈</div>
+      <div style={{ fontSize: 12, letterSpacing: "0.05em" }}>aguardando execução do pipeline</div>
+    </div>
+  );
+}

frontend/src/components/ControlPanel.tsx ADDED Viewed

	@@ -0,0 +1,443 @@

+import { useEffect, useRef } from "react";
+import type { AgentState, StepStatus } from "../types";
+const C = {
+  bg: "#0d1117",
+  surface: "#161b22",
+  border: "#21262d",
+  text: "#c9d1d9",
+  muted: "#8b949e",
+  dim: "#484f58",
+  accent: "#58a6ff",
+  green: "#3fb950",
+  red: "#f85149",
+  yellow: "#d29922",
+};
+const AGENT_COLORS: Record<string, string> = {
+  coder: "#58a6ff",
+  auditor: "#d29922",
+  tester: "#3fb950",
+};
+const DEFAULT_REQUIREMENT = `Crie um contrato de staking com as seguintes características:
+- Usuários podem depositar ETH e receber créditos proporcionais ao valor
+- O owner pode pausar e retomar os depósitos
+- Função de saque que devolve ETH proporcional ao crédito do usuário
+- Acumula recompensas de 1% ao dia sobre o saldo depositado
+- Emite eventos para depósito, saque e distribuição de recompensas`;
+interface Props {
+  requirements: string;
+  onRequirementsChange: (v: string) => void;
+  onRun: (e: React.FormEvent) => void;
+  running: boolean;
+  agentStates: AgentState[];
+  logs: string[];
+}
+export function ControlPanel({ requirements, onRequirementsChange, onRun, running, agentStates, logs }: Props) {
+  return (
+    <div
+      style={{
+        width: 400,
+        flexShrink: 0,
+        display: "flex",
+        flexDirection: "column",
+        background: C.bg,
+        overflow: "hidden",
+      }}
+    >
+      <Header />
+      <InputForm requirements={requirements} onChange={onRequirementsChange} onRun={onRun} running={running} />
+      <div style={{ flex: 1, display: "flex", flexDirection: "column", overflow: "hidden", minHeight: 0 }}>
+        <PipelineStatus agents={agentStates} running={running} />
+        <TerminalLog logs={logs} />
+      </div>
+    </div>
+  );
+}
+function Header() {
+  return (
+    <div
+      style={{
+        padding: "14px 18px 10px",
+        borderBottom: `1px solid ${C.border}`,
+        flexShrink: 0,
+      }}
+    >
+      <div style={{ display: "flex", alignItems: "baseline", gap: 8, marginBottom: 3 }}>
+        <span style={{ fontSize: 15, fontWeight: 700, color: C.accent, letterSpacing: "0.05em" }}>TALP1</span>
+        <span style={{ fontSize: 10, color: C.dim }}>v0.1</span>
+      </div>
+      <div style={{ fontSize: 11, color: C.dim, lineHeight: 1.5 }}>multi-agent smart contract pipeline</div>
+    </div>
+  );
+}
+function InputForm({
+  requirements,
+  onChange,
+  onRun,
+  running,
+}: {
+  requirements: string;
+  onChange: (v: string) => void;
+  onRun: (e: React.FormEvent) => void;
+  running: boolean;
+}) {
+  const canRun = !running && requirements.trim().length > 0;
+  return (
+    <form
+      onSubmit={onRun}
+      style={{
+        padding: "12px 18px",
+        borderBottom: `1px solid ${C.border}`,
+        flexShrink: 0,
+        display: "flex",
+        flexDirection: "column",
+        gap: 8,
+      }}
+    >
+      <div style={{ fontSize: 10, color: C.dim, letterSpacing: "0.1em", textTransform: "uppercase", marginBottom: 2 }}>
+        requisitos
+      </div>
+      <textarea
+        value={requirements}
+        onChange={(e) => onChange(e.target.value)}
+        disabled={running}
+        rows={5}
+        placeholder="Descreva o smart contract a ser gerado, auditado e testado..."
+        style={{
+          width: "100%",
+          padding: "10px 12px",
+          fontSize: 12,
+          fontFamily: "inherit",
+          background: C.surface,
+          border: `1px solid ${C.border}`,
+          borderRadius: 5,
+          color: C.text,
+          resize: "none",
+          outline: "none",
+          lineHeight: 1.65,
+          transition: "border-color 0.15s",
+        }}
+        onFocus={(e) => (e.target.style.borderColor = `${C.accent}60`)}
+        onBlur={(e) => (e.target.style.borderColor = C.border)}
+      />
+      <div style={{ display: "flex", gap: 8 }}>
+        <button
+          type="button"
+          onClick={() => onChange(DEFAULT_REQUIREMENT)}
+          disabled={running}
+          style={{
+            padding: "7px 10px",
+            fontSize: 11,
+            fontFamily: "inherit",
+            background: "transparent",
+            border: `1px solid ${C.border}`,
+            borderRadius: 4,
+            color: C.muted,
+            cursor: running ? "default" : "pointer",
+            opacity: running ? 0.4 : 1,
+            whiteSpace: "nowrap",
+          }}
+        >
+          usar exemplo
+        </button>
+        <button
+          type="submit"
+          disabled={!canRun}
+          style={{
+            flex: 1,
+            padding: "7px 14px",
+            fontSize: 12,
+            fontFamily: "inherit",
+            fontWeight: 600,
+            background: canRun ? C.accent : "transparent",
+            border: `1px solid ${canRun ? C.accent : C.border}`,
+            borderRadius: 4,
+            color: canRun ? "#fff" : C.dim,
+            cursor: canRun ? "pointer" : "default",
+            transition: "all 0.15s",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            gap: 7,
+          }}
+        >
+          {running && (
+            <span
+              style={{
+                width: 10,
+                height: 10,
+                borderRadius: "50%",
+                border: "1.5px solid rgba(255,255,255,0.3)",
+                borderTopColor: "#fff",
+                display: "inline-block",
+                animation: "spin 0.7s linear infinite",
+                flexShrink: 0,
+              }}
+            />
+          )}
+          {running ? "executando..." : "▶  executar"}
+        </button>
+      </div>
+    </form>
+  );
+}
+function PipelineStatus({ agents, running }: { agents: AgentState[]; running: boolean }) {
+  const anyActive = agents.some((a) => a.status === "running");
+  return (
+    <div
+      style={{
+        flexShrink: 0,
+        borderBottom: `1px solid ${C.border}`,
+        padding: "10px 0",
+        maxHeight: 280,
+        overflow: "auto",
+      }}
+    >
+      <div
+        style={{
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+          padding: "0 18px 6px",
+        }}
+      >
+        <span style={{ fontSize: 10, color: C.dim, letterSpacing: "0.1em", textTransform: "uppercase" }}>pipeline</span>
+        {anyActive && (
+          <span
+            style={{
+              width: 6,
+              height: 6,
+              borderRadius: "50%",
+              background: C.accent,
+              animation: "pulse 1.2s ease-in-out infinite",
+              flexShrink: 0,
+            }}
+          />
+        )}
+      </div>
+      {agents.map((agent) => (
+        <AgentBlock key={agent.id} agent={agent} />
+      ))}
+    </div>
+  );
+}
+function AgentBlock({ agent }: { agent: AgentState }) {
+  const color = AGENT_COLORS[agent.id] ?? C.muted;
+  const isRunning = agent.status === "running";
+  const isDone = agent.status === "done";
+  const isError = agent.status === "error";
+  const isSkipped = agent.status === "skipped";
+  return (
+    <div style={{ padding: "4px 18px" }}>
+      {/* Agent header */}
+      <div style={{ display: "flex", alignItems: "center", gap: 8, marginBottom: 3 }}>
+        <AgentDot status={agent.status} color={color} />
+        <span
+          style={{
+            fontSize: 11,
+            fontWeight: 600,
+            letterSpacing: "0.08em",
+            color: isDone || isRunning ? color : C.dim,
+          }}
+        >
+          {agent.label}
+        </span>
+        <span
+          style={{
+            marginLeft: "auto",
+            fontSize: 10,
+            color: isDone ? C.green : isError ? C.red : isSkipped ? C.dim : isRunning ? color : C.dim,
+            opacity: isDone || isError || isSkipped || isRunning ? 1 : 0.5,
+          }}
+        >
+          {isDone ? "done" : isError ? "error" : isSkipped ? "skip" : isRunning ? "running" : "pending"}
+        </span>
+      </div>
+      {/* Steps */}
+      <div style={{ paddingLeft: 20 }}>
+        {agent.steps.map((step) => (
+          <StepRow key={step.id} step={step} agentColor={color} />
+        ))}
+      </div>
+    </div>
+  );
+}
+function AgentDot({ status, color }: { status: StepStatus; color: string }) {
+  if (status === "running") {
+    return (
+      <span
+        style={{
+          width: 8,
+          height: 8,
+          borderRadius: "50%",
+          border: `1.5px solid ${color}40`,
+          borderTopColor: color,
+          display: "inline-block",
+          animation: "spin 0.7s linear infinite",
+          flexShrink: 0,
+        }}
+      />
+    );
+  }
+  if (status === "done") {
+    return <span style={{ color, fontSize: 10, lineHeight: 1 }}>✓</span>;
+  }
+  if (status === "error") {
+    return <span style={{ color: C.red, fontSize: 10, lineHeight: 1 }}>✗</span>;
+  }
+  if (status === "skipped") {
+    return <span style={{ color: C.dim, fontSize: 10, lineHeight: 1 }}>–</span>;
+  }
+  return <span style={{ color: C.dim, fontSize: 10, lineHeight: 1 }}>○</span>;
+}
+function StepRow({
+  step,
+  agentColor,
+}: {
+  step: { label: string; status: StepStatus; detail?: string };
+  agentColor: string;
+}) {
+  const isRunning = step.status === "running";
+  const isDone = step.status === "done";
+  const isError = step.status === "error";
+  const isSkipped = step.status === "skipped";
+  return (
+    <div
+      style={{
+        display: "flex",
+        alignItems: "center",
+        gap: 6,
+        padding: "2px 0",
+        fontSize: 11,
+        color: isDone ? C.muted : isRunning ? C.text : C.dim,
+        animation: isRunning ? "fadein 0.15s ease" : undefined,
+      }}
+    >
+      <span style={{ width: 10, flexShrink: 0, textAlign: "center" }}>
+        {isDone ? (
+          <span style={{ color: C.green, fontSize: 9 }}>✓</span>
+        ) : isRunning ? (
+          <span
+            style={{
+              width: 6,
+              height: 6,
+              borderRadius: "50%",
+              border: `1px solid ${agentColor}40`,
+              borderTopColor: agentColor,
+              display: "inline-block",
+              animation: "spin 0.7s linear infinite",
+            }}
+          />
+        ) : isError ? (
+          <span style={{ color: C.red, fontSize: 9 }}>✗</span>
+        ) : isSkipped ? (
+          <span style={{ color: C.dim, fontSize: 9 }}>–</span>
+        ) : (
+          <span style={{ color: C.dim, fontSize: 9 }}>·</span>
+        )}
+      </span>
+      <span>{step.label}</span>
+      {step.detail && <span style={{ color: agentColor, fontSize: 10, opacity: 0.8 }}>{step.detail}</span>}
+    </div>
+  );
+}
+function logColor(log: string): string {
+  if (log.includes("[Coder]")) return "#58a6ff";
+  if (log.includes("[Auditor]")) return "#d29922";
+  if (log.includes("[Tester]")) return "#3fb950";
+  if (log.includes("[ERRO]") || log.toLowerCase().startsWith("error")) return "#f85149";
+  if (log === "Pipeline concluído.") return "#3fb950";
+  return "#6e7681";
+}
+function TerminalLog({ logs }: { logs: string[] }) {
+  const endRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    endRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [logs]);
+  return (
+    <div style={{ flex: 1, display: "flex", flexDirection: "column", overflow: "hidden", minHeight: 0 }}>
+      <div
+        style={{
+          padding: "6px 18px 4px",
+          borderBottom: `1px solid ${C.border}`,
+          flexShrink: 0,
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+        }}
+      >
+        <span style={{ fontSize: 10, color: C.dim, letterSpacing: "0.1em", textTransform: "uppercase" }}>terminal</span>
+        {logs.length > 0 && <span style={{ fontSize: 10, color: C.dim }}>{logs.length} lines</span>}
+      </div>
+      <div
+        style={{
+          flex: 1,
+          overflow: "auto",
+          padding: "10px 18px",
+          background: "#070c10",
+          fontSize: 11.5,
+          lineHeight: 1.7,
+        }}
+      >
+        {logs.length === 0 ? (
+          <span style={{ color: C.dim }}>
+            <BlinkCursor />
+          </span>
+        ) : (
+          logs.map((log, i) => (
+            <div
+              key={i}
+              style={{
+                color: logColor(log),
+                display: "flex",
+                gap: 8,
+                animation: "fadein 0.1s ease",
+              }}
+            >
+              <span style={{ color: C.dim, userSelect: "none", flexShrink: 0 }}>›</span>
+              <span style={{ wordBreak: "break-word", whiteSpace: "pre-wrap" }}>{log}</span>
+            </div>
+          ))
+        )}
+        <div ref={endRef} />
+      </div>
+    </div>
+  );
+}
+function BlinkCursor() {
+  return (
+    <span
+      style={{
+        display: "inline-block",
+        width: 7,
+        height: 13,
+        background: C.dim,
+        verticalAlign: "middle",
+        animation: "blink 1.2s step-end infinite",
+        borderRadius: 1,
+      }}
+    />
+  );
+}

frontend/src/types.ts ADDED Viewed

	@@ -0,0 +1,48 @@

+export interface Finding {
+  title: string;
+  description: string;
+  recommendation: string;
+  severity: "high" | "medium" | "low";
+  codeSnippet: string;
+  location: string;
+  path: string;
+  judgeReview: {
+    review: string;
+    confidence: number;
+    exploitablePaths: string[];
+  };
+}
+export interface CoderResult {
+  contract: string;
+  compilationErrors: string[];
+  reviewSummary: string;
+}
+export interface AuditorResult {
+  findings: Finding[];
+}
+export interface TesterResult {
+  status: "success" | "failed" | "timeout" | "skipped" | "running";
+  pocCode?: string;
+  executionLogs?: string[];
+  iterations: number;
+}
+export type StepStatus = "pending" | "running" | "done" | "error" | "skipped";
+export interface PipelineStep {
+  id: string;
+  label: string;
+  status: StepStatus;
+  detail?: string;
+}
+export interface AgentState {
+  id: "coder" | "auditor" | "tester";
+  label: string;
+  color: string;
+  status: StepStatus;
+  steps: PipelineStep[];
+}

frontend/src/utils/diff.ts ADDED Viewed

	@@ -0,0 +1,54 @@

+export interface DiffLine {
+  type: "added" | "removed" | "unchanged";
+  line: string;
+  lineNo: number;
+}
+export function computeDiff(prev: string | null, next: string): DiffLine[] {
+  const nextLines = next.split("\n");
+  if (!prev) {
+    return nextLines.map((line, i) => ({ type: "added", line, lineNo: i + 1 }));
+  }
+  if (prev === next) {
+    return nextLines.map((line, i) => ({ type: "unchanged", line, lineNo: i + 1 }));
+  }
+  const prevLines = prev.split("\n");
+  const m = prevLines.length;
+  const n = nextLines.length;
+  if (m > 600 || n > 600) {
+    return nextLines.map((line, i) => ({ type: "added", line, lineNo: i + 1 }));
+  }
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0) as number[]);
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = prevLines[i - 1] === nextLines[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+  const result: DiffLine[] = [];
+  let i = m;
+  let j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && prevLines[i - 1] === nextLines[j - 1]) {
+      result.unshift({ type: "unchanged", line: nextLines[j - 1], lineNo: j });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: "added", line: nextLines[j - 1], lineNo: j });
+      j--;
+    } else {
+      result.unshift({ type: "removed", line: prevLines[i - 1], lineNo: 0 });
+      i--;
+    }
+  }
+  return result;
+}
+export function diffHasChanges(lines: DiffLine[]): boolean {
+  return lines.some((l) => l.type !== "unchanged");
+}

frontend/src/utils/status.ts ADDED Viewed

	@@ -0,0 +1,100 @@

+import type { AgentState, StepStatus } from "../types";
+export interface StepEvent {
+  agent: "coder" | "auditor" | "tester";
+  step: string;
+  status: "running" | "done" | "error" | "skipped";
+  detail?: string;
+}
+export const INITIAL_AGENT_STATES: AgentState[] = [
+  {
+    id: "coder",
+    label: "CODER",
+    color: "#58a6ff",
+    status: "pending",
+    steps: [
+      { id: "coder.gen", label: "Gerando contrato", status: "pending" },
+      { id: "coder.compile", label: "Compilando", status: "pending" },
+      { id: "coder.review", label: "Revisando segurança", status: "pending" },
+    ],
+  },
+  {
+    id: "auditor",
+    label: "AUDITOR",
+    color: "#d29922",
+    status: "pending",
+    steps: [
+      { id: "audit.scope", label: "Mapeando escopo", status: "pending" },
+      { id: "audit.ctx", label: "Coletando contexto", status: "pending" },
+      { id: "audit.find", label: "Analisando vulnerabilidades", status: "pending" },
+      { id: "audit.judge", label: "Julgando findings", status: "pending" },
+    ],
+  },
+  {
+    id: "tester",
+    label: "TESTER",
+    color: "#3fb950",
+    status: "pending",
+    steps: [
+      { id: "test.oracle", label: "Preparando scaffold", status: "pending" },
+      { id: "test.gen", label: "Gerando PoC", status: "pending" },
+      { id: "test.run", label: "Executando Foundry", status: "pending" },
+      { id: "test.reflect", label: "Analisando falha", status: "pending" },
+    ],
+  },
+];
+const AGENT_ORDER = ["coder", "auditor", "tester"] as const;
+const STEP_PREFIX: Record<string, string> = {
+  coder: "coder.",
+  auditor: "audit.",
+  tester: "test.",
+};
+export function applyStepEvent(states: AgentState[], event: StepEvent): AgentState[] {
+  const s = states.map((a) => ({ ...a, steps: a.steps.map((st) => ({ ...st })) }));
+  const fullStepId = STEP_PREFIX[event.agent] + event.step;
+  if (event.status === "running") {
+    // Mark all preceding agents as done when a new agent starts its first step
+    const agentIndex = AGENT_ORDER.indexOf(event.agent);
+    for (let i = 0; i < agentIndex; i++) {
+      const prev = s.find((a) => a.id === AGENT_ORDER[i]);
+      if (prev && prev.status !== "done" && prev.status !== "error") {
+        prev.status = "done";
+        prev.steps.forEach((st) => {
+          if (st.status === "pending") st.status = "done";
+        });
+      }
+    }
+    const agent = s.find((a) => a.id === event.agent);
+    if (agent && agent.status === "pending") agent.status = "running";
+  }
+  // Update the step
+  const step = s.flatMap((a) => a.steps).find((st) => st.id === fullStepId);
+  if (step) {
+    step.status = event.status;
+    if (event.detail !== undefined) step.detail = event.detail;
+  }
+  // When a step finishes, check if all steps are settled → update agent status
+  if (event.status !== "running") {
+    const agent = s.find((a) => a.id === event.agent);
+    if (agent) {
+      const settled: StepStatus[] = ["done", "error", "skipped"];
+      const allSettled = agent.steps.every((st) => settled.includes(st.status));
+      if (allSettled) {
+        const hasError = agent.steps.some((st) => st.status === "error");
+        const allSkipped = agent.steps.every((st) => st.status === "skipped");
+        agent.status = hasError ? "error" : allSkipped ? "skipped" : "done";
+      }
+    }
+  }
+  return s;
+}

src/agents/auditor/agent.ts CHANGED Viewed

@@ -5,7 +5,7 @@ import { END, type GraphNode, START, StateGraph } from "@langchain/langgraph";
 import { z } from "zod";
 import { createLLM } from "../../config/llm.ts";
-import { logger } from "../../logger.ts";
 import { MAX_DOC_CHARS, MAX_REFLECTIONS, MAX_SOL_CHARS, MIN_FILE_IMPORTANCE } from "./config.ts";
 import {
   FIND_VULNERABILITIES_PROMPT,
@@ -24,7 +24,8 @@ const llmOpus = createLLM("anthropic", { model: "claude-opus-4-8", temperature:
 const llmSonnet = createLLM("anthropic", { model: "claude-sonnet-4-6", maxTokens: 20000 });
 const defineScope: GraphNode<typeof AuditorState> = async (state) => {
-  logger.info(`defineScope: walking repo at ${state.repoPath}`);
   const solFiles: string[] = [];
   const docFiles: string[] = [];
@@ -33,12 +34,16 @@ const defineScope: GraphNode<typeof AuditorState> = async (state) => {
   const fileTree = buildRepoTree(state.repoPath);
-  logger.info(`defineScope: found ${solFiles.length} Solidity file(s), ${docFiles.length} doc file(s)`);
-  logger.debug(`defineScope: Solidity files: ${JSON.stringify(solFiles)}`);
-  logger.debug(`defineScope: doc files: ${JSON.stringify(docFiles)}`);
-  logger.debug(`defineScope: file tree:\n${fileTree}`);
-  logger.info("defineScope: ranking files by importance");
   const RankFilesSchema = z.object({ rankings: z.array(FileRankingSchema) });
   const rankingModel = llmHaiku.withStructuredOutput(RankFilesSchema);
@@ -52,20 +57,25 @@ const defineScope: GraphNode<typeof AuditorState> = async (state) => {
   const sorted = [...rankings].sort((a, b) => b.importance - a.importance);
   logger.info(
-    `defineScope: rankings:\n${sorted.map((r) => `  [${r.importance}/5] ${r.filePath} — ${r.reasoning}`).join("\n")}`,
   );
   const importantFiles = sorted.filter((r) => r.importance >= MIN_FILE_IMPORTANCE).map((r) => r.filePath);
   const skipped = solFiles.length - importantFiles.length;
   if (skipped > 0) {
-    logger.info(`defineScope: skipping ${skipped} low-importance file(s) (importance < ${MIN_FILE_IMPORTANCE})`);
   }
   return { scope: importantFiles, docs: docFiles, fileTree, fileRankings: sorted };
 };
 const gatherContext: GraphNode<typeof AuditorState> = async (state) => {
-  logger.info(`gatherContext: processing ${state.scope.length} Solidity file(s) and ${state.docs.length} doc file(s)`);
   const readFile = (filePath: string): string => {
     try {
@@ -120,9 +130,11 @@ const gatherContext: GraphNode<typeof AuditorState> = async (state) => {
   const structuralBlock = `## Análise Estrutural dos Contratos\n\n${solidityEntries.map(({ analysis }) => analysis).join("\n\n---\n\n")}`;
   const repoContext = [result.context, fileTreeBlock, structuralBlock].join("\n\n");
-  logger.debug(`gatherContext: full context:\n${parts.join("\n\n")}`);
-  logger.info(`gatherContext: context built (${repoContext.length} chars)`);
-  logger.debug(`gatherContext: compact context:\n${repoContext}`);
   return { repoContext };
 };
@@ -133,9 +145,11 @@ const findVulnerabilities: GraphNode<typeof AuditorState> = async (state) => {
   const isReflection = state.judgeReviews.length > 0;
   logger.info(
-    `findVulnerabilities: invoking LLM for ${state.scope.length} file(s) in parallel (iteration ${state.reflectionCount + 1})`,
   );
   const cachedContext = {
     type: "text" as const,
     text: `Contexto do Protocolo:\n${state.repoContext}`,
@@ -163,7 +177,7 @@ const findVulnerabilities: GraphNode<typeof AuditorState> = async (state) => {
       ? `Contrato (${filePath}):\n\n${source}\n\n${buildReviewBlocks(fileEntries, state.reflectionCount)}`
       : `Contrato (${filePath}):\n\n${source}`;
-    logger.debug(`findVulnerabilities: processing ${filePath}`);
     const result = await model.invoke([
       new SystemMessage({ content: [{ type: "text", text: promptText, cache_control: { type: "ephemeral" } }] }),
@@ -182,15 +196,20 @@ const findVulnerabilities: GraphNode<typeof AuditorState> = async (state) => {
   const restFindings = await Promise.all(restFiles.map(processFile));
   const candidateFindings = [firstFindings, ...restFindings].flat();
-  logger.info(`findVulnerabilities: LLM returned ${candidateFindings.length} total candidate finding(s)`);
-  logger.debug(`findVulnerabilities: findings:\n${JSON.stringify(candidateFindings, null, 2)}`);
   return { candidateFindings };
 };
 const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
   if (state.candidateFindings.length === 0) {
-    logger.info("judgeFindings: no candidate findings to review, skipping LLM call");
     return {
       judgeReviews: [],
       findings: [],
@@ -200,7 +219,9 @@ const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
   const model = llmSonnet.withStructuredOutput(JudgeReviewSchema);
-  logger.info(`judgeFindings: reviewing ${state.candidateFindings.length} candidate finding(s) in parallel`);
   const cachedContext = {
     type: "text" as const,
@@ -218,7 +239,7 @@ const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
     const findingText = `[Achado ${i + 1}] ${finding.title}\nSeveridade: ${finding.severity}\nDescrição: ${finding.description}\nLocalização: ${finding.path} linhas ${finding.location}\nCódigo:\n\`\`\`solidity\n${finding.codeSnippet}\n\`\`\``;
-    logger.debug(`judgeFindings: reviewing finding ${i + 1}: ${finding.title}`);
     return model.invoke([
       new SystemMessage({
         content: [{ type: "text", text: JUDGE_FINDINGS_PROMPT, cache_control: { type: "ephemeral" } }],
@@ -252,9 +273,10 @@ const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
   const falsePositiveCount = state.candidateFindings.length - findings.length;
-  logger.info(`judgeFindings: ${findings.length} confirmed, ${falsePositiveCount} false positive(s)`);
-  logger.debug(`judgeFindings: reviews:\n${JSON.stringify(reviews, null, 2)}`);
   return {
     judgeReviews: reviews,
     findings,

 import { z } from "zod";
 import { createLLM } from "../../config/llm.ts";
+import { emitStep, logger } from "../../logger.ts";
 import { MAX_DOC_CHARS, MAX_REFLECTIONS, MAX_SOL_CHARS, MIN_FILE_IMPORTANCE } from "./config.ts";
 import {
   FIND_VULNERABILITIES_PROMPT,
 const llmSonnet = createLLM("anthropic", { model: "claude-sonnet-4-6", maxTokens: 20000 });
 const defineScope: GraphNode<typeof AuditorState> = async (state) => {
+  emitStep({ agent: "auditor", step: "scope", status: "running" });
+  logger.info(`[Auditor] defineScope: percorrendo repositório em ${state.repoPath}`);
   const solFiles: string[] = [];
   const docFiles: string[] = [];
   const fileTree = buildRepoTree(state.repoPath);
+  logger.info(
+    `[Auditor] defineScope: encontrado(s) ${solFiles.length} arquivo(s) Solidity e ${docFiles.length} arquivo(s) de documentação`,
+  );
+  logger.debug(`[Auditor] defineScope: arquivos Solidity: ${JSON.stringify(solFiles)}`);
+  logger.debug(`[Auditor] defineScope: arquivos de documentação: ${JSON.stringify(docFiles)}`);
+  logger.debug(`[Auditor] defineScope: árvore de arquivos:\n${fileTree}`);
+  emitStep({ agent: "auditor", step: "scope", status: "done" });
+  logger.info("[Auditor] defineScope: rankeando arquivos por importância");
   const RankFilesSchema = z.object({ rankings: z.array(FileRankingSchema) });
   const rankingModel = llmHaiku.withStructuredOutput(RankFilesSchema);
   const sorted = [...rankings].sort((a, b) => b.importance - a.importance);
   logger.info(
+    `[Auditor] defineScope: rankings:\n${sorted.map((r) => `  [${r.importance}/5] ${r.filePath} — ${r.reasoning}`).join("\n")}`,
   );
   const importantFiles = sorted.filter((r) => r.importance >= MIN_FILE_IMPORTANCE).map((r) => r.filePath);
   const skipped = solFiles.length - importantFiles.length;
   if (skipped > 0) {
+    logger.info(
+      `[Auditor] defineScope: pulando ${skipped} arquivo(s) de baixa importância (importância < ${MIN_FILE_IMPORTANCE})`,
+    );
   }
   return { scope: importantFiles, docs: docFiles, fileTree, fileRankings: sorted };
 };
 const gatherContext: GraphNode<typeof AuditorState> = async (state) => {
+  emitStep({ agent: "auditor", step: "ctx", status: "running" });
+  logger.info(
+    `[Auditor] gatherContext: processando ${state.scope.length} arquivo(s) Solidity e ${state.docs.length} arquivo(s) de documentação`,
+  );
   const readFile = (filePath: string): string => {
     try {
   const structuralBlock = `## Análise Estrutural dos Contratos\n\n${solidityEntries.map(({ analysis }) => analysis).join("\n\n---\n\n")}`;
   const repoContext = [result.context, fileTreeBlock, structuralBlock].join("\n\n");
+  logger.debug(`[Auditor] gatherContext: contexto completo:\n${parts.join("\n\n")}`);
+  logger.info(`[Auditor] gatherContext: contexto construído (${repoContext.length} caracteres)`);
+  logger.debug(`[Auditor] gatherContext: contexto compactado:\n${repoContext}`);
+  emitStep({ agent: "auditor", step: "ctx", status: "done" });
   return { repoContext };
 };
   const isReflection = state.judgeReviews.length > 0;
   logger.info(
+    `[Auditor] findVulnerabilities: invocando LLM para ${state.scope.length} arquivo(s) em paralelo (iteração ${state.reflectionCount + 1})`,
   );
+  emitStep({ agent: "auditor", step: "find", status: "running", detail: `iter ${state.reflectionCount + 1}` });
   const cachedContext = {
     type: "text" as const,
     text: `Contexto do Protocolo:\n${state.repoContext}`,
       ? `Contrato (${filePath}):\n\n${source}\n\n${buildReviewBlocks(fileEntries, state.reflectionCount)}`
       : `Contrato (${filePath}):\n\n${source}`;
+    logger.debug(`[Auditor] findVulnerabilities: processando ${filePath}`);
     const result = await model.invoke([
       new SystemMessage({ content: [{ type: "text", text: promptText, cache_control: { type: "ephemeral" } }] }),
   const restFindings = await Promise.all(restFiles.map(processFile));
   const candidateFindings = [firstFindings, ...restFindings].flat();
+  logger.info(
+    `[Auditor] findVulnerabilities: LLM retornou ${candidateFindings.length} finding(s) candidato(s) no total`,
+  );
+  logger.debug(`[Auditor] findVulnerabilities: findings:\n${JSON.stringify(candidateFindings, null, 2)}`);
+  emitStep({ agent: "auditor", step: "find", status: "done" });
   return { candidateFindings };
 };
 const judgeFindings: GraphNode<typeof AuditorState> = async (state) => {
+  emitStep({ agent: "auditor", step: "judge", status: "running" });
   if (state.candidateFindings.length === 0) {
+    logger.info("[Auditor] judgeFindings: sem findings candidatos para revisar, pulando chamada ao LLM");
+    emitStep({ agent: "auditor", step: "judge", status: "done" });
     return {
       judgeReviews: [],
       findings: [],
   const model = llmSonnet.withStructuredOutput(JudgeReviewSchema);
+  logger.info(
+    `[Auditor] judgeFindings: revisando ${state.candidateFindings.length} finding(s) candidato(s) em paralelo`,
+  );
   const cachedContext = {
     type: "text" as const,
     const findingText = `[Achado ${i + 1}] ${finding.title}\nSeveridade: ${finding.severity}\nDescrição: ${finding.description}\nLocalização: ${finding.path} linhas ${finding.location}\nCódigo:\n\`\`\`solidity\n${finding.codeSnippet}\n\`\`\``;
+    logger.debug(`[Auditor] judgeFindings: revisando finding ${i + 1}: ${finding.title}`);
     return model.invoke([
       new SystemMessage({
         content: [{ type: "text", text: JUDGE_FINDINGS_PROMPT, cache_control: { type: "ephemeral" } }],
   const falsePositiveCount = state.candidateFindings.length - findings.length;
+  logger.info(`[Auditor] judgeFindings: ${findings.length} confirmado(s), ${falsePositiveCount} falso(s) positivo(s)`);
+  logger.debug(`[Auditor] judgeFindings: revisões:\n${JSON.stringify(reviews, null, 2)}`);
+  emitStep({ agent: "auditor", step: "judge", status: "done" });
   return {
     judgeReviews: reviews,
     findings,

src/agents/coder/agent.ts CHANGED Viewed

@@ -4,6 +4,7 @@ import { CoderState } from "./state.ts";
 import { solidityCoderPrompt, solidityFixPrompt, solidityReviewPrompt } from "./prompts.ts";
 import { compileSolidityTool } from "./tools/compile-solidity.ts";
 import { createLLM } from "../../config/llm.ts";
 const MAX_FIX_ATTEMPTS = 3;
@@ -21,6 +22,7 @@ function extractSolidityCode(text: string): string {
  * Nó 1: Gera o smart contract a partir dos requisitos.
  */
 const generateContract: GraphNode<typeof CoderState> = async (state) => {
   const llm = createLLM();
   const chain = solidityCoderPrompt.pipe(llm);
@@ -33,6 +35,7 @@ const generateContract: GraphNode<typeof CoderState> = async (state) => {
     typeof result.content === "string" ? result.content : JSON.stringify(result.content),
   );
   return { contract: code, compilationErrors: [] };
 };
@@ -40,11 +43,15 @@ const generateContract: GraphNode<typeof CoderState> = async (state) => {
  * Nó 2: Compila o contrato e armazena erros (se houver).
  */
 const compileContract: GraphNode<typeof CoderState> = async (state) => {
   const result = await compileSolidityTool.invoke({
     sourceCode: state.contract,
     filename: "Contract.sol",
   });
   return { compilationErrors: result.errors };
 };
@@ -52,6 +59,7 @@ const compileContract: GraphNode<typeof CoderState> = async (state) => {
  * Nó 3: Corrige o contrato com base nos erros de compilação.
  */
 const fixContract: GraphNode<typeof CoderState> = async (state) => {
   const llm = createLLM();
   const chain = solidityFixPrompt.pipe(llm);
@@ -73,6 +81,7 @@ const fixContract: GraphNode<typeof CoderState> = async (state) => {
  * Nó 4: Revisa o contrato compilado quanto a segurança e boas práticas.
  */
 const reviewContract: GraphNode<typeof CoderState> = async (state) => {
   const llm = createLLM();
   const chain = solidityReviewPrompt.pipe(llm);
@@ -86,6 +95,7 @@ const reviewContract: GraphNode<typeof CoderState> = async (state) => {
   const summary =
     typeof result.content === "string" ? result.content : JSON.stringify(result.content);
   return { reviewSummary: summary };
 };
@@ -100,7 +110,10 @@ function shouldFix(state: { compilationErrors: string[] }): "fixContract" | "rev
     fixAttempts++;
     return "fixContract";
   }
-  fixAttempts = 0; // reset para próxima execução
   return "reviewContract";
 }

 import { solidityCoderPrompt, solidityFixPrompt, solidityReviewPrompt } from "./prompts.ts";
 import { compileSolidityTool } from "./tools/compile-solidity.ts";
 import { createLLM } from "../../config/llm.ts";
+import { emitStep } from "../../logger.ts";
 const MAX_FIX_ATTEMPTS = 3;
  * Nó 1: Gera o smart contract a partir dos requisitos.
  */
 const generateContract: GraphNode<typeof CoderState> = async (state) => {
+  emitStep({ agent: "coder", step: "gen", status: "running" });
   const llm = createLLM();
   const chain = solidityCoderPrompt.pipe(llm);
     typeof result.content === "string" ? result.content : JSON.stringify(result.content),
   );
+  emitStep({ agent: "coder", step: "gen", status: "done" });
   return { contract: code, compilationErrors: [] };
 };
  * Nó 2: Compila o contrato e armazena erros (se houver).
  */
 const compileContract: GraphNode<typeof CoderState> = async (state) => {
+  emitStep({ agent: "coder", step: "compile", status: "running" });
   const result = await compileSolidityTool.invoke({
     sourceCode: state.contract,
     filename: "Contract.sol",
   });
+  if (result.errors.length === 0) {
+    emitStep({ agent: "coder", step: "compile", status: "done" });
+  }
   return { compilationErrors: result.errors };
 };
  * Nó 3: Corrige o contrato com base nos erros de compilação.
  */
 const fixContract: GraphNode<typeof CoderState> = async (state) => {
+  emitStep({ agent: "coder", step: "compile", status: "running", detail: `fix ${fixAttempts}/${MAX_FIX_ATTEMPTS}` });
   const llm = createLLM();
   const chain = solidityFixPrompt.pipe(llm);
  * Nó 4: Revisa o contrato compilado quanto a segurança e boas práticas.
  */
 const reviewContract: GraphNode<typeof CoderState> = async (state) => {
+  emitStep({ agent: "coder", step: "review", status: "running" });
   const llm = createLLM();
   const chain = solidityReviewPrompt.pipe(llm);
   const summary =
     typeof result.content === "string" ? result.content : JSON.stringify(result.content);
+  emitStep({ agent: "coder", step: "review", status: "done" });
   return { reviewSummary: summary };
 };
     fixAttempts++;
     return "fixContract";
   }
+  if (state.compilationErrors.length > 0) {
+    emitStep({ agent: "coder", step: "compile", status: "error" });
+  }
+  fixAttempts = 0;
   return "reviewContract";
 }

src/agents/tester/agent.ts CHANGED Viewed

@@ -1,25 +1,28 @@
-import "dotenv/config";
 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 } from "./prompts/system.js";
 import { extractSolidity } from "./utils/extractSolidity.js";
 import { runFoundry } from "./tools/foundryRunner.js";
 import { analyzeFoundryLog } from "./utils/logAnalyzer.js";
 const MAX_ITERATIONS = 5;
 const llm = createLLM();
 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 };
 }
@@ -53,7 +56,8 @@ Scaffold (complete APENAS test_Exploit):
 ${oracleContext!.solidityScaffold}
 \`\`\``;
-  console.log(`[testerAgent] generatePoCNode iteração ${iterations + 1}, isRetry=${isRetry}`);
   try {
     const response = await llm.invoke([
@@ -61,16 +65,19 @@ ${oracleContext!.solidityScaffold}
       { role: "user", content: userMessage },
     ]);
     const solidityCode = extractSolidity(response.content as string);
-    console.log("[testerAgent] Solidity extraído, tamanho:", solidityCode.length);
     return { pocCode: solidityCode, iterations: 1 };
   } catch (err) {
-    console.error("[testerAgent] falha na geração:", (err as Error).message);
     return { iterations: 1, lastError: `Erro na geração/extração: ${(err as Error).message}` };
   }
 }
 async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
-  console.log("[testerAgent] Executando runFoundryNode...");
   const trimmedCode = state.pocCode.trim();
   const isMissingCode = trimmedCode.length === 0;
@@ -78,14 +85,15 @@ async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
   const isMissingTest = !trimmedCode.includes("function test_Exploit()");
   const isPlaceholder = trimmedCode.includes("TODO: implementar exploit");
   if (isMissingCode || isMissingContract || isMissingTest || isPlaceholder) {
-    const summary = state.lastError ?? (isMissingCode
-      ? "Código Solidity ausente. O LLM não retornou o arquivo do exploit."
-      : isMissingContract
-        ? "Contrato ExploitTest não encontrado no arquivo."
-        : isMissingTest
-          ? "Função test_Exploit() não encontrada no arquivo."
-          : "Exploit não implementado (placeholder TODO ainda presente)."
-    );
     const status = state.iterations >= MAX_ITERATIONS ? "failed" : "running";
     return {
       executionLogs: [summary],
@@ -94,51 +102,52 @@ async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
     };
   }
-  const result   = await runFoundry(state.pocCode);
   const analysis = analyzeFoundryLog(result);
   const noTestsFound = result.combined.includes("No tests found");
   const summary = noTestsFound
     ? "Forge não encontrou nenhum teste. Verifique se o contrato se chama ExploitTest e se existe test_Exploit()."
     : analysis.summary;
-  const passed   = result.exitCode === 0 && result.stdout.includes("ok") && !noTestsFound;
   const isLastAttempt = state.iterations >= MAX_ITERATIONS;
-  const status = passed
-    ? "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}`);
   }
   return {
-    executionLogs: [result.combined],   // reducer append
     lastError: summary,
     status,
   };
 }
 async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
   const lastLog = state.executionLogs[state.executionLogs.length - 1];
   if (!lastLog) {
     return { lastError: "Sem logs disponíveis para análise." };
   }
   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")}`,
   };

 import { StateGraph, END, START } from "@langchain/langgraph";
+import { PoCStateAnnotation, type PoCState } from "./state.js";
 import { generateLocalScaffold } from "./tools/scaffoldGenerator.js";
+import type { OracleContext } from "./types.js";
 import { createLLM } from "../../config/llm.ts";
 import { SYSTEM_PROMPT } from "./prompts/system.js";
 import { extractSolidity } from "./utils/extractSolidity.js";
 import { runFoundry } from "./tools/foundryRunner.js";
 import { analyzeFoundryLog } from "./utils/logAnalyzer.js";
+import { logger, emitStep } from "../../logger.ts";
 const MAX_ITERATIONS = 5;
 const llm = createLLM();
 async function oracleNode(state: PoCState): Promise<Partial<PoCState>> {
+  emitStep({ agent: "tester", step: "oracle", status: "running" });
+  logger.info(`[Tester] oracleNode: gerando scaffold para: ${state.report.title}`);
   const solidityScaffold = generateLocalScaffold(state.report);
   const oracleContext: OracleContext = { solidityScaffold };
+  logger.info(`[Tester] oracleNode: scaffold gerado, tamanho: ${solidityScaffold.length} chars`);
+  emitStep({ agent: "tester", step: "oracle", status: "done" });
   return { oracleContext };
 }
 ${oracleContext!.solidityScaffold}
 \`\`\``;
+  logger.info(`[Tester] generatePoCNode: iteração ${iterations + 1}, isRetry=${isRetry}`);
+  emitStep({ agent: "tester", step: "gen", status: "running", detail: `iter ${iterations + 1}` });
   try {
     const response = await llm.invoke([
       { role: "user", content: userMessage },
     ]);
     const solidityCode = extractSolidity(response.content as string);
+    logger.info(`[Tester] generatePoCNode: Solidity extraído, tamanho: ${solidityCode.length}`);
+    emitStep({ agent: "tester", step: "gen", status: "done" });
     return { pocCode: solidityCode, iterations: 1 };
   } catch (err) {
+    logger.error(`[Tester] generatePoCNode: falha na geração: ${(err as Error).message}`);
+    emitStep({ agent: "tester", step: "gen", status: "error" });
     return { iterations: 1, lastError: `Erro na geração/extração: ${(err as Error).message}` };
   }
 }
 async function runFoundryNode(state: PoCState): Promise<Partial<PoCState>> {
+  emitStep({ agent: "tester", step: "run", status: "running" });
+  logger.info("[Tester] runFoundryNode: executando...");
   const trimmedCode = state.pocCode.trim();
   const isMissingCode = trimmedCode.length === 0;
   const isMissingTest = !trimmedCode.includes("function test_Exploit()");
   const isPlaceholder = trimmedCode.includes("TODO: implementar exploit");
   if (isMissingCode || isMissingContract || isMissingTest || isPlaceholder) {
+    const summary =
+      state.lastError ??
+      (isMissingCode
+        ? "Código Solidity ausente. O LLM não retornou o arquivo do exploit."
+        : isMissingContract
+          ? "Contrato ExploitTest não encontrado no arquivo."
+          : isMissingTest
+            ? "Função test_Exploit() não encontrada no arquivo."
+            : "Exploit não implementado (placeholder TODO ainda presente).");
     const status = state.iterations >= MAX_ITERATIONS ? "failed" : "running";
     return {
       executionLogs: [summary],
     };
   }
+  const result = await runFoundry(state.pocCode);
   const analysis = analyzeFoundryLog(result);
   const noTestsFound = result.combined.includes("No tests found");
   const summary = noTestsFound
     ? "Forge não encontrou nenhum teste. Verifique se o contrato se chama ExploitTest e se existe test_Exploit()."
     : analysis.summary;
+  const passed = result.exitCode === 0 && result.stdout.includes("ok") && !noTestsFound;
   const isLastAttempt = state.iterations >= MAX_ITERATIONS;
+  const status = passed ? "success" : result.timedOut ? "timeout" : isLastAttempt ? "failed" : "running";
+  logger.info(`[Tester] runFoundryNode: resultado Foundry: exitCode=${result.exitCode}, passed=${passed}`);
   if (!passed) {
+    logger.info(`[Tester] runFoundryNode: falha detectada: ${analysis.summary}`);
   }
+  emitStep({ agent: "tester", step: "run", status: passed ? "done" : result.timedOut ? "error" : "done" });
   return {
+    executionLogs: [result.combined], // reducer append
     lastError: summary,
     status,
   };
 }
 async function reflectNode(state: PoCState): Promise<Partial<PoCState>> {
+  emitStep({ agent: "tester", step: "reflect", status: "running" });
   const lastLog = state.executionLogs[state.executionLogs.length - 1];
   if (!lastLog) {
     return { lastError: "Sem logs disponíveis para análise." };
   }
   const mockResult = {
+    exitCode: 1,
+    timedOut: lastLog.includes("TIMEOUT"),
+    stdout: "",
+    stderr: "",
+    combined: lastLog,
   };
   const analysis = analyzeFoundryLog(mockResult as any);
+  logger.info(`[Tester] reflectNode: categoria: ${analysis.category}`);
+  logger.info(`[Tester] reflectNode: resumo: ${analysis.summary}`);
+  emitStep({ agent: "tester", step: "reflect", status: "done" });
   return {
     lastError: `[${analysis.category.toUpperCase()}] ${analysis.summary}\n\nLinhas relevantes:\n${analysis.relevantLines.join("\n")}`,
   };

src/agents/tester/index.ts DELETED Viewed

@@ -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 });
-  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/tools/foundryRunner.ts CHANGED Viewed

@@ -3,7 +3,9 @@ import { promisify } from "util";
 import { writeFile, access } from "fs/promises";
 import { join } from "path";
-const execAsync  = promisify(exec);
 const SANDBOX = process.env.SANDBOX_DIR || "/tmp/poc-sandbox";
 const TIMEOUT_MS = 60_000;
@@ -22,7 +24,7 @@ async function ensureSandbox() {
   try {
     await access(join(SANDBOX, "foundry.toml"));
   } catch {
-    console.log("[foundryRunner] Sandbox não encontrado. Inicializando...");
     // Caminho absoluto para o script de setup (assume execução da raiz do projeto)
     await execAsync("./scripts/setup-sandbox.sh");
   }
@@ -30,19 +32,16 @@ async function ensureSandbox() {
 export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
   await ensureSandbox();
   // 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, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` }
-      }
-    );
     return {
       exitCode: 0,
       stdout,
@@ -53,7 +52,9 @@ export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
   } 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,
       };

 import { writeFile, access } from "fs/promises";
 import { join } from "path";
+import { logger } from "../../../logger.js";
+const execAsync = promisify(exec);
 const SANDBOX = process.env.SANDBOX_DIR || "/tmp/poc-sandbox";
 const TIMEOUT_MS = 60_000;
   try {
     await access(join(SANDBOX, "foundry.toml"));
   } catch {
+    logger.info("[Tester] foundryRunner: sandbox não encontrado, inicializando...");
     // Caminho absoluto para o script de setup (assume execução da raiz do projeto)
     await execAsync("./scripts/setup-sandbox.sh");
   }
 export async function runFoundry(solidityCode: string): Promise<FoundryResult> {
   await ensureSandbox();
   // 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, PATH: `${process.env.HOME}/.foundry/bin:${process.env.PATH}` },
+    });
     return {
       exitCode: 0,
       stdout,
   } 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,
       };

src/logger.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import winston from "winston";
@@ -15,6 +16,50 @@ const lineFormat = printf(({ level, message, timestamp: ts, stack }) => {
   return stack ? `${base}\n${stack}` : base;
 });
 export const logger = winston.createLogger({
   level: "debug",
   transports: [
@@ -25,5 +70,10 @@ export const logger = winston.createLogger({
       filename: path.join(logsDir, `app-${runTimestamp}.log`),
       format: combine(timestamp(), errors({ stack: true }), lineFormat),
     }),
   ],
 });

 import fs from "node:fs";
 import path from "node:path";
+import { Writable } from "node:stream";
 import winston from "winston";
   return stack ? `${base}\n${stack}` : base;
 });
+type LogSink = (message: string) => void | Promise<void>;
+let activeSink: LogSink | null = null;
+export function setLogSink(sink: LogSink): void {
+  activeSink = sink;
+}
+export function clearLogSink(): void {
+  activeSink = null;
+}
+const sinkStream = new Writable({
+  write(chunk: Buffer, _encoding: string, callback: () => void) {
+    if (activeSink) {
+      void activeSink(chunk.toString().trim());
+    }
+    callback();
+  },
+});
+export interface StepEvent {
+  agent: "coder" | "auditor" | "tester";
+  step: string;
+  status: "running" | "done" | "error" | "skipped";
+  detail?: string;
+}
+type StepSink = (event: StepEvent) => void | Promise<void>;
+let activeStepSink: StepSink | null = null;
+export function setStepSink(sink: StepSink): void {
+  activeStepSink = sink;
+}
+export function clearStepSink(): void {
+  activeStepSink = null;
+}
+export function emitStep(event: StepEvent): void {
+  if (activeStepSink) void activeStepSink(event);
+}
 export const logger = winston.createLogger({
   level: "debug",
   transports: [
       filename: path.join(logsDir, `app-${runTimestamp}.log`),
       format: combine(timestamp(), errors({ stack: true }), lineFormat),
     }),
+    new winston.transports.Stream({
+      stream: sinkStream,
+      level: "info",
+      format: winston.format.printf(({ message }) => String(message)),
+    }),
   ],
 });

src/server.ts CHANGED Viewed

@@ -13,6 +13,7 @@ import { coderAgent } from "./agents/coder/agent.ts";
 import { auditorAgent } from "./agents/auditor/agent.ts";
 import { testerAgent } from "./agents/tester/agent.ts";
 import { mapFindingToReport } from "./utils/mapFinding.js";
 const app = new Hono();
@@ -35,16 +36,17 @@ app.post("/api/run", (c) => {
     };
     try {
       // === CODER ===
-      await send("log", "[Coder] Gerando smart contract a partir dos requisitos...");
       const coderResult = await coderAgent.invoke({ requirements: [requirements] });
-      await send("log", "[Coder] Contrato gerado com sucesso.");
       if (coderResult.compilationErrors.length > 0) {
-        await send("log", `[Coder] Erros de compilação restantes: ${coderResult.compilationErrors.length}`);
       } else {
-        await send("log", "[Coder] Contrato compilado sem erros.");
       }
       await send(
@@ -62,11 +64,11 @@ app.post("/api/run", (c) => {
       writeFileSync(resolve(outputDir, "Contract.sol"), coderResult.contract, "utf-8");
       writeFileSync(resolve(outputDir, "README.md"), requirements, "utf-8");
-      await send("log", "[Auditor] Iniciando auditoria de segurança...");
       const auditorResult = await auditorAgent.invoke({ repoPath: outputDir });
-      await send("log", `[Auditor] ${auditorResult.findings.length} vulnerabilidade(s) encontrada(s).`);
       for (const f of auditorResult.findings) {
-        await send("log", `[Auditor] [${f.severity.toUpperCase()}] ${f.title} — ${f.location}`);
       }
       await send(
@@ -77,14 +79,14 @@ app.post("/api/run", (c) => {
       );
       // === TESTER ===
-      await send("log", "[Tester] Gerando testes de prova de conceito...");
       if (auditorResult.findings.length > 0) {
         const report = mapFindingToReport(auditorResult.findings[0], coderResult.contract);
         const testerResult = await testerAgent.invoke({ report });
-        await send("log", `[Tester] Execução concluída com status: ${testerResult.status}`);
         // Garante que o objeto enviado tem exatamente o que o front espera
         await send(
           "tester",
@@ -96,15 +98,18 @@ app.post("/api/run", (c) => {
           }),
         );
       } else {
-        await send("log", "[Tester] Nenhuma vulnerabilidade para testar.");
         await send("tester", JSON.stringify({ status: "skipped", iterations: 0 }));
       }
-      await send("log", "Pipeline concluído.");
       await send("done", "ok");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       await send("error", message);
     }
   });
 });

 import { auditorAgent } from "./agents/auditor/agent.ts";
 import { testerAgent } from "./agents/tester/agent.ts";
 import { mapFindingToReport } from "./utils/mapFinding.js";
+import { logger, setLogSink, clearLogSink, setStepSink, clearStepSink } from "./logger.ts";
 const app = new Hono();
     };
     try {
+      setLogSink((msg) => send("log", msg));
+      setStepSink((event) => send("step", JSON.stringify(event)));
       // === CODER ===
+      logger.info("[Coder] Gerando smart contract a partir dos requisitos...");
       const coderResult = await coderAgent.invoke({ requirements: [requirements] });
       if (coderResult.compilationErrors.length > 0) {
+        logger.info(`[Coder] Erros de compilação restantes: ${coderResult.compilationErrors.length}`);
       } else {
+        logger.info("[Coder] Contrato compilado sem erros.");
       }
       await send(
       writeFileSync(resolve(outputDir, "Contract.sol"), coderResult.contract, "utf-8");
       writeFileSync(resolve(outputDir, "README.md"), requirements, "utf-8");
+      logger.info("[Auditor] Iniciando auditoria de segurança...");
       const auditorResult = await auditorAgent.invoke({ repoPath: outputDir });
+      logger.info(`[Auditor] ${auditorResult.findings.length} vulnerabilidade(s) encontrada(s).`);
       for (const f of auditorResult.findings) {
+        logger.info(`[Auditor] [${f.severity.toUpperCase()}] ${f.title} — ${f.location}`);
       }
       await send(
       );
       // === TESTER ===
+      logger.info("[Tester] Gerando testes de prova de conceito...");
       if (auditorResult.findings.length > 0) {
         const report = mapFindingToReport(auditorResult.findings[0], coderResult.contract);
         const testerResult = await testerAgent.invoke({ report });
+        logger.info(`[Tester] Execução concluída com status: ${testerResult.status}`);
         // Garante que o objeto enviado tem exatamente o que o front espera
         await send(
           "tester",
           }),
         );
       } else {
+        logger.info("[Tester] Nenhuma vulnerabilidade para testar.");
         await send("tester", JSON.stringify({ status: "skipped", iterations: 0 }));
       }
+      logger.info("Pipeline concluído.");
       await send("done", "ok");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       await send("error", message);
+    } finally {
+      clearLogSink();
+      clearStepSink();
     }
   });
 });