minovative-mind-cli 2.14.1 → 2.14.3

package/dist/utils/analysisRunner.js

@@ -1,10 +1,8 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
+import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-const execAsync = promisify(exec);
 /** Supported language aliases map. */
 const LANGUAGE_ALIASES = {
     js: 'node',
@@ -56,6 +54,85 @@ export const SUPPORTED_LANGUAGES = [
     'php',
     'java',
 ];
+/**
+ * High-performance Least-Recently-Used (LRU) environment and runner cache with per-item TTL.
+ * Prevents repetitive filesystem traversal and binary probing across ephemeral executions.
+ */
+export class EnvironmentLRUCache {
+    cache = new Map();
+    max;
+    ttlMs;
+    constructor(max = 100, ttlMs = 30_000) {
+        this.max = max;
+        this.ttlMs = ttlMs;
+    }
+    get size() {
+        return this.cache.size;
+    }
+    clear() {
+        this.cache.clear();
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        // Refresh LRU order (delete & re-insert)
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.value;
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    set(key, value, ttlMs) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.max) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+            }
+        }
+        this.cache.set(key, {
+            expiresAt: Date.now() + (ttlMs ?? this.ttlMs),
+            value,
+        });
+    }
+}
+// Global LRU cache instances for workspace runner probes
+const tsRunnerCache = new EnvironmentLRUCache(100, 30_000);
+const pyEnvCache = new EnvironmentLRUCache(100, 30_000);
+const moduleTypeCache = new EnvironmentLRUCache(100, 30_000);
+const projectRuntimeCache = new EnvironmentLRUCache(100, 30_000);
+/**
+ * Clears cached environment and runner resolution data.
+ * If workspaceRoot is provided, invalidates cache entries for that workspace;
+ * otherwise, clears all cached runner environments globally.
+ *
+ * @param workspaceRoot - Optional workspace root directory to invalidate.
+ */
+export function clearRunnerCache(workspaceRoot) {
+    if (workspaceRoot) {
+        tsRunnerCache.delete(workspaceRoot);
+        pyEnvCache.delete(workspaceRoot);
+        moduleTypeCache.delete(workspaceRoot);
+        projectRuntimeCache.delete(workspaceRoot);
+    }
+    else {
+        tsRunnerCache.clear();
+        pyEnvCache.clear();
+        moduleTypeCache.clear();
+        projectRuntimeCache.clear();
+    }
+}
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
@@ -141,11 +218,15 @@ export function detectLanguageFromCode(code) {
 }
 /**
  * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ * Caches results per workspace root via LRU cache.
  *
  * @param workspaceRoot - Path to the workspace root directory.
  * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
  */
 export async function detectProjectRuntime(workspaceRoot) {
+    const cached = projectRuntimeCache.get(workspaceRoot);
+    if (cached)
+        return cached;
     const probeFiles = [
         { file: 'Cargo.toml', runtime: 'rust' },
         { file: 'go.mod', runtime: 'go' },
@@ -164,12 +245,14 @@ export async function detectProjectRuntime(workspaceRoot) {
     for (const { file, runtime } of probeFiles) {
         try {
             await fs.access(path.join(workspaceRoot, file));
+            projectRuntimeCache.set(workspaceRoot, runtime);
             return runtime;
         }
         catch {
             // Continue searching
         }
     }
+    projectRuntimeCache.set(workspaceRoot, 'node');
     return 'node';
 }
 /**
@@ -194,16 +277,22 @@ export async function resolveEffectiveRuntime(workspaceRoot, language, code) {
 }
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
- * Returns `'module'` or `'commonjs'`.
+ * Returns `'module'` or `'commonjs'`. Caches results per workspace root via LRU cache.
  */
 export async function detectWorkspaceModuleType(workspaceRoot) {
+    const cached = moduleTypeCache.get(workspaceRoot);
+    if (cached)
+        return cached;
     try {
         const pkgPath = path.join(workspaceRoot, 'package.json');
         const content = await fs.readFile(pkgPath, 'utf-8');
         const pkg = JSON.parse(content);
-        return pkg.type === 'module' ? 'module' : 'commonjs';
+        const result = pkg.type === 'module' ? 'module' : 'commonjs';
+        moduleTypeCache.set(workspaceRoot, result);
+        return result;
     }
     catch {
+        moduleTypeCache.set(workspaceRoot, 'commonjs');
         return 'commonjs';
     }
 }
@@ -254,44 +343,574 @@ function buildTempPath(code, ext) {
     return path.join(os.tmpdir(), `.mino-analysis-${hash}-${nonce}${ext}`);
 }
 /**
- * Constructs the shell command for executing the given language runtime.
- * Returns null for unsupported languages.
+ * Probes the workspace for available TypeScript runners (tsx, ts-node-esm, ts-node)
+ * and resolves tsconfig.json configuration for path aliases.
+ * Caches results per workspace root via LRU cache.
+ *
+ * @param workspaceRoot - Path to the root directory of the workspace.
+ * @returns Runner info with executable command and tsconfig path if available.
+ */
+export async function findTypeScriptRunner(workspaceRoot) {
+    const cached = tsRunnerCache.get(workspaceRoot);
+    if (cached)
+        return cached;
+    const binDir = path.join(workspaceRoot, 'node_modules', '.bin');
+    const isWin = os.platform() === 'win32';
+    const tsconfigPath = path.join(workspaceRoot, 'tsconfig.json');
+    let hasTsconfig = false;
+    try {
+        await fs.access(tsconfigPath);
+        hasTsconfig = true;
+    }
+    catch {
+        // tsconfig not present in root
+    }
+    // 1. Prefer local workspace tsx if installed (fastest, native ESM/CJS and tsconfig paths support)
+    const tsxBin = path.join(binDir, isWin ? 'tsx.cmd' : 'tsx');
+    try {
+        await fs.access(tsxBin);
+        const result = {
+            runnerType: 'local-tsx',
+            command: `"${tsxBin}"`,
+            binaryPath: tsxBin,
+            tsconfigPath: hasTsconfig ? tsconfigPath : undefined,
+        };
+        tsRunnerCache.set(workspaceRoot, result);
+        return result;
+    }
+    catch {
+        // Continue probing
+    }
+    // 2. Check workspace module type for ts-node variant
+    const moduleType = await detectWorkspaceModuleType(workspaceRoot);
+    if (moduleType === 'module') {
+        const tsNodeEsmBin = path.join(binDir, isWin ? 'ts-node-esm.cmd' : 'ts-node-esm');
+        try {
+            await fs.access(tsNodeEsmBin);
+            const result = {
+                runnerType: 'local-ts-node-esm',
+                command: `"${tsNodeEsmBin}"`,
+                binaryPath: tsNodeEsmBin,
+                tsconfigPath: hasTsconfig ? tsconfigPath : undefined,
+            };
+            tsRunnerCache.set(workspaceRoot, result);
+            return result;
+        }
+        catch {
+            // Continue probing
+        }
+    }
+    // 3. Check local ts-node binary
+    const tsNodeBin = path.join(binDir, isWin ? 'ts-node.cmd' : 'ts-node');
+    try {
+        await fs.access(tsNodeBin);
+        const extraFlag = moduleType === 'module' ? '--esm ' : '';
+        const result = {
+            runnerType: 'local-ts-node',
+            command: `"${tsNodeBin}" ${extraFlag}`.trim(),
+            binaryPath: tsNodeBin,
+            tsconfigPath: hasTsconfig ? tsconfigPath : undefined,
+        };
+        tsRunnerCache.set(workspaceRoot, result);
+        return result;
+    }
+    catch {
+        // Continue probing
+    }
+    // 4. Default fallback: npx tsx (preferred) or npx ts-node
+    const result = {
+        runnerType: 'npx-tsx',
+        command: 'npx tsx',
+        binaryPath: 'npx',
+        tsconfigPath: hasTsconfig ? tsconfigPath : undefined,
+    };
+    tsRunnerCache.set(workspaceRoot, result);
+    return result;
+}
+/**
+ * Probes the workspace for virtual environments (.venv, venv, env, .env, virtualenv)
+ * and resolves the appropriate Python binary path and environment directories.
+ * Caches results per workspace root via LRU cache.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @returns Detected Python interpreter binary and virtual environment metadata.
  */
-function buildCommand(language, scriptPath) {
+export async function findPythonBinary(workspaceRoot) {
+    const cached = pyEnvCache.get(workspaceRoot);
+    if (cached)
+        return cached;
+    const isWin = os.platform() === 'win32';
+    const candidateDirs = ['.venv', 'venv', 'env', '.env', 'virtualenv', '.virtualenv'];
+    for (const dir of candidateDirs) {
+        const venvDir = path.join(workspaceRoot, dir);
+        const probeBinaries = isWin
+            ? [
+                path.join(venvDir, 'Scripts', 'python.exe'),
+                path.join(venvDir, 'python.exe'),
+                path.join(venvDir, 'Scripts', 'python.cmd'),
+            ]
+            : [
+                path.join(venvDir, 'bin', 'python'),
+                path.join(venvDir, 'bin', 'python3'),
+                path.join(venvDir, 'bin', 'python.exe'),
+            ];
+        for (const binPath of probeBinaries) {
+            try {
+                await fs.access(binPath);
+                const result = {
+                    pythonBin: binPath,
+                    isVenv: true,
+                    venvDir,
+                    binDir: path.dirname(binPath),
+                };
+                pyEnvCache.set(workspaceRoot, result);
+                return result;
+            }
+            catch {
+                // Continue probing
+            }
+        }
+    }
+    const fallback = {
+        pythonBin: 'python3',
+        isVenv: false,
+    };
+    pyEnvCache.set(workspaceRoot, fallback);
+    return fallback;
+}
+/**
+ * Injects sandbox query helpers into user/agent script source code.
+ * Provides preloaded `emitResult` / `__emitResult` (structured JSON emission via dedicated FD-3 with stdout fallback)
+ * and `inspectSymbols` / `inspectObject` (reflection & AST property analysis).
+ *
+ * Preserves 1:1 source line offsets so compiler/runtime stack traces and syntax diagnostics
+ * accurately align with original source lines.
+ *
+ * @param code - Raw source code of the script.
+ * @param language - Target runtime language.
+ * @returns Source code augmented with runtime-specific helper preambles.
+ */
+export function injectSandboxHelpers(code, language) {
     const normLang = normalizeLanguage(language);
-    const binExt = os.platform() === 'win32' ? '.exe' : '';
-    switch (normLang) {
-        case 'node':
-            return `node "${scriptPath}"`;
-        case 'ts-node':
-            return `npx ts-node "${scriptPath}"`;
-        case 'python':
-            return `python3 "${scriptPath}"`;
-        case 'bash':
-            return `bash "${scriptPath}"`;
-        case 'go':
-            return `go run "${scriptPath}"`;
-        case 'rust': {
-            const binPath = scriptPath.replace(/\.rs$/, binExt);
-            return `rustc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+    if (code.includes('__MINO_PREAMBLE_START__')) {
+        return code;
+    }
+    if (normLang === 'node' || normLang === 'ts-node') {
+        // Single-line preamble preserving exact 1:1 line offsets
+        const preamble = `/* __MINO_PREAMBLE_START__ */ if (typeof globalThis.emitResult === 'undefined') { globalThis.emitResult = (data) => { const payload = typeof data === 'string' ? data : JSON.stringify(data); try { const _fs = typeof require !== 'undefined' ? require('node:fs') : (typeof process !== 'undefined' && process.getBuiltinModule ? process.getBuiltinModule('node:fs') : null); if (_fs && _fs.writeSync) { _fs.writeSync(3, payload + '\\n'); return; } } catch {} console.log('__MINO_RESULT__' + payload + '__MINO_RESULT__'); }; globalThis.__emitResult = globalThis.emitResult; } if (typeof globalThis.inspectSymbols === 'undefined') { globalThis.inspectSymbols = (target) => { if (target === null || target === undefined) return []; const symbols = []; const seen = new Set(); let curr = target; let depth = 0; while (curr && depth < 2) { for (const key of Object.getOwnPropertyNames(curr)) { if (key === 'constructor' && depth > 0) continue; if (seen.has(key)) continue; seen.add(key); let val; let type = 'unknown'; let isFunc = false; try { val = curr[key]; type = typeof val; isFunc = type === 'function'; } catch { type = 'inaccessible'; } symbols.push({ name: key, type, isFunction: isFunc, inherited: depth > 0 }); } curr = Object.getPrototypeOf(curr); depth++; if (curr === Object.prototype) break; } return symbols; }; globalThis.inspectObject = globalThis.inspectSymbols; } /* __MINO_PREAMBLE_END__ */ `;
+        if (code.startsWith('#!')) {
+            const firstLineEnd = code.indexOf('\n');
+            if (firstLineEnd !== -1) {
+                const shebang = code.slice(0, firstLineEnd + 1);
+                const rest = code.slice(firstLineEnd + 1);
+                return shebang + preamble + rest;
+            }
         }
-        case 'c': {
-            const binPath = scriptPath.replace(/\.c$/, binExt);
-            return `gcc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+        return preamble + code;
+    }
+    if (normLang === 'python') {
+        const preamble = `# __MINO_PREAMBLE_START__
+import json as _mino_json
+import inspect as _mino_inspect
+import os as _mino_os
+
+def emitResult(data):
+    payload = data if isinstance(data, str) else _mino_json.dumps(data)
+    try:
+        _mino_os.write(3, (payload + '\\n').encode('utf-8'))
+    except Exception:
+        print(f"__MINO_RESULT__{payload}__MINO_RESULT__")
+
+__emitResult = emitResult
+
+def inspect_symbols(target):
+    symbols = []
+    if target is None:
+        return symbols
+    for name in dir(target):
+        if name.startswith('__') and name.endswith('__'):
+            continue
+        try:
+            val = getattr(target, name)
+            is_fn = _mino_inspect.isfunction(val) or _mino_inspect.ismethod(val) or _mino_inspect.isbuiltin(val)
+            is_cls = _mino_inspect.isclass(val)
+            t_name = type(val).__name__
+            symbols.append({
+                "name": name,
+                "type": t_name,
+                "is_callable": callable(val),
+                "is_function": is_fn,
+                "is_class": is_cls
+            })
+        except Exception:
+            symbols.append({"name": name, "type": "unknown", "is_callable": False})
+    return symbols
+
+inspectSymbols = inspect_symbols
+inspect_object = inspect_symbols
+inspectObject = inspect_symbols
+# __MINO_PREAMBLE_END__\n`;
+        const lines = code.split('\n');
+        const headerLines = [];
+        const restLines = [];
+        let inHeader = true;
+        for (const line of lines) {
+            const stripped = line.trim();
+            if (inHeader &&
+                (stripped.startsWith('#') ||
+                    stripped.startsWith('from __future__') ||
+                    stripped === '')) {
+                headerLines.push(line);
+            }
+            else {
+                inHeader = false;
+                restLines.push(line);
+            }
         }
-        case 'cpp': {
-            const binPath = scriptPath.replace(/\.cpp$/, binExt);
-            return `g++ -std=c++17 "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+        if (headerLines.length > 0) {
+            return headerLines.join('\n') + '\n' + preamble + restLines.join('\n');
         }
-        case 'ruby':
-            return `ruby "${scriptPath}"`;
-        case 'php':
-            return `php "${scriptPath}"`;
-        case 'java':
-            return `java "${scriptPath}"`;
-        default:
-            return null;
+        return preamble + code;
+    }
+    return code;
+}
+/**
+ * Parses universal structured result markers (__MINO_RESULT__) from stdout stream.
+ * Returns the cleaned human-readable stdout and the parsed structured result object/primitive.
+ *
+ * @param stdout - Captured standard output text.
+ */
+export function parseStructuredResult(stdout) {
+    const resultRegex = /__MINO_RESULT__([\s\S]*?)__MINO_RESULT__/g;
+    let match;
+    let lastPayload;
+    while ((match = resultRegex.exec(stdout)) !== null) {
+        lastPayload = match[1].trim();
+    }
+    let structuredResult;
+    if (lastPayload !== undefined) {
+        try {
+            structuredResult = JSON.parse(lastPayload);
+        }
+        catch {
+            structuredResult = lastPayload;
+        }
+    }
+    const cleanedStdout = stdout
+        .replace(/__MINO_RESULT__[\s\S]*?__MINO_RESULT__/g, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return { cleanedStdout, structuredResult };
+}
+/**
+ * Diagnostic-first error middleware for sandbox script execution.
+ * Intercepts common sandbox execution traps (module resolution, ESM/CJS mismatch,
+ * Python import errors, TypeScript compile failures, linker errors) and produces
+ * actionable remediation advisories.
+ *
+ * @param stderr - Standard error output.
+ * @param stdout - Standard output text.
+ * @param language - Runtime language identifier.
+ * @param workspaceRoot - Path to workspace root directory.
+ * @returns Formatted diagnostic advisory string or null if no matching pattern.
+ */
+export function diagnoseSandboxError(stderr, stdout, language, workspaceRoot) {
+    const combined = `${stderr}\n${stdout}`;
+    const diagnostics = [];
+    // 1. Module not found (Node/TypeScript)
+    if (/ERR_MODULE_NOT_FOUND|Cannot find module\s+'([^']+)'|Cannot find package\s+'([^']+)'/i.test(combined)) {
+        const match = combined.match(/Cannot find (?:module|package)\s+'([^']+)'/i);
+        const mod = match ? match[1] : 'the requested package';
+        diagnostics.push(`• Cause: Module resolution failure for '${mod}'.\n` +
+            `• Action: Ensure '${mod}' is installed in workspace node_modules (e.g. npm install ${mod}).\n` +
+            `  If referencing a local file, ensure relative path and extension (.js, .ts, .mjs) are correct.\n` +
+            `  Note: NODE_PATH is configured to search ${workspaceRoot ? path.join(workspaceRoot, 'node_modules') : 'workspace node_modules'}.`);
+    }
+    // 2. ESM / CommonJS mismatch
+    if (/ERR_REQUIRE_ESM|Must use import to load ES Module|require\(\) of ES Module/i.test(combined)) {
+        diagnostics.push(`• Cause: CommonJS require() attempted to load an ES Module.\n` +
+            `• Action: Use dynamic import(...) or standard 'import ... from ...' syntax with .mjs or tsx runtime.`);
+    }
+    else if (/Cannot use import statement outside a module/i.test(combined)) {
+        diagnostics.push(`• Cause: Static ES Module import used in CommonJS execution context.\n` +
+            `• Action: Rename script to use .mjs or execute with ts-node/tsx runtime.`);
+    }
+    // 3. Python ModuleNotFoundError / ImportError
+    if (/ModuleNotFoundError:\s*No module named\s+'([^']+)'|ImportError:\s*(?:cannot import name\s+'([^']+)'|No module named\s+'([^']+)')/i.test(combined)) {
+        const match = combined.match(/No module named\s+'([^']+)'|cannot import name\s+'([^']+)'/i);
+        const mod = match ? match[1] || match[2] : 'requested module';
+        diagnostics.push(`• Cause: Python module '${mod}' could not be imported.\n` +
+            `• Action: Verify that '${mod}' is installed in your virtual environment (.venv / venv) or requirements.txt.\n` +
+            `  Note: PYTHONPATH is pre-configured to include workspace root and src directory.`);
+    }
+    // 4. TypeScript compiler error
+    if (/error TS\d{4}:|TS\d{4}:/i.test(combined)) {
+        const tsCode = combined.match(/TS(\d{4})/i)?.[0] || 'TS Error';
+        diagnostics.push(`• Cause: TypeScript compiler reported an issue (${tsCode}).\n` +
+            `• Action: Verify type definitions and tsconfig.json path mappings.\n` +
+            `  For ephemeral debugging scripts, add '// @ts-nocheck' at the top of the script to bypass static type checks.`);
+    }
+    // 5. Rust crate / import errors
+    if (/error\[E0432\]|error\[E0463\]|can't find crate/i.test(combined)) {
+        diagnostics.push(`• Cause: Rust crate or unresolved import.\n` +
+            `• Action: Standalone rustc scripts only have access to std.\n` +
+            `  For external crates, compile via cargo or test against compiled workspace libraries.`);
+    }
+    // 6. Go package errors
+    if (/cannot find package\s+"([^"]+)"|no required module provides package/i.test(combined)) {
+        const match = combined.match(/cannot find package\s+"([^"]+)"/i);
+        const pkg = match ? match[1] : 'package';
+        diagnostics.push(`• Cause: Go package '${pkg}' not found in GOPATH/workspace module.\n` +
+            `• Action: Ensure '${pkg}' is declared in go.mod or run 'go get ${pkg}'.`);
+    }
+    // 7. C/C++ header / linker errors
+    if (/fatal error:\s*([^:]+):\s*No such file or directory/i.test(combined)) {
+        const match = combined.match(/fatal error:\s*([^:]+):\s*No such file or directory/i);
+        const hdr = match ? match[1] : 'header';
+        diagnostics.push(`• Cause: C/C++ header file '${hdr}' not found.\n` +
+            `• Action: Verify system library installation or specify include path.`);
+    }
+    else if (/undefined reference to|ld returned \d+ exit status/i.test(combined)) {
+        diagnostics.push(`• Cause: C/C++ linker unresolved symbol reference.\n` +
+            `• Action: Link required libraries (e.g., -lm, -lpthread, -lstdc++).`);
+    }
+    // 8. Timeout
+    if (/Execution timed out after \d+ms/i.test(combined)) {
+        diagnostics.push(`• Cause: Execution timed out.\n` +
+            `• Action: Increase timeoutMs in options, reduce iteration count, or check for infinite loops / blocking I/O.`);
+    }
+    if (diagnostics.length === 0)
+        return null;
+    return `[SANDBOX DIAGNOSTIC]\n` + diagnostics.join('\n\n');
+}
+/**
+ * Spawns a direct subprocess with dedicated FD-3 payload streaming,
+ * zero-shell overhead, and clean signal propagation.
+ */
+function spawnSubprocess(executable, args, options) {
+    return new Promise((resolve) => {
+        let stdoutData = '';
+        let stderrData = '';
+        let fd3Data = '';
+        let isSettled = false;
+        let killedByTimeout = false;
+        let aborted = false;
+        let timer = null;
+        let killTimer = null;
+        // Windows compatibility for .cmd / .bat executables
+        const isWin = os.platform() === 'win32';
+        const useShell = isWin && (executable.endsWith('.cmd') || executable.endsWith('.bat'));
+        let child;
+        try {
+            child = spawn(executable, args, {
+                cwd: options.cwd,
+                env: options.env,
+                stdio: ['pipe', 'pipe', 'pipe', 'pipe'],
+                shell: useShell,
+                windowsHide: true,
+            });
+        }
+        catch (err) {
+            resolve({
+                stdout: '',
+                stderr: err.message || String(err),
+                fd3: '',
+                exitCode: 1,
+            });
+            return;
+        }
+        const cleanupTimers = () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            if (killTimer) {
+                clearTimeout(killTimer);
+                killTimer = null;
+            }
+        };
+        const abortHandler = () => {
+            aborted = true;
+            cleanupTimers();
+            try {
+                child.kill('SIGTERM');
+            }
+            catch {
+                // Ignore kill errors
+            }
+            killTimer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    // Ignore
+                }
+            }, 500);
+        };
+        if (options.abortSignal) {
+            if (options.abortSignal.aborted) {
+                abortHandler();
+            }
+            else {
+                options.abortSignal.addEventListener('abort', abortHandler, { once: true });
+            }
+        }
+        if (options.timeoutMs > 0) {
+            timer = setTimeout(() => {
+                killedByTimeout = true;
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch {
+                    // Ignore
+                }
+                killTimer = setTimeout(() => {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }, 1000);
+            }, options.timeoutMs);
+        }
+        if (child.stdout) {
+            child.stdout.setEncoding('utf-8');
+            child.stdout.on('data', (chunk) => {
+                if (stdoutData.length < options.maxOutputChars * 2) {
+                    stdoutData += chunk;
+                }
+            });
+        }
+        if (child.stderr) {
+            child.stderr.setEncoding('utf-8');
+            child.stderr.on('data', (chunk) => {
+                if (stderrData.length < options.maxOutputChars * 2) {
+                    stderrData += chunk;
+                }
+            });
+        }
+        const fd3Stream = child.stdio[3];
+        if (fd3Stream) {
+            fd3Stream.setEncoding('utf-8');
+            fd3Stream.on('data', (chunk) => {
+                fd3Data += chunk;
+            });
+        }
+        if (options.stdinContent !== undefined && child.stdin) {
+            child.stdin.on('error', () => {
+                // Avoid unhandled EPIPE if child process exits early
+            });
+            try {
+                child.stdin.write(options.stdinContent, 'utf-8');
+                child.stdin.end();
+            }
+            catch {
+                // Ignore write errors
+            }
+        }
+        else if (child.stdin) {
+            try {
+                child.stdin.end();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        const finish = (code, signal) => {
+            if (isSettled)
+                return;
+            isSettled = true;
+            cleanupTimers();
+            if (options.abortSignal) {
+                options.abortSignal.removeEventListener('abort', abortHandler);
+            }
+            let exitCode = code ?? (signal ? 128 + 15 : 0);
+            if (killedByTimeout) {
+                exitCode = 124;
+            }
+            else if (aborted) {
+                exitCode = 130;
+            }
+            resolve({
+                stdout: stdoutData,
+                stderr: stderrData,
+                fd3: fd3Data,
+                exitCode,
+                killedByTimeout,
+                aborted,
+            });
+        };
+        child.on('error', (err) => {
+            stderrData += `\n${err.message}`;
+            finish(1, null);
+        });
+        child.on('close', (code, signal) => {
+            finish(code, signal);
+        });
+    });
+}
+/**
+ * Formats subprocess execution results, resolving structured results from FD-3 or stdout fallback.
+ */
+function handleExecutionResult(res, normLang, workspaceRoot, options) {
+    if (res.aborted) {
+        return {
+            exitCode: 130,
+            stderr: 'Analysis script aborted by user.',
+            stdout: '',
+        };
+    }
+    if (res.killedByTimeout) {
+        const tMs = options.timeoutMs ?? 60_000;
+        const diag = diagnoseSandboxError(`Execution timed out after ${tMs}ms.`, '', normLang, workspaceRoot);
+        const errOut = diag
+            ? `Execution timed out after ${tMs}ms.\n\n${diag}`
+            : `Execution timed out after ${tMs}ms.`;
+        return {
+            exitCode: 124,
+            stderr: errOut,
+            stdout: '',
+        };
     }
+    const rawStdout = res.stdout.trim();
+    const rawStderr = res.stderr.trim();
+    // 1. Check FD-3 structured payload first
+    let structuredResult;
+    let hasFd3Payload = false;
+    if (res.fd3 && res.fd3.trim()) {
+        const lines = res.fd3.trim().split('\n').map((l) => l.trim()).filter(Boolean);
+        if (lines.length > 0) {
+            const lastPayload = lines[lines.length - 1];
+            try {
+                structuredResult = JSON.parse(lastPayload);
+                hasFd3Payload = true;
+            }
+            catch {
+                structuredResult = lastPayload;
+                hasFd3Payload = true;
+            }
+        }
+    }
+    // 2. Fallback to stdout regex extraction
+    const parsed = parseStructuredResult(rawStdout);
+    if (!hasFd3Payload && parsed.structuredResult !== undefined) {
+        structuredResult = parsed.structuredResult;
+    }
+    const cleanedStdout = parsed.cleanedStdout;
+    let finalStderr = rawStderr;
+    if (finalStderr) {
+        const diag = diagnoseSandboxError(finalStderr, rawStdout, normLang, workspaceRoot);
+        if (diag) {
+            finalStderr = `${finalStderr}\n\n${diag}`.trim();
+        }
+    }
+    return {
+        exitCode: res.exitCode,
+        stderr: truncateOutput(finalStderr, options.maxOutputChars),
+        stdout: truncateOutput(cleanedStdout || (structuredResult !== undefined ? '' : rawStdout), options.maxOutputChars),
+        structuredResult,
+    };
 }
 /**
  * Truncates a string to the specified maximum length, appending an ellipsis marker if truncated.
@@ -302,15 +921,15 @@ function truncateOutput(text, max) {
     return text.substring(0, max) + '\n... (output truncated)';
 }
 /**
- * Write a disposable analysis script to a temporary file, execute it using the
+ * Write a disposable analysis script or stream it directly via stdin, execute it using the
  * specified language runtime, capture its output, and guarantee cleanup.
  *
- * Scripts are written to `os.tmpdir()` — never to the workspace directory — to
- * prevent pollution, `.gitignore` conflicts, and interference with the user's project.
+ * For interpreted runtimes (Node, Python, Bash, Ruby, PHP), zero-disk stdin streaming is used
+ * to eliminate disk I/O, watcher churn, and temporary file artifacts.
  *
  * @param workspaceRoot - The workspace root, used as the `cwd` for script execution
  *                        so relative file paths in the script resolve correctly.
- * @param language - The runtime to use: "node", "ts-node", "python", "bash", "go", or "rust".
+ * @param language - The runtime to use: "node", "ts-node", "python", "bash", "go", "rust", etc.
  * @param code - The script source code to execute.
  * @param options - Optional timeout, output cap, and abort signal.
  * @returns Captured stdout, stderr, and exit code.
@@ -320,65 +939,250 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
     const maxOutputChars = options?.maxOutputChars ?? 100_000;
     const normLang = await resolveEffectiveRuntime(workspaceRoot, language, code);
     const ext = await resolveScriptExtension(workspaceRoot, normLang, code);
-    const scriptPath = buildTempPath(code, ext);
-    const cmd = buildCommand(normLang, scriptPath);
-    if (!cmd) {
-        return {
-            stdout: '',
-            stderr: `Unsupported language runtime: "${language}". Supported: ${SUPPORTED_LANGUAGES.join(', ')}`,
-            exitCode: 1,
-        };
+    const [tsRunnerInfo, pyEnvInfo, moduleType] = await Promise.all([
+        findTypeScriptRunner(workspaceRoot),
+        findPythonBinary(workspaceRoot),
+        detectWorkspaceModuleType(workspaceRoot),
+    ]);
+    const finalCode = options?.injectHelpers !== false
+        ? injectSandboxHelpers(code, normLang)
+        : code;
+    const mergedEnv = {
+        ...process.env,
+        ...options?.env,
+    };
+    // 1. NODE_PATH injection for workspace packages
+    const workspaceNodeModules = path.join(workspaceRoot, 'node_modules');
+    if (mergedEnv.NODE_PATH) {
+        mergedEnv.NODE_PATH = `${workspaceNodeModules}${path.delimiter}${mergedEnv.NODE_PATH}`;
+    }
+    else {
+        mergedEnv.NODE_PATH = workspaceNodeModules;
+    }
+    // 2. TypeScript configuration
+    if (tsRunnerInfo.tsconfigPath) {
+        mergedEnv.TS_NODE_PROJECT = tsRunnerInfo.tsconfigPath;
+        mergedEnv.TSCONFIG_PATH = tsRunnerInfo.tsconfigPath;
+    }
+    // 3. Python environment & PYTHONPATH injection
+    const workspaceSrc = path.join(workspaceRoot, 'src');
+    let hasSrc = false;
+    try {
+        await fs.access(workspaceSrc);
+        hasSrc = true;
     }
-    // Collect all temp files created so we can clean them up unconditionally
-    const tempFiles = [scriptPath];
-    const binExt = os.platform() === 'win32' ? '.exe' : '';
-    if (normLang === 'rust') {
-        tempFiles.push(scriptPath.replace(/\.rs$/, binExt));
-        tempFiles.push(scriptPath.replace(/\.rs$/, '.pdb'));
+    catch {
+        // no src dir
+    }
+    const pythonPaths = [workspaceRoot];
+    if (hasSrc) {
+        pythonPaths.push(workspaceSrc);
+    }
+    if (mergedEnv.PYTHONPATH) {
+        mergedEnv.PYTHONPATH = `${pythonPaths.join(path.delimiter)}${path.delimiter}${mergedEnv.PYTHONPATH}`;
     }
-    else if (normLang === 'c') {
-        tempFiles.push(scriptPath.replace(/\.c$/, binExt));
+    else {
+        mergedEnv.PYTHONPATH = pythonPaths.join(path.delimiter);
     }
-    else if (normLang === 'cpp') {
-        tempFiles.push(scriptPath.replace(/\.cpp$/, binExt));
+    mergedEnv.PYTHONUNBUFFERED = '1';
+    if (pyEnvInfo.isVenv && pyEnvInfo.venvDir && pyEnvInfo.binDir) {
+        mergedEnv.VIRTUAL_ENV = pyEnvInfo.venvDir;
+        mergedEnv.PATH = `${pyEnvInfo.binDir}${path.delimiter}${mergedEnv.PATH || ''}`;
     }
+    // 4. Ruby RUBYLIB injection
+    const workspaceLib = path.join(workspaceRoot, 'lib');
+    let hasLib = false;
     try {
-        await fs.writeFile(scriptPath, code, 'utf-8');
-        const mergedEnv = options?.env ? { ...process.env, ...options.env } : process.env;
-        const { stdout, stderr } = await execAsync(cmd, {
-            cwd: workspaceRoot,
-            timeout: timeoutMs,
-            maxBuffer: 1024 * 1024, // 1 MB buffer
-            signal: options?.abortSignal,
-            env: mergedEnv,
-        });
-        return {
-            stdout: truncateOutput(stdout.trim(), maxOutputChars),
-            stderr: truncateOutput(stderr.trim(), maxOutputChars),
-            exitCode: 0,
-        };
+        await fs.access(workspaceLib);
+        hasLib = true;
+    }
+    catch {
+        // no lib dir
+    }
+    const rubyPaths = [workspaceRoot];
+    if (hasLib) {
+        rubyPaths.push(workspaceLib);
     }
-    catch (err) {
-        // AbortError — propagate cleanly
-        if (err.name === 'AbortError' || err.message?.includes('abort')) {
-            return { stdout: '', stderr: 'Analysis script aborted by user.', exitCode: 130 };
+    if (mergedEnv.RUBYLIB) {
+        mergedEnv.RUBYLIB = `${rubyPaths.join(path.delimiter)}${path.delimiter}${mergedEnv.RUBYLIB}`;
+    }
+    else {
+        mergedEnv.RUBYLIB = rubyPaths.join(path.delimiter);
+    }
+    const binExt = os.platform() === 'win32' ? '.exe' : '';
+    const tempFiles = [];
+    let executable = null;
+    let args = [];
+    let stdinContent;
+    let isZeroDisk = false;
+    switch (normLang) {
+        case 'node': {
+            executable = process.execPath || 'node';
+            const hasCJS = /\b(require\s*\(|module\\.exports|exports\.)/.test(code);
+            const hasESM = /\b(import\s+|import\(|export\s+|export\{|export\s+default)\b/.test(code) || /^\s*await\s+/m.test(code);
+            const isESM = (hasESM && !hasCJS) || (!hasCJS && moduleType === 'module');
+            args = isESM ? ['--input-type=module', '-'] : ['--input-type=commonjs', '-'];
+            stdinContent = finalCode;
+            isZeroDisk = true;
+            break;
+        }
+        case 'python': {
+            executable = pyEnvInfo.pythonBin;
+            args = ['-u', '-'];
+            stdinContent = finalCode;
+            isZeroDisk = true;
+            break;
+        }
+        case 'bash': {
+            executable = 'bash';
+            args = ['-s'];
+            stdinContent = finalCode;
+            isZeroDisk = true;
+            break;
+        }
+        case 'ruby': {
+            executable = 'ruby';
+            args = ['-'];
+            stdinContent = finalCode;
+            isZeroDisk = true;
+            break;
+        }
+        case 'php': {
+            executable = 'php';
+            args = [];
+            stdinContent = finalCode.trim().startsWith('<?php') ? finalCode : `<?php\n${finalCode}`;
+            isZeroDisk = true;
+            break;
+        }
+        case 'ts-node': {
+            const scriptPath = buildTempPath(code, ext);
+            tempFiles.push(scriptPath);
+            await fs.writeFile(scriptPath, finalCode, 'utf-8');
+            if (tsRunnerInfo.runnerType === 'local-tsx') {
+                executable = tsRunnerInfo.binaryPath || 'tsx';
+                args = [scriptPath];
+            }
+            else if (tsRunnerInfo.runnerType === 'local-ts-node-esm') {
+                executable = tsRunnerInfo.binaryPath || 'ts-node-esm';
+                args = [scriptPath];
+            }
+            else if (tsRunnerInfo.runnerType === 'local-ts-node') {
+                executable = tsRunnerInfo.binaryPath || 'ts-node';
+                args = moduleType === 'module' ? ['--esm', scriptPath] : [scriptPath];
+            }
+            else if (tsRunnerInfo.runnerType === 'npx-ts-node') {
+                executable = 'npx';
+                args = ['ts-node', scriptPath];
+            }
+            else {
+                executable = 'npx';
+                args = ['tsx', scriptPath];
+            }
+            break;
+        }
+        case 'go': {
+            const scriptPath = buildTempPath(code, ext);
+            tempFiles.push(scriptPath);
+            await fs.writeFile(scriptPath, finalCode, 'utf-8');
+            executable = 'go';
+            args = ['run', scriptPath];
+            break;
+        }
+        case 'java': {
+            const scriptPath = buildTempPath(code, ext);
+            tempFiles.push(scriptPath);
+            await fs.writeFile(scriptPath, finalCode, 'utf-8');
+            executable = 'java';
+            args = [scriptPath];
+            break;
+        }
+        case 'rust': {
+            const scriptPath = buildTempPath(code, ext);
+            const binPath = scriptPath.replace(/\.rs$/, binExt);
+            tempFiles.push(scriptPath, binPath, scriptPath.replace(/\.rs$/, '.pdb'));
+            await fs.writeFile(scriptPath, finalCode, 'utf-8');
+            // Compile step
+            const compileRes = await spawnSubprocess('rustc', [scriptPath, '-o', binPath], {
+                cwd: workspaceRoot,
+                env: mergedEnv,
+                timeoutMs: Math.min(timeoutMs, 30_000),
+                maxOutputChars,
+                abortSignal: options?.abortSignal,
+            });
+            if (compileRes.exitCode !== 0) {
+                return handleExecutionResult(compileRes, normLang, workspaceRoot, { maxOutputChars, timeoutMs });
+            }
+            executable = binPath;
+            args = [];
+            break;
         }
-        if (err.killed && err.signal === 'SIGTERM') {
-            return { stdout: '', stderr: `Execution timed out after ${timeoutMs}ms.`, exitCode: 124 };
+        case 'c': {
+            const scriptPath = buildTempPath(code, ext);
+            const binPath = scriptPath.replace(/\.c$/, binExt);
+            tempFiles.push(scriptPath, binPath);
+            await fs.writeFile(scriptPath, finalCode, 'utf-8');
+            // Compile step
+            const compileRes = await spawnSubprocess('gcc', [scriptPath, '-o', binPath], {
+                cwd: workspaceRoot,
+                env: mergedEnv,
+                timeoutMs: Math.min(timeoutMs, 30_000),
+                maxOutputChars,
+                abortSignal: options?.abortSignal,
+            });
+            if (compileRes.exitCode !== 0) {
+                return handleExecutionResult(compileRes, normLang, workspaceRoot, { maxOutputChars, timeoutMs });
+            }
+            executable = binPath;
+            args = [];
+            break;
         }
-        const stdout = truncateOutput((err.stdout || '').trim(), maxOutputChars);
-        const stderr = truncateOutput((err.stderr || '').trim(), maxOutputChars);
-        const exitCode = typeof err.code === 'number' ? err.code : 1;
-        return { stdout, stderr, exitCode };
+        case 'cpp': {
+            const scriptPath = buildTempPath(code, ext);
+            const binPath = scriptPath.replace(/\.cpp$/, binExt);
+            tempFiles.push(scriptPath, binPath);
+            await fs.writeFile(scriptPath, finalCode, 'utf-8');
+            // Compile step
+            const compileRes = await spawnSubprocess('g++', ['-std=c++17', scriptPath, '-o', binPath], {
+                cwd: workspaceRoot,
+                env: mergedEnv,
+                timeoutMs: Math.min(timeoutMs, 30_000),
+                maxOutputChars,
+                abortSignal: options?.abortSignal,
+            });
+            if (compileRes.exitCode !== 0) {
+                return handleExecutionResult(compileRes, normLang, workspaceRoot, { maxOutputChars, timeoutMs });
+            }
+            executable = binPath;
+            args = [];
+            break;
+        }
+        default:
+            return {
+                stdout: '',
+                stderr: `Unsupported language runtime: "${language}". Supported: ${SUPPORTED_LANGUAGES.join(', ')}`,
+                exitCode: 1,
+            };
+    }
+    try {
+        const runRes = await spawnSubprocess(executable, args, {
+            cwd: workspaceRoot,
+            env: mergedEnv,
+            timeoutMs,
+            maxOutputChars,
+            abortSignal: options?.abortSignal,
+            stdinContent,
+        });
+        return handleExecutionResult(runRes, normLang, workspaceRoot, { maxOutputChars, timeoutMs });
     }
     finally {
-        // Guarantee temp file cleanup regardless of success or failure
-        for (const tmpFile of tempFiles) {
-            try {
-                await fs.rm(tmpFile, { force: true, recursive: true });
-            }
-            catch {
-                // Ignore cleanup errors — temp files will be reaped by the OS eventually
+        if (!isZeroDisk && tempFiles.length > 0) {
+            for (const tmpFile of tempFiles) {
+                try {
+                    await fs.rm(tmpFile, { force: true, recursive: true });
+                }
+                catch {
+                    // ignore cleanup errors
+                }
             }
         }
     }
@@ -486,7 +1290,8 @@ export async function runPropertyBasedTest(workspaceRoot, code, language = 'node
     }
     const scriptResult = await runEphemeralScript(workspaceRoot, lang, code, opts);
     const combinedOutput = `${scriptResult.stdout}\n${scriptResult.stderr}`;
-    const isPassed = combinedOutput.includes('[PBT PASSED]') || (scriptResult.exitCode === 0 && !combinedOutput.includes('[PBT FAILED]'));
+    const isPassed = combinedOutput.includes('[PBT PASSED]') ||
+        (scriptResult.exitCode === 0 && !combinedOutput.includes('[PBT FAILED]'));
     let counterexample;
     let shrunkInput;
     let seed;
@@ -504,20 +1309,20 @@ export async function runPropertyBasedTest(workspaceRoot, code, language = 'node
     // Extract seed
     const seedMatch = combinedOutput.match(/Seed(?:|\/Iteration):\s*(\d+)/i);
     if (seedMatch) {
-        seed = parseInt(seedMatch[1], 10);
+        seed = Number.parseInt(seedMatch[1], 10);
     }
     // Extract completed runs
     const runsMatch = combinedOutput.match(/Completed\s+(\d+)\s+runs/i);
     if (runsMatch) {
-        numRunsCompleted = parseInt(runsMatch[1], 10);
+        numRunsCompleted = Number.parseInt(runsMatch[1], 10);
     }
     return {
         ...scriptResult,
-        passed: isPassed,
         counterexample,
-        shrunkInput,
-        seed,
         numRunsCompleted,
+        passed: isPassed,
+        seed,
+        shrunkInput,
     };
 }
 /**
@@ -710,28 +1515,31 @@ export async function runFuzzProbe(workspaceRoot, code, language = 'node', confi
         failingInputs.push(match[1].trim());
     }
     let totalFuzzRuns = 0;
-    const runsMatch = combinedOutput.match(/(?:Total Runs|Runs):\s*(\d+)/i) || combinedOutput.match(/Completed\s+(\d+)\s+(?:fuzz\s+)?runs/i);
+    const runsMatch = combinedOutput.match(/(?:Total Runs|Runs):\s*(\d+)/i) ||
+        combinedOutput.match(/Completed\s+(\d+)\s+(?:fuzz\s+)?runs/i);
     if (runsMatch) {
-        totalFuzzRuns = parseInt(runsMatch[1], 10);
+        totalFuzzRuns = Number.parseInt(runsMatch[1], 10);
     }
     let seed;
     const seedMatch = combinedOutput.match(/Seed:\s*(\d+)/i);
     if (seedMatch) {
-        seed = parseInt(seedMatch[1], 10);
+        seed = Number.parseInt(seedMatch[1], 10);
     }
     let errorSummary;
     if (!isPassed) {
         const errLine = scriptResult.stderr.split('\n').find((l) => l.trim().length > 0) ||
-            combinedOutput.split('\n').find((l) => l.toLowerCase().includes('error') || l.includes('[FUZZ FAILED]'));
+            combinedOutput
+                .split('\n')
+                .find((l) => l.toLowerCase().includes('error') || l.includes('[FUZZ FAILED]'));
         errorSummary = errLine?.trim() || 'Fuzzing probe encountered unexpected failure or crash.';
     }
     return {
         ...scriptResult,
-        passed: isPassed,
-        totalFuzzRuns,
-        failingInputs: failingInputs.length > 0 ? failingInputs : undefined,
         errorSummary,
+        failingInputs: failingInputs.length > 0 ? failingInputs : undefined,
+        passed: isPassed,
         seed,
+        totalFuzzRuns,
     };
 }
 /**
@@ -837,7 +1645,8 @@ const testIters = ${testIters};
 for (let i = 0; i < testIters; i++) {
   if (i % Math.max(1, Math.floor(testIters / 5)) === 0) {
     if (global.gc) global.gc();
-    console.log(\`[HEAP_SAMPLE] \${i}, \${process.memoryUsage().heapUsed}\`);
+    const curr = process.memoryUsage().heapUsed;
+    console.log(\`[HEAP_SAMPLE] \${i}, \${curr}\`);
   }
 }
 
@@ -866,26 +1675,26 @@ export async function checkHeapDelta(workspaceRoot, code, language = 'node', con
     let initialHeapBytes = 0;
     const startMatch = combinedOutput.match(/(?:\[HEAP_START\]|Heap start:)\s*(-?\d+)/i);
     if (startMatch) {
-        initialHeapBytes = parseInt(startMatch[1], 10);
+        initialHeapBytes = Number.parseInt(startMatch[1], 10);
     }
     let finalHeapBytes = 0;
     const finalMatch = combinedOutput.match(/(?:\[HEAP_FINAL\]|Heap final:)\s*(-?\d+)/i);
     if (finalMatch) {
-        finalHeapBytes = parseInt(finalMatch[1], 10);
+        finalHeapBytes = Number.parseInt(finalMatch[1], 10);
     }
     let deltaBytes = finalHeapBytes - initialHeapBytes;
     const deltaMatch = combinedOutput.match(/(?:\[HEAP_DELTA\]|Heap delta:)\s*(-?\d+)/i);
     if (deltaMatch) {
-        deltaBytes = parseInt(deltaMatch[1], 10);
+        deltaBytes = Number.parseInt(deltaMatch[1], 10);
     }
     const samples = [];
     const sampleRegex = /(?:\[HEAP_SAMPLE\]|Sample\s+(\d+):?)\s*(\d+)(?:,\s*(\d+))?/gi;
     let sMatch;
     while ((sMatch = sampleRegex.exec(combinedOutput)) !== null) {
-        const iter = parseInt(sMatch[1], 10);
-        const bytes = sMatch[3] ? parseInt(sMatch[3], 10) : parseInt(sMatch[2], 10);
-        if (!isNaN(iter) && !isNaN(bytes)) {
-            samples.push({ iteration: iter, heapBytes: bytes });
+        const iter = Number.parseInt(sMatch[1], 10);
+        const bytes = sMatch[3] ? Number.parseInt(sMatch[3], 10) : Number.parseInt(sMatch[2], 10);
+        if (!Number.isNaN(iter) && !Number.isNaN(bytes)) {
+            samples.push({ heapBytes: bytes, iteration: iter });
         }
     }
     let growthRateBytesPerIter;
@@ -905,11 +1714,11 @@ export async function checkHeapDelta(workspaceRoot, code, language = 'node', con
         (growthRateBytesPerIter !== undefined && growthRateBytesPerIter > 10_000);
     return {
         ...scriptResult,
-        initialHeapBytes,
-        finalHeapBytes,
         deltaBytes,
-        leakDetected,
+        finalHeapBytes,
         growthRateBytesPerIter,
+        initialHeapBytes,
+        leakDetected,
         samples: samples.length > 0 ? samples : undefined,
     };
 }
@@ -922,30 +1731,30 @@ function compareJsonValues(val1, val2, pathStr, tolerance, details) {
     if (typeof val1 === 'number' && typeof val2 === 'number') {
         if (Math.abs(val1 - val2) > tolerance) {
             details.push({
-                field: pathStr,
                 baseline: val1,
                 candidate: val2,
                 diff: `Numeric difference exceeds tolerance (${tolerance}): |${val1} - ${val2}| = ${Math.abs(val1 - val2)}`,
+                field: pathStr,
             });
         }
         return;
     }
     if (typeof val1 !== typeof val2 || val1 === null || val2 === null) {
         details.push({
-            field: pathStr,
             baseline: val1,
             candidate: val2,
             diff: `Type mismatch: baseline is ${typeof val1}, candidate is ${typeof val2}`,
+            field: pathStr,
         });
         return;
     }
     if (Array.isArray(val1) && Array.isArray(val2)) {
         if (val1.length !== val2.length) {
             details.push({
-                field: `${pathStr}.length`,
                 baseline: val1.length,
                 candidate: val2.length,
                 diff: `Array length mismatch: baseline length ${val1.length}, candidate length ${val2.length}`,
+                field: `${pathStr}.length`,
             });
         }
         const minLen = Math.min(val1.length, val2.length);
@@ -962,18 +1771,18 @@ function compareJsonValues(val1, val2, pathStr, tolerance, details) {
             const subPath = pathStr ? `${pathStr}.${key}` : key;
             if (!(key in val1)) {
                 details.push({
-                    field: subPath,
                     baseline: undefined,
                     candidate: val2[key],
                     diff: `Key "${key}" missing in baseline`,
+                    field: subPath,
                 });
             }
             else if (!(key in val2)) {
                 details.push({
-                    field: subPath,
                     baseline: val1[key],
                     candidate: undefined,
                     diff: `Key "${key}" missing in candidate`,
+                    field: subPath,
                 });
             }
             else {
@@ -983,10 +1792,10 @@ function compareJsonValues(val1, val2, pathStr, tolerance, details) {
         return;
     }
     details.push({
-        field: pathStr,
         baseline: val1,
         candidate: val2,
         diff: `Value mismatch: baseline="${val1}", candidate="${val2}"`,
+        field: pathStr,
     });
 }
 /**
@@ -1057,10 +1866,10 @@ export async function checkBehavioralDrift(workspaceRoot, baselineCode, candidat
     }
     if (baselineResult.exitCode !== candidateResult.exitCode) {
         driftDetails.push({
-            field: 'exitCode',
             baseline: baselineResult.exitCode,
             candidate: candidateResult.exitCode,
             diff: `Exit code mismatch: baseline exited with ${baselineResult.exitCode}, candidate with ${candidateResult.exitCode}`,
+            field: 'exitCode',
         });
     }
     const hasDrift = driftDetails.length > 0;
@@ -1068,13 +1877,25 @@ export async function checkBehavioralDrift(workspaceRoot, baselineCode, candidat
     const combinedStdout = `--- Baseline Stdout ---\n${baselineResult.stdout}\n--- Candidate Stdout ---\n${candidateResult.stdout}`;
     const combinedStderr = `--- Baseline Stderr ---\n${baselineResult.stderr}\n--- Candidate Stderr ---\n${candidateResult.stderr}`;
     return {
-        stdout: combinedStdout,
-        stderr: combinedStderr,
-        exitCode: hasDrift ? 1 : 0,
-        hasDrift,
         baselineOutput: baselineOut,
         candidateOutput: candidateOut,
         diffSummary,
         driftDetails: driftDetails.length > 0 ? driftDetails : undefined,
+        exitCode: hasDrift ? 1 : 0,
+        hasDrift,
+        stderr: combinedStderr,
+        stdout: combinedStdout,
     };
 }
+/**
+ * Runs a heap delta memory profiling script and evaluates memory growth characteristics.
+ */
+export async function runHeapDeltaCheck(workspaceRoot, code, language = 'node', config) {
+    return checkHeapDelta(workspaceRoot, code, language, config);
+}
+/**
+ * Runs two scripts (baseline vs candidate) and compares output for behavioral drift.
+ */
+export async function runBehavioralDriftCheck(workspaceRoot, baselineCode, candidateCode, language = 'node', config) {
+    return checkBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language, config);
+}