research-copilot 0.2.1 → 0.2.3

package/app/out/main/index.mjs

@@ -1,7 +1,7 @@
 import { app, shell, ipcMain, BrowserWindow, dialog, Menu } from "electron";
 import { setMaxListeners } from "node:events";
 import fs, { existsSync as existsSync$1 } from "node:fs";
-import { execFile, execSync } from "node:child_process";
+import { execFile, spawn, execSync } from "node:child_process";
 import path, { resolve, join, sep, isAbsolute, extname, basename, dirname, relative } from "path";
 import { existsSync, statSync, readdirSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, rmSync, unlinkSync, renameSync } from "fs";
 import os$1, { homedir } from "os";
@@ -13,7 +13,7 @@ import { Type } from "@sinclair/typebox";
 import { mkdir, writeFile } from "fs/promises";
 import path$1 from "node:path";
 import fsp from "node:fs/promises";
-import { createHash as createHash$1 } from "node:crypto";
+import crypto$1, { createHash as createHash$1 } from "node:crypto";
 import { promisify } from "node:util";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
@@ -262,30 +262,83 @@ function loadOrCreateSessionId(rootPathKey, path2) {
   writeFileSync(sessionFile, JSON.stringify({ sessionId: newId }));
   return newId;
 }
-function resolveCoordinatorAuth(modelId) {
+const CODEX_CRED_FILE = join(CONFIG_DIR, "openai-codex-credentials.json");
+function loadCodexCredentials() {
+  try {
+    if (existsSync(CODEX_CRED_FILE)) {
+      const data = JSON.parse(readFileSync(CODEX_CRED_FILE, "utf-8"));
+      if (data.access && data.refresh) return data;
+    }
+  } catch {
+  }
+  try {
+    const codexHome = join(homedir(), ".codex");
+    const codexAuth = join(codexHome, "auth.json");
+    if (existsSync(codexAuth)) {
+      const data = JSON.parse(readFileSync(codexAuth, "utf-8"));
+      if (data.tokens?.access_token && data.tokens?.refresh_token) {
+        return {
+          access: data.tokens.access_token,
+          refresh: data.tokens.refresh_token,
+          expires: data.tokens.expires_at ? data.tokens.expires_at * 1e3 : Date.now() + 36e5,
+          accountId: data.tokens.account_id
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function saveCodexCredentials(creds) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CODEX_CRED_FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+}
+function clearCodexCredentials() {
+  try {
+    if (existsSync(CODEX_CRED_FILE)) {
+      const { unlinkSync: unlinkSync2 } = require2("fs");
+      unlinkSync2(CODEX_CRED_FILE);
+    }
+  } catch {
+  }
+}
+function resolveCoordinatorAuth(compositeKey) {
   const openaiApiKey = (process.env.OPENAI_API_KEY || "").trim();
   const anthropicApiKey = (process.env.ANTHROPIC_API_KEY || "").trim();
-  const isAnthropic = modelId.startsWith("claude-");
-  if (!isAnthropic) {
-    if (!openaiApiKey) {
-      throw new Error("OPENAI_API_KEY is required for the selected OpenAI model.");
-    }
-    return {
-      apiKey: openaiApiKey,
-      authMode: "api-key",
-      isAnthropicModel: false,
-      billingSource: "api-key"
-    };
+  const i = compositeKey.indexOf(":");
+  let provider;
+  if (i > 0) {
+    provider = compositeKey.slice(0, i);
+  } else {
+    provider = compositeKey.startsWith("claude-") ? "anthropic" : "openai";
   }
-  if (!anthropicApiKey) {
-    throw new Error("ANTHROPIC_API_KEY is required for the selected Anthropic model.");
+  switch (provider) {
+    case "openai-codex": {
+      const creds = loadCodexCredentials();
+      if (!creds) {
+        throw new Error("ChatGPT subscription login required. Please sign in via the model selector.");
+      }
+      return {
+        apiKey: creds.access,
+        authMode: "subscription",
+        isAnthropicModel: false,
+        billingSource: "subscription",
+        piProvider: "openai-codex"
+      };
+    }
+    case "anthropic": {
+      if (!anthropicApiKey) {
+        throw new Error("ANTHROPIC_API_KEY is required for the selected Anthropic model.");
+      }
+      return { apiKey: anthropicApiKey, authMode: "api-key", isAnthropicModel: true, billingSource: "api-key" };
+    }
+    default: {
+      if (!openaiApiKey) {
+        throw new Error("OPENAI_API_KEY is required for the selected OpenAI model.");
+      }
+      return { apiKey: openaiApiKey, authMode: "api-key", isAnthropicModel: false, billingSource: "api-key" };
+    }
   }
-  return {
-    apiKey: anthropicApiKey,
-    authMode: "api-key",
-    isAnthropicModel: true,
-    billingSource: "api-key"
-  };
 }
 function registerFileHandlers(handle, getCtx) {
   handle("file:list-root", () => {
@@ -520,6 +573,51 @@ function registerAuthHandlers(handleRaw) {
       hasApiKey: !!(process.env.OPENAI_API_KEY || "").trim()
     };
   });
+  handleRaw("auth:get-openai-codex-status", () => {
+    const creds = loadCodexCredentials();
+    return {
+      isLoggedIn: !!creds,
+      isExpired: creds ? creds.expires < Date.now() : false
+    };
+  });
+  handleRaw("auth:openai-codex-login", async () => {
+    const { loginOpenAICodex } = await import("@mariozechner/pi-ai/oauth");
+    const { shell: shell2 } = await import("electron");
+    try {
+      const creds = await loginOpenAICodex({
+        onAuth: (info) => {
+          shell2.openExternal(info.url);
+        },
+        onPrompt: async (prompt) => {
+          console.warn("[OAuth] Unexpected prompt:", prompt.message);
+          return "";
+        },
+        onProgress: (msg) => {
+          console.log("[OAuth]", msg);
+        }
+      });
+      saveCodexCredentials(creds);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err.message || "OAuth login failed" };
+    }
+  });
+  handleRaw("auth:openai-codex-logout", () => {
+    clearCodexCredentials();
+    return { success: true };
+  });
+  handleRaw("auth:openai-codex-refresh", async () => {
+    const creds = loadCodexCredentials();
+    if (!creds) return { success: false, error: "Not logged in" };
+    try {
+      const { refreshOpenAICodexToken } = await import("@mariozechner/pi-ai/oauth");
+      const newCreds = await refreshOpenAICodexToken(creds);
+      saveCodexCredentials(newCreds);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err.message || "Token refresh failed" };
+    }
+  });
 }
 function registerFolderOpenHandler(handle, getCtx) {
   handle("folder:open-with", async (appName) => {
@@ -664,7 +762,9 @@ const PATHS = {
   memory: ".research-pilot/memory",
   // Skills
   skills: ".research-pilot/skills",
-  skillsConfig: ".research-pilot/skills-config.json"
+  skillsConfig: ".research-pilot/skills-config.json",
+  // Local compute runs
+  computeRuns: ".research-pilot/compute-runs"
 };
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -3100,7 +3200,7 @@ Additional context: ${extraContext}` : `Research request: ${query}`;
     }
   };
 }
-const execFileAsync$1 = promisify(execFile);
+const execFileAsync$3 = promisify(execFile);
 const DEFAULT_MAX_OUTPUT_CHARS = 5e5;
 const DEFAULT_PREVIEW_CHARS = 4e3;
 const DEFAULT_COMMAND_TIMEOUT_MS = 12e4;
@@ -3231,7 +3331,7 @@ async function detectTextLikeFile(filePath) {
 }
 async function runCommand(command, args, timeoutMs) {
   try {
-    await execFileAsync$1(command, args, {
+    await execFileAsync$3(command, args, {
       timeout: timeoutMs,
       maxBuffer: 10 * 1024 * 1024
     });
@@ -3322,7 +3422,7 @@ print(json.dumps(result, ensure_ascii=False))
   let foundAnyRuntime = false;
   for (const attempt of attempts) {
     try {
-      const { stdout } = await execFileAsync$1(
+      const { stdout } = await execFileAsync$3(
         attempt.command,
         ["-c", script, inputPath, JSON.stringify(ranges)],
         { timeout: timeoutMs, maxBuffer: 50 * 1024 * 1024, encoding: "utf8" }
@@ -3828,187 +3928,2245 @@ function createConvertDocumentTool(ctx) {
         page_count: pageCount,
         page_ranges: pageRanges.length > 0 ? pageRanges.map((r) => r.raw) : void 0
       };
-      return success(payload);
+      return success(payload);
+    }
+  };
+}
+const execFileAsync$2 = promisify(execFile);
+const DATA_ANALYSIS_SYSTEM = loadPrompt("data-analysis-system");
+const DATA_ANALYSIS_TASKS = loadPrompt("data-analysis-tasks");
+const DATA_CODE_TEMPLATE = loadPrompt("data-code-template");
+const TASK_DESCRIPTIONS = {
+  analyze: "Statistical Analysis",
+  visualize: "Data Visualization",
+  transform: "Data Transformation",
+  model: "Statistical Modeling"
+};
+const DataAnalyzeSchema = Type.Object({
+  file_path: Type.String({ description: "Relative path to data file (CSV, JSON, TSV, XLSX)" }),
+  instructions: Type.String({ description: "What analysis to perform" }),
+  task_type: Type.Optional(
+    Type.String({ description: "analyze | visualize | transform | model (default: analyze)" })
+  )
+});
+function createDataAnalyzeTool(ctx) {
+  return {
+    name: "data_analyze",
+    label: "Data Analysis",
+    description: "Analyze a dataset using Python. Supports statistics, visualization (matplotlib/seaborn), data transformation, and modeling. Generated outputs (figures, tables) are saved to disk.\nUsage guidelines: (1) Use this tool for ANY analysis, visualization, statistics, or modeling — do not compute from raw data with read/grep. (2) Generate only the outputs the user requested; no extras.",
+    parameters: DataAnalyzeSchema,
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const filePath = typeof params.file_path === "string" ? params.file_path.trim() : "";
+      const instructions = typeof params.instructions === "string" ? params.instructions.trim() : "";
+      const taskType = typeof params.task_type === "string" ? params.task_type.trim().toLowerCase() : "analyze";
+      if (!filePath) {
+        return toAgentResult("data_analyze", toolError("MISSING_PARAMETER", "Missing file_path.", {
+          suggestions: ["Provide a relative path to the data file (CSV, JSON, TSV, or XLSX)."]
+        }));
+      }
+      if (!instructions) {
+        return toAgentResult("data_analyze", toolError("MISSING_PARAMETER", "Missing instructions.", {
+          suggestions: ["Describe what analysis to perform on the data."]
+        }));
+      }
+      if (!["analyze", "visualize", "transform", "model"].includes(taskType)) {
+        return toAgentResult("data_analyze", toolError("INVALID_PARAMETER", `Invalid task_type: ${taskType}. Use: analyze | visualize | transform | model.`, {
+          suggestions: ["Valid task types: analyze, visualize, transform, model."]
+        }));
+      }
+      const absDataFile = path$1.resolve(ctx.workspacePath, filePath);
+      if (!fs.existsSync(absDataFile)) {
+        return toAgentResult("data_analyze", toolError("FILE_NOT_FOUND", `File not found: ${filePath}`, {
+          suggestions: [
+            "Verify the file path is relative to the workspace root.",
+            "Use the find or glob tool to locate the data file."
+          ],
+          context: { workspacePath: ctx.workspacePath, resolvedPath: absDataFile }
+        }));
+      }
+      const runId = Date.now().toString(36);
+      const outputBase = path$1.join(ctx.workspacePath, ".research-pilot", "data-runs", runId);
+      const figuresDir = path$1.join(outputBase, "figures");
+      const tablesDir = path$1.join(outputBase, "tables");
+      const dataDir = path$1.join(outputBase, "data");
+      fs.mkdirSync(figuresDir, { recursive: true });
+      fs.mkdirSync(tablesDir, { recursive: true });
+      fs.mkdirSync(dataDir, { recursive: true });
+      const resultsFile = path$1.join(outputBase, "results.json");
+      const rawPreview = fs.readFileSync(absDataFile, "utf-8").slice(0, 2e3);
+      const ext = path$1.extname(absDataFile).toLowerCase();
+      const formatHint = ext === ".csv" ? "CSV" : ext === ".tsv" ? "TSV" : ext === ".json" ? "JSON" : ext === ".xlsx" ? "XLSX" : "unknown";
+      if (!ctx.callLlm) {
+        return toAgentResult("data_analyze", toolError("LLM_UNAVAILABLE", "LLM not available for code generation.", {
+          suggestions: ["Ensure the agent runtime has an LLM provider configured (callLlm in ResearchToolContext)."]
+        }));
+      }
+      const taskSection = DATA_ANALYSIS_TASKS.split(/^## /m).find((s) => s.startsWith(taskType));
+      const taskDesc = taskSection ? `## ${taskSection}` : "";
+      const userPrompt = [
+        `Task type: ${taskType} (${TASK_DESCRIPTIONS[taskType] ?? "Analysis"})`,
+        "",
+        taskDesc,
+        "",
+        `Data file format: ${formatHint}`,
+        `Data file preview (first 2000 chars):`,
+        "```",
+        rawPreview,
+        "```",
+        "",
+        `Instructions: ${instructions}`,
+        "",
+        "IMPORTANT: Use the pre-defined path variables (DATA_FILE, FIGURES_DIR, TABLES_DIR, DATA_DIR, RESULTS_FILE).",
+        "Call write_results() at the end with your outputs list and summary dict.",
+        "Output ONLY the Python code in a ```python code block."
+      ].join("\n");
+      let generatedCode;
+      try {
+        const llmResponse = await ctx.callLlm(DATA_ANALYSIS_SYSTEM, userPrompt);
+        const codeMatch = llmResponse.match(/```python\n([\s\S]*?)```/) || llmResponse.match(/```\n([\s\S]*?)```/);
+        generatedCode = codeMatch ? codeMatch[1] : llmResponse;
+      } catch (err) {
+        return toAgentResult("data_analyze", toolError("EXECUTION_FAILED", `Code generation failed: ${err.message}`, {
+          retryable: true,
+          suggestions: ["Retry — the LLM may produce valid code on a subsequent attempt.", "Try simplifying the instructions."]
+        }));
+      }
+      const pathDefinitions = [
+        "",
+        "# Pre-defined paths (set by the tool runtime)",
+        `DATA_FILE = ${JSON.stringify(absDataFile)}`,
+        `FIGURES_DIR = ${JSON.stringify(figuresDir)}`,
+        `TABLES_DIR = ${JSON.stringify(tablesDir)}`,
+        `DATA_DIR = ${JSON.stringify(dataDir)}`,
+        `RESULTS_FILE = ${JSON.stringify(resultsFile)}`,
+        ""
+      ].join("\n");
+      const fullScript = DATA_CODE_TEMPLATE + pathDefinitions + "\n" + generatedCode;
+      const scriptPath = path$1.join(outputBase, "script.py");
+      fs.writeFileSync(scriptPath, fullScript, "utf-8");
+      try {
+        const { stdout, stderr } = await execFileAsync$2("python3", [scriptPath], {
+          cwd: ctx.workspacePath,
+          timeout: 12e4,
+          // 2 minutes
+          maxBuffer: 10 * 1024 * 1024
+        });
+        let manifest = null;
+        if (fs.existsSync(resultsFile)) {
+          try {
+            manifest = JSON.parse(fs.readFileSync(resultsFile, "utf-8"));
+          } catch {
+          }
+        }
+        const outputs = [];
+        for (const [dir, type] of [
+          [figuresDir, "figure"],
+          [tablesDir, "table"],
+          [dataDir, "data"]
+        ]) {
+          if (fs.existsSync(dir)) {
+            for (const f of fs.readdirSync(dir)) {
+              outputs.push({
+                name: f,
+                type,
+                path: path$1.relative(ctx.workspacePath, path$1.join(dir, f))
+              });
+            }
+          }
+        }
+        const payload = {
+          stdout: stdout.slice(0, 4e3),
+          stderr: stderr ? stderr.slice(0, 1e3) : void 0,
+          outputs,
+          manifest: manifest ? {
+            summary: manifest.summary,
+            warnings: manifest.warnings
+          } : void 0,
+          scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
+          runId
+        };
+        return toAgentResult("data_analyze", { success: true, data: payload });
+      } catch (err) {
+        const errorDetail = err.stderr?.slice(0, 2e3) || err.message;
+        return toAgentResult("data_analyze", toolError("EXECUTION_FAILED", `Python execution failed: ${errorDetail}`, {
+          retryable: true,
+          suggestions: [
+            `Review the generated script at ${path$1.relative(ctx.workspacePath, scriptPath)} for errors.`,
+            "Check that required Python packages (pandas, matplotlib, seaborn, etc.) are installed.",
+            "Try simplifying the analysis instructions."
+          ],
+          context: {
+            scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
+            runId
+          },
+          data: {
+            scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
+            runId
+          }
+        }));
+      }
+    }
+  };
+}
+function isTerminal(state) {
+  return state === "completed" || state === "failed" || state === "timed_out" || state === "cancelled";
+}
+const RUNS_FILE = "runs.jsonl";
+const EVICT_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+const FLUSH_INTERVAL_MS = 3e4;
+class RunStore {
+  constructor(projectPath) {
+    this.records = /* @__PURE__ */ new Map();
+    this.loaded = false;
+    this.dirty = false;
+    this.flushTimer = null;
+    this.dir = path$1.join(projectPath, ".research-pilot", "compute-runs");
+    this.filePath = path$1.join(this.dir, RUNS_FILE);
+  }
+  ensureDir() {
+    if (!fs.existsSync(this.dir)) {
+      fs.mkdirSync(this.dir, { recursive: true });
+    }
+  }
+  load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    if (!fs.existsSync(this.filePath)) return;
+    const content = fs.readFileSync(this.filePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const record = JSON.parse(trimmed);
+        this.records.set(record.runId, record);
+      } catch {
+      }
+    }
+  }
+  writeToDisk() {
+    this.ensureDir();
+    const lines = Array.from(this.records.values()).map((r) => JSON.stringify(r)).join("\n");
+    const tmpPath = this.filePath + ".tmp." + process.pid + "." + Date.now();
+    fs.writeFileSync(tmpPath, lines + "\n", "utf-8");
+    fs.renameSync(tmpPath, this.filePath);
+    this.dirty = false;
+  }
+  /**
+   * Mark store as dirty. Starts the periodic flush timer if not running.
+   */
+  markDirty() {
+    this.dirty = true;
+    if (!this.flushTimer) {
+      this.flushTimer = setInterval(() => {
+        if (this.dirty) this.writeToDisk();
+      }, FLUSH_INTERVAL_MS);
+      if (this.flushTimer.unref) this.flushTimer.unref();
+    }
+  }
+  /**
+   * Flush immediately (synchronous). Called on critical events:
+   * - createRun (new record must survive crash)
+   * - Terminal state transition (completed/failed/cancelled/timed_out)
+   * - Shutdown (destroy)
+   */
+  flushNow() {
+    if (this.dirty) this.writeToDisk();
+  }
+  /**
+   * Stop the periodic flush timer. Called on destroy.
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  getRun(runId) {
+    this.load();
+    return this.records.get(runId);
+  }
+  getAllRuns() {
+    this.load();
+    return Array.from(this.records.values());
+  }
+  getActiveRuns() {
+    this.load();
+    return Array.from(this.records.values()).filter((r) => !isTerminal(r.status));
+  }
+  createRun(record) {
+    this.load();
+    this.records.set(record.runId, record);
+    this.writeToDisk();
+  }
+  updateRun(runId, patch) {
+    this.load();
+    const existing = this.records.get(runId);
+    if (!existing) return void 0;
+    const updated = { ...existing, ...patch };
+    this.records.set(runId, updated);
+    if (patch.status && isTerminal(patch.status)) {
+      this.writeToDisk();
+    } else {
+      this.markDirty();
+    }
+    return updated;
+  }
+  /**
+   * Remove completed runs older than maxAgeMs.
+   */
+  evictOld(maxAgeMs = EVICT_AGE_MS) {
+    this.load();
+    const cutoff = Date.now() - maxAgeMs;
+    let evicted = 0;
+    for (const [id, record] of this.records) {
+      if (isTerminal(record.status) && record.completedAt) {
+        const completedTime = new Date(record.completedAt).getTime();
+        if (completedTime < cutoff) {
+          this.records.delete(id);
+          const runDir = this.getRunDir(id);
+          try {
+            fs.rmSync(runDir, { recursive: true, force: true });
+          } catch {
+          }
+          evicted++;
+        }
+      }
+    }
+    if (evicted > 0) this.writeToDisk();
+    return evicted;
+  }
+  getRunDir(runId) {
+    return path$1.join(this.dir, runId);
+  }
+  getOutputPath(runId) {
+    return path$1.join(this.dir, runId, "output.log");
+  }
+  getStderrPath(runId) {
+    return path$1.join(this.dir, runId, "output.log.stderr");
+  }
+}
+class ProcessSandbox {
+  constructor() {
+    this.name = "process";
+  }
+  async available() {
+    return true;
+  }
+  async spawn(config) {
+    const outputDir = path$1.dirname(config.outputPath);
+    fs.mkdirSync(outputDir, { recursive: true });
+    const stderrPath = config.outputPath + ".stderr";
+    const wrappedCommand = `( ${config.command} ) 2> >(tee -a ${JSON.stringify(stderrPath)} >&2) >> ${JSON.stringify(config.outputPath)} 2>&1`;
+    fs.writeFileSync(config.outputPath, "");
+    fs.writeFileSync(stderrPath, "");
+    const child = spawn("/bin/bash", ["-c", wrappedCommand], {
+      cwd: config.workDir,
+      env: { ...process.env, ...config.env },
+      stdio: ["ignore", "ignore", "ignore"],
+      detached: true
+    });
+    const pid = child.pid;
+    if (pid === void 0) {
+      throw new Error("Failed to spawn process: no PID returned");
+    }
+    if (config.signal) {
+      const onAbort = () => {
+        try {
+          process.kill(-pid, "SIGTERM");
+        } catch {
+        }
+      };
+      config.signal.addEventListener("abort", onAbort, { once: true });
+      child.on("exit", () => config.signal.removeEventListener("abort", onAbort));
+    }
+    let settled = false;
+    const waitPromise = new Promise((resolve2) => {
+      child.on("exit", (code, signal) => {
+        if (settled) return;
+        settled = true;
+        resolve2({
+          exitCode: code ?? 1,
+          exitSignal: signal ?? void 0
+        });
+      });
+      child.on("error", () => {
+        if (settled) return;
+        settled = true;
+        resolve2({ exitCode: 1, exitSignal: void 0 });
+      });
+    });
+    return {
+      pid,
+      async kill(sig = "SIGTERM") {
+        try {
+          process.kill(-pid, sig);
+        } catch {
+        }
+      },
+      wait() {
+        return waitPromise;
+      },
+      async cleanup() {
+        try {
+          child.unref();
+        } catch {
+        }
+      }
+    };
+  }
+}
+promisify(execFile);
+let cachedProviders = null;
+async function detectProviders() {
+  if (cachedProviders) return cachedProviders;
+  const providers = [];
+  providers.push(new ProcessSandbox());
+  cachedProviders = providers;
+  return providers;
+}
+async function getProvider(preference) {
+  const providers = await detectProviders();
+  if (preference && preference !== "auto") {
+    const match = providers.find((p) => p.name === preference);
+    if (match) return match;
+  }
+  return providers[0];
+}
+function deriveFailure(run) {
+  if (run.status === "completed") return void 0;
+  if (run.status === "cancelled") return void 0;
+  const stderr = run.stderrTail ?? "";
+  const exit = run.exitCode;
+  if (exit === 137 || /\bMemoryError\b|OOM|Cannot allocate memory/i.test(stderr) || exit === 137 && /\bKilled\b$/m.test(stderr)) {
+    return {
+      code: "OOM_KILLED",
+      retryable: true,
+      message: "Process was killed due to insufficient memory.",
+      suggestions: [
+        "Reduce the dataset size or batch size.",
+        "Close other memory-intensive applications.",
+        "Process large data in chunks if possible."
+      ]
+    };
+  }
+  if (run.status === "timed_out") {
+    const timeoutMin = Math.round(run.timeoutMs / 6e4);
+    return {
+      code: "TIMEOUT",
+      retryable: true,
+      message: `Process exceeded the ${timeoutMin}-minute timeout.`,
+      suggestions: [
+        "Increase the timeout_minutes parameter.",
+        "Optimize the code for faster execution.",
+        "Process a smaller subset of the data."
+      ]
+    };
+  }
+  if (run.status === "stalled") {
+    return {
+      code: "STALL",
+      retryable: true,
+      message: "Process stopped producing output and appears stuck.",
+      suggestions: [
+        "Check for deadlocks or blocking I/O in the code.",
+        "Add progress logging to detect where execution hangs.",
+        "Check if the process is waiting for interactive input."
+      ]
+    };
+  }
+  if (/ModuleNotFoundError|No module named/i.test(stderr)) {
+    const moduleMatch = stderr.match(/No module named '([^']+)'/i) ?? stderr.match(/ModuleNotFoundError:\s*No module named\s+'?([^\s']+)/i);
+    const moduleName = moduleMatch?.[1] ?? "unknown";
+    return {
+      code: "MODULE_NOT_FOUND",
+      retryable: true,
+      message: `Python module not found: ${moduleName}`,
+      suggestions: [
+        `Add "${moduleName}" to requirements.txt and retry.`,
+        `Or install directly: pip install ${moduleName}`
+      ]
+    };
+  }
+  if (/PermissionError|EACCES|Permission denied/i.test(stderr)) {
+    return {
+      code: "PERMISSION_DENIED",
+      retryable: false,
+      message: "Permission denied during execution.",
+      suggestions: [
+        "Check file permissions on input/output paths.",
+        "Ensure the output directory is writable."
+      ]
+    };
+  }
+  if (/Traceback \(most recent call last\)/i.test(stderr) || /^\w+Error:/m.test(stderr) || /^\w+Exception:/m.test(stderr)) {
+    const lines = stderr.split("\n").filter((l) => l.trim());
+    const lastErrorLine = lines[lines.length - 1] ?? "";
+    return {
+      code: "PYTHON_ERROR",
+      retryable: true,
+      message: `Python error: ${lastErrorLine.slice(0, 200)}`,
+      suggestions: [
+        "Read the stderr output to understand the error.",
+        "Fix the code and retry."
+      ]
+    };
+  }
+  if (run.exitSignal) {
+    return {
+      code: "SIGNAL_KILLED",
+      retryable: run.exitSignal === "SIGTERM",
+      // SIGTERM is often retryable
+      message: `Process was killed by signal: ${run.exitSignal}`,
+      suggestions: [
+        "Check if another process or the system killed this task.",
+        "If the signal was SIGTERM, it may be safe to retry."
+      ]
+    };
+  }
+  return {
+    code: "COMMAND_FAILED",
+    retryable: false,
+    message: `Command exited with code ${exit ?? "unknown"}.`,
+    suggestions: [
+      "Review stderr output for details on the failure.",
+      "Fix the script error and re-submit."
+    ]
+  };
+}
+function extractProgress(tail) {
+  const cooperative = extractCooperativeProgress(tail);
+  if (cooperative) return cooperative;
+  return extractRegexProgress(tail);
+}
+function extractCooperativeProgress(tail) {
+  const lines = tail.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line.startsWith("##PROGRESS##")) continue;
+    const jsonStr = line.slice("##PROGRESS##".length).trim();
+    try {
+      const data = JSON.parse(jsonStr);
+      const progress = {};
+      if (typeof data.step === "number") progress.currentStep = data.step;
+      if (typeof data.total === "number") progress.totalSteps = data.total;
+      if (typeof data.percentage === "number") progress.percentage = data.percentage;
+      if (typeof data.phase === "string") progress.phase = data.phase;
+      if (typeof data.eta === "number") progress.etaSeconds = data.eta;
+      if (typeof data.eta_seconds === "number") progress.etaSeconds = data.eta_seconds;
+      const knownKeys = /* @__PURE__ */ new Set(["step", "total", "percentage", "phase", "eta", "eta_seconds"]);
+      const metrics = {};
+      for (const [k, v] of Object.entries(data)) {
+        if (!knownKeys.has(k) && typeof v === "number") metrics[k] = v;
+      }
+      if (Object.keys(metrics).length > 0) progress.metrics = metrics;
+      if (progress.percentage === void 0 && progress.currentStep !== void 0 && progress.totalSteps) {
+        progress.percentage = Math.round(progress.currentStep / progress.totalSteps * 100);
+      }
+      return progress;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function extractRegexProgress(tail) {
+  const progress = {};
+  let found = false;
+  const normalizedTail = tail.replace(/\r/g, "\n");
+  const tqdmMatches = [...normalizedTail.matchAll(/(\d+)%\|[^|]*\|\s*(\d+)\/(\d+)\s*\[[\d:]+<([\d:?]+)/g)];
+  const tqdm = tqdmMatches.length > 0 ? tqdmMatches[tqdmMatches.length - 1] : null;
+  if (tqdm) {
+    progress.percentage = parseInt(tqdm[1], 10);
+    progress.currentStep = parseInt(tqdm[2], 10);
+    progress.totalSteps = parseInt(tqdm[3], 10);
+    progress.etaSeconds = parseTimeStr(tqdm[4]);
+    found = true;
+  }
+  if (!found) {
+    const epoch = normalizedTail.match(/[Ee]pochs?\s+(\d+)\s*[/of]+\s*(\d+)/);
+    if (epoch) {
+      progress.currentStep = parseInt(epoch[1], 10);
+      progress.totalSteps = parseInt(epoch[2], 10);
+      progress.percentage = Math.round(progress.currentStep / progress.totalSteps * 100);
+      progress.phase = "training";
+      found = true;
+    }
+  }
+  if (!found) {
+    const step = normalizedTail.match(/[Ss]teps?\s+(\d+)\s*[/of]+\s*(\d+)/);
+    if (step) {
+      progress.currentStep = parseInt(step[1], 10);
+      progress.totalSteps = parseInt(step[2], 10);
+      progress.percentage = Math.round(progress.currentStep / progress.totalSteps * 100);
+      found = true;
+    }
+  }
+  if (!found) {
+    const pctMatches = [...normalizedTail.matchAll(/(\d{1,3})%/g)];
+    const pct = pctMatches.length > 0 ? pctMatches[pctMatches.length - 1] : null;
+    if (pct) {
+      const val = parseInt(pct[1], 10);
+      if (val >= 0 && val <= 100) {
+        progress.percentage = val;
+        found = true;
+      }
+    }
+  }
+  const metrics = {};
+  const metricPattern = /\b(loss|acc(?:uracy)?|f1|auc|mse|mae|rmse|r2|lr|learning_rate|val_loss|val_acc(?:uracy)?)\s*[=:]\s*([\d.]+(?:e[+-]?\d+)?)/gi;
+  for (const m of normalizedTail.matchAll(metricPattern)) {
+    const key = m[1].toLowerCase();
+    const val = parseFloat(m[2]);
+    if (!isNaN(val)) metrics[key] = val;
+  }
+  if (Object.keys(metrics).length > 0) {
+    progress.metrics = metrics;
+    found = true;
+  }
+  const lastLines = normalizedTail.slice(-2048).toLowerCase();
+  if (/download|fetching|pulling/i.test(lastLines)) progress.phase = "downloading";
+  else if (/train|fitting|epoch/i.test(lastLines)) progress.phase = "training";
+  else if (/evaluat|validat|testing/i.test(lastLines)) progress.phase = "evaluating";
+  else if (/preprocess|clean|transform/i.test(lastLines)) progress.phase = "preprocessing";
+  else if (/saving|export|writing.*output/i.test(lastLines)) progress.phase = "saving";
+  return found ? progress : void 0;
+}
+function parseTimeStr(s) {
+  if (!s || s.includes("?")) return void 0;
+  const parts = s.split(":").map((p) => parseInt(p, 10));
+  if (parts.some(isNaN)) return void 0;
+  if (parts.length === 2) return parts[0] * 60 + parts[1];
+  if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  return void 0;
+}
+const MAX_HEAVY_CONCURRENT = 1;
+const MAX_TOTAL_CONCURRENT = 3;
+const MIN_FREE_MEMORY_MB = 500;
+const MIN_FREE_DISK_MB = 500;
+function classifyWeight(timeoutMinutes, command) {
+  if (timeoutMinutes <= 2) return "light";
+  if (timeoutMinutes <= 10 && /\b(plot|viz|chart|figure|draw|render)\b/i.test(command)) return "light";
+  return "heavy";
+}
+function canAdmit(snapshot, weight) {
+  const activeHeavy = snapshot.activeRuns.filter((r) => r.weight === "heavy").length;
+  const totalActive = snapshot.activeRuns.length;
+  if (weight === "heavy" && activeHeavy >= MAX_HEAVY_CONCURRENT) {
+    const heavyRun = snapshot.activeRuns.find((r) => r.weight === "heavy");
+    return {
+      allowed: false,
+      reason: `A heavy compute run is already active${heavyRun ? ` (${heavyRun.runId})` : ""}. Wait for it to finish, or stop it first.`
+    };
+  }
+  if (totalActive >= MAX_TOTAL_CONCURRENT) {
+    return {
+      allowed: false,
+      reason: `Too many concurrent runs (${totalActive}/${MAX_TOTAL_CONCURRENT}). Wait for one to finish, or stop one.`
+    };
+  }
+  if (snapshot.freeMemoryMb < MIN_FREE_MEMORY_MB) {
+    return {
+      allowed: false,
+      reason: `Low memory (${Math.round(snapshot.freeMemoryMb)}MB free, need ${MIN_FREE_MEMORY_MB}MB). Close applications to free resources.`
+    };
+  }
+  if (snapshot.freeDiskMb < MIN_FREE_DISK_MB) {
+    return {
+      allowed: false,
+      reason: `Low disk space (${Math.round(snapshot.freeDiskMb)}MB free, need ${MIN_FREE_DISK_MB}MB).`
+    };
+  }
+  return { allowed: true, reason: "Resources available" };
+}
+const execFileAsync$1 = promisify(execFile);
+async function checkSyntax(scriptPath, pythonPath) {
+  const start = Date.now();
+  if (!scriptPath.endsWith(".py")) {
+    return { name: "syntax", status: "passed", message: "Not a Python script — skipped.", durationMs: Date.now() - start };
+  }
+  if (!fs.existsSync(scriptPath)) {
+    return { name: "syntax", status: "failed", message: `Script not found: ${scriptPath}`, durationMs: Date.now() - start };
+  }
+  try {
+    await execFileAsync$1(pythonPath, ["-m", "py_compile", scriptPath], { timeout: 1e4 });
+    return { name: "syntax", status: "passed", message: "Python syntax OK.", durationMs: Date.now() - start };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const syntaxLine = msg.split("\n").find((l) => /SyntaxError|IndentationError|TabError/i.test(l)) ?? msg.slice(0, 200);
+    return { name: "syntax", status: "failed", message: `Syntax error: ${syntaxLine}`, durationMs: Date.now() - start };
+  }
+}
+async function checkImports(scriptPath, pythonPath) {
+  const start = Date.now();
+  if (!scriptPath.endsWith(".py") || !fs.existsSync(scriptPath)) {
+    return { name: "imports", status: "passed", message: "Skipped.", durationMs: Date.now() - start };
+  }
+  const content = fs.readFileSync(scriptPath, "utf-8");
+  const imports = /* @__PURE__ */ new Set();
+  for (const match of content.matchAll(/^\s*(?:import|from)\s+([a-zA-Z_][a-zA-Z0-9_]*)/gm)) {
+    const mod = match[1];
+    if (STDLIB_MODULES.has(mod)) continue;
+    imports.add(mod);
+  }
+  if (imports.size === 0) {
+    return { name: "imports", status: "passed", message: "No third-party imports detected.", durationMs: Date.now() - start };
+  }
+  const importList = Array.from(imports);
+  const testScript = importList.map((mod) => `try:
+ import ${mod}
+except ImportError:
+ print("MISSING:" + "${mod}")`).join("\n");
+  const missing = [];
+  try {
+    const { stdout } = await execFileAsync$1(pythonPath, ["-c", testScript], { timeout: 3e4 });
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("MISSING:")) missing.push(line.slice(8));
+    }
+  } catch {
+    return { name: "imports", status: "warning", message: `Could not verify imports: ${importList.join(", ")}`, durationMs: Date.now() - start };
+  }
+  if (missing.length === 0) {
+    return { name: "imports", status: "passed", message: `All ${imports.size} imports available.`, durationMs: Date.now() - start };
+  }
+  return {
+    name: "imports",
+    status: "failed",
+    message: `Missing modules: ${missing.join(", ")}. Add to requirements.txt or pip install.`,
+    durationMs: Date.now() - start
+  };
+}
+function checkDataPaths(command, workDir) {
+  const start = Date.now();
+  const pathPattern = /(?:["']([^"']+\.(?:csv|tsv|json|jsonl|xlsx|xls|parquet|feather|h5|hdf5|npy|npz|pkl|pickle|txt|dat))["']|(\S+\.(?:csv|tsv|json|jsonl|xlsx|xls|parquet|feather|h5|hdf5|npy|npz|pkl|pickle)))/gi;
+  const refs = [];
+  for (const m of command.matchAll(pathPattern)) {
+    refs.push(m[1] ?? m[2]);
+  }
+  if (refs.length === 0) {
+    return { name: "data_paths", status: "passed", message: "No data file references detected in command.", durationMs: Date.now() - start };
+  }
+  const missing = [];
+  for (const ref of refs) {
+    const abs = path$1.isAbsolute(ref) ? ref : path$1.resolve(workDir, ref);
+    if (!fs.existsSync(abs)) missing.push(ref);
+  }
+  if (missing.length === 0) {
+    return { name: "data_paths", status: "passed", message: `All ${refs.length} data files found.`, durationMs: Date.now() - start };
+  }
+  return {
+    name: "data_paths",
+    status: "failed",
+    message: `Data files not found: ${missing.join(", ")}`,
+    durationMs: Date.now() - start
+  };
+}
+function checkDiskSpace(workDir) {
+  const start = Date.now();
+  try {
+    const output = execSync("df -m .", { cwd: workDir, encoding: "utf-8", timeout: 3e3 });
+    const lines = output.trim().split("\n");
+    if (lines.length >= 2) {
+      const parts = lines[1].split(/\s+/);
+      const availMb = parseInt(parts[3], 10);
+      if (!isNaN(availMb)) {
+        if (availMb < 500) {
+          return { name: "disk_space", status: "failed", message: `Only ${availMb}MB free disk space. Need at least 500MB.`, durationMs: Date.now() - start };
+        }
+        if (availMb < 2e3) {
+          return { name: "disk_space", status: "warning", message: `${availMb}MB free disk space. May be tight for large outputs.`, durationMs: Date.now() - start };
+        }
+        return { name: "disk_space", status: "passed", message: `${availMb}MB free disk space.`, durationMs: Date.now() - start };
+      }
+    }
+  } catch {
+  }
+  return { name: "disk_space", status: "passed", message: "Could not detect disk space — proceeding.", durationMs: Date.now() - start };
+}
+function checkOutputDir(workDir) {
+  const start = Date.now();
+  try {
+    const testFile = path$1.join(workDir, ".compute-preflight-test");
+    fs.writeFileSync(testFile, "test");
+    fs.unlinkSync(testFile);
+    return { name: "output_dir", status: "passed", message: "Working directory is writable.", durationMs: Date.now() - start };
+  } catch {
+    return { name: "output_dir", status: "failed", message: `Working directory is not writable: ${workDir}`, durationMs: Date.now() - start };
+  }
+}
+async function runPreflight(opts) {
+  const pythonPath = opts.pythonPath ?? "python3";
+  const scriptPath = opts.scriptPath ?? extractScriptPath(opts.command, opts.workDir);
+  const [syntax, imports, dataPaths, diskSpace, outputDir] = await Promise.all([
+    scriptPath ? checkSyntax(scriptPath, pythonPath) : Promise.resolve(null),
+    scriptPath ? checkImports(scriptPath, pythonPath) : Promise.resolve(null),
+    Promise.resolve(checkDataPaths(opts.command, opts.workDir)),
+    Promise.resolve(checkDiskSpace(opts.workDir)),
+    Promise.resolve(checkOutputDir(opts.workDir))
+  ]);
+  const checks = [syntax, imports, dataPaths, diskSpace, outputDir].filter(Boolean);
+  const blockingIssues = checks.filter((c) => c.status === "failed").map((c) => c.message);
+  const warnings = checks.filter((c) => c.status === "warning").map((c) => c.message);
+  return {
+    passed: blockingIssues.length === 0,
+    checks,
+    blockingIssues,
+    warnings
+  };
+}
+function extractScriptPath(command, workDir) {
+  const match = command.match(/python3?\s+([^\s]+\.py)/);
+  if (!match) return void 0;
+  const scriptRef = match[1];
+  return path$1.isAbsolute(scriptRef) ? scriptRef : path$1.resolve(workDir, scriptRef);
+}
+const STDLIB_MODULES = /* @__PURE__ */ new Set([
+  "abc",
+  "aifc",
+  "argparse",
+  "array",
+  "ast",
+  "asynchat",
+  "asyncio",
+  "asyncore",
+  "atexit",
+  "base64",
+  "bdb",
+  "binascii",
+  "binhex",
+  "bisect",
+  "builtins",
+  "bz2",
+  "calendar",
+  "cgi",
+  "cgitb",
+  "chunk",
+  "cmath",
+  "cmd",
+  "code",
+  "codecs",
+  "codeop",
+  "collections",
+  "colorsys",
+  "compileall",
+  "concurrent",
+  "configparser",
+  "contextlib",
+  "contextvars",
+  "copy",
+  "copyreg",
+  "cProfile",
+  "crypt",
+  "csv",
+  "ctypes",
+  "curses",
+  "dataclasses",
+  "datetime",
+  "dbm",
+  "decimal",
+  "difflib",
+  "dis",
+  "distutils",
+  "doctest",
+  "email",
+  "encodings",
+  "enum",
+  "errno",
+  "faulthandler",
+  "fcntl",
+  "filecmp",
+  "fileinput",
+  "fnmatch",
+  "fractions",
+  "ftplib",
+  "functools",
+  "gc",
+  "getopt",
+  "getpass",
+  "gettext",
+  "glob",
+  "grp",
+  "gzip",
+  "hashlib",
+  "heapq",
+  "hmac",
+  "html",
+  "http",
+  "idlelib",
+  "imaplib",
+  "imghdr",
+  "imp",
+  "importlib",
+  "inspect",
+  "io",
+  "ipaddress",
+  "itertools",
+  "json",
+  "keyword",
+  "lib2to3",
+  "linecache",
+  "locale",
+  "logging",
+  "lzma",
+  "mailbox",
+  "mailcap",
+  "marshal",
+  "math",
+  "mimetypes",
+  "mmap",
+  "modulefinder",
+  "multiprocessing",
+  "netrc",
+  "nis",
+  "nntplib",
+  "numbers",
+  "operator",
+  "optparse",
+  "os",
+  "ossaudiodev",
+  "pathlib",
+  "pdb",
+  "pickle",
+  "pickletools",
+  "pipes",
+  "pkgutil",
+  "platform",
+  "plistlib",
+  "poplib",
+  "posix",
+  "posixpath",
+  "pprint",
+  "profile",
+  "pstats",
+  "pty",
+  "pwd",
+  "py_compile",
+  "pyclbr",
+  "pydoc",
+  "queue",
+  "quopri",
+  "random",
+  "re",
+  "readline",
+  "reprlib",
+  "resource",
+  "rlcompleter",
+  "runpy",
+  "sched",
+  "secrets",
+  "select",
+  "selectors",
+  "shelve",
+  "shlex",
+  "shutil",
+  "signal",
+  "site",
+  "smtpd",
+  "smtplib",
+  "sndhdr",
+  "socket",
+  "socketserver",
+  "sqlite3",
+  "sre_compile",
+  "sre_constants",
+  "sre_parse",
+  "ssl",
+  "stat",
+  "statistics",
+  "string",
+  "stringprep",
+  "struct",
+  "subprocess",
+  "sunau",
+  "symtable",
+  "sys",
+  "sysconfig",
+  "syslog",
+  "tabnanny",
+  "tarfile",
+  "telnetlib",
+  "tempfile",
+  "termios",
+  "test",
+  "textwrap",
+  "threading",
+  "time",
+  "timeit",
+  "tkinter",
+  "token",
+  "tokenize",
+  "tomllib",
+  "trace",
+  "traceback",
+  "tracemalloc",
+  "tty",
+  "turtle",
+  "turtledemo",
+  "types",
+  "typing",
+  "unicodedata",
+  "unittest",
+  "urllib",
+  "uu",
+  "uuid",
+  "venv",
+  "warnings",
+  "wave",
+  "weakref",
+  "webbrowser",
+  "winreg",
+  "winsound",
+  "wsgiref",
+  "xdrlib",
+  "xml",
+  "xmlrpc",
+  "zipapp",
+  "zipfile",
+  "zipimport",
+  "zlib",
+  // Common aliases / submodules
+  "os",
+  "sys",
+  "typing",
+  "collections",
+  "__future__"
+]);
+const EXPERIENCE_FILE = "experience.jsonl";
+class ExperienceStore {
+  constructor(projectPath) {
+    this.records = null;
+    const dir = path$1.join(projectPath, ".research-pilot", "compute-runs");
+    this.filePath = path$1.join(dir, EXPERIENCE_FILE);
+  }
+  load() {
+    if (this.records !== null) return this.records;
+    this.records = [];
+    if (!fs.existsSync(this.filePath)) return this.records;
+    const content = fs.readFileSync(this.filePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        this.records.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+    return this.records;
+  }
+  flush() {
+    const dir = path$1.dirname(this.filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const records = this.load();
+    const trimmed = records.slice(-200);
+    const content = trimmed.map((r) => JSON.stringify(r)).join("\n") + "\n";
+    const tmpPath = this.filePath + ".tmp." + process.pid;
+    fs.writeFileSync(tmpPath, content, "utf-8");
+    fs.renameSync(tmpPath, this.filePath);
+    this.records = trimmed;
+  }
+  /**
+   * Record a completed run's experience.
+   */
+  record(entry) {
+    this.load();
+    this.records.push(entry);
+    this.flush();
+  }
+  /**
+   * Find relevant past experience by taskKind.
+   * Primary: exact match. Fallback: most recent regardless of kind.
+   */
+  findRelevant(taskKind, limit = 10) {
+    const all = this.load();
+    const exact = all.filter((r) => r.taskKind === taskKind);
+    if (exact.length > 0) return exact.slice(-limit);
+    return all.slice(-limit);
+  }
+  /**
+   * Get all records (for UI display or export).
+   */
+  getAll() {
+    return [...this.load()];
+  }
+  /**
+   * Compute summary statistics for a taskKind.
+   */
+  summarize(taskKind) {
+    const records = this.findRelevant(taskKind);
+    if (records.length === 0) return void 0;
+    const successes = records.filter((r) => r.outcome === "success");
+    const failures = records.filter((r) => r.outcome === "failed");
+    const durations = successes.map((r) => r.durationSeconds);
+    const avgDuration = durations.length > 0 ? Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : void 0;
+    const failureCodes = {};
+    for (const f of failures) {
+      if (f.failureCode) {
+        failureCodes[f.failureCode] = (failureCodes[f.failureCode] ?? 0) + 1;
+      }
+    }
+    return {
+      taskKind,
+      totalRuns: records.length,
+      successes: successes.length,
+      failures: failures.length,
+      avgDurationSeconds: avgDuration,
+      commonFailures: failureCodes,
+      lastRun: records[records.length - 1]
+    };
+  }
+}
+function inferTaskKind(command, scriptContent) {
+  const combined = (command + " " + (scriptContent ?? "")).toLowerCase();
+  let framework = "python";
+  if (/\bimport\s+(?:torch|pytorch)\b|from\s+torch\b/.test(combined)) framework = "pytorch";
+  else if (/\bimport\s+tensorflow\b|from\s+tensorflow\b|import\s+keras\b/.test(combined)) framework = "tensorflow";
+  else if (/\bimport\s+mlx\b|from\s+mlx\b/.test(combined)) framework = "mlx";
+  else if (/\bimport\s+sklearn\b|from\s+sklearn\b/.test(combined)) framework = "sklearn";
+  else if (/\bimport\s+pandas\b|from\s+pandas\b/.test(combined)) framework = "pandas";
+  else if (/\bimport\s+(?:matplotlib|seaborn|plotly)\b/.test(combined)) framework = "matplotlib";
+  else if (/\bimport\s+(?:numpy|scipy)\b/.test(combined)) framework = "numpy";
+  let action = "script";
+  if (/\.fit\(|\.train\(|train|epoch/i.test(combined)) action = "training";
+  else if (/\.predict\(|\.score\(|evaluat|test.*accuracy/i.test(combined)) action = "evaluation";
+  else if (/preprocess|clean|transform|etl|\.to_csv\(|\.to_parquet\(/i.test(combined)) action = "etl";
+  else if (/\.savefig\(|\.show\(|plot|chart|graph|viz/i.test(combined)) action = "viz";
+  else if (/download|fetch|scrape|request/i.test(combined)) action = "download";
+  else if (/statist|correlat|describe|summary/i.test(combined)) action = "analysis";
+  return `${framework}-${action}`;
+}
+const POLL_INTERVAL_MS = 5e3;
+const OUTPUT_TAIL_BYTES = 8192;
+const STDERR_TAIL_BYTES = 4096;
+const MAX_TIMEOUT_MS = 24 * 60 * 6e4;
+const MAX_OUTPUT_BYTES = 1024 * 1024 * 1024;
+const DESTROY_KILL_TIMEOUT_MS = 5e3;
+function nextRunId() {
+  return "cr-" + crypto$1.randomBytes(4).toString("hex");
+}
+function getPidStartTime(pid) {
+  try {
+    if (process.platform === "darwin") {
+      const raw = execSync(`ps -p ${pid} -o lstart=`, { encoding: "utf-8", timeout: 3e3 }).trim();
+      if (!raw) return void 0;
+      return new Date(raw).getTime();
+    } else {
+      const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf-8");
+      const fields = stat.split(" ");
+      const startTicks = parseInt(fields[21], 10);
+      if (isNaN(startTicks)) return void 0;
+      const uptime = parseFloat(fs.readFileSync("/proc/uptime", "utf-8").split(" ")[0]);
+      const hz = 100;
+      const bootTime = Date.now() - uptime * 1e3;
+      return Math.round(bootTime + startTicks / hz * 1e3);
+    }
+  } catch {
+    return void 0;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isStaleRun(record) {
+  if (!record.pid) return true;
+  if (!isPidAlive(record.pid)) return true;
+  if (record.pidStartTime) {
+    const currentStartTime = getPidStartTime(record.pid);
+    if (currentStartTime === void 0) return true;
+    if (Math.abs(currentStartTime - record.pidStartTime) > 2e3) return true;
+  }
+  return false;
+}
+function takeSnapshot(store) {
+  const activeRuns = store.getActiveRuns().map((r) => ({
+    runId: r.runId,
+    weight: r.weight
+  }));
+  let freeDiskMb = 1e4;
+  try {
+    const dfOutput = execSync("df -m .", { encoding: "utf-8", timeout: 3e3 });
+    const lines = dfOutput.trim().split("\n");
+    if (lines.length >= 2) {
+      const parts = lines[1].split(/\s+/);
+      const available = parseInt(parts[3], 10);
+      if (!isNaN(available)) freeDiskMb = available;
+    }
+  } catch {
+  }
+  return {
+    freeMemoryMb: Math.round(os.freemem() / (1024 * 1024)),
+    cpuLoadPercent: Math.round(os.loadavg()[0] / os.cpus().length * 100),
+    freeDiskMb,
+    activeRuns
+  };
+}
+function readFileTail(filePath, maxBytes) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size === 0) return "";
+    const start = Math.max(0, stat.size - maxBytes);
+    const fd = fs.openSync(filePath, "r");
+    const buf = Buffer.alloc(Math.min(stat.size, maxBytes));
+    fs.readSync(fd, buf, 0, buf.length, start);
+    fs.closeSync(fd);
+    return buf.toString("utf-8");
+  } catch {
+    return "";
+  }
+}
+function getFileSize(filePath) {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function estimateLines(bytes, tail) {
+  if (bytes === 0 || tail.length === 0) return 0;
+  const tailLines = tail.split("\n").length;
+  if (tail.length >= bytes) return tailLines;
+  return Math.max(tailLines, Math.round(bytes / tail.length * tailLines));
+}
+class ComputeRunner {
+  constructor(opts) {
+    this.handles = /* @__PURE__ */ new Map();
+    this.pollTimer = null;
+    this.pollInFlight = /* @__PURE__ */ new Set();
+    this.store = new RunStore(opts.projectPath);
+    this.experience = new ExperienceStore(opts.projectPath);
+    this.workspacePath = opts.workspacePath;
+    this.projectPath = opts.projectPath;
+    this.reconcileStaleRuns();
+    const active = this.store.getActiveRuns();
+    if (active.length > 0) this.ensurePolling();
+    this.store.evictOld();
+  }
+  /**
+   * On startup, detect and transition stale 'running'/'stalled' records whose
+   * processes are gone (crashed app, killed process, PID reused).
+   */
+  reconcileStaleRuns() {
+    const active = this.store.getActiveRuns();
+    for (const run of active) {
+      if (isStaleRun(run)) {
+        this.store.updateRun(run.runId, {
+          status: "failed",
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: "Process no longer running (app crashed or process was killed).",
+          stalled: false
+        });
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Submit
+  // -------------------------------------------------------------------------
+  async submit(config) {
+    const timeoutMs = Math.min(
+      (config.timeoutMinutes ?? 60) * 6e4,
+      MAX_TIMEOUT_MS
+    );
+    const stallThresholdMs = (config.stallThresholdMinutes ?? 5) * 6e4;
+    const weight = classifyWeight(config.timeoutMinutes ?? 60, config.command);
+    const snapshot = takeSnapshot(this.store);
+    const decision = canAdmit(snapshot, weight);
+    if (!decision.allowed) {
+      throw new Error(`Scheduler: ${decision.reason}`);
+    }
+    const workDir = config.workDir ? path$1.resolve(this.workspacePath, config.workDir) : this.workspacePath;
+    const preflight = await runPreflight({
+      command: config.command,
+      workDir
+    });
+    if (!preflight.passed) {
+      throw new Error(`Preflight failed: ${preflight.blockingIssues.join("; ")}`);
+    }
+    const provider = await getProvider(config.sandbox);
+    const runId = nextRunId();
+    this.store.getRunDir(runId);
+    const outputPath = this.store.getOutputPath(runId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      runId,
+      status: "running",
+      weight,
+      currentPhase: config.smokeCommand ? "smoke" : "full",
+      command: config.command,
+      smokeCommand: config.smokeCommand,
+      workDir: config.workDir ?? ".",
+      sandboxWorkDir: workDir,
+      sandbox: provider.name,
+      env: config.env,
+      createdAt: now,
+      startedAt: now,
+      outputPath,
+      outputBytes: 0,
+      outputLines: 0,
+      timeoutMs,
+      stallThresholdMs,
+      stalled: false,
+      retryCount: config.parentRunId ? (this.store.getRun(config.parentRunId)?.retryCount ?? 0) + 1 : 0,
+      parentRunId: config.parentRunId
+    };
+    this.store.createRun(record);
+    const commandToRun = config.smokeCommand ?? config.command;
+    try {
+      const handle = await provider.spawn({
+        command: commandToRun,
+        workDir,
+        outputPath,
+        env: config.env
+      });
+      this.handles.set(runId, handle);
+      this.ensurePolling();
+      const pid = typeof handle.pid === "number" ? handle.pid : void 0;
+      const pidStartTime = pid ? getPidStartTime(pid) : void 0;
+      if (pid) {
+        this.store.updateRun(runId, { pid, pidStartTime });
+      }
+      handle.wait().then(async (result) => {
+        await this.handleExit(runId, result, config);
+      }).catch(() => {
+      });
+    } catch (err) {
+      this.store.updateRun(runId, {
+        status: "failed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+    return Object.assign(record, { preflight });
+  }
+  // -------------------------------------------------------------------------
+  // Exit handler
+  // -------------------------------------------------------------------------
+  async handleExit(runId, result, config) {
+    const run = this.store.getRun(runId);
+    if (!run || isTerminal(run.status)) return;
+    const stderrPath = this.store.getStderrPath(runId);
+    const stderrTail = readFileTail(stderrPath, STDERR_TAIL_BYTES);
+    if (run.currentPhase === "smoke" && result.exitCode === 0 && config.smokeCommand && config.command !== config.smokeCommand) {
+      this.store.updateRun(runId, {
+        currentPhase: "full",
+        stderrTail
+      });
+      const provider = await getProvider(run.sandbox);
+      try {
+        const handle2 = await provider.spawn({
+          command: config.command,
+          workDir: run.sandboxWorkDir,
+          outputPath: run.outputPath,
+          env: config.env
+        });
+        this.handles.set(runId, handle2);
+        handle2.wait().then(async (fullResult) => {
+          await this.handleExit(runId, fullResult, { ...config, smokeCommand: void 0 });
+        }).catch(() => {
+        });
+        return;
+      } catch (err) {
+        this.store.updateRun(runId, {
+          status: "failed",
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return;
+      }
+    }
+    const status = result.exitCode === 0 ? "completed" : "failed";
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = this.store.updateRun(runId, {
+      status,
+      exitCode: result.exitCode,
+      exitSignal: result.exitSignal,
+      completedAt,
+      stderrTail,
+      stalled: false
+      // Clear stall flag on terminal transition
+    });
+    if (updated) {
+      try {
+        const durationSeconds = updated.startedAt ? Math.round((Date.now() - new Date(updated.startedAt).getTime()) / 1e3) : 0;
+        const taskKind = inferTaskKind(updated.command);
+        const failure2 = status !== "completed" ? deriveFailure(updated) : void 0;
+        this.experience.record({
+          runId,
+          taskKind,
+          sandbox: updated.sandbox,
+          outcome: status === "completed" ? "success" : "failed",
+          failureCode: failure2?.code,
+          durationSeconds,
+          retryCount: updated.retryCount,
+          timestamp: completedAt
+        });
+      } catch {
+      }
+    }
+    const handle = this.handles.get(runId);
+    if (handle) {
+      await handle.cleanup().catch(() => {
+      });
+      this.handles.delete(runId);
+    }
+    this.stopPollingIfIdle();
+  }
+  // -------------------------------------------------------------------------
+  // Stop (cancel)
+  // -------------------------------------------------------------------------
+  async stop(runId) {
+    const run = this.store.getRun(runId);
+    if (!run || isTerminal(run.status)) return;
+    const handle = this.handles.get(runId);
+    if (handle) {
+      await handle.kill("SIGTERM");
+      setTimeout(async () => {
+        await handle.kill("SIGKILL").catch(() => {
+        });
+      }, 3e3);
+    }
+    const stderrPath = this.store.getStderrPath(runId);
+    const stderrTail = readFileTail(stderrPath, STDERR_TAIL_BYTES);
+    this.store.updateRun(runId, {
+      status: "cancelled",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      stderrTail
+    });
+    this.handles.delete(runId);
+    this.stopPollingIfIdle();
+  }
+  // -------------------------------------------------------------------------
+  // Status queries
+  // -------------------------------------------------------------------------
+  getStatus(runId) {
+    const run = this.store.getRun(runId);
+    if (!run) return void 0;
+    const outputTail = readFileTail(run.outputPath, OUTPUT_TAIL_BYTES);
+    const structured = extractProgress(outputTail);
+    const elapsed = run.startedAt ? (Date.now() - new Date(run.startedAt).getTime()) / 1e3 : 0;
+    const failure2 = isTerminal(run.status) ? deriveFailure(run) : void 0;
+    return {
+      status: run.status,
+      currentPhase: run.currentPhase,
+      exitCode: run.exitCode,
+      outputTail,
+      outputBytes: run.outputBytes,
+      outputLines: run.outputLines,
+      elapsedSeconds: Math.round(elapsed),
+      stalled: run.stalled,
+      progress: structured,
+      failure: failure2
+    };
+  }
+  /**
+   * Block until the run reaches a terminal state, stalls, or timeout.
+   */
+  async waitForCompletion(runId, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const status = this.getStatus(runId);
+      if (!status) return void 0;
+      if (isTerminal(status.status)) return status;
+      if (status.stalled) return status;
+      await new Promise((resolve2) => setTimeout(resolve2, Math.min(5e3, deadline - Date.now())));
+    }
+    return this.getStatus(runId);
+  }
+  // -------------------------------------------------------------------------
+  // Polling — shared interval for all active runs
+  // -------------------------------------------------------------------------
+  ensurePolling() {
+    if (this.pollTimer) return;
+    this.pollTimer = setInterval(() => {
+      this.pollAll();
+    }, POLL_INTERVAL_MS);
+    if (this.pollTimer.unref) this.pollTimer.unref();
+  }
+  stopPollingIfIdle() {
+    const active = this.store.getActiveRuns();
+    if (active.length === 0 && this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  pollAll() {
+    const active = this.store.getActiveRuns();
+    for (const record of active) {
+      if (this.pollInFlight.has(record.runId)) continue;
+      this.pollInFlight.add(record.runId);
+      try {
+        this.pollOnce(record.runId);
+      } finally {
+        this.pollInFlight.delete(record.runId);
+      }
+    }
+    this.stopPollingIfIdle();
+  }
+  pollOnce(runId) {
+    const run = this.store.getRun(runId);
+    if (!run || isTerminal(run.status)) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const currentBytes = getFileSize(run.outputPath);
+    const outputGrew = currentBytes > run.outputBytes;
+    const tail = readFileTail(run.outputPath, OUTPUT_TAIL_BYTES);
+    const lines = estimateLines(currentBytes, tail);
+    const patch = {
+      outputBytes: currentBytes,
+      outputLines: lines
+    };
+    if (outputGrew) {
+      patch.lastOutputAt = now;
+      if (run.stalled) {
+        patch.stalled = false;
+        patch.status = "running";
+      }
+    }
+    if (!outputGrew && run.lastOutputAt) {
+      const silentMs = Date.now() - new Date(run.lastOutputAt).getTime();
+      if (silentMs > run.stallThresholdMs && !run.stalled) {
+        patch.stalled = true;
+        patch.status = "stalled";
+      }
+    }
+    if (currentBytes > MAX_OUTPUT_BYTES) {
+      const handle = this.handles.get(run.runId);
+      if (handle) {
+        handle.kill("SIGTERM").catch(() => {
+        });
+        setTimeout(() => {
+          handle.kill("SIGKILL").catch(() => {
+          });
+        }, 3e3);
+        this.handles.delete(run.runId);
+      }
+      const stderrTail = readFileTail(this.store.getStderrPath(run.runId), STDERR_TAIL_BYTES);
+      this.store.updateRun(run.runId, {
+        ...patch,
+        status: "failed",
+        completedAt: now,
+        stalled: false,
+        stderrTail,
+        error: `Output exceeded ${Math.round(MAX_OUTPUT_BYTES / (1024 * 1024))}MB limit. Process killed.`
+      });
+      return;
+    }
+    if (run.startedAt) {
+      const elapsedMs = Date.now() - new Date(run.startedAt).getTime();
+      if (elapsedMs > run.timeoutMs) {
+        const handle = this.handles.get(run.runId);
+        if (handle) {
+          handle.kill("SIGTERM").catch(() => {
+          });
+          setTimeout(() => {
+            handle.kill("SIGKILL").catch(() => {
+            });
+          }, 3e3);
+          this.handles.delete(run.runId);
+        }
+        const stderrTail = readFileTail(this.store.getStderrPath(run.runId), STDERR_TAIL_BYTES);
+        this.store.updateRun(run.runId, {
+          ...patch,
+          status: "timed_out",
+          completedAt: now,
+          stalled: false,
+          // Clear stall flag on terminal transition
+          stderrTail
+        });
+        return;
+      }
+    }
+    this.store.updateRun(run.runId, patch);
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  /**
+   * Stop all active runs and clean up. Called on coordinator destroy / app quit.
+   * Sends SIGTERM, waits up to 5s, then SIGKILL any survivors.
+   */
+  async destroy() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.store.stopFlushTimer();
+    this.store.flushNow();
+    if (this.handles.size === 0) return;
+    const entries = [...this.handles.entries()];
+    for (const [, handle] of entries) {
+      await handle.kill("SIGTERM").catch(() => {
+      });
+    }
+    const deadline = Date.now() + DESTROY_KILL_TIMEOUT_MS;
+    const pending = new Map(entries);
+    while (pending.size > 0 && Date.now() < deadline) {
+      for (const [runId, handle] of pending) {
+        const record = this.store.getRun(runId);
+        if (!record?.pid || !isPidAlive(record.pid)) {
+          pending.delete(runId);
+        }
+      }
+      if (pending.size > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+      }
+    }
+    for (const [, handle] of pending) {
+      await handle.kill("SIGKILL").catch(() => {
+      });
+    }
+    for (const [runId, handle] of entries) {
+      await handle.cleanup().catch(() => {
+      });
+      this.store.updateRun(runId, {
+        status: "cancelled",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        stalled: false
+      });
+    }
+    this.handles.clear();
+    this.store.flushNow();
+  }
+  /**
+   * Get the RunStore for direct queries (used by tools).
+   */
+  getStore() {
+    return this.store;
+  }
+  /**
+   * Get the ExperienceStore for queries.
+   */
+  getExperience() {
+    return this.experience;
+  }
+}
+const PROFILER_SYSTEM_PROMPT = `You are a compute task profiler. Analyze the given script and command, then output a JSON object with these fields:
+
+{
+  "cpuDensity": "low" | "medium" | "high",
+  "gpuDensity": "none" | "light" | "heavy",
+  "memoryPattern": "constant" | "growing" | "spike",
+  "ioPattern": "read_heavy" | "write_heavy" | "balanced" | "minimal",
+  "chunkable": boolean,     // Can be split into smaller data pieces
+  "resumable": boolean,     // Produces checkpoints, can restart
+  "idempotent": boolean,    // Safe to re-run without side effects
+  "hasExternalSideEffects": boolean,  // API calls, DB writes, emails
+  "networkRequired": boolean,
+  "smokeSupported": boolean,  // Has --smoke or similar quick-validation flag
+  "expectedDurationClass": "seconds" | "minutes" | "hours",
+  "confidence": "high" | "medium" | "low",
+  "reasoning": "Brief explanation of your analysis"
+}
+
+Guidelines:
+- cpuDensity: "high" for training loops, simulations, heavy computation
+- gpuDensity: "heavy" if torch/tensorflow/mlx with .fit() or training loops; "light" for inference; "none" for CPU-only
+- memoryPattern: "spike" if large dataset loaded at once; "growing" if accumulating; "constant" if streaming/fixed
+- ioPattern: "read_heavy" if large data loads; "write_heavy" if many output files; "balanced" if both
+- chunkable: true if data can be split (pandas, numpy batch processing)
+- resumable: true if checkpointing detected (torch.save, callbacks)
+- smokeSupported: true ONLY if --smoke, --dry-run, or --validate flag is in argparse/click
+- Be conservative with confidence: "high" only if the pattern is unmistakable
+
+Output ONLY the JSON object, no explanation outside it.`;
+async function profileTask(command, scriptContent, callLlm) {
+  if (!callLlm || !scriptContent) return defaultProfile(command);
+  try {
+    const response = await callLlm(
+      PROFILER_SYSTEM_PROMPT,
+      `Command: ${command}
+
+Script content:
+${scriptContent.slice(0, 8e3)}`
+    );
+    const parsed = parseJsonFromLlm(response);
+    if (!parsed) return defaultProfile(command);
+    return mergeWithDefaults$1(parsed, command);
+  } catch {
+    return defaultProfile(command);
+  }
+}
+function defaultProfile(command) {
+  const cmd = command.toLowerCase();
+  const isTrain = /train|fit|epoch/i.test(cmd);
+  const isViz = /plot|chart|viz|figure|graph/i.test(cmd);
+  return {
+    cpuDensity: isTrain ? "high" : isViz ? "low" : "medium",
+    gpuDensity: "none",
+    memoryPattern: "constant",
+    ioPattern: "balanced",
+    chunkable: false,
+    resumable: false,
+    idempotent: true,
+    hasExternalSideEffects: false,
+    networkRequired: false,
+    smokeSupported: false,
+    expectedDurationClass: isViz ? "seconds" : isTrain ? "hours" : "minutes",
+    confidence: "low",
+    reasoning: "Default profile (LLM unavailable or no script content)."
+  };
+}
+function mergeWithDefaults$1(partial, command) {
+  const defaults = defaultProfile(command);
+  return {
+    cpuDensity: partial.cpuDensity ?? defaults.cpuDensity,
+    gpuDensity: partial.gpuDensity ?? defaults.gpuDensity,
+    memoryPattern: partial.memoryPattern ?? defaults.memoryPattern,
+    ioPattern: partial.ioPattern ?? defaults.ioPattern,
+    chunkable: partial.chunkable ?? defaults.chunkable,
+    resumable: partial.resumable ?? defaults.resumable,
+    idempotent: partial.idempotent ?? defaults.idempotent,
+    hasExternalSideEffects: partial.hasExternalSideEffects ?? defaults.hasExternalSideEffects,
+    networkRequired: partial.networkRequired ?? defaults.networkRequired,
+    smokeSupported: partial.smokeSupported ?? defaults.smokeSupported,
+    expectedDurationClass: partial.expectedDurationClass ?? defaults.expectedDurationClass,
+    confidence: partial.confidence ?? defaults.confidence,
+    reasoning: partial.reasoning ?? defaults.reasoning
+  };
+}
+function parseJsonFromLlm(response) {
+  let text = response.replace(/```json\s*/g, "").replace(/```\s*/g, "").trim();
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+  try {
+    return JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+const execFileAsync = promisify(execFile);
+async function probePython() {
+  let version = "unknown";
+  try {
+    const { stdout } = await execFileAsync("python3", ["--version"], { timeout: 5e3 });
+    version = stdout.trim().replace("Python ", "");
+  } catch {
+  }
+  let packages = [];
+  try {
+    const { stdout } = await execFileAsync("python3", ["-m", "pip", "list", "--format=json"], { timeout: 15e3 });
+    const parsed = JSON.parse(stdout);
+    packages = parsed.map((p) => p.name.toLowerCase());
+  } catch {
+    try {
+      const { stdout } = await execFileAsync("pip3", ["list", "--format=json"], { timeout: 15e3 });
+      const parsed = JSON.parse(stdout);
+      packages = parsed.map((p) => p.name.toLowerCase());
+    } catch {
+    }
+  }
+  return { version, packages };
+}
+async function probeGpu(pipPackages) {
+  const platform = os.platform();
+  const arch = os.arch();
+  if (platform === "darwin" && arch === "arm64") {
+    let mlxAvailable = false;
+    const mlxPackages = [];
+    const mlxRelated = ["mlx", "mlx-nn", "mlx-data", "mlx-lm", "mlx-optimizers", "mlx-audio", "mlx-vlm"];
+    for (const pkg of mlxRelated) {
+      if (pipPackages.includes(pkg)) {
+        mlxPackages.push(pkg);
+      }
+    }
+    if (pipPackages.includes("mlx")) {
+      try {
+        await execFileAsync("python3", ["-c", "import mlx; print(mlx.__version__)"], { timeout: 1e4 });
+        mlxAvailable = true;
+      } catch {
+      }
+    }
+    let model = "Apple Silicon";
+    try {
+      const output = execSync("sysctl -n machdep.cpu.brand_string", { encoding: "utf-8", timeout: 3e3 }).trim();
+      if (output) model = output;
+    } catch {
+    }
+    return {
+      type: "apple_silicon",
+      model,
+      memoryMb: Math.round(os.totalmem() / (1024 * 1024)),
+      // Unified memory
+      mlxAvailable,
+      mlxPackages,
+      cudaAvailable: false,
+      metalAvailable: true
+    };
+  }
+  try {
+    const { stdout } = await execFileAsync("nvidia-smi", [
+      "--query-gpu=name,memory.total",
+      "--format=csv,noheader,nounits"
+    ], { timeout: 5e3 });
+    const parts = stdout.trim().split(",").map((s) => s.trim());
+    return {
+      type: "nvidia",
+      model: parts[0] ?? "NVIDIA GPU",
+      memoryMb: parseInt(parts[1] ?? "0", 10) || void 0,
+      mlxAvailable: false,
+      mlxPackages: [],
+      cudaAvailable: true,
+      metalAvailable: false
+    };
+  } catch {
+  }
+  return {
+    type: "none",
+    model: "No GPU detected",
+    mlxAvailable: false,
+    mlxPackages: [],
+    cudaAvailable: false,
+    metalAvailable: false
+  };
+}
+async function probeDocker() {
+  try {
+    await execFileAsync("docker", ["info"], { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+let cachedProfile = null;
+async function probeStaticProfile() {
+  if (cachedProfile) return cachedProfile;
+  const [python, docker] = await Promise.all([
+    probePython(),
+    probeDocker()
+  ]);
+  const gpu = await probeGpu(python.packages);
+  const platform = os.platform();
+  cachedProfile = {
+    os: platform === "darwin" ? "darwin" : platform === "linux" ? "linux" : "other",
+    arch: os.arch(),
+    cpuCores: os.cpus().length,
+    cpuModel: os.cpus()[0]?.model ?? "Unknown CPU",
+    totalMemoryMb: Math.round(os.totalmem() / (1024 * 1024)),
+    gpu,
+    pythonVersion: python.version,
+    pipPackages: python.packages,
+    dockerAvailable: docker
+  };
+  return cachedProfile;
+}
+function generateAgentGuidance(profile) {
+  const lines = [];
+  lines.push("## Local Compute Environment");
+  lines.push("");
+  lines.push(`Machine: ${profile.os} ${profile.arch}, ${profile.cpuCores} CPU cores, ${profile.totalMemoryMb}MB RAM`);
+  lines.push(`Python: ${profile.pythonVersion}`);
+  if (profile.gpu.type === "apple_silicon") {
+    lines.push(`GPU: ${profile.gpu.model} (${profile.gpu.memoryMb}MB unified memory, Metal available)`);
+    if (profile.gpu.mlxAvailable) {
+      lines.push("");
+      lines.push("### MLX Acceleration Available");
+      lines.push(`Installed MLX packages: ${profile.gpu.mlxPackages.join(", ")}`);
+      lines.push("When writing ML training code for local_compute_execute:");
+      lines.push("- Prefer mlx over PyTorch/TensorFlow for training — native Metal acceleration, no CUDA needed");
+      lines.push("- Use mlx.core.array for GPU-accelerated array operations");
+      lines.push("- Check mlx-community on HuggingFace for MLX-converted model weights");
+      lines.push("- mlx uses lazy evaluation — call mx.eval() to force computation");
+      lines.push("- mlx supports 4-bit quantization via mlx-lm for large models");
+    } else {
+      lines.push("");
+      lines.push("MLX is NOT installed. For Apple Silicon ML acceleration, install: pip install mlx mlx-nn");
+      lines.push("Without MLX, PyTorch MPS backend is available for GPU-accelerated training on Apple Silicon.");
+    }
+  } else if (profile.gpu.type === "nvidia") {
+    lines.push(`GPU: ${profile.gpu.model}${profile.gpu.memoryMb ? ` (${profile.gpu.memoryMb}MB VRAM)` : ""}, CUDA available`);
+    lines.push("PyTorch/TensorFlow can use CUDA acceleration.");
+  } else {
+    lines.push("GPU: None detected. ML training will use CPU only.");
+    lines.push("Consider using smaller models/datasets, or running on a machine with a GPU.");
+  }
+  if (profile.dockerAvailable) {
+    lines.push("");
+    lines.push("Docker: Available. Can use docker sandbox for stronger isolation.");
+  }
+  lines.push("");
+  lines.push("### Sandbox Guidelines");
+  lines.push("When writing scripts for local_compute_execute:");
+  lines.push("- All required packages must be importable (preflight checks imports before running)");
+  lines.push("- For long-running tasks, consider adding a --smoke flag for quick validation");
+  lines.push('- Print progress lines: ##PROGRESS## {"step": N, "total": M, "loss": 0.85, "phase": "training"}');
+  lines.push("- Write output files to the working directory (results, figures, checkpoints)");
+  return lines.join("\n");
+}
+const RISK_ASSESSMENT_PROMPT = `You are a compute execution risk assessor. Given the task profile, system environment, and past experience, assess risks and recommend execution parameters.
+
+Output a JSON object:
+{
+  "feasible": boolean,
+  "risks": [
+    { "severity": "low"|"medium"|"high"|"blocking", "category": "memory"|"disk"|"gpu"|"dependency"|"network"|"timeout", "message": "...", "mitigation": "..." }
+  ],
+  "recommendedSandbox": "docker" | "process",
+  "recommendedTimeoutMinutes": number,
+  "recommendedStallThresholdMinutes": number,
+  "warnings": ["..."],
+  "agentGuidance": ["tips for the coding agent..."]
+}
+
+Guidelines:
+- Mark "blocking" severity only for showstopper issues (no GPU when GPU required, <100MB disk)
+- recommendedTimeoutMinutes: use experience average × 2 if available, else estimate from task type
+- recommendedSandbox: prefer "process" on macOS (Docker lacks GPU passthrough), "docker" on Linux with NVIDIA
+- For Apple Silicon with MLX: recommend process sandbox for Metal GPU access
+- Be actionable in mitigations and guidance
+
+Output ONLY the JSON object.`;
+async function assessRisk(opts) {
+  const { taskProfile, env, snapshot, experience, command, callLlm } = opts;
+  if (!callLlm) return defaultAdvice(env, snapshot);
+  try {
+    const facts = formatFacts(taskProfile, env, snapshot, experience, command);
+    const response = await callLlm(RISK_ASSESSMENT_PROMPT, facts);
+    const parsed = parseJsonFromLlm(response);
+    if (!parsed) return defaultAdvice(env, snapshot);
+    return mergeWithDefaults(parsed, env, snapshot);
+  } catch {
+    return defaultAdvice(env, snapshot);
+  }
+}
+function formatFacts(taskProfile, env, snapshot, experience, command) {
+  const sections = [];
+  if (taskProfile) {
+    sections.push(`## Task Profile
+${JSON.stringify(taskProfile, null, 2)}`);
+  }
+  sections.push(`## Command
+${command}`);
+  sections.push(`## Environment
+OS: ${env.os} ${env.arch}
+CPU: ${env.cpuCores} cores (${env.cpuModel})
+RAM: ${env.totalMemoryMb}MB total, ~${snapshot.freeMemoryMb}MB free
+GPU: ${env.gpu.type === "none" ? "None" : `${env.gpu.model} (${env.gpu.type})`}
+MLX: ${env.gpu.mlxAvailable ? `Yes (${env.gpu.mlxPackages.join(", ")})` : "No"}
+CUDA: ${env.gpu.cudaAvailable ? "Yes" : "No"}
+Python: ${env.pythonVersion}
+Docker: ${env.dockerAvailable ? "Yes" : "No"}
+Disk free: ~${snapshot.freeDiskMb}MB
+CPU load: ${snapshot.cpuLoadPercent}%
+Active runs: ${snapshot.activeRuns.length}`);
+  if (experience) {
+    sections.push(`## Past Experience (${experience.taskKind})
+Total runs: ${experience.totalRuns}
+Successes: ${experience.successes}, Failures: ${experience.failures}
+${experience.avgDurationSeconds ? `Avg duration: ${Math.round(experience.avgDurationSeconds / 60)} min` : ""}
+${Object.keys(experience.commonFailures).length > 0 ? `Common failures: ${JSON.stringify(experience.commonFailures)}` : ""}`);
+  }
+  return sections.join("\n\n");
+}
+function defaultAdvice(env, snapshot) {
+  const risks = [];
+  const warnings = [];
+  if (snapshot.freeMemoryMb < 1e3) {
+    risks.push({
+      severity: snapshot.freeMemoryMb < 500 ? "high" : "medium",
+      category: "memory",
+      message: `Only ${snapshot.freeMemoryMb}MB free memory.`,
+      mitigation: "Close memory-intensive applications."
+    });
+  }
+  if (snapshot.freeDiskMb < 2e3) {
+    risks.push({
+      severity: snapshot.freeDiskMb < 500 ? "blocking" : "medium",
+      category: "disk",
+      message: `Only ${snapshot.freeDiskMb}MB free disk space.`
+    });
+  }
+  if (snapshot.cpuLoadPercent > 80) {
+    warnings.push(`High CPU load (${snapshot.cpuLoadPercent}%). Run may be slower than expected.`);
+  }
+  return {
+    feasible: !risks.some((r) => r.severity === "blocking"),
+    risks,
+    recommendedSandbox: "process",
+    recommendedTimeoutMinutes: 60,
+    recommendedStallThresholdMinutes: 5,
+    warnings,
+    agentGuidance: []
+  };
+}
+function mergeWithDefaults(partial, env, snapshot) {
+  const defaults = defaultAdvice(env, snapshot);
+  return {
+    feasible: partial.feasible ?? defaults.feasible,
+    risks: partial.risks ?? defaults.risks,
+    recommendedSandbox: partial.recommendedSandbox ?? defaults.recommendedSandbox,
+    recommendedTimeoutMinutes: partial.recommendedTimeoutMinutes ?? defaults.recommendedTimeoutMinutes,
+    recommendedStallThresholdMinutes: partial.recommendedStallThresholdMinutes ?? defaults.recommendedStallThresholdMinutes,
+    warnings: partial.warnings ?? defaults.warnings,
+    agentGuidance: partial.agentGuidance ?? defaults.agentGuidance
+  };
+}
+function createLocalComputeTools(ctx) {
+  const runner = new ComputeRunner({
+    projectPath: ctx.projectPath,
+    workspacePath: ctx.workspacePath
+  });
+  const tools = [
+    createPlanTool(runner, ctx),
+    createExecuteTool(runner, ctx),
+    createWaitTool(runner),
+    createStatusTool(runner),
+    createStopTool(runner)
+  ];
+  return {
+    tools,
+    destroy: () => runner.destroy()
+  };
+}
+function createPlanTool(runner, ctx) {
+  return {
+    name: "local_compute_plan",
+    label: "Local Compute: Plan",
+    description: "Analyze a script before execution: profile the task, assess risks, and get recommendations.\nOptional — you can skip this and call local_compute_execute directly for simple tasks.\nUse this for complex or risky tasks (large datasets, GPU training, unfamiliar code).",
+    parameters: Type.Object({
+      command: Type.String({ description: "Shell command to execute" }),
+      script_path: Type.Optional(Type.String({ description: "Relative path to the main script (for deeper analysis)" })),
+      sandbox: Type.Optional(Type.String({ description: '"docker" | "process" | "auto"' })),
+      timeout_minutes: Type.Optional(Type.Number({ description: "Suggested timeout" })),
+      smoke_command: Type.Optional(Type.String({ description: 'Quick validation command (e.g., "python3 script.py --smoke")' }))
+    }),
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const command = typeof params.command === "string" ? params.command.trim() : "";
+      if (!command) {
+        return toAgentResult("local_compute_plan", toolError("MISSING_PARAMETER", "command is required."));
+      }
+      let scriptContent;
+      if (typeof params.script_path === "string") {
+        const scriptPath = path$1.isAbsolute(params.script_path) ? params.script_path : path$1.resolve(ctx.workspacePath, params.script_path);
+        try {
+          scriptContent = fs.readFileSync(scriptPath, "utf-8");
+        } catch {
+        }
+      }
+      const taskProfile = await profileTask(command, scriptContent, ctx.callLlm);
+      let env;
+      try {
+        env = await probeStaticProfile();
+      } catch {
+        return toAgentResult("local_compute_plan", toolError("EXECUTION_FAILED", "Failed to probe system environment."));
+      }
+      let freeDiskMb = 1e4;
+      try {
+        const dfOut = execSync("df -m .", { cwd: ctx.workspacePath, encoding: "utf-8", timeout: 3e3 });
+        const parts = dfOut.trim().split("\n")[1]?.split(/\s+/);
+        const avail = parseInt(parts?.[3] ?? "", 10);
+        if (!isNaN(avail)) freeDiskMb = avail;
+      } catch {
+      }
+      const snapshot = {
+        freeMemoryMb: Math.round(os.freemem() / (1024 * 1024)),
+        cpuLoadPercent: Math.round(os.loadavg()[0] / os.cpus().length * 100),
+        freeDiskMb,
+        activeRuns: runner.getStore().getActiveRuns().map((r) => ({ runId: r.runId, weight: r.weight }))
+      };
+      const taskKind = inferTaskKind(command, scriptContent);
+      const experience = runner.getExperience().summarize(taskKind);
+      const riskAdvice = await assessRisk({
+        taskProfile,
+        env,
+        snapshot,
+        experience,
+        command,
+        callLlm: ctx.callLlm
+      });
+      return toAgentResult("local_compute_plan", {
+        success: true,
+        data: {
+          task_profile: taskProfile,
+          risk_assessment: {
+            feasible: riskAdvice.feasible,
+            risks: riskAdvice.risks,
+            warnings: riskAdvice.warnings
+          },
+          recommendations: {
+            sandbox: riskAdvice.recommendedSandbox,
+            timeout_minutes: riskAdvice.recommendedTimeoutMinutes,
+            stall_threshold_minutes: riskAdvice.recommendedStallThresholdMinutes,
+            agent_guidance: riskAdvice.agentGuidance
+          },
+          experience_summary: experience ? {
+            task_kind: experience.taskKind,
+            total_runs: experience.totalRuns,
+            successes: experience.successes,
+            failures: experience.failures,
+            avg_duration_seconds: experience.avgDurationSeconds,
+            common_failures: experience.commonFailures
+          } : null
+        }
+      });
     }
   };
 }
-const execFileAsync = promisify(execFile);
-const DATA_ANALYSIS_SYSTEM = loadPrompt("data-analysis-system");
-const DATA_ANALYSIS_TASKS = loadPrompt("data-analysis-tasks");
-const DATA_CODE_TEMPLATE = loadPrompt("data-code-template");
-const TASK_DESCRIPTIONS = {
-  analyze: "Statistical Analysis",
-  visualize: "Data Visualization",
-  transform: "Data Transformation",
-  model: "Statistical Modeling"
-};
-const DataAnalyzeSchema = Type.Object({
-  file_path: Type.String({ description: "Relative path to data file (CSV, JSON, TSV, XLSX)" }),
-  instructions: Type.String({ description: "What analysis to perform" }),
-  task_type: Type.Optional(
-    Type.String({ description: "analyze | visualize | transform | model (default: analyze)" })
-  )
-});
-function createDataAnalyzeTool(ctx) {
+function createExecuteTool(runner, ctx) {
   return {
-    name: "data_analyze",
-    label: "Data Analysis",
-    description: "Analyze a dataset using Python. Supports statistics, visualization (matplotlib/seaborn), data transformation, and modeling. Generated outputs (figures, tables) are saved to disk.\nUsage guidelines: (1) Use this tool for ANY analysis, visualization, statistics, or modeling — do not compute from raw data with read/grep. (2) Generate only the outputs the user requested; no extras.",
-    parameters: DataAnalyzeSchema,
+    name: "local_compute_execute",
+    label: "Local Compute: Execute",
+    description: 'Execute a command in a sandboxed local environment. Use this for long-running tasks like ML training, data preprocessing, or heavy analysis that may take minutes to hours.\nThe command runs asynchronously. Use local_compute_wait or local_compute_status to monitor.\nFor long-running scripts, consider adding a --smoke flag for quick validation.\n\nProgress monitoring: print lines starting with ##PROGRESS## followed by JSON for structured progress:\n  ##PROGRESS## {"step": 3, "total": 10, "loss": 0.85, "phase": "training"}',
+    parameters: Type.Object({
+      command: Type.String({ description: 'Shell command to execute (e.g., "python3 train.py")' }),
+      work_dir: Type.Optional(Type.String({ description: "Relative path within workspace (default: workspace root)" })),
+      sandbox: Type.Optional(Type.String({ description: '"docker" | "process" | "auto" (default: auto)' })),
+      timeout_minutes: Type.Optional(Type.Number({ description: "Max runtime in minutes (default: 60, max: 1440)" })),
+      stall_threshold_minutes: Type.Optional(Type.Number({ description: "Minutes without output before flagging stall (default: 5)" })),
+      env: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "Extra environment variables" })),
+      smoke_command: Type.Optional(Type.String({ description: 'Quick validation command (e.g., "python3 train.py --smoke"). Runs before full command.' })),
+      parent_run_id: Type.Optional(Type.String({ description: "Previous failed run ID (for retry lineage tracking)" }))
+    }),
     execute: async (_toolCallId, rawParams) => {
       const params = rawParams;
-      const filePath = typeof params.file_path === "string" ? params.file_path.trim() : "";
-      const instructions = typeof params.instructions === "string" ? params.instructions.trim() : "";
-      const taskType = typeof params.task_type === "string" ? params.task_type.trim().toLowerCase() : "analyze";
-      if (!filePath) {
-        return toAgentResult("data_analyze", toolError("MISSING_PARAMETER", "Missing file_path.", {
-          suggestions: ["Provide a relative path to the data file (CSV, JSON, TSV, or XLSX)."]
+      const command = typeof params.command === "string" ? params.command.trim() : "";
+      if (!command) {
+        return toAgentResult("local_compute_execute", toolError("MISSING_PARAMETER", "command is required.", {
+          suggestions: ['Provide a shell command to execute (e.g., "python3 train.py").']
         }));
       }
-      if (!instructions) {
-        return toAgentResult("data_analyze", toolError("MISSING_PARAMETER", "Missing instructions.", {
-          suggestions: ["Describe what analysis to perform on the data."]
+      const config = {
+        command,
+        workDir: typeof params.work_dir === "string" ? params.work_dir : void 0,
+        sandbox: typeof params.sandbox === "string" ? params.sandbox : "auto",
+        timeoutMinutes: typeof params.timeout_minutes === "number" ? params.timeout_minutes : 60,
+        stallThresholdMinutes: typeof params.stall_threshold_minutes === "number" ? params.stall_threshold_minutes : 5,
+        env: typeof params.env === "object" && params.env !== null ? params.env : void 0,
+        smokeCommand: typeof params.smoke_command === "string" ? params.smoke_command : void 0,
+        parentRunId: typeof params.parent_run_id === "string" ? params.parent_run_id : void 0
+      };
+      try {
+        const run = await runner.submit(config);
+        ctx.onToolCall?.("local_compute_execute", { command, runId: run.runId });
+        return toAgentResult("local_compute_execute", {
+          success: true,
+          data: {
+            run_id: run.runId,
+            sandbox: run.sandbox,
+            status: run.status,
+            current_phase: run.currentPhase,
+            output_path: run.outputPath,
+            weight: run.weight
+          }
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.startsWith("Scheduler:")) {
+          return toAgentResult("local_compute_execute", toolError("EXECUTION_FAILED", msg, {
+            retryable: true,
+            suggestions: ["Wait for the active run to finish, or stop it with local_compute_stop."]
+          }));
+        }
+        return toAgentResult("local_compute_execute", toolError("EXECUTION_FAILED", msg, {
+          retryable: false,
+          suggestions: ["Check the command and try again."]
         }));
       }
-      if (!["analyze", "visualize", "transform", "model"].includes(taskType)) {
-        return toAgentResult("data_analyze", toolError("INVALID_PARAMETER", `Invalid task_type: ${taskType}. Use: analyze | visualize | transform | model.`, {
-          suggestions: ["Valid task types: analyze, visualize, transform, model."]
+    }
+  };
+}
+function createWaitTool(runner) {
+  return {
+    name: "local_compute_wait",
+    label: "Local Compute: Wait",
+    description: "Wait for a compute run to complete. Blocks until the run finishes, stalls, or the wait timeout elapses.\nReturns immediately if the run has already completed or stalled.",
+    parameters: Type.Object({
+      run_id: Type.String({ description: "The run ID returned by local_compute_execute" }),
+      timeout_seconds: Type.Optional(Type.Number({ description: "Max seconds to wait (default: 120, max: 600)" }))
+    }),
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const runId = typeof params.run_id === "string" ? params.run_id.trim() : "";
+      if (!runId) {
+        return toAgentResult("local_compute_wait", toolError("MISSING_PARAMETER", "run_id is required."));
+      }
+      const timeoutSec = typeof params.timeout_seconds === "number" ? Math.min(params.timeout_seconds, 600) : 120;
+      const result = await runner.waitForCompletion(runId, timeoutSec * 1e3);
+      if (!result) {
+        return toAgentResult("local_compute_wait", toolError("NOT_FOUND", `Run not found: ${runId}`, {
+          suggestions: ["Check the run_id. Use local_compute_execute to start a new run."]
         }));
       }
-      const absDataFile = path$1.resolve(ctx.workspacePath, filePath);
-      if (!fs.existsSync(absDataFile)) {
-        return toAgentResult("data_analyze", toolError("FILE_NOT_FOUND", `File not found: ${filePath}`, {
-          suggestions: [
-            "Verify the file path is relative to the workspace root.",
-            "Use the find or glob tool to locate the data file."
-          ],
-          context: { workspacePath: ctx.workspacePath, resolvedPath: absDataFile }
-        }));
+      return toAgentResult("local_compute_wait", {
+        success: true,
+        data: formatStatusResult(runId, result)
+      });
+    }
+  };
+}
+function createStatusTool(runner) {
+  return {
+    name: "local_compute_status",
+    label: "Local Compute: Status",
+    description: "Check the current status of a compute run. Non-blocking — returns immediately.\nIncludes output tail, progress, stall detection, and failure analysis.",
+    parameters: Type.Object({
+      run_id: Type.String({ description: "The run ID to check" })
+    }),
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const runId = typeof params.run_id === "string" ? params.run_id.trim() : "";
+      if (!runId) {
+        return toAgentResult("local_compute_status", toolError("MISSING_PARAMETER", "run_id is required."));
       }
-      const runId = Date.now().toString(36);
-      const outputBase = path$1.join(ctx.workspacePath, ".research-pilot", "data-runs", runId);
-      const figuresDir = path$1.join(outputBase, "figures");
-      const tablesDir = path$1.join(outputBase, "tables");
-      const dataDir = path$1.join(outputBase, "data");
-      fs.mkdirSync(figuresDir, { recursive: true });
-      fs.mkdirSync(tablesDir, { recursive: true });
-      fs.mkdirSync(dataDir, { recursive: true });
-      const resultsFile = path$1.join(outputBase, "results.json");
-      const rawPreview = fs.readFileSync(absDataFile, "utf-8").slice(0, 2e3);
-      const ext = path$1.extname(absDataFile).toLowerCase();
-      const formatHint = ext === ".csv" ? "CSV" : ext === ".tsv" ? "TSV" : ext === ".json" ? "JSON" : ext === ".xlsx" ? "XLSX" : "unknown";
-      if (!ctx.callLlm) {
-        return toAgentResult("data_analyze", toolError("LLM_UNAVAILABLE", "LLM not available for code generation.", {
-          suggestions: ["Ensure the agent runtime has an LLM provider configured (callLlm in ResearchToolContext)."]
-        }));
+      const result = runner.getStatus(runId);
+      if (!result) {
+        return toAgentResult("local_compute_status", toolError("NOT_FOUND", `Run not found: ${runId}`));
       }
-      const taskSection = DATA_ANALYSIS_TASKS.split(/^## /m).find((s) => s.startsWith(taskType));
-      const taskDesc = taskSection ? `## ${taskSection}` : "";
-      const userPrompt = [
-        `Task type: ${taskType} (${TASK_DESCRIPTIONS[taskType] ?? "Analysis"})`,
-        "",
-        taskDesc,
-        "",
-        `Data file format: ${formatHint}`,
-        `Data file preview (first 2000 chars):`,
-        "```",
-        rawPreview,
-        "```",
-        "",
-        `Instructions: ${instructions}`,
-        "",
-        "IMPORTANT: Use the pre-defined path variables (DATA_FILE, FIGURES_DIR, TABLES_DIR, DATA_DIR, RESULTS_FILE).",
-        "Call write_results() at the end with your outputs list and summary dict.",
-        "Output ONLY the Python code in a ```python code block."
-      ].join("\n");
-      let generatedCode;
-      try {
-        const llmResponse = await ctx.callLlm(DATA_ANALYSIS_SYSTEM, userPrompt);
-        const codeMatch = llmResponse.match(/```python\n([\s\S]*?)```/) || llmResponse.match(/```\n([\s\S]*?)```/);
-        generatedCode = codeMatch ? codeMatch[1] : llmResponse;
-      } catch (err) {
-        return toAgentResult("data_analyze", toolError("EXECUTION_FAILED", `Code generation failed: ${err.message}`, {
-          retryable: true,
-          suggestions: ["Retry — the LLM may produce valid code on a subsequent attempt.", "Try simplifying the instructions."]
-        }));
+      return toAgentResult("local_compute_status", {
+        success: true,
+        data: formatStatusResult(runId, result)
+      });
+    }
+  };
+}
+function createStopTool(runner) {
+  return {
+    name: "local_compute_stop",
+    label: "Local Compute: Stop",
+    description: "Stop (cancel) a running compute task. The process is killed.",
+    parameters: Type.Object({
+      run_id: Type.String({ description: "The run ID to stop" })
+    }),
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const runId = typeof params.run_id === "string" ? params.run_id.trim() : "";
+      if (!runId) {
+        return toAgentResult("local_compute_stop", toolError("MISSING_PARAMETER", "run_id is required."));
       }
-      const pathDefinitions = [
-        "",
-        "# Pre-defined paths (set by the tool runtime)",
-        `DATA_FILE = ${JSON.stringify(absDataFile)}`,
-        `FIGURES_DIR = ${JSON.stringify(figuresDir)}`,
-        `TABLES_DIR = ${JSON.stringify(tablesDir)}`,
-        `DATA_DIR = ${JSON.stringify(dataDir)}`,
-        `RESULTS_FILE = ${JSON.stringify(resultsFile)}`,
-        ""
-      ].join("\n");
-      const fullScript = DATA_CODE_TEMPLATE + pathDefinitions + "\n" + generatedCode;
-      const scriptPath = path$1.join(outputBase, "script.py");
-      fs.writeFileSync(scriptPath, fullScript, "utf-8");
       try {
-        const { stdout, stderr } = await execFileAsync("python3", [scriptPath], {
-          cwd: ctx.workspacePath,
-          timeout: 12e4,
-          // 2 minutes
-          maxBuffer: 10 * 1024 * 1024
+        await runner.stop(runId);
+        return toAgentResult("local_compute_stop", {
+          success: true,
+          data: { run_id: runId, status: "cancelled" }
         });
-        let manifest = null;
-        if (fs.existsSync(resultsFile)) {
-          try {
-            manifest = JSON.parse(fs.readFileSync(resultsFile, "utf-8"));
-          } catch {
-          }
-        }
-        const outputs = [];
-        for (const [dir, type] of [
-          [figuresDir, "figure"],
-          [tablesDir, "table"],
-          [dataDir, "data"]
-        ]) {
-          if (fs.existsSync(dir)) {
-            for (const f of fs.readdirSync(dir)) {
-              outputs.push({
-                name: f,
-                type,
-                path: path$1.relative(ctx.workspacePath, path$1.join(dir, f))
-              });
-            }
-          }
-        }
-        const payload = {
-          stdout: stdout.slice(0, 4e3),
-          stderr: stderr ? stderr.slice(0, 1e3) : void 0,
-          outputs,
-          manifest: manifest ? {
-            summary: manifest.summary,
-            warnings: manifest.warnings
-          } : void 0,
-          scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
-          runId
-        };
-        return toAgentResult("data_analyze", { success: true, data: payload });
       } catch (err) {
-        const errorDetail = err.stderr?.slice(0, 2e3) || err.message;
-        return toAgentResult("data_analyze", toolError("EXECUTION_FAILED", `Python execution failed: ${errorDetail}`, {
-          retryable: true,
-          suggestions: [
-            `Review the generated script at ${path$1.relative(ctx.workspacePath, scriptPath)} for errors.`,
-            "Check that required Python packages (pandas, matplotlib, seaborn, etc.) are installed.",
-            "Try simplifying the analysis instructions."
-          ],
-          context: {
-            scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
-            runId
-          },
-          data: {
-            scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
-            runId
-          }
-        }));
+        return toAgentResult("local_compute_stop", toolError(
+          "EXECUTION_FAILED",
+          err instanceof Error ? err.message : String(err)
+        ));
       }
     }
   };
 }
+function formatStatusResult(runId, result) {
+  const data = {
+    run_id: runId,
+    status: result.status,
+    current_phase: result.currentPhase,
+    elapsed_seconds: result.elapsedSeconds,
+    output_bytes: result.outputBytes,
+    output_lines: result.outputLines,
+    stalled: result.stalled
+  };
+  if (result.exitCode !== void 0) data.exit_code = result.exitCode;
+  if (result.outputTail) data.output_tail = result.outputTail;
+  if (result.progress) data.progress = result.progress;
+  if (result.failure) data.failure = result.failure;
+  return data;
+}
 function wrapResearchTool(tool) {
   const properties = {};
   const jsonProps = tool.parameters.properties ?? {};
@@ -4049,6 +6207,7 @@ function wrapResearchTool(tool) {
 }
 function createResearchTools(ctx) {
   const tools = [];
+  const destroyers = [];
   tools.push(createWebSearchTool());
   tools.push(createWebFetchTool(ctx));
   tools.push(createLiteratureSearchTool(ctx));
@@ -4065,7 +6224,20 @@ function createResearchTools(ctx) {
   for (const tool of structuredMemoryTools) {
     tools.push(wrapResearchTool(tool));
   }
-  return tools;
+  if (process.env.ENABLE_LOCAL_COMPUTE === "1") {
+    const compute = createLocalComputeTools(ctx);
+    tools.push(...compute.tools);
+    destroyers.push(compute.destroy);
+  }
+  return {
+    tools,
+    destroy: async () => {
+      for (const d of destroyers) {
+        await d().catch(() => {
+        });
+      }
+    }
+  };
 }
 const VALID_TYPES = ["user", "feedback", "project", "reference"];
 const EXTRACTION_PROMPT = `Analyze the recent conversation above and extract information worth remembering across sessions.
@@ -4611,6 +6783,7 @@ function writeExplainSnapshot(projectPath, snapshot) {
 async function createCoordinator(config) {
   const {
     apiKey,
+    getApiKeyOverride,
     model: modelId,
     projectPath = process.cwd(),
     debug = false,
@@ -4623,6 +6796,7 @@ async function createCoordinator(config) {
     onUsage,
     onSkillLoaded
   } = config;
+  const resolveApiKey = getApiKeyOverride ?? (async () => apiKey);
   let turnCount = 0;
   let activeTurnToolCallCount = null;
   const turnHistory = [];
@@ -4667,13 +6841,15 @@ async function createCoordinator(config) {
     const routerByProvider = {
       anthropic: "claude-haiku-4-5-20251001",
       openai: "gpt-5.4-nano",
+      "openai-codex": "gpt-5.4-mini",
+      // nano not available in openai-codex provider
       google: "gemini-2.0-flash-lite"
     };
     let mainProvider = null;
     if (modelId) {
       const parts = modelId.split(":");
       if (parts.length === 2) {
-        mainProvider = parts[0];
+        mainProvider = parts[0] === "openai-codex" ? "openai-codex" : parts[0];
       } else {
         mainProvider = modelId.startsWith("claude-") ? "anthropic" : modelId.startsWith("gpt-") || modelId.startsWith("o3") || modelId.startsWith("o4") ? "openai" : modelId.startsWith("gemini-") ? "google" : null;
       }
@@ -4703,17 +6879,18 @@ async function createCoordinator(config) {
     projectPath,
     callLlm: async (systemPrompt, userContent) => {
       if (!piModel) throw new Error("No model available for sub-call");
+      const currentKey = await resolveApiKey();
       const result = await completeSimple(piModel, {
         systemPrompt,
         messages: [{ role: "user", content: userContent, timestamp: Date.now() }]
-      }, { maxTokens: 4096, apiKey });
+      }, { maxTokens: 4096, apiKey: currentKey });
       const textContent = result.content.find((c) => c.type === "text");
       return textContent?.text ?? "";
     },
     onToolCall,
     onToolResult: wrappedOnToolResult
   };
-  const researchAgentTools = createResearchTools(toolCtx);
+  const { tools: researchAgentTools, destroy: destroyResearchTools } = createResearchTools(toolCtx);
   const codingTools = createCodingTools(projectPath);
   const grepTool = createGrepTool(projectPath);
   const findTool = createFindTool(projectPath);
@@ -4736,17 +6913,17 @@ async function createCoordinator(config) {
     loadSkillTool
   ];
   const skillsCatalog = buildSkillsCatalogPrompt(skills);
-  const fullSystemPrompt = skillsCatalog ? SYSTEM_PROMPT + "\n\n" + skillsCatalog : SYSTEM_PROMPT;
+  const baseSystemPrompt = SYSTEM_PROMPT + (skillsCatalog ? "\n\n" + skillsCatalog : "");
   let compactionSummary;
   const agent = new Agent({
     initialState: {
-      systemPrompt: fullSystemPrompt,
+      systemPrompt: baseSystemPrompt,
       model: piModel ?? void 0,
       tools: allTools,
       thinkingLevel: reasoningEffort === "high" ? "high" : reasoningEffort === "medium" ? "medium" : "low"
     },
     sessionId,
-    getApiKey: async () => apiKey,
+    getApiKey: resolveApiKey,
     // ── Context compaction via transformContext ──
     // Before each LLM call, check if accumulated messages exceed the model's
     // context window.  If so, summarize old messages and keep only recent ones.
@@ -4785,11 +6962,12 @@ async function createCoordinator(config) {
       const messagesToSummarize = messages.slice(0, cutIndex);
       const messagesToKeep = messages.slice(cutIndex);
       try {
+        const currentKey = await resolveApiKey();
         const summary = await generateSummary(
           messagesToSummarize,
           piModel,
           settings.reserveTokens,
-          apiKey,
+          currentKey,
           signal,
           void 0,
           compactionSummary
@@ -4878,6 +7056,7 @@ The conversation continues below.`,
     const historyText = turnHistory.map((t, i) => `Turn ${turnCount - turnHistory.length + i + 1}: User: ${t.userMessage}
 Assistant: ${t.response}`).join("\n\n");
     try {
+      const currentKey = await resolveApiKey();
       const result = await completeSimple(intentRouterModel, {
         systemPrompt: "You summarize research conversations concisely. Output JSON with keys: summary (string), topicsDiscussed (string[]), openQuestions (string[]). Output ONLY valid JSON.",
         messages: [{
@@ -4889,7 +7068,7 @@ ${historyText}`,
         }]
       }, {
         maxTokens: 512,
-        apiKey
+        apiKey: currentKey
       });
       const textContent = result.content.find((c) => c.type === "text");
       const text = textContent?.text?.trim() ?? "";
@@ -4915,12 +7094,20 @@ ${historyText}`,
       }
     }
   }
+  if (process.env.ENABLE_LOCAL_COMPUTE === "1") {
+    probeStaticProfile().then((profile) => {
+      const envGuidance = generateAgentGuidance(profile);
+      agent.setSystemPrompt(baseSystemPrompt + "\n\n" + envGuidance);
+    }).catch(() => {
+    });
+  }
   return {
     agent,
     async chat(message, mentions, images) {
       try {
         const intents = detectIntentsByRules(message);
-        const matchedSkillNames = await matchSkillsWithLLM(intentRouterModel, apiKey, message, skills);
+        const currentKey = await resolveApiKey();
+        const matchedSkillNames = await matchSkillsWithLLM(intentRouterModel, currentKey, message, skills);
         const matchedSkills = matchedSkillNames.map((name) => skills.find((s) => s.name === name)).filter((s) => s !== void 0);
         for (const s of matchedSkills) {
           onSkillLoaded?.(s.name);
@@ -4961,7 +7148,7 @@ ${historyText}`,
           console.log(`[Chat] Matched skills: ${skillList}`);
           console.log(`[Chat] Sending message to agent (${mentions?.filter((m) => !m.error).length ?? 0} mentions, summary=${!!latestSummary})...`);
         }
-        let enrichedSystem = fullSystemPrompt;
+        let enrichedSystem = baseSystemPrompt;
         if (agentMdContent) {
           enrichedSystem = `${enrichedSystem}
 
@@ -5024,8 +7211,9 @@ ${message}` : message;
         });
         if (turnHistory.length > 8) turnHistory.shift();
         void maybeGenerateSummary();
+        const memoryKey = await resolveApiKey();
         void maybeExtractMemories(
-          { projectPath, model: piModel, apiKey, systemPrompt: enrichedSystem, debug },
+          { projectPath, model: piModel, apiKey: memoryKey, systemPrompt: enrichedSystem, debug },
           agent.state.messages,
           turnCount
         );
@@ -5048,6 +7236,7 @@ ${message}` : message;
     clearSessionMemory,
     async destroy() {
       agent.abort();
+      await destroyResearchTools();
     }
   };
 }
@@ -6717,7 +8906,7 @@ let ipcHandlersRegistered = false;
 function createWindowRuntimeState() {
   return {
     coordinator: null,
-    currentModel: "gpt-5.4",
+    currentModel: "openai:gpt-5.4",
     currentReasoningEffort: "medium",
     currentAuthMode: "none",
     projectPath: "",
@@ -6848,11 +9037,27 @@ async function ensureCoordinator(state, win, model, options) {
   if (!state.coordinator) {
     const apiKey = resolvedAuth.apiKey;
     const runProjectPath = state.projectPath;
+    const getApiKeyOverride = resolvedAuth.authMode === "subscription" ? async () => {
+      const creds = loadCodexCredentials();
+      if (!creds) throw new Error("ChatGPT subscription credentials not found. Please sign in again.");
+      if (creds.expires < Date.now() + 6e4) {
+        try {
+          const { refreshOpenAICodexToken } = await import("@mariozechner/pi-ai/oauth");
+          const newCreds = await refreshOpenAICodexToken(creds);
+          saveCodexCredentials(newCreds);
+          return newCreds.access;
+        } catch {
+          return creds.access;
+        }
+      }
+      return creds.access;
+    } : void 0;
     const initEvent = { type: "system", summary: "Initializing agent (first run may take 1-2 minutes for document processing setup)..." };
     state.realtimeBuffer.pushActivity(initEvent);
     safeSend(win, "agent:activity", initEvent);
     state.coordinator = await createCoordinator({
       apiKey,
+      getApiKeyOverride,
       model: state.currentModel,
       reasoningEffort: state.currentReasoningEffort,
       projectPath: state.projectPath,
@@ -6925,6 +9130,49 @@ async function ensureCoordinator(state, win, model, options) {
             }
           }
         }
+        if (tool === "local_compute_execute" && result && typeof result === "object" && "success" in result) {
+          const cr = result;
+          if (cr.success && cr.data) {
+            safeSend(win, "compute:run-update", {
+              runId: cr.data.run_id,
+              status: cr.data.status,
+              currentPhase: cr.data.current_phase,
+              command: args?.command ?? "",
+              sandbox: cr.data.sandbox,
+              weight: cr.data.weight,
+              startedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        if ((tool === "local_compute_status" || tool === "local_compute_wait") && result && typeof result === "object" && "success" in result) {
+          const cr = result;
+          if (cr.success && cr.data?.run_id) {
+            const isComplete = ["completed", "failed", "timed_out", "cancelled"].includes(cr.data.status);
+            const channel = isComplete ? "compute:run-complete" : "compute:run-update";
+            safeSend(win, channel, {
+              runId: cr.data.run_id,
+              status: cr.data.status,
+              currentPhase: cr.data.current_phase,
+              exitCode: cr.data.exit_code,
+              elapsedSeconds: cr.data.elapsed_seconds,
+              outputBytes: cr.data.output_bytes,
+              outputLines: cr.data.output_lines,
+              stalled: cr.data.stalled,
+              progress: cr.data.progress,
+              outputTail: cr.data.output_tail?.slice(-2048),
+              failure: cr.data.failure
+            });
+          }
+        }
+        if (tool === "local_compute_stop" && result && typeof result === "object" && "success" in result) {
+          const cr = result;
+          if (cr.success && cr.data?.run_id) {
+            safeSend(win, "compute:run-complete", {
+              runId: cr.data.run_id,
+              status: "cancelled"
+            });
+          }
+        }
         const r = result;
         const success2 = r?.success !== false;
         const error = !success2 ? r?.error || "Unknown error" : void 0;
@@ -6980,9 +9228,36 @@ async function ensureCoordinator(state, win, model, options) {
     const readyEvent = { type: "system", summary: "Agent ready" };
     state.realtimeBuffer.pushActivity(readyEvent);
     safeSend(win, "agent:activity", readyEvent);
+    probeStaticProfile().then((profile) => {
+      safeSend(win, "compute:environment", {
+        os: profile.os,
+        arch: profile.arch,
+        cpuCores: profile.cpuCores,
+        totalMemoryMb: profile.totalMemoryMb,
+        gpu: profile.gpu.model,
+        mlxAvailable: profile.gpu.mlxAvailable,
+        sandbox: profile.dockerAvailable ? "docker" : "process"
+      });
+    }).catch(() => {
+    });
   }
   return state.coordinator;
 }
+async function destroyAllCoordinators() {
+  const promises = [];
+  for (const [, state] of windowStates) {
+    if (state.coordinator) {
+      promises.push(
+        state.coordinator.destroy().catch(() => {
+        })
+      );
+    }
+  }
+  await Promise.race([
+    Promise.all(promises),
+    new Promise((resolve2) => setTimeout(resolve2, 8e3))
+  ]);
+}
 function registerIpcHandlers() {
   if (ipcHandlersRegistered) return;
   ipcHandlersRegistered = true;
@@ -7449,6 +9724,24 @@ function registerIpcHandlers() {
     }
   });
   handleWindow("session:current", ({ state }) => ({ sessionId: state.sessionId, projectPath: state.projectPath }));
+  handleWindow("compute:probe-environment", async ({ win }) => {
+    try {
+      const profile = await probeStaticProfile();
+      const env = {
+        os: profile.os,
+        arch: profile.arch,
+        cpuCores: profile.cpuCores,
+        totalMemoryMb: profile.totalMemoryMb,
+        gpu: profile.gpu.model,
+        mlxAvailable: profile.gpu.mlxAvailable,
+        sandbox: profile.dockerAvailable ? "docker" : "process"
+      };
+      safeSend(win, "compute:environment", env);
+      return env;
+    } catch {
+      return null;
+    }
+  });
   handleWindow("project:pick-folder", async ({ win, state }) => {
     const result = await dialog.showOpenDialog(win, {
       properties: ["openDirectory", "createDirectory"]
@@ -7473,11 +9766,33 @@ function registerIpcHandlers() {
       if (existsSync(prefsFile)) {
         try {
           const prefs = JSON.parse(readFileSync(prefsFile, "utf-8"));
-          if (prefs.selectedModel) state.currentModel = prefs.selectedModel;
+          if (prefs.selectedModel) {
+            const m = prefs.selectedModel;
+            if (!m.includes(":")) {
+              const provider = m.startsWith("claude-") ? "anthropic" : m.startsWith("gemini-") ? "google" : "openai";
+              state.currentModel = `${provider}:${m}`;
+            } else {
+              state.currentModel = m;
+            }
+          }
           if (prefs.reasoningEffort) state.currentReasoningEffort = prefs.reasoningEffort;
         } catch {
         }
       }
+      if (process.env.ENABLE_LOCAL_COMPUTE === "1") {
+        probeStaticProfile().then((profile) => {
+          safeSend(win, "compute:environment", {
+            os: profile.os,
+            arch: profile.arch,
+            cpuCores: profile.cpuCores,
+            totalMemoryMb: profile.totalMemoryMb,
+            gpu: profile.gpu.model,
+            mlxAvailable: profile.gpu.mlxAvailable,
+            sandbox: profile.dockerAvailable ? "docker" : "process"
+          });
+        }).catch(() => {
+        });
+      }
       return { projectPath: state.projectPath, sessionId: state.sessionId };
     }
     return null;
@@ -7503,7 +9818,7 @@ function registerIpcHandlers() {
       state.realtimeBuffer.reset();
       state.projectPath = "";
       state.sessionId = crypto.randomUUID();
-      state.currentModel = "gpt-5.4";
+      state.currentModel = "openai:gpt-5.4";
       state.currentReasoningEffort = "medium";
       state.currentAuthMode = "none";
     } finally {
@@ -7751,6 +10066,10 @@ app.on("window-all-closed", () => {
   destroyAllTerminals();
   if (process.platform !== "darwin") app.quit();
 });
-app.on("before-quit", () => {
+app.on("before-quit", (event) => {
   destroyAllTerminals();
+  event.preventDefault();
+  destroyAllCoordinators().finally(() => {
+    app.exit(0);
+  });
 });