@probelabs/probe 0.6.0-rc231 → 0.6.0-rc233

package/build/agent/dsl/output-buffer-test.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * Quick E2E test of the output buffer feature.
+ */
+
+import { createDSLRuntime } from './runtime.js';
+
+const outputBuffer = { items: [] };
+const runtime = createDSLRuntime({
+  toolImplementations: {
+    search: { execute: async (p) => 'Result for: ' + p.query + '\nLine 1\nLine 2\nLine 3' },
+  },
+  llmCall: async (inst, data) => 'LLM processed: ' + String(data).substring(0, 50),
+  outputBuffer,
+});
+
+let passed = 0;
+let failed = 0;
+
+function check(name, condition) {
+  if (condition) {
+    console.log('  ✓ ' + name);
+    passed++;
+  } else {
+    console.log('  ✗ ' + name);
+    failed++;
+  }
+}
+
+// Test 1: output() writes to buffer, return value separate
+console.log('\nTest 1: output() + return');
+outputBuffer.items = [];
+const r1 = await runtime.execute(`
+  const data = search("test query");
+  output("## Full Results");
+  output(data);
+  return "Summary: found results";
+`, 'test 1');
+
+check('status is success', r1.status === 'success');
+check('return value correct', r1.result === 'Summary: found results');
+check('buffer has 2 items', outputBuffer.items.length === 2);
+check('buffer[0] is header', outputBuffer.items[0] === '## Full Results');
+check('buffer[1] has search data', outputBuffer.items[1].includes('Result for: test query'));
+check('logs include [output]', r1.logs.some(l => l.startsWith('[output]')));
+
+// Test 2: output() with JSON object
+console.log('\nTest 2: output() with JSON');
+outputBuffer.items = [];
+const r2 = await runtime.execute(`
+  output({ customers: ["Acme", "BigCo"], count: 2 });
+  return "Found 2 customers";
+`, 'test 2');
+
+check('status is success', r2.status === 'success');
+check('return is summary', r2.result === 'Found 2 customers');
+check('buffer has 1 item', outputBuffer.items.length === 1);
+const parsed = JSON.parse(outputBuffer.items[0]);
+check('parsed JSON correct', parsed.count === 2 && parsed.customers[0] === 'Acme');
+
+// Test 3: output() persists across calls (accumulates)
+console.log('\nTest 3: Accumulation across calls');
+outputBuffer.items = [];
+await runtime.execute(`output("first call")`, 'call 1');
+await runtime.execute(`output("second call")`, 'call 2');
+check('buffer has 2 items from 2 calls', outputBuffer.items.length === 2);
+check('items correct', outputBuffer.items[0] === 'first call' && outputBuffer.items[1] === 'second call');
+
+// Test 4: output() ignores null/undefined
+console.log('\nTest 4: Ignores null/undefined');
+outputBuffer.items = [];
+const r4 = await runtime.execute(`
+  output(null);
+  output(undefined);
+  output("real content");
+  return "done";
+`, 'test 4');
+check('buffer has only 1 item', outputBuffer.items.length === 1);
+check('only real content', outputBuffer.items[0] === 'real content');
+
+// Test 5: Large table simulation
+console.log('\nTest 5: Large table');
+outputBuffer.items = [];
+const r5 = await runtime.execute(`
+  var rows = [];
+  for (var i = 0; i < 100; i++) {
+    rows.push("| Customer " + i + " | Tech | Active |");
+  }
+  var header = "| Customer | Industry | Status |\\n| --- | --- | --- |\\n";
+  var table = header;
+  for (const row of rows) {
+    table = table + row + "\\n";
+  }
+  output(table);
+  return "Generated table with 100 customers";
+`, 'test 5');
+
+check('status is success', r5.status === 'success');
+check('return is summary', r5.result === 'Generated table with 100 customers');
+check('buffer has table', outputBuffer.items[0].includes('Customer 99'));
+check('table is large', outputBuffer.items[0].length > 2000);
+
+// Test 6: No outputBuffer = no output() function
+console.log('\nTest 6: No outputBuffer');
+const runtimeNoBuffer = createDSLRuntime({
+  toolImplementations: {
+    search: { execute: async (p) => 'ok' },
+  },
+  llmCall: async () => 'ok',
+});
+
+const r6 = await runtimeNoBuffer.execute(`
+  if (typeof output === "undefined") {
+    return "output not available";
+  }
+  return "output available";
+`, 'test 6');
+check('output not available without buffer', r6.result === 'output not available');
+
+// Summary
+console.log('\n' + '═'.repeat(50));
+console.log(`  Output Buffer E2E: ${passed} passed, ${failed} failed`);
+console.log('═'.repeat(50));
+process.exit(failed > 0 ? 1 : 0);

package/build/agent/dsl/pipeline-direct-test.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+/**
+ * Direct DSL runtime test against customer-insights repo.
+ * Bypasses ProbeAgent — runs scripts directly against the runtime.
+ */
+
+import { createDSLRuntime } from './runtime.js';
+import { search } from '../../search.js';
+import { extract } from '../../extract.js';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { generateText } from 'ai';
+import { config } from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '../../../..');
+config({ path: resolve(projectRoot, '.env') });
+
+const apiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
+if (!apiKey) { console.error('No API key'); process.exit(1); }
+
+const google = createGoogleGenerativeAI({ apiKey });
+
+async function llmCall(instruction, data, options = {}) {
+  const dataStr = data == null ? '' : (typeof data === 'string' ? data : JSON.stringify(data, null, 2));
+  const prompt = (dataStr || '(empty)').substring(0, 100000);
+  const result = await generateText({
+    model: google('gemini-2.5-flash'),
+    system: instruction,
+    prompt,
+    temperature: options.temperature || 0.3,
+    maxTokens: options.maxTokens || 4000,
+  });
+  return result.text;
+}
+
+const TARGET = '/tmp/customer-insights';
+
+const runtime = createDSLRuntime({
+  toolImplementations: {
+    search: { execute: async (params) => {
+      try {
+        return await search({ query: params.query, path: TARGET, maxTokens: 20000, timeout: 60 });
+      } catch(e) { return 'Search error: ' + e.message; }
+    }},
+    extract: { execute: async (params) => {
+      try {
+        return await extract({ targets: params.targets, cwd: TARGET });
+      } catch(e) { return 'Extract error: ' + e.message; }
+    }},
+    listFiles: { execute: async (params) => {
+      try {
+        return await search({ query: params.pattern || 'customer', path: TARGET, filesOnly: true, maxTokens: 10000, timeout: 60 });
+      } catch(e) { return 'listFiles error: ' + e.message; }
+    }},
+  },
+  llmCall,
+  mapConcurrency: 3,
+  timeoutMs: 300000,
+  maxLoopIterations: 5000,
+});
+
+console.log('═'.repeat(70));
+console.log('  Direct DSL Pipeline Test — customer-insights repo');
+console.log('═'.repeat(70));
+
+const start = Date.now();
+const result = await runtime.execute(`
+// Step 1: Broad search for customer data
+const results = search("customer onboarding playbook");
+log("Search returned " + String(results).length + " chars");
+
+// Step 2: Split into chunks and extract customer info using LLM
+const chunks = chunk(results);
+log("Split into " + chunks.length + " chunks");
+
+const classified = map(chunks, (c) => LLM(
+  "Extract customer names and their industry from this text. " +
+  "Return a JSON array: [{customer: string, industry: string, notes: string}]. " +
+  "Return ONLY valid JSON array, no other text.",
+  c
+));
+
+// Step 3: Accumulate parsed results
+var allCustomers = [];
+for (const batch of classified) {
+  try {
+    var text = String(batch).trim();
+    var jsonStart = text.indexOf("[");
+    var jsonEnd = text.lastIndexOf("]");
+    if (jsonStart >= 0 && jsonEnd > jsonStart) {
+      text = text.substring(jsonStart, jsonEnd + 1);
+    }
+    var parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) {
+      for (const item of parsed) { allCustomers.push(item); }
+    }
+  } catch (e) {
+    log("Parse error, skipping chunk");
+  }
+}
+
+log("Total customers extracted: " + allCustomers.length);
+
+// Step 4: Deduplicate
+var seen = {};
+var uniqueCustomers = [];
+for (const c of allCustomers) {
+  var key = String(c.customer || "").trim().toLowerCase();
+  if (key.length > 0 && !seen[key]) {
+    seen[key] = true;
+    uniqueCustomers.push(c);
+  }
+}
+
+log("Unique customers: " + uniqueCustomers.length);
+
+// Step 5: Build markdown table
+var table = "| Customer | Industry | Notes |\\n|---|---|---|\\n";
+for (const c of uniqueCustomers) {
+  table = table + "| " + (c.customer || "Unknown") + " | " + (c.industry || "Unknown") + " | " + (c.notes || "-") + " |\\n";
+}
+
+// Step 6: Small LLM summary
+const summary = LLM(
+  "Based on this customer table, write a brief 2-3 sentence summary of the customer base — what industries are represented, any patterns.",
+  table
+);
+
+return table + "\\n" + summary;
+`, 'Customer classification pipeline');
+
+const elapsed = Math.round((Date.now() - start) / 1000);
+
+console.log('\n' + '─'.repeat(70));
+console.log(`Status: ${result.status} (${elapsed}s)`);
+console.log(`Logs: ${result.logs.join(' | ')}`);
+
+if (result.status === 'error') {
+  console.log(`Error: ${result.error}`);
+} else {
+  console.log('─'.repeat(70));
+  console.log(result.result);
+}
+
+process.exit(result.status === 'error' ? 1 : 0);

package/build/agent/dsl/pipeline-test.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+/**
+ * Data pipeline end-to-end test using ProbeAgent with enableExecutePlan.
+ *
+ * Tests against the TykTechnologies/customer-insights repo (/tmp/customer-insights)
+ * to verify the full data pipeline flow:
+ *   1. Agent picks execute_plan for comprehensive/inventory questions
+ *   2. LLM generates DSL scripts with search → chunk → LLM classify → accumulate
+ *   3. Session store persists data across multi-step execution
+ *   4. Returns structured results (tables, JSON, reports)
+ *
+ * Usage:
+ *   node npm/src/agent/dsl/pipeline-test.mjs
+ *
+ * Requires:
+ *   - GOOGLE_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY in .env
+ *   - /tmp/customer-insights repo cloned
+ */
+
+import { ProbeAgent } from '../ProbeAgent.js';
+import { config } from 'dotenv';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, '../../../..');
+
+config({ path: resolve(projectRoot, '.env') });
+
+const apiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GOOGLE_API_KEY;
+if (!apiKey) {
+  console.error('ERROR: No Google API key found. Set GOOGLE_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY');
+  process.exit(1);
+}
+
+const TARGET_REPO = '/tmp/customer-insights';
+if (!existsSync(TARGET_REPO)) {
+  console.error('ERROR: customer-insights repo not found at ' + TARGET_REPO);
+  console.error('Clone it: git clone <repo-url> /tmp/customer-insights');
+  process.exit(1);
+}
+
+// ── Test definitions ──
+const tests = [
+  {
+    name: 'Customer classification — categorize all customers by industry/type',
+    query: 'Analyze ALL customer files in this repository. For every customer, classify them by industry (finance, tech, healthcare, government, etc.) and determine their use case type (API management, security, integration, etc.). Produce a comprehensive markdown table with columns: Customer, Industry, Use Case Type, and a brief note. Give me complete inventory.',
+    maxIterations: 50,
+    timeoutMs: 300000,
+    check: (result, toolCalls) => {
+      // Should have triggered execute_plan
+      const usedExecutePlan = toolCalls.some(t => t === 'execute_plan');
+      if (!usedExecutePlan) return 'Did not trigger execute_plan — used: ' + toolCalls.join(', ');
+      // Result should be substantial
+      if (!result || result.length < 200) return 'Result too short: ' + (result?.length || 0);
+      return true;
+    },
+  },
+  {
+    name: 'Sentiment & pain points extraction — data pipeline pattern',
+    query: 'Go through every customer document in this repo. For each customer, extract their main pain points and sentiment (positive, neutral, negative) about Tyk. Produce a structured report with: 1) A summary table of sentiment distribution, 2) Top 5 most common pain points with customer counts, 3) Customers with negative sentiment and why. Be comprehensive — cover ALL customers.',
+    maxIterations: 50,
+    timeoutMs: 300000,
+    check: (result, toolCalls) => {
+      const usedExecutePlan = toolCalls.some(t => t === 'execute_plan');
+      if (!usedExecutePlan) return 'Did not trigger execute_plan';
+      if (!result || result.length < 200) return 'Result too short: ' + (result?.length || 0);
+      return true;
+    },
+  },
+  {
+    name: 'Feature adoption matrix — multi-search data pipeline',
+    query: 'Create a complete feature adoption matrix for this customer base. Search for mentions of: API gateway, dashboard, developer portal, analytics, rate limiting, authentication, policies, and GraphQL. For each feature, list which customers use it. Return a markdown table where rows are features and columns show customer count + list of customer names.',
+    maxIterations: 50,
+    timeoutMs: 300000,
+    check: (result, toolCalls) => {
+      const usedExecutePlan = toolCalls.some(t => t === 'execute_plan');
+      if (!usedExecutePlan) return 'Did not trigger execute_plan';
+      if (!result || result.length < 100) return 'Result too short: ' + (result?.length || 0);
+      return true;
+    },
+  },
+];
+
+// ── Test runner ──
+let testNum = 0;
+let passed = 0;
+let failed = 0;
+
+async function runPipelineTest(test) {
+  testNum++;
+  console.log(`\n${'═'.repeat(70)}`);
+  console.log(`▶ Test ${testNum}/${tests.length}: ${test.name}`);
+  console.log(`  Query: "${test.query.substring(0, 120)}..."`);
+  console.log('─'.repeat(70));
+
+  const toolCalls = [];
+  const toolDetails = [];
+
+  const agent = new ProbeAgent({
+    path: TARGET_REPO,
+    provider: 'google',
+    model: 'gemini-2.5-flash',
+    enableExecutePlan: true,
+    maxIterations: test.maxIterations || 50,
+  });
+
+  // Listen for tool call events
+  agent.events.on('toolCall', (event) => {
+    if (event.status === 'started') {
+      toolCalls.push(event.name);
+      const desc = event.description ? ` — ${event.description.substring(0, 80)}` : '';
+      console.log(`  [tool:start] ${event.name}${desc}`);
+    }
+    if (event.status === 'completed') {
+      const preview = event.resultPreview || '';
+      console.log(`  [tool:done]  ${event.name} (${String(preview).length} chars preview)`);
+    }
+    if (event.status === 'error') {
+      console.log(`  [tool:error] ${event.name}: ${event.error?.substring(0, 100)}`);
+    }
+  });
+
+  await agent.initialize();
+
+  const start = Date.now();
+  let result;
+  try {
+    result = await Promise.race([
+      agent.answer(test.query),
+      new Promise((_, reject) =>
+        setTimeout(() => reject(new Error('Test timeout')), test.timeoutMs || 180000)
+      ),
+    ]);
+  } catch (e) {
+    const elapsed = Math.round((Date.now() - start) / 1000);
+    console.log(`\n  [warn] Agent finished with: ${e.message?.substring(0, 150)} (${elapsed}s)`);
+    // Still check what we got — agent may have partial result
+    result = e.message;
+  }
+
+  const elapsed = Math.round((Date.now() - start) / 1000);
+
+  console.log('─'.repeat(70));
+  console.log(`  Duration: ${elapsed}s`);
+  console.log(`  Tool calls: [${toolCalls.join(', ')}]`);
+  console.log(`  execute_plan used: ${toolCalls.includes('execute_plan') ? 'YES' : 'NO'}`);
+
+  const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+  console.log(`  Result length: ${resultStr?.length || 0} chars`);
+
+  // Show result preview
+  if (resultStr) {
+    console.log('─'.repeat(70));
+    console.log('  Result preview:');
+    const lines = resultStr.split('\n').slice(0, 25);
+    for (const line of lines) {
+      console.log('  │ ' + line.substring(0, 100));
+    }
+    if (resultStr.split('\n').length > 25) {
+      console.log('  │ ... (' + (resultStr.split('\n').length - 25) + ' more lines)');
+    }
+  }
+
+  // Run check
+  const checkResult = test.check(resultStr, toolCalls);
+  if (checkResult === true) {
+    console.log(`\n  ✓ PASSED (${elapsed}s)`);
+    passed++;
+  } else {
+    console.log(`\n  ✗ FAILED — ${checkResult} (${elapsed}s)`);
+    failed++;
+  }
+
+  // Token usage
+  try {
+    const usage = agent.getTokenUsage();
+    if (usage) {
+      console.log(`  Tokens: input=${usage.inputTokens || 0} output=${usage.outputTokens || 0} total=${usage.totalTokens || 0}`);
+    }
+  } catch (e) {
+    // ignore
+  }
+
+  try {
+    await agent.close();
+  } catch (e) {
+    // ignore cleanup errors
+  }
+}
+
+// ── Main ──
+async function main() {
+  console.log('═'.repeat(70));
+  console.log('  Data Pipeline E2E Tests — ProbeAgent + execute_plan');
+  console.log('  Target: TykTechnologies/customer-insights');
+  console.log('  Config: enableExecutePlan=true, provider=google, model=gemini-2.5-flash');
+  console.log('═'.repeat(70));
+
+  // Allow running a specific test by number
+  const testIndex = process.argv[2] ? parseInt(process.argv[2], 10) - 1 : null;
+
+  if (testIndex !== null && testIndex >= 0 && testIndex < tests.length) {
+    console.log(`\nRunning test ${testIndex + 1} only: "${tests[testIndex].name}"`);
+    await runPipelineTest(tests[testIndex]);
+  } else {
+    for (const test of tests) {
+      await runPipelineTest(test);
+    }
+  }
+
+  console.log(`\n${'═'.repeat(70)}`);
+  console.log(`  Results: ${passed} passed, ${failed} failed, ${testNum} total`);
+  console.log('═'.repeat(70));
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch(e => {
+  console.error('Fatal error:', e);
+  process.exit(1);
+});

package/build/agent/dsl/runtime.js

@@ -0,0 +1,206 @@
+/**
+ * DSL Runtime - SandboxJS execution engine.
+ *
+ * Orchestrates the full pipeline:
+ * 1. Validate (AST whitelist)
+ * 2. Transform (inject await, wrap in async IIFE)
+ * 3. Execute in SandboxJS with tool globals + timeout
+ *
+ * Returns the result or a structured error.
+ */
+
+import SandboxModule from '@nyariv/sandboxjs';
+import { validateDSL } from './validator.js';
+import { transformDSL } from './transformer.js';
+import { generateSandboxGlobals, getAsyncFunctionNames } from './environment.js';
+
+const Sandbox = SandboxModule.default || SandboxModule;
+
+/**
+ * Create a DSL runtime instance.
+ *
+ * @param {Object} options
+ * @param {Object} options.toolImplementations - Native tool execute functions
+ * @param {Object} [options.mcpBridge] - MCP bridge for calling MCP tools
+ * @param {Object} [options.mcpTools={}] - MCP tool metadata
+ * @param {Function} options.llmCall - Function for LLM() calls: (instruction, data, options?) => Promise<any>
+ * @param {number} [options.mapConcurrency=3] - Concurrency limit for map()
+ * @param {number} [options.timeoutMs=120000] - Execution timeout in milliseconds (default 2 min)
+ * @param {number} [options.maxLoopIterations=5000] - Max iterations for while/for loops
+ * @param {Object} [options.tracer=null] - SimpleAppTracer instance for OTEL telemetry
+ * @returns {Object} Runtime with execute() method
+ */
+export function createDSLRuntime(options) {
+  const {
+    toolImplementations = {},
+    mcpBridge = null,
+    mcpTools = {},
+    llmCall,
+    mapConcurrency = 3,
+    timeoutMs = 120000,
+    maxLoopIterations = 5000,
+    tracer = null,
+    sessionStore = {},
+    outputBuffer = null,
+  } = options;
+
+  // Generate the globals and async function names, passing tracer for per-call tracing
+  const toolGlobals = generateSandboxGlobals({
+    toolImplementations,
+    mcpBridge,
+    mcpTools,
+    llmCall,
+    mapConcurrency,
+    tracer,
+    sessionStore,
+    outputBuffer,
+  });
+
+  const asyncFunctionNames = getAsyncFunctionNames(mcpTools);
+
+  /**
+   * Execute DSL code.
+   *
+   * @param {string} code - The LLM-generated DSL code (sync-looking)
+   * @param {string} [description] - Human-readable description for logging
+   * @returns {Promise<{ status: 'success'|'error', result?: any, error?: string, logs: string[] }>}
+   */
+  async function execute(code, description) {
+    const logs = [];
+    const startTime = Date.now();
+
+    // Step 1: Validate
+    tracer?.addEvent?.('dsl.phase.validate_start', {
+      'dsl.code_length': code.length,
+    });
+
+    const validation = validateDSL(code);
+    if (!validation.valid) {
+      tracer?.addEvent?.('dsl.phase.validate_failed', {
+        'dsl.error_count': validation.errors.length,
+        'dsl.errors': validation.errors.join('; ').substring(0, 500),
+      });
+      return {
+        status: 'error',
+        error: `Validation failed:\n${validation.errors.join('\n')}`,
+        logs,
+      };
+    }
+
+    tracer?.addEvent?.('dsl.phase.validate_complete');
+
+    // Step 2: Transform (inject await, wrap in async IIFE)
+    let transformedCode;
+    try {
+      tracer?.addEvent?.('dsl.phase.transform_start');
+      transformedCode = transformDSL(code, asyncFunctionNames);
+      tracer?.addEvent?.('dsl.phase.transform_complete', {
+        'dsl.transformed_length': transformedCode.length,
+      });
+    } catch (e) {
+      tracer?.addEvent?.('dsl.phase.transform_failed', {
+        'dsl.error': e.message,
+      });
+      return {
+        status: 'error',
+        error: `Transform failed: ${e.message}`,
+        logs,
+      };
+    }
+
+    // Step 3: Execute in SandboxJS with timeout
+    tracer?.addEvent?.('dsl.phase.execute_start', {
+      'dsl.timeout_ms': timeoutMs,
+      'dsl.max_loop_iterations': maxLoopIterations,
+    });
+
+    try {
+      // Set up log collector
+      toolGlobals._logs = logs;
+
+      // Loop iteration counter for infinite loop protection
+      let loopIterations = 0;
+      toolGlobals.__checkLoop = () => {
+        loopIterations++;
+        if (loopIterations > maxLoopIterations) {
+          throw new Error(`Loop exceeded maximum of ${maxLoopIterations} iterations. Use break to exit loops earlier or process fewer items.`);
+        }
+      };
+
+      const sandbox = new Sandbox({
+        globals: {
+          ...Sandbox.SAFE_GLOBALS,
+          ...toolGlobals,
+          // Override: remove dangerous globals that SAFE_GLOBALS might include
+          Function: undefined,
+          eval: undefined,
+        },
+        prototypeWhitelist: Sandbox.SAFE_PROTOTYPES,
+      });
+
+      const exec = sandbox.compileAsync(transformedCode);
+
+      // Catch unhandled rejections from SandboxJS async error propagation
+      let escapedError = null;
+      const rejectionHandler = (reason) => {
+        escapedError = reason;
+      };
+      process.on('unhandledRejection', rejectionHandler);
+
+      // Race execution against timeout
+      let timeoutHandle;
+      const executionPromise = exec().run();
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`Execution timed out after ${Math.round(timeoutMs / 1000)}s. Script took too long — reduce the amount of work (fewer items, smaller data) or increase timeout.`));
+        }, timeoutMs);
+      });
+
+      let result;
+      try {
+        result = await Promise.race([executionPromise, timeoutPromise]);
+      } finally {
+        clearTimeout(timeoutHandle);
+        // Delay handler removal — SandboxJS can throw async errors after execution completes
+        setTimeout(() => {
+          process.removeListener('unhandledRejection', rejectionHandler);
+        }, 500);
+      }
+
+      // Check for escaped async errors
+      if (escapedError) {
+        throw escapedError;
+      }
+
+      const elapsed = Date.now() - startTime;
+      logs.push(`[runtime] Completed in ${elapsed}ms`);
+
+      tracer?.addEvent?.('dsl.phase.execute_complete', {
+        'dsl.duration_ms': elapsed,
+        'dsl.loop_iterations': loopIterations,
+      });
+
+      return {
+        status: 'success',
+        result,
+        logs,
+      };
+    } catch (e) {
+      const elapsed = Date.now() - startTime;
+      logs.push(`[runtime] Failed after ${elapsed}ms`);
+
+      tracer?.addEvent?.('dsl.phase.execute_failed', {
+        'dsl.duration_ms': elapsed,
+        'dsl.error': e.message?.substring(0, 500),
+      });
+
+      return {
+        status: 'error',
+        error: `Execution failed: ${e.message}`,
+        logs,
+      };
+    }
+  }
+
+  return { execute };
+}