cipher-security 2.1.0 → 2.2.0

package/lib/benchmark/runner.js

@@ -3,6 +3,9 @@
 
 /**
  * CIPHER Benchmark — Runner (orchestrates build → start → solve → score → report).
+ *
+ * Supports parallel execution with concurrency limits and retry/best-of-N
+ * for reliability on flaky benchmarks.
  */
 
 import { BenchmarkBuilder } from './builder.js';
@@ -11,18 +14,18 @@ import { SolverResult } from './models.js';
 import { aggregateResults, scoreResult } from './scorer.js';
 import { getSolver } from './solver.js';
 
-export function runSingleBenchmark(builder, solver, name, flag) {
+// ---------------------------------------------------------------------------
+// Single benchmark execution
+// ---------------------------------------------------------------------------
+
+export async function runSingleBenchmark(builder, solver, name, flag) {
   const config = builder.getBenchmark(name);
   flag = flag || builder.config.generateFlag(name);
   let targetUrl = '';
   try {
     const result = builder.runBenchmark(name, flag);
     targetUrl = result.targetUrl;
-    const solverResult = solver.solve(config, targetUrl, result.expectedFlag);
-    // Handle promise (autonomous) or sync (stub)
-    if (solverResult && typeof solverResult.then === 'function') {
-      return solverResult.then((sr) => scoreResult(config, sr, flag, targetUrl));
-    }
+    const solverResult = await solver.solve(config, targetUrl, result.expectedFlag);
     return scoreResult(config, solverResult, flag, targetUrl);
   } catch (e) {
     return scoreResult(config, new SolverResult({ error: String(e) }), flag, targetUrl);
@@ -31,7 +34,85 @@ export function runSingleBenchmark(builder, solver, name, flag) {
   }
 }
 
-export async function runBenchmarks({ builder, solver, benchmarkNames, runAll = false, levelFilter, tagFilter }) {
+// ---------------------------------------------------------------------------
+// Retry logic — best-of-N
+// ---------------------------------------------------------------------------
+
+/**
+ * Run a single benchmark with retries, keeping the best result.
+ *
+ * @param {BenchmarkBuilder} builder
+ * @param {object} solver
+ * @param {string} name
+ * @param {object} [opts]
+ * @param {number} [opts.retries=1] - Total attempts (1 = no retry)
+ * @param {string} [opts.flag]
+ * @param {Function} [opts.onAttempt] - Called with (attemptNum, result) after each attempt
+ * @returns {Promise<import('./models.js').BenchmarkResult>}
+ */
+export async function runWithRetry(builder, solver, name, opts = {}) {
+  const maxAttempts = opts.retries ?? 1;
+  const flag = opts.flag || builder.config.generateFlag(name);
+  let bestResult = null;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const result = await runSingleBenchmark(builder, solver, name, flag);
+
+    if (opts.onAttempt) opts.onAttempt(attempt, result);
+
+    // Keep the best result: passed > failed > error
+    if (!bestResult || _isBetterResult(result, bestResult)) {
+      bestResult = result;
+    }
+
+    // If passed, no need to retry
+    if (result.passed) break;
+  }
+
+  return bestResult;
+}
+
+/**
+ * Compare two results — passed beats failed, failed beats error.
+ * @param {import('./models.js').BenchmarkResult} a
+ * @param {import('./models.js').BenchmarkResult} b
+ * @returns {boolean} True if a is better than b
+ */
+function _isBetterResult(a, b) {
+  if (a.passed && !b.passed) return true;
+  if (!a.passed && b.passed) return false;
+  // Both same pass/fail status — prefer no error
+  if (!a.solverResult.error && b.solverResult.error) return true;
+  if (a.solverResult.error && !b.solverResult.error) return false;
+  // Both same error status — prefer more tool calls (more progress)
+  return a.solverResult.toolCalls > b.solverResult.toolCalls;
+}
+
+// ---------------------------------------------------------------------------
+// Parallel execution with concurrency limit
+// ---------------------------------------------------------------------------
+
+/**
+ * Run benchmarks with parallel execution and optional retries.
+ *
+ * @param {object} opts
+ * @param {BenchmarkBuilder} opts.builder
+ * @param {object} opts.solver
+ * @param {string[]} [opts.benchmarkNames]
+ * @param {boolean} [opts.runAll=false]
+ * @param {number} [opts.levelFilter]
+ * @param {string} [opts.tagFilter]
+ * @param {number} [opts.concurrency=1] - Max parallel benchmarks
+ * @param {number} [opts.retries=1] - Attempts per benchmark
+ * @param {Function} [opts.onResult] - Called with (name, result) after each benchmark
+ * @param {Function} [opts.onTrace] - Called with trace event objects for observability
+ * @returns {Promise<import('./models.js').RunReport>}
+ */
+export async function runBenchmarks({
+  builder, solver, benchmarkNames, runAll = false,
+  levelFilter, tagFilter, concurrency = 1, retries = 1,
+  onResult, onTrace,
+}) {
   let allBenchmarks;
   try {
     allBenchmarks = builder.listBenchmarks();
@@ -61,14 +142,94 @@ export async function runBenchmarks({ builder, solver, benchmarkNames, runAll =
   }
 
   const results = [];
-  for (const name of targets) {
-    const result = await runSingleBenchmark(builder, solver, name);
-    results.push(result);
+
+  if (concurrency <= 1) {
+    // Sequential execution (original behavior)
+    for (const name of targets) {
+      const startTime = performance.now();
+      const result = await runWithRetry(builder, solver, name, { retries });
+      const durationMs = performance.now() - startTime;
+
+      results.push(result);
+      if (onResult) onResult(name, result);
+      if (onTrace) onTrace({
+        type: 'benchmark_complete',
+        benchmark: name,
+        passed: result.passed,
+        durationMs: Math.round(durationMs),
+        attempts: retries,
+        error: result.solverResult.error,
+      });
+    }
+  } else {
+    // Parallel execution with concurrency limit
+    const inFlight = new Set();
+    const queue = [...targets];
+
+    while (queue.length > 0 || inFlight.size > 0) {
+      // Fill up to concurrency limit
+      while (queue.length > 0 && inFlight.size < concurrency) {
+        const name = queue.shift();
+        const startTime = performance.now();
+        const promise = runWithRetry(builder, solver, name, { retries })
+          .then((result) => {
+            const durationMs = performance.now() - startTime;
+            results.push(result);
+            inFlight.delete(promise);
+            if (onResult) onResult(name, result);
+            if (onTrace) onTrace({
+              type: 'benchmark_complete',
+              benchmark: name,
+              passed: result.passed,
+              durationMs: Math.round(durationMs),
+              attempts: retries,
+              error: result.solverResult.error,
+            });
+          })
+          .catch((err) => {
+            results.push({
+              config: builder.getBenchmark(name),
+              solverResult: new SolverResult({ error: String(err) }),
+              passed: false,
+              expectedFlag: '',
+              actualFlag: '',
+            });
+            inFlight.delete(promise);
+            if (onTrace) onTrace({
+              type: 'benchmark_error',
+              benchmark: name,
+              error: String(err),
+            });
+          });
+        inFlight.add(promise);
+      }
+
+      // Wait for at least one to complete
+      if (inFlight.size > 0) {
+        await Promise.race(inFlight);
+      }
+    }
   }
+
   return aggregateResults(results);
 }
 
+// ---------------------------------------------------------------------------
+// Report serialization
+// ---------------------------------------------------------------------------
+
 export function reportToDict(report) {
+  const byTag = report.resultsByTag();
+  const tagRates = {};
+  for (const [tag, tagResults] of Object.entries(byTag)) {
+    const p = tagResults.filter(r => r.passed).length;
+    tagRates[tag] = {
+      total: tagResults.length,
+      passed: p,
+      rate: tagResults.length ? Math.round((p / tagResults.length) * 1000) / 10 : 0,
+    };
+  }
+
   return {
     summary: {
       total: report.total,
@@ -81,6 +242,7 @@ export function reportToDict(report) {
       pass_rate_by_level: Object.fromEntries(
         Object.entries(report.passRateByLevel()).map(([k, v]) => [k, Math.round(v * 10) / 10]),
       ),
+      pass_rate_by_tag: tagRates,
     },
     results: report.results.map((r) => ({
       benchmark: r.config.dirName,
@@ -101,3 +263,5 @@ export function reportToDict(report) {
     })),
   };
 }
+
+export { _isBetterResult };

package/lib/benchmark/sandbox.js

@@ -77,6 +77,41 @@ export class SandboxContainer {
     this._connectedNetworks.push(networkName);
   }
 
+  /**
+   * Copy a file from the host into the sandbox container.
+   * @param {string} hostPath - Absolute path on the host
+   * @param {string} containerPath - Path inside the container (default: /tmp/<filename>)
+   */
+  copyFileIn(hostPath, containerPath) {
+    if (!this._containerId) throw new SandboxError('Container not created.');
+    const result = spawnSync('docker', ['cp', hostPath, `${this._containerId}:${containerPath}`], {
+      timeout: 30000,
+      stdio: 'pipe',
+    });
+    if (result.status !== 0) {
+      throw new SandboxError(`Failed to copy ${hostPath} to container: ${(result.stderr || '').toString().slice(0, 200)}`);
+    }
+  }
+
+  /**
+   * Parse a docker-compose.yml and return all service URLs.
+   * @param {object} services - Parsed docker-compose services object
+   * @param {string} networkName - Docker network the sandbox is connected to
+   * @returns {Array<{ name: string, url: string, port: number }>}
+   */
+  static resolveServiceUrls(services, networkName) {
+    const urls = [];
+    for (const [name, svc] of Object.entries(services)) {
+      let port = 80;
+      if (svc.ports?.length) {
+        port = parseInt(String(svc.ports[0]).split(':').pop(), 10);
+      }
+      const protocol = [443, 8443].includes(port) ? 'https' : 'http';
+      urls.push({ name, url: `${protocol}://${name}:${port}`, port });
+    }
+    return urls;
+  }
+
   getInternalUrl(serviceName, port = 80) {
     const protocol = [443, 8443].includes(port) ? 'https' : 'http';
     return `${protocol}://${serviceName}:${port}`;

package/lib/benchmark/scorer.js

@@ -13,10 +13,28 @@ export function scoreFlag(expected, actual) {
 }
 
 export function scoreResult(config, solverResult, expectedFlag, targetUrl = '') {
-  const passed = solverResult.flagFound && solverResult.flagValue
-    ? scoreFlag(expectedFlag, solverResult.flagValue)
-    : false;
-  return new BenchmarkResult({ config, solverResult, passed, expectedFlag, actualFlag: solverResult.flagValue, targetUrl });
+  let passed = false;
+  let actualValue = '';
+
+  if (config.winCondition === 'question') {
+    // Question-type: check answer
+    if (solverResult.answerFound && solverResult.answerValue) {
+      actualValue = solverResult.answerValue;
+      passed = scoreFlag(expectedFlag, solverResult.answerValue);
+    }
+  } else {
+    // Flag-type: check flag
+    if (solverResult.flagFound && solverResult.flagValue) {
+      actualValue = solverResult.flagValue;
+      passed = scoreFlag(expectedFlag, solverResult.flagValue);
+    }
+  }
+
+  return new BenchmarkResult({
+    config, solverResult, passed, expectedFlag,
+    actualFlag: actualValue || solverResult.flagValue || solverResult.answerValue || '',
+    targetUrl,
+  });
 }
 
 export function aggregateResults(results) {

package/lib/benchmark/solver.js

@@ -159,8 +159,41 @@ export class MultiAgentSolver extends SolverAdapter {
 
 export const SOLVERS = { stub: StubSolver, manual: ManualSolver, autonomous: AutonomousSolver, 'autonomous-multi': MultiAgentSolver };
 
+// Lazy-load RemoteSolver to avoid circular imports
 export function getSolver(name, opts = {}) {
+  if (name === 'remote') {
+    return new RemoteSolverProxy(opts);
+  }
+  if (name === 'claude-code') {
+    return new ClaudeCodeSolverProxy(opts);
+  }
   const Cls = SOLVERS[name];
-  if (!Cls) throw new Error(`Unknown solver: ${name}. Available: ${Object.keys(SOLVERS).join(', ')}`);
+  if (!Cls) throw new Error(`Unknown solver: ${name}. Available: ${[...Object.keys(SOLVERS), 'remote', 'claude-code'].join(', ')}`);
   return new Cls(opts);
 }
+
+/** Proxy that lazy-loads RemoteSolver on first solve(). */
+class RemoteSolverProxy extends SolverAdapter {
+  constructor(opts) { super(); this._opts = opts; this._impl = null; }
+  get name() { return 'remote'; }
+  async solve(config, targetUrl, expectedFlag) {
+    if (!this._impl) {
+      const { RemoteSolver } = await import('./remote-solver.js');
+      this._impl = new RemoteSolver(this._opts);
+    }
+    return this._impl.solve(config, targetUrl, expectedFlag);
+  }
+}
+
+/** Proxy that lazy-loads ClaudeCodeSolver on first solve(). */
+class ClaudeCodeSolverProxy extends SolverAdapter {
+  constructor(opts) { super(); this._opts = opts; this._impl = null; }
+  get name() { return 'claude-code'; }
+  async solve(config, targetUrl, expectedFlag) {
+    if (!this._impl) {
+      const { ClaudeCodeSolver } = await import('./claude-code-solver.js');
+      this._impl = new ClaudeCodeSolver(this._opts);
+    }
+    return this._impl.solve(config, targetUrl, expectedFlag);
+  }
+}

package/lib/benchmark/tools.js

@@ -3,10 +3,23 @@
 
 /**
  * CIPHER Benchmark — Tool definitions for the security agent.
+ *
+ * 7 tools for autonomous CTF solving:
+ * - sandbox_exec: execute shell commands
+ * - submit_flag: submit a captured flag (flag win condition)
+ * - submit_answer: submit an answer (question win condition)
+ * - read_file: read a file from the sandbox filesystem
+ * - write_file: write a file to the sandbox filesystem
+ * - list_directory: list directory contents in the sandbox
+ * - http_request: make structured HTTP requests with headers/body
  */
 
 const MAX_OUTPUT_CHARS = 4000;
 
+// ---------------------------------------------------------------------------
+// Tool schemas
+// ---------------------------------------------------------------------------
+
 export const SANDBOX_EXEC_SCHEMA = {
   name: 'sandbox_exec',
   description: 'Execute a shell command in the security sandbox. Returns stdout, stderr, and exit code.',
@@ -32,31 +45,264 @@ export const SUBMIT_FLAG_SCHEMA = {
   },
 };
 
-export const AGENT_TOOLS = [SANDBOX_EXEC_SCHEMA, SUBMIT_FLAG_SCHEMA];
+export const SUBMIT_ANSWER_SCHEMA = {
+  name: 'submit_answer',
+  description: 'Submit an answer to a question-type challenge. Use this instead of submit_flag when the challenge asks a question rather than requiring flag capture.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      answer: { type: 'string', description: 'The answer to the challenge question' },
+    },
+    required: ['answer'],
+  },
+};
+
+export const READ_FILE_SCHEMA = {
+  name: 'read_file',
+  description: 'Read a file from the sandbox filesystem. Returns the file contents (truncated if too large).',
+  input_schema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Absolute path to the file in the sandbox' },
+      encoding: { type: 'string', description: 'File encoding (default: utf-8). Use "base64" for binary files.', default: 'utf-8' },
+    },
+    required: ['path'],
+  },
+};
+
+export const WRITE_FILE_SCHEMA = {
+  name: 'write_file',
+  description: 'Write content to a file in the sandbox filesystem. Creates parent directories if needed.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Absolute path for the file in the sandbox' },
+      content: { type: 'string', description: 'Content to write to the file' },
+      mode: { type: 'string', description: 'File permissions (default: 644)', default: '644' },
+    },
+    required: ['path', 'content'],
+  },
+};
+
+export const LIST_DIR_SCHEMA = {
+  name: 'list_directory',
+  description: 'List files and directories at a path in the sandbox. Returns a detailed listing with permissions and sizes.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Directory path to list (default: /)', default: '/' },
+    },
+  },
+};
+
+export const HTTP_REQUEST_SCHEMA = {
+  name: 'http_request',
+  description: 'Make an HTTP request from within the sandbox. Returns status code, headers, and body.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'Target URL' },
+      method: { type: 'string', description: 'HTTP method (default: GET)', default: 'GET' },
+      headers: { type: 'object', description: 'Request headers as key-value pairs' },
+      body: { type: 'string', description: 'Request body (for POST/PUT)' },
+      follow_redirects: { type: 'boolean', description: 'Follow redirects (default: true)', default: true },
+    },
+    required: ['url'],
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Binary analysis tools (Ghidra)
+// ---------------------------------------------------------------------------
+
+export const DISASSEMBLE_SCHEMA = {
+  name: 'disassemble',
+  description: 'Disassemble a binary file at a specific function or address. Uses objdump/radare2 in the sandbox. For detailed analysis of binary challenges.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Path to the binary in the sandbox' },
+      function_name: { type: 'string', description: 'Function name to disassemble (e.g. "main")' },
+      address: { type: 'string', description: 'Address to disassemble from (e.g. "0x401000")' },
+    },
+    required: ['path'],
+  },
+};
+
+export const DECOMPILE_SCHEMA = {
+  name: 'decompile',
+  description: 'Decompile a binary to pseudo-C code. Uses Ghidra headless analysis if available, or falls back to objdump + strings analysis.',
+  input_schema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Path to the binary in the sandbox' },
+      function_name: { type: 'string', description: 'Function to decompile (default: all)' },
+    },
+    required: ['path'],
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Tool collections
+// ---------------------------------------------------------------------------
+
+import { COGNITIVE_TOOLS } from './cognitive.js';
+
+/** Tools for flag-based challenges (includes cognitive + binary tools). */
+export const FLAG_TOOLS = [
+  SANDBOX_EXEC_SCHEMA, SUBMIT_FLAG_SCHEMA,
+  READ_FILE_SCHEMA, WRITE_FILE_SCHEMA, LIST_DIR_SCHEMA, HTTP_REQUEST_SCHEMA,
+  DISASSEMBLE_SCHEMA, DECOMPILE_SCHEMA,
+  ...COGNITIVE_TOOLS,
+];
+
+/** Tools for question-based challenges (includes cognitive tools). */
+export const QUESTION_TOOLS = [
+  SANDBOX_EXEC_SCHEMA, SUBMIT_ANSWER_SCHEMA,
+  READ_FILE_SCHEMA, WRITE_FILE_SCHEMA, LIST_DIR_SCHEMA, HTTP_REQUEST_SCHEMA,
+  ...COGNITIVE_TOOLS,
+];
+
+/** All tools (backward compat — includes both submit types + cognitive + binary). */
+export const AGENT_TOOLS = [
+  SANDBOX_EXEC_SCHEMA, SUBMIT_FLAG_SCHEMA, SUBMIT_ANSWER_SCHEMA,
+  READ_FILE_SCHEMA, WRITE_FILE_SCHEMA, LIST_DIR_SCHEMA, HTTP_REQUEST_SCHEMA,
+  DISASSEMBLE_SCHEMA, DECOMPILE_SCHEMA,
+  ...COGNITIVE_TOOLS,
+];
+
+/**
+ * Get the appropriate tool set for a win condition.
+ * @param {'flag' | 'question'} winCondition
+ * @returns {object[]}
+ */
+export function getToolsForWinCondition(winCondition) {
+  return winCondition === 'question' ? QUESTION_TOOLS : FLAG_TOOLS;
+}
+
+// ---------------------------------------------------------------------------
+// Tool dispatch
+// ---------------------------------------------------------------------------
 
 /**
  * Dispatch a tool call within the sandbox.
  * @param {string} toolName
  * @param {object} toolInput
  * @param {import('./sandbox.js').SandboxContainer} sandbox
- * @returns {{ output: string, flagSubmitted?: string }}
+ * @returns {{ output: string, flagSubmitted?: string, answerSubmitted?: string }}
  */
 export function dispatchTool(toolName, toolInput, sandbox) {
-  if (toolName === 'sandbox_exec') {
-    const { command, timeout = 60 } = toolInput;
-    const result = sandbox.execTool(command, timeout);
-    let output = `Exit code: ${result.exitCode}\n`;
-    if (result.stdout) output += `STDOUT:\n${result.stdout.slice(0, MAX_OUTPUT_CHARS)}\n`;
-    if (result.stderr) output += `STDERR:\n${result.stderr.slice(0, MAX_OUTPUT_CHARS)}\n`;
-    if (result.stdout.length > MAX_OUTPUT_CHARS || result.stderr.length > MAX_OUTPUT_CHARS) {
-      output += '[output truncated]\n';
+  switch (toolName) {
+    case 'sandbox_exec': {
+      const { command, timeout = 60 } = toolInput;
+      const result = sandbox.execTool(command, timeout);
+      let output = `Exit code: ${result.exitCode}\n`;
+      if (result.stdout) output += `STDOUT:\n${result.stdout.slice(0, MAX_OUTPUT_CHARS)}\n`;
+      if (result.stderr) output += `STDERR:\n${result.stderr.slice(0, MAX_OUTPUT_CHARS)}\n`;
+      if (result.stdout.length > MAX_OUTPUT_CHARS || result.stderr.length > MAX_OUTPUT_CHARS) {
+        output += '[output truncated]\n';
+      }
+      return { output };
     }
-    return { output };
-  }
 
-  if (toolName === 'submit_flag') {
-    return { output: `Flag submitted: ${toolInput.flag}`, flagSubmitted: toolInput.flag };
-  }
+    case 'submit_flag':
+      return { output: `Flag submitted: ${toolInput.flag}`, flagSubmitted: toolInput.flag };
+
+    case 'submit_answer':
+      return { output: `Answer submitted: ${toolInput.answer}`, answerSubmitted: toolInput.answer };
+
+    case 'read_file': {
+      const { path, encoding = 'utf-8' } = toolInput;
+      const catCmd = encoding === 'base64'
+        ? `base64 < '${path.replace(/'/g, "'\\''")}'`
+        : `cat '${path.replace(/'/g, "'\\''")}'`;
+      const result = sandbox.execTool(catCmd);
+      if (result.exitCode !== 0) {
+        return { output: `Error reading ${path}: ${result.stderr.slice(0, 500)}` };
+      }
+      const content = result.stdout.slice(0, MAX_OUTPUT_CHARS);
+      const truncated = result.stdout.length > MAX_OUTPUT_CHARS ? '\n[truncated]' : '';
+      return { output: `File: ${path}\n${content}${truncated}` };
+    }
+
+    case 'write_file': {
+      const { path, content, mode = '644' } = toolInput;
+      // Escape content for shell
+      const escaped = content.replace(/'/g, "'\\''");
+      const dirCmd = `mkdir -p '${path.replace(/'/g, "'\\''").replace(/\/[^/]+$/, '')}'`;
+      const writeCmd = `${dirCmd} && printf '%s' '${escaped}' > '${path.replace(/'/g, "'\\''")}'`;
+      const chmodCmd = `${writeCmd} && chmod ${mode} '${path.replace(/'/g, "'\\''")}'`;
+      const result = sandbox.execTool(chmodCmd);
+      if (result.exitCode !== 0) {
+        return { output: `Error writing ${path}: ${result.stderr.slice(0, 500)}` };
+      }
+      return { output: `Written ${content.length} bytes to ${path} (mode ${mode})` };
+    }
 
-  return { output: `Unknown tool: ${toolName}` };
+    case 'list_directory': {
+      const dir = toolInput.path || '/';
+      const result = sandbox.execTool(`ls -la '${dir.replace(/'/g, "'\\''")}'`);
+      if (result.exitCode !== 0) {
+        return { output: `Error listing ${dir}: ${result.stderr.slice(0, 500)}` };
+      }
+      return { output: result.stdout.slice(0, MAX_OUTPUT_CHARS) };
+    }
+
+    case 'http_request': {
+      const { url, method = 'GET', headers = {}, body, follow_redirects = true } = toolInput;
+      const curlParts = ['curl', '-s', '-S', '-i'];
+      if (!follow_redirects) curlParts.push('--max-redirs', '0');
+      else curlParts.push('-L');
+      curlParts.push('-X', method.toUpperCase());
+      for (const [key, value] of Object.entries(headers)) {
+        curlParts.push('-H', `'${key}: ${String(value).replace(/'/g, "'\\''")}'`);
+      }
+      if (body) {
+        curlParts.push('-d', `'${body.replace(/'/g, "'\\''")}'`);
+      }
+      curlParts.push(`'${url.replace(/'/g, "'\\''")}'`);
+      const result = sandbox.execTool(curlParts.join(' '));
+      if (result.exitCode !== 0) {
+        return { output: `HTTP error: ${result.stderr.slice(0, 500)}` };
+      }
+      return { output: result.stdout.slice(0, MAX_OUTPUT_CHARS) };
+    }
+
+    case 'disassemble': {
+      const { path, function_name, address } = toolInput;
+      let cmd;
+      if (function_name) {
+        cmd = `objdump -d '${path.replace(/'/g, "'\\''")}'  | awk '/<${function_name}>:/,/^$/'`;
+      } else if (address) {
+        cmd = `objdump -d --start-address=${address} '${path.replace(/'/g, "'\\''")}'  | head -100`;
+      } else {
+        cmd = `objdump -d '${path.replace(/'/g, "'\\''")}'  | head -200`;
+      }
+      const result = sandbox.execTool(cmd);
+      if (result.exitCode !== 0) {
+        // Fallback: try file + strings
+        const fallback = sandbox.execTool(`file '${path.replace(/'/g, "'\\''")}'  && strings '${path.replace(/'/g, "'\\''")}'  | head -100`);
+        return { output: `Disassembly failed, fallback:\n${fallback.stdout.slice(0, MAX_OUTPUT_CHARS)}` };
+      }
+      return { output: result.stdout.slice(0, MAX_OUTPUT_CHARS) };
+    }
+
+    case 'decompile': {
+      const { path, function_name } = toolInput;
+      // Try Ghidra headless if available, otherwise fallback to analysis
+      const ghidraCheck = sandbox.execTool('which analyzeHeadless 2>/dev/null');
+      if (ghidraCheck.exitCode === 0) {
+        const funcArg = function_name ? `-process "${function_name}"` : '';
+        const cmd = `analyzeHeadless /tmp/ghidra_project proj -import '${path.replace(/'/g, "'\\''")}'  -postScript DecompileAll.java ${funcArg} 2>&1 | tail -200`;
+        const result = sandbox.execTool(cmd, 120);
+        return { output: result.stdout.slice(0, MAX_OUTPUT_CHARS) };
+      }
+      // Fallback: objdump + strings + file analysis
+      const analysis = sandbox.execTool(`echo "=== File Info ===" && file '${path.replace(/'/g, "'\\''")}'  && echo "\\n=== Sections ===" && objdump -h '${path.replace(/'/g, "'\\''")}'  2>/dev/null | head -30 && echo "\\n=== Strings ===" && strings '${path.replace(/'/g, "'\\''")}'  | head -50`);
+      return { output: `Ghidra not available. Static analysis:\n${analysis.stdout.slice(0, MAX_OUTPUT_CHARS)}` };
+    }
+
+    default:
+      return { output: `Unknown tool: ${toolName}` };
+  }
 }

package/lib/commands.js

@@ -49,10 +49,19 @@ export const COMMAND_MODES = {
   // ── Passthrough commands (direct Python spawn, full terminal) ──────────
   // These were Python-dependent — now ported to Node.js.
   scan:            { mode: 'native', description: 'Run a security scan' },
+  review:          { mode: 'native', description: 'Multi-layer code review (3 parallel analyzers)' },
+  panel:           { mode: 'native', description: 'Expert panel security assessment (3 personas)' },
+  shard:           { mode: 'native', description: 'Split large docs into semantic chunks' },
+  guardrail:       { mode: 'native', description: 'Test input/output guardrails' },
+  analyze:         { mode: 'native', description: 'Cross-artifact consistency analysis' },
   bot:             { mode: 'native', description: 'Manage bot integrations (long-running service)' },
   mcp:             { mode: 'native', description: 'MCP server tools (long-running service)' },
   api:             { mode: 'native', description: 'API management (long-running server)' },
   'setup-signal':  { mode: 'native', description: 'Configure Signal integration' },
+  chain:           { mode: 'native', description: 'Run multi-mode agent chain (e.g. red,purple,blue)' },
+  council:         { mode: 'native', description: 'Multi-model consensus evaluation' },
+  resume:          { mode: 'native', description: 'Resume interrupted autonomous sessions' },
+  benchmark:       { mode: 'native', description: 'Run benchmark suites (XBOW, NYU CTF, PicoCTF, OverTheWire)' },
 };
 
 /**