research-copilot 0.2.0 → 0.2.2

package/app/out/main/index.mjs

@@ -1,20 +1,22 @@
 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 { resolve, join, sep, isAbsolute, extname, basename, dirname, relative } from "path";
+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";
+import { createHash, randomUUID } from "crypto";
 import { Agent } from "@mariozechner/pi-agent-core";
 import { completeSimple, getModel } from "@mariozechner/pi-ai";
 import { createCodingTools, createGrepTool, createFindTool, createLsTool, DEFAULT_COMPACTION_SETTINGS, estimateTokens, shouldCompact, generateSummary } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import path from "node:path";
+import { mkdir, writeFile } from "fs/promises";
+import path$1 from "node:path";
 import fsp from "node:fs/promises";
-import { createHash } 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";
-import { createHash as createHash$1 } from "crypto";
 import { execFile as execFile$1 } from "child_process";
 import __cjs_mod__ from "node:module";
 const __filename = import.meta.filename;
@@ -233,10 +235,6 @@ function registerConfigHandlers(handleRaw) {
     return { success: true };
   });
 }
-function getFileName(path2) {
-  if (!path2) return "";
-  return path2.split("/").pop() || path2;
-}
 function inferMimeType(path2) {
   const ext = extname(path2).toLowerCase();
   if (ext === ".md" || ext === ".txt") return "text/plain";
@@ -264,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", () => {
@@ -522,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) => {
@@ -576,13 +672,39 @@ function truncateHeadTail(text, maxChars, headRatio = 0.7) {
 ...[truncated ${truncatedChars} chars]
 ${text.slice(-tailChars)}`;
 }
+function truncateStructuredData(data, maxChars) {
+  const json = JSON.stringify(data, null, 2);
+  if (json.length <= maxChars) return data;
+  const obj = { ...data };
+  let largestKey = "";
+  let largestSize = 0;
+  for (const [k, v] of Object.entries(obj)) {
+    if (typeof v === "string" && v.length > largestSize) {
+      largestKey = k;
+      largestSize = v.length;
+    }
+  }
+  if (largestKey) {
+    const overhead = json.length - largestSize;
+    const fieldBudget = Math.max(1e3, maxChars - overhead);
+    obj[largestKey] = truncateHeadTail(obj[largestKey], fieldBudget);
+  }
+  return obj;
+}
 function toAgentResult(toolName, result) {
   let text;
+  const MAX_RESULT_CHARS = 1e5;
   if (result.success) {
     if (result.data === void 0 || result.data === null) {
       text = `[${toolName}] OK`;
     } else if (typeof result.data === "string") {
-      text = result.data;
+      text = truncateHeadTail(result.data, MAX_RESULT_CHARS);
+    } else if (typeof result.data === "object" && result.data !== null && !Array.isArray(result.data)) {
+      const bounded = truncateStructuredData(
+        result.data,
+        MAX_RESULT_CHARS
+      );
+      text = JSON.stringify(bounded, null, 2);
     } else {
       text = JSON.stringify(result.data, null, 2);
     }
@@ -607,10 +729,11 @@ ${result.suggestions.map((s) => `- ${s}`).join("\n")}`);
     }
     text = parts.join("\n");
   }
-  const MAX_RESULT_CHARS = 1e5;
-  const bounded = truncateHeadTail(text, MAX_RESULT_CHARS);
+  if (text.length > MAX_RESULT_CHARS) {
+    text = truncateHeadTail(text, MAX_RESULT_CHARS);
+  }
   return {
-    content: [{ type: "text", text: bounded }],
+    content: [{ type: "text", text }],
     details: { success: result.success, tool_name: toolName }
   };
 }
@@ -639,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();
@@ -1255,7 +1380,12 @@ function createResearchMemoryTools(params) {
   ];
 }
 function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+  if (slug.length < 3) {
+    const hash = createHash("sha256").update(text.toLowerCase().trim()).digest("hex").slice(0, 12);
+    return slug ? `${slug}-${hash}` : hash;
+  }
+  return slug;
 }
 function memoryFilename(type, name) {
   return `${type}_${slugify(name)}.md`;
@@ -1267,22 +1397,40 @@ function ensureMemoryDir(projectPath) {
   const dir = memoryDir(projectPath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 }
+function yamlSafe(value) {
+  if (!value) return '""';
+  if (/[:\#{}\[\]"'`\n\r|>]/.test(value) || value !== value.trim()) {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+    return `"${escaped}"`;
+  }
+  return value;
+}
 function formatFrontmatter(fm) {
   return [
     "---",
-    `name: ${fm.name}`,
-    `description: ${fm.description}`,
+    `name: ${yamlSafe(fm.name)}`,
+    `description: ${yamlSafe(fm.description)}`,
     `type: ${fm.type}`,
     "---"
   ].join("\n");
 }
+function yamlUnescape(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).replace(/''/g, "'");
+  }
+  return trimmed;
+}
 function parseFrontmatter(text) {
   const match = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (!match) return null;
   const fm = {};
   for (const line of match[1].split("\n")) {
     const kv = line.match(/^(\w+):\s*(.+)$/);
-    if (kv) fm[kv[1]] = kv[2].trim();
+    if (kv) fm[kv[1]] = yamlUnescape(kv[2]);
   }
   if (!fm.name || !fm.type) return null;
   const validTypes = ["user", "feedback", "project", "reference"];
@@ -1339,9 +1487,24 @@ function listMemoryFiles(projectPath) {
     return [];
   }
 }
-function findMemoryByName(projectPath, name) {
+function findMemoryByName(projectPath, name, type) {
+  const lower = name.toLowerCase();
+  const entries = listMemoryFiles(projectPath);
+  return entries.find(
+    (e) => e.frontmatter.name.toLowerCase() === lower && (!type || e.frontmatter.type === type)
+  ) ?? null;
+}
+function findAllMemoriesByName(projectPath, name) {
   const lower = name.toLowerCase();
-  return listMemoryFiles(projectPath).find((e) => e.frontmatter.name.toLowerCase() === lower) ?? null;
+  return listMemoryFiles(projectPath).filter((e) => e.frontmatter.name.toLowerCase() === lower);
+}
+let _indexWriteLock = Promise.resolve();
+function withIndexLock(fn) {
+  const next = _indexWriteLock.then(fn, fn);
+  _indexWriteLock = next.then(() => {
+  }, () => {
+  });
+  return next;
 }
 function buildMemoryIndex(entries) {
   if (entries.length === 0) return "";
@@ -1381,6 +1544,9 @@ function migrateAgentMemoryToFile(projectPath) {
   if (markerIdx < 0) return false;
   const agentMemory = content.slice(markerIdx + marker.length).trim();
   if (!agentMemory || /\[.*\]\(memory\/.*\)/.test(agentMemory)) return false;
+  const legacyFilename = memoryFilename("project", "legacy-notes");
+  const legacyPath = join(memoryDir(projectPath), legacyFilename);
+  if (existsSync(legacyPath)) return false;
   ensureMemoryDir(projectPath);
   const entry = {
     frontmatter: {
@@ -1435,73 +1601,98 @@ function createSaveMemoryTool(projectPath) {
       if (!content) return toolError("MISSING_PARAMETER", "content is required.", {
         suggestions: ["Provide the memory content to save."]
       });
-      ensureMemoryDir(projectPath);
-      const filename = memoryFilename(type, name);
-      const description = content.split("\n")[0].replace(/^#+\s*/, "").slice(0, 120);
-      const entry = {
-        frontmatter: { name, description, type },
-        content,
-        filename
-      };
-      writeMemoryFile(projectPath, entry);
-      const allEntries = listMemoryFiles(projectPath);
-      const indexResult = updateAgentMdIndex(projectPath, allEntries);
-      if (!indexResult.success) {
-        return toolError(
-          "OUTPUT_TOO_LARGE",
-          "agent.md index exceeded size limit. Remove some memories first.",
-          {
-            suggestions: ["Use delete-memory to remove outdated entries before saving new ones."]
-          }
-        );
-      }
-      return {
-        success: true,
-        data: {
-          message: `Memory saved: ${name} (${type})`,
-          filename,
-          totalMemories: allEntries.length,
-          agentMdChars: indexResult.charCount
+      const lines = content.split("\n");
+      const firstNonEmpty = lines.find((l) => l.trim().length > 0) || "";
+      const description = firstNonEmpty.replace(/^#+\s*/, "").trim().slice(0, 120) || name;
+      return withIndexLock(() => {
+        ensureMemoryDir(projectPath);
+        const filename = memoryFilename(type, name);
+        const entry = {
+          frontmatter: { name, description, type },
+          content,
+          filename
+        };
+        writeMemoryFile(projectPath, entry);
+        const allEntries = listMemoryFiles(projectPath);
+        const indexResult = updateAgentMdIndex(projectPath, allEntries);
+        if (!indexResult.success) {
+          deleteMemoryFile(projectPath, filename);
+          return toolError(
+            "OUTPUT_TOO_LARGE",
+            "agent.md index exceeded size limit. Remove some memories first.",
+            {
+              suggestions: ["Use delete-memory to remove outdated entries before saving new ones."]
+            }
+          );
         }
-      };
+        return {
+          success: true,
+          data: {
+            message: `Memory saved: ${name} (${type})`,
+            filename,
+            totalMemories: allEntries.length,
+            agentMdChars: indexResult.charCount
+          }
+        };
+      });
     }
   };
 }
 function createDeleteMemoryTool(projectPath) {
   return {
     name: "delete-memory",
-    description: "Delete a memory by name. Removes the file and its index entry in agent.md.",
+    description: "Delete a memory by name. Removes the file and its index entry in agent.md. If multiple memories share the same name (different types), specify type to disambiguate.",
     parameters: {
       type: "object",
       properties: {
         name: {
           type: "string",
           description: "Name of the memory to delete (case-insensitive match)"
+        },
+        type: {
+          type: "string",
+          enum: VALID_TYPES$1,
+          description: "Optional: memory type to disambiguate when multiple memories share the same name"
         }
       },
       required: ["name"]
     },
     execute: async (input) => {
       const name = String(input.name || "").trim();
+      const type = input.type ? String(input.type) : void 0;
       if (!name) return toolError("MISSING_PARAMETER", "name is required.", {
         suggestions: ["Provide the name of the memory to delete."]
       });
-      const existing = findMemoryByName(projectPath, name);
-      if (!existing) {
+      const allMatches = findAllMemoriesByName(projectPath, name);
+      if (allMatches.length === 0) {
         return toolError("NOT_FOUND", `Memory not found: "${name}"`, {
           suggestions: ["Check the memory name — it is case-insensitive. Current memories are listed in agent.md."]
         });
       }
-      deleteMemoryFile(projectPath, existing.filename);
-      const allEntries = listMemoryFiles(projectPath);
-      updateAgentMdIndex(projectPath, allEntries);
-      return {
-        success: true,
-        data: {
-          message: `Memory deleted: ${name}`,
-          totalMemories: allEntries.length
-        }
-      };
+      if (allMatches.length > 1 && !type) {
+        const types = allMatches.map((m) => m.frontmatter.type).join(", ");
+        return toolError("AMBIGUOUS", `Multiple memories named "${name}" (types: ${types}). Specify type to disambiguate.`, {
+          suggestions: [`Add type parameter: one of ${types}`]
+        });
+      }
+      const existing = type ? findMemoryByName(projectPath, name, type) : allMatches[0];
+      if (!existing) {
+        return toolError("NOT_FOUND", `Memory not found: "${name}" with type "${type}"`, {
+          suggestions: ["Check the memory name and type."]
+        });
+      }
+      return withIndexLock(() => {
+        deleteMemoryFile(projectPath, existing.filename);
+        const allEntries = listMemoryFiles(projectPath);
+        updateAgentMdIndex(projectPath, allEntries);
+        return {
+          success: true,
+          data: {
+            message: `Memory deleted: ${name}`,
+            totalMemories: allEntries.length
+          }
+        };
+      });
     }
   };
 }
@@ -1526,8 +1717,11 @@ const WEB_DEFAULTS = {
   maxFetchMaxChars: 2e5,
   defaultFetchTimeoutMs: 3e4,
   maxArxivCacheEntries: 100,
-  arxivSearchCacheTtlMs: 10 * 60 * 1e3
+  arxivSearchCacheTtlMs: 10 * 60 * 1e3,
   // 10 min
+  /** Content above this size is saved to disk; agent gets preview + file path */
+  fetchPersistThresholdChars: 3e4,
+  fetchPreviewChars: 2e3
 };
 class ProviderRateGate {
   constructor(minIntervalMs) {
@@ -1774,7 +1968,6 @@ function createWebSearchTool(ctx) {
       const providerRequested = normalizeSearchProvider(params.provider);
       const braveApiKey = process.env.BRAVE_API_KEY?.trim();
       let effectiveProvider = providerRequested === "auto" ? braveApiKey ? "brave" : "arxiv" : providerRequested;
-      ctx.onToolCall?.("web_search", { query, count, provider: effectiveProvider });
       let results = [];
       try {
         if (effectiveProvider === "brave") {
@@ -1818,7 +2011,6 @@ function createWebSearchTool(ctx) {
         count: results.length,
         results
       };
-      ctx.onToolResult?.("web_search", payload);
       return toAgentResult("web_search", {
         success: true,
         data: payload
@@ -1830,7 +2022,7 @@ function createWebFetchTool(ctx) {
   return {
     name: "web_fetch",
     label: "Web Fetch",
-    description: "Fetch a URL and extract readable text or markdown for downstream analysis.",
+    description: "Fetch a URL and extract readable text or markdown. Content over 30K chars is saved to disk — use the read tool on the returned content_path to access full content.",
     parameters: WebFetchSchema,
     execute: async (_toolCallId, rawParams) => {
       const params = rawParams;
@@ -1859,7 +2051,6 @@ function createWebFetchTool(ctx) {
       const maxChars = typeof maxCharsRaw === "number" ? Math.max(100, Math.min(WEB_DEFAULTS.maxFetchMaxChars, Math.floor(maxCharsRaw))) : WEB_DEFAULTS.defaultFetchMaxChars;
       const timeoutSecRaw = (typeof params.timeout_sec === "number" && Number.isFinite(params.timeout_sec) ? params.timeout_sec : void 0) ?? (typeof params.timeoutSec === "number" && Number.isFinite(params.timeoutSec) ? params.timeoutSec : void 0);
       const timeoutMs = typeof timeoutSecRaw === "number" ? Math.max(1e3, Math.floor(timeoutSecRaw * 1e3)) : WEB_DEFAULTS.defaultFetchTimeoutMs;
-      ctx.onToolCall?.("web_fetch", { url: url.toString(), extractMode, maxChars });
       let response;
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1897,16 +2088,37 @@ Source: ${url.toString()}
 ---
 
 ${sliced}` : sliced;
-      const payload = {
-        url: url.toString(),
-        status_code: response.status,
-        content_type: contentType,
-        extract_mode: extractMode,
-        chars: normalized.length,
-        truncated,
-        content: output || "(empty response)"
-      };
-      ctx.onToolResult?.("web_fetch", payload);
+      let payload;
+      if (output.length > WEB_DEFAULTS.fetchPersistThresholdChars) {
+        const hash = createHash("md5").update(url.toString() + Date.now()).digest("hex").slice(0, 12);
+        const ext = extractMode === "markdown" ? "md" : "txt";
+        const contentDir = path.join(ctx.projectPath, "web-content");
+        await mkdir(contentDir, { recursive: true });
+        const filePath = path.join(contentDir, `${hash}.${ext}`);
+        await writeFile(filePath, output, "utf-8");
+        const previewRaw = output.slice(0, WEB_DEFAULTS.fetchPreviewChars);
+        const lastNl = previewRaw.lastIndexOf("\n");
+        const preview = (lastNl > WEB_DEFAULTS.fetchPreviewChars * 0.5 ? previewRaw.slice(0, lastNl) : previewRaw) + "\n...";
+        payload = {
+          url: url.toString(),
+          status_code: response.status,
+          content_type: contentType,
+          extract_mode: extractMode,
+          chars: normalized.length,
+          content_path: path.relative(ctx.workspacePath, filePath),
+          preview
+        };
+      } else {
+        payload = {
+          url: url.toString(),
+          status_code: response.status,
+          content_type: contentType,
+          extract_mode: extractMode,
+          chars: normalized.length,
+          truncated,
+          content: output || "(empty response)"
+        };
+      }
       return toAgentResult("web_fetch", {
         success: response.ok,
         data: payload,
@@ -2774,7 +2986,6 @@ function createLiteratureSearchTool(ctx) {
           suggestions: ["Ensure the agent runtime has an LLM provider configured (callLlm in ResearchToolContext)."]
         }));
       }
-      ctx.onToolCall?.("literature-search", { query, context: extraContext });
       const planUserPrompt = extraContext ? `Research request: ${query}
 
 Additional context: ${extraContext}` : `Research request: ${query}`;
@@ -2951,9 +3162,9 @@ Additional context: ${extraContext}` : `Research request: ${query}`;
           }
         }
       }
-      const reviewDir = path.join(ctx.projectPath, ".research-pilot", "literature-runs", runId);
+      const reviewDir = path$1.join(ctx.projectPath, ".research-pilot", "literature-runs", runId);
       fs.mkdirSync(reviewDir, { recursive: true });
-      const fullReviewPath = path.join(reviewDir, "review.json");
+      const fullReviewPath = path$1.join(reviewDir, "review.json");
       fs.writeFileSync(fullReviewPath, JSON.stringify({
         plan,
         allPapersCount: deduplicated.length,
@@ -2962,7 +3173,7 @@ Additional context: ${extraContext}` : `Research request: ${query}`;
         queriesUsed,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }, null, 2), "utf-8");
-      const relReviewPath = path.relative(ctx.projectPath, fullReviewPath);
+      const relReviewPath = path$1.relative(ctx.projectPath, fullReviewPath);
       const payload = {
         totalFound: deduplicated.length,
         reviewedCount: review.relevantPapers.length,
@@ -2985,12 +3196,11 @@ Additional context: ${extraContext}` : `Research request: ${query}`;
         runId,
         queriesUsed: queriesUsed.slice(0, 10)
       };
-      ctx.onToolResult?.("literature-search", payload);
       return toAgentResult("literature-search", toolSuccess(payload, pipelineWarnings.length > 0 ? pipelineWarnings : void 0));
     }
   };
 }
-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;
@@ -3028,16 +3238,16 @@ const FORMAT_EXTENSIONS = {
   zip: "zip"
 };
 function resolveWithinProject(projectPath, targetPath) {
-  const root = path.resolve(projectPath);
-  const resolved = targetPath.startsWith("/") ? path.resolve(targetPath) : path.resolve(root, targetPath);
-  const rel = path.relative(root, resolved);
-  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+  const root = path$1.resolve(projectPath);
+  const resolved = targetPath.startsWith("/") ? path$1.resolve(targetPath) : path$1.resolve(root, targetPath);
+  const rel = path$1.relative(root, resolved);
+  if (rel.startsWith("..") || path$1.isAbsolute(rel)) {
     throw new Error(`Path escapes project directory: ${targetPath}`);
   }
   return resolved;
 }
 function toProjectRelative(projectPath, absolutePath) {
-  return path.relative(path.resolve(projectPath), absolutePath);
+  return path$1.relative(path$1.resolve(projectPath), absolutePath);
 }
 function isHttpUrl(value) {
   try {
@@ -3057,7 +3267,7 @@ function sanitizeBaseName(value) {
 function inferUrlBaseName(sourceUrl) {
   try {
     const parsed = new URL(sourceUrl);
-    const candidate = path.parse(parsed.pathname).name || parsed.hostname;
+    const candidate = path$1.parse(parsed.pathname).name || parsed.hostname;
     return sanitizeBaseName(candidate);
   } catch {
     return sanitizeBaseName(sourceUrl);
@@ -3067,7 +3277,7 @@ function outputExtensionForMode(mode) {
   return mode === "text" ? ".txt" : ".md";
 }
 function extensionFromPath(filePath) {
-  const ext = path.extname(filePath).replace(".", "").toLowerCase();
+  const ext = path$1.extname(filePath).replace(".", "").toLowerCase();
   return ext || void 0;
 }
 function normalizeMode(value) {
@@ -3121,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
     });
@@ -3212,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" }
@@ -3301,15 +3511,15 @@ async function downloadToProject(projectPath, sourceUrl) {
   if (bytes.length > DEFAULT_MAX_DOWNLOAD_BYTES) {
     return { ok: false, error: `Downloaded file too large (${bytes.length} bytes > ${DEFAULT_MAX_DOWNLOAD_BYTES} bytes)` };
   }
-  const downloadDir = path.join(path.resolve(projectPath), ".research-pilot", "cache", "downloads");
+  const downloadDir = path$1.join(path$1.resolve(projectPath), ".research-pilot", "cache", "downloads");
   await fsp.mkdir(downloadDir, { recursive: true });
   const urlObj = new URL(sourceUrl);
   const fromExt = extensionFromPath(urlObj.pathname);
   const fromContentType = detectFormatFromContentType(response.headers.get("content-type"));
   const chosenExt = FORMAT_EXTENSIONS[fromContentType || ""] || FORMAT_EXTENSIONS[fromExt || ""] || "bin";
-  const hash = createHash("sha256").update(sourceUrl).digest("hex").slice(0, 12);
+  const hash = createHash$1("sha256").update(sourceUrl).digest("hex").slice(0, 12);
   const fileName = `${isoStamp()}-${hash}.${chosenExt}`;
-  const inputPath = path.join(downloadDir, fileName);
+  const inputPath = path$1.join(downloadDir, fileName);
   await fsp.writeFile(inputPath, bytes);
   return {
     ok: true,
@@ -3389,9 +3599,9 @@ ${sections}
 `;
 }
 function buildPerRangeOutputPath(baseAbsolutePath, range, mode) {
-  const parsed = path.parse(baseAbsolutePath);
+  const parsed = path$1.parse(baseAbsolutePath);
   const ext = parsed.ext || outputExtensionForMode(mode);
-  return path.join(parsed.dir, `${parsed.name}-${rangeFileToken(range)}${ext}`);
+  return path$1.join(parsed.dir, `${parsed.name}-${rangeFileToken(range)}${ext}`);
 }
 function buildPreview(text, maxPreviewChars = DEFAULT_PREVIEW_CHARS) {
   const content = text.slice(0, maxPreviewChars);
@@ -3403,14 +3613,14 @@ function buildPreview(text, maxPreviewChars = DEFAULT_PREVIEW_CHARS) {
   };
 }
 function defaultOutputPath(args) {
-  const outputDir = path.join(
-    path.resolve(args.projectPath),
+  const outputDir = path$1.join(
+    path$1.resolve(args.projectPath),
     ".research-pilot",
     "cache",
     "converted"
   );
-  const baseName = args.isUrl ? inferUrlBaseName(args.sourceRaw) : sanitizeBaseName(path.parse(args.inputPath || "document").name || "document");
-  return path.join(outputDir, `${baseName}-${isoStamp()}${outputExtensionForMode(args.mode)}`);
+  const baseName = args.isUrl ? inferUrlBaseName(args.sourceRaw) : sanitizeBaseName(path$1.parse(args.inputPath || "document").name || "document");
+  return path$1.join(outputDir, `${baseName}-${isoStamp()}${outputExtensionForMode(args.mode)}`);
 }
 function failure(payload) {
   return toAgentResult("convert_document", { success: false, error: payload.error, data: payload });
@@ -3593,7 +3803,7 @@ function createConvertDocumentTool(ctx) {
           mode
         });
       }
-      await fsp.mkdir(path.dirname(outputAbsolutePath), { recursive: true });
+      await fsp.mkdir(path$1.dirname(outputAbsolutePath), { recursive: true });
       let converter;
       let producedText = "";
       let pageCount;
@@ -3626,7 +3836,7 @@ function createConvertDocumentTool(ctx) {
               anyTruncated = true;
             }
             const segmentAbsPath = buildPerRangeOutputPath(outputAbsolutePath, range, mode);
-            await fsp.mkdir(path.dirname(segmentAbsPath), { recursive: true });
+            await fsp.mkdir(path$1.dirname(segmentAbsPath), { recursive: true });
             await fsp.writeFile(segmentAbsPath, segmentText, "utf8");
             const segmentRelPath = toProjectRelative(projectPath, segmentAbsPath);
             const segmentPreview = buildPreview(segmentText);
@@ -3722,7 +3932,7 @@ function createConvertDocumentTool(ctx) {
     }
   };
 }
-const execFileAsync = promisify(execFile);
+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");
@@ -3765,7 +3975,7 @@ function createDataAnalyzeTool(ctx) {
           suggestions: ["Valid task types: analyze, visualize, transform, model."]
         }));
       }
-      const absDataFile = path.resolve(ctx.workspacePath, filePath);
+      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: [
@@ -3775,18 +3985,17 @@ function createDataAnalyzeTool(ctx) {
           context: { workspacePath: ctx.workspacePath, resolvedPath: absDataFile }
         }));
       }
-      ctx.onToolCall?.("data_analyze", { file_path: filePath, instructions, task_type: taskType });
       const runId = Date.now().toString(36);
-      const outputBase = path.join(ctx.workspacePath, ".research-pilot", "data-runs", runId);
-      const figuresDir = path.join(outputBase, "figures");
-      const tablesDir = path.join(outputBase, "tables");
-      const dataDir = path.join(outputBase, "data");
+      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.join(outputBase, "results.json");
+      const resultsFile = path$1.join(outputBase, "results.json");
       const rawPreview = fs.readFileSync(absDataFile, "utf-8").slice(0, 2e3);
-      const ext = path.extname(absDataFile).toLowerCase();
+      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.", {
@@ -3834,10 +4043,10 @@ function createDataAnalyzeTool(ctx) {
         ""
       ].join("\n");
       const fullScript = DATA_CODE_TEMPLATE + pathDefinitions + "\n" + generatedCode;
-      const scriptPath = path.join(outputBase, "script.py");
+      const scriptPath = path$1.join(outputBase, "script.py");
       fs.writeFileSync(scriptPath, fullScript, "utf-8");
       try {
-        const { stdout, stderr } = await execFileAsync("python3", [scriptPath], {
+        const { stdout, stderr } = await execFileAsync$2("python3", [scriptPath], {
           cwd: ctx.workspacePath,
           timeout: 12e4,
           // 2 minutes
@@ -3861,7 +4070,7 @@ function createDataAnalyzeTool(ctx) {
               outputs.push({
                 name: f,
                 type,
-                path: path.relative(ctx.workspacePath, path.join(dir, f))
+                path: path$1.relative(ctx.workspacePath, path$1.join(dir, f))
               });
             }
           }
@@ -3874,26 +4083,25 @@ function createDataAnalyzeTool(ctx) {
             summary: manifest.summary,
             warnings: manifest.warnings
           } : void 0,
-          scriptPath: path.relative(ctx.workspacePath, scriptPath),
+          scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
           runId
         };
-        ctx.onToolResult?.("data_analyze", payload);
         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.relative(ctx.workspacePath, scriptPath)} for errors.`,
+            `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.relative(ctx.workspacePath, scriptPath),
+            scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
             runId
           },
           data: {
-            scriptPath: path.relative(ctx.workspacePath, scriptPath),
+            scriptPath: path$1.relative(ctx.workspacePath, scriptPath),
             runId
           }
         }));
@@ -3901,133 +4109,2205 @@ function createDataAnalyzeTool(ctx) {
     }
   };
 }
-function wrapResearchTool(tool) {
-  const properties = {};
-  const jsonProps = tool.parameters.properties ?? {};
-  const requiredFields = tool.parameters.required ?? [];
-  for (const [key, prop] of Object.entries(jsonProps)) {
-    const isRequired = requiredFields.includes(key);
-    let schema;
-    if (prop.enum) {
-      schema = Type.Union(prop.enum.map((v) => Type.Literal(v)));
-    } else if (prop.type === "number") {
-      schema = Type.Number({ description: prop.description });
-    } else if (prop.type === "array") {
-      schema = Type.Array(Type.String(), { description: prop.description });
-    } else {
-      schema = Type.String({ description: prop.description });
-    }
-    properties[key] = isRequired ? schema : Type.Optional(schema);
-  }
-  const parametersSchema = Type.Object(properties);
-  return {
-    name: tool.name,
-    description: tool.description,
-    label: tool.name,
-    parameters: parametersSchema,
-    execute: async (_toolCallId, params, _signal) => {
+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 result = await tool.execute(params);
-        return toAgentResult(tool.name, result);
-      } catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        return toAgentResult(tool.name, toolError("EXECUTION_FAILED", errorMsg, {
-          retryable: false,
-          suggestions: ["Check tool parameters and try again."]
-        }));
+        const record = JSON.parse(trimmed);
+        this.records.set(record.runId, record);
+      } catch {
       }
     }
-  };
-}
-function createResearchTools(ctx) {
-  const tools = [];
-  tools.push(createWebSearchTool(ctx));
-  tools.push(createWebFetchTool(ctx));
-  tools.push(createLiteratureSearchTool(ctx));
-  tools.push(createConvertDocumentTool(ctx));
-  tools.push(createDataAnalyzeTool(ctx));
-  const artifactTools = createResearchMemoryTools({
-    sessionId: ctx.sessionId,
-    projectPath: ctx.projectPath
-  });
-  for (const tool of artifactTools) {
-    tools.push(wrapResearchTool(tool));
   }
-  const structuredMemoryTools = createMemoryTools(ctx.projectPath);
-  for (const tool of structuredMemoryTools) {
-    tools.push(wrapResearchTool(tool));
+  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;
   }
-  return tools;
-}
-const VALID_TYPES = ["user", "feedback", "project", "reference"];
-const EXTRACTION_PROMPT = `Analyze the recent conversation above and extract information worth remembering across sessions.
-
-Rules:
-- Only extract DURABLE, IMPORTANT information — things a future session would need.
-- Types: "user" (preferences/background), "feedback" (behavior corrections), "project" (decisions/deadlines), "reference" (external pointers).
-- Ignore text inside "[Previous conversation summary]" or "[Session context]" markers — that is old context, not new information.
-- Do NOT extract: routine task results, ephemeral details, things already in workspace files.
-- Each memory should be atomic — one concept per entry.
-- If nothing is worth saving, return an empty array.
-
-Return ONLY a JSON array (no markdown fences, no explanation):
-[{"type":"user|feedback|project|reference","name":"short-name","description":"one line","content":"full text"}]
-Or: []`;
-function simplifyMessages(messages, maxMessages) {
-  const recent = messages.slice(-20);
-  const result = [];
-  for (const msg of recent) {
-    if (msg.role !== "user" && msg.role !== "assistant") continue;
-    let content = "";
-    if (typeof msg.content === "string") {
-      content = msg.content;
-    } else if (Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block && typeof block === "object" && "type" in block) {
-          if (block.type === "text" && "text" in block) {
-            const text = block.text;
-            content += text.length > 500 ? text.slice(0, 500) + "...[truncated]" : text;
-            content += "\n";
-          } else if (block.type === "tool_use" && "name" in block) {
-            content += `[Called ${block.name}]
-`;
-          }
-        }
-      }
+  /**
+   * 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();
     }
-    content = content.trim();
-    if (content) {
-      result.push({
-        role: msg.role,
-        content: content.slice(0, 2e3),
-        timestamp: Date.now()
-      });
+  }
+  /**
+   * 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;
   }
-  return result;
-}
-function agentCalledSaveMemoryThisTurn(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "user") break;
-    if (msg.role === "assistant" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block && typeof block === "object" && "type" in block && block.type === "tool_use") {
-          if (block.name === "save-memory") return true;
+  /**
+   * 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");
   }
-  return false;
 }
-async function maybeExtractMemories(config, messages, turnCount, extractEveryN = 3) {
-  if (process.env.RESEARCH_COPILOT_AUTO_EXTRACT === "0") return;
-  if (turnCount % extractEveryN !== 0) return;
-  if (agentCalledSaveMemoryThisTurn(messages)) {
-    if (config.debug) console.log("[Extractor] Skipped — agent called save-memory this turn");
-    return;
+class ProcessSandbox {
+  constructor() {
+    this.name = "process";
   }
-  try {
+  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
+        }
+      });
+    }
+  };
+}
+function createExecuteTool(runner, ctx) {
+  return {
+    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 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").']
+        }));
+      }
+      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."]
+        }));
+      }
+    }
+  };
+}
+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."]
+        }));
+      }
+      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 result = runner.getStatus(runId);
+      if (!result) {
+        return toAgentResult("local_compute_status", toolError("NOT_FOUND", `Run not found: ${runId}`));
+      }
+      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."));
+      }
+      try {
+        await runner.stop(runId);
+        return toAgentResult("local_compute_stop", {
+          success: true,
+          data: { run_id: runId, status: "cancelled" }
+        });
+      } catch (err) {
+        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 ?? {};
+  const requiredFields = tool.parameters.required ?? [];
+  for (const [key, prop] of Object.entries(jsonProps)) {
+    const isRequired = requiredFields.includes(key);
+    let schema;
+    if (prop.enum) {
+      schema = Type.Union(prop.enum.map((v) => Type.Literal(v)));
+    } else if (prop.type === "number") {
+      schema = Type.Number({ description: prop.description });
+    } else if (prop.type === "array") {
+      schema = Type.Array(Type.String(), { description: prop.description });
+    } else {
+      schema = Type.String({ description: prop.description });
+    }
+    properties[key] = isRequired ? schema : Type.Optional(schema);
+  }
+  const parametersSchema = Type.Object(properties);
+  return {
+    name: tool.name,
+    description: tool.description,
+    label: tool.name,
+    parameters: parametersSchema,
+    execute: async (_toolCallId, params, _signal) => {
+      try {
+        const result = await tool.execute(params);
+        return toAgentResult(tool.name, result);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        return toAgentResult(tool.name, toolError("EXECUTION_FAILED", errorMsg, {
+          retryable: false,
+          suggestions: ["Check tool parameters and try again."]
+        }));
+      }
+    }
+  };
+}
+function createResearchTools(ctx) {
+  const tools = [];
+  const destroyers = [];
+  tools.push(createWebSearchTool());
+  tools.push(createWebFetchTool(ctx));
+  tools.push(createLiteratureSearchTool(ctx));
+  tools.push(createConvertDocumentTool(ctx));
+  tools.push(createDataAnalyzeTool(ctx));
+  const artifactTools = createResearchMemoryTools({
+    sessionId: ctx.sessionId,
+    projectPath: ctx.projectPath
+  });
+  for (const tool of artifactTools) {
+    tools.push(wrapResearchTool(tool));
+  }
+  const structuredMemoryTools = createMemoryTools(ctx.projectPath);
+  for (const tool of structuredMemoryTools) {
+    tools.push(wrapResearchTool(tool));
+  }
+  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.
+
+Rules:
+- Only extract DURABLE, IMPORTANT information — things a future session would need.
+- Types: "user" (preferences/background), "feedback" (behavior corrections), "project" (decisions/deadlines), "reference" (external pointers).
+- Ignore text inside "[Previous conversation summary]" or "[Session context]" markers — that is old context, not new information.
+- Do NOT extract: routine task results, ephemeral details, things already in workspace files.
+- Each memory should be atomic — one concept per entry.
+- If nothing is worth saving, return an empty array.
+
+Return ONLY a JSON array (no markdown fences, no explanation):
+[{"type":"user|feedback|project|reference","name":"short-name","description":"one line","content":"full text"}]
+Or: []`;
+function simplifyMessages(messages, maxMessages) {
+  const recent = messages.slice(-20);
+  const result = [];
+  for (const msg of recent) {
+    if (msg.role !== "user" && msg.role !== "assistant") continue;
+    let content = "";
+    if (typeof msg.content === "string") {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block && typeof block === "object" && "type" in block) {
+          if (block.type === "text" && "text" in block) {
+            const text = block.text;
+            content += text.length > 500 ? text.slice(0, 500) + "...[truncated]" : text;
+            content += "\n";
+          } else if (block.type === "tool_use" && "name" in block) {
+            content += `[Called ${block.name}]
+`;
+          }
+        }
+      }
+    }
+    content = content.trim();
+    if (content) {
+      result.push({
+        role: msg.role,
+        content: content.slice(0, 2e3),
+        timestamp: Date.now()
+      });
+    }
+  }
+  return result;
+}
+function agentCalledSaveMemoryThisTurn(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") break;
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block && typeof block === "object" && "type" in block && block.type === "tool_use") {
+          if (block.name === "save-memory") return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+async function maybeExtractMemories(config, messages, turnCount, extractEveryN = 3) {
+  if (process.env.RESEARCH_COPILOT_AUTO_EXTRACT !== "1") return;
+  if (turnCount % extractEveryN !== 0) return;
+  if (agentCalledSaveMemoryThisTurn(messages)) {
+    if (config.debug) console.log("[Extractor] Skipped — agent called save-memory this turn");
+    return;
+  }
+  try {
     const simplified = simplifyMessages(messages, 20);
     if (simplified.length < 2) return;
     simplified.push({
@@ -4045,33 +6325,57 @@ async function maybeExtractMemories(config, messages, turnCount, extractEveryN =
     const textContent = result.content.find((c) => c.type === "text");
     const text = textContent?.text?.trim() ?? "";
     if (!text || text === "[]") return;
-    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? text.match(/(\[[\s\S]*?\])/);
-    const jsonStr = jsonMatch?.[1]?.trim() ?? text;
-    const extracted = JSON.parse(jsonStr);
+    let jsonStr;
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+      jsonStr = fenceMatch[1].trim();
+    } else {
+      const firstBracket = text.indexOf("[");
+      const lastBracket = text.lastIndexOf("]");
+      if (firstBracket !== -1 && lastBracket > firstBracket) {
+        jsonStr = text.slice(firstBracket, lastBracket + 1);
+      } else {
+        jsonStr = text;
+      }
+    }
+    let extracted;
+    try {
+      extracted = JSON.parse(jsonStr);
+    } catch (parseErr) {
+      if (config.debug) {
+        console.warn("[Extractor] JSON parse failed:", parseErr, "Raw text:", text.slice(0, 200));
+      }
+      return;
+    }
     if (!Array.isArray(extracted) || extracted.length === 0) return;
     ensureMemoryDir(config.projectPath);
-    let written = 0;
+    const validEntries = [];
     for (const mem of extracted) {
       if (!mem.type || !mem.name || !mem.content) continue;
       if (!VALID_TYPES.includes(mem.type)) continue;
-      const entry = {
+      const desc = (mem.description || "").trim();
+      const contentFirstLine = mem.content.split("\n").find((l) => l.trim().length > 0) || "";
+      const description = (desc || contentFirstLine.replace(/^#+\s*/, "").trim().slice(0, 120) || mem.name).replace(/\n/g, " ");
+      validEntries.push({
         frontmatter: {
           name: mem.name,
-          description: (mem.description || mem.content.slice(0, 120)).replace(/\n/g, " "),
+          description,
           type: mem.type
         },
         content: mem.content,
         filename: memoryFilename(mem.type, mem.name)
-      };
-      writeMemoryFile(config.projectPath, entry);
-      written++;
+      });
     }
-    if (written > 0) {
+    if (validEntries.length === 0) return;
+    await withIndexLock(() => {
+      for (const entry of validEntries) {
+        writeMemoryFile(config.projectPath, entry);
+      }
       const allEntries = listMemoryFiles(config.projectPath);
       updateAgentMdIndex(config.projectPath, allEntries);
-      if (config.debug) {
-        console.log(`[Extractor] Saved ${written} memories from conversation`);
-      }
+    });
+    if (config.debug) {
+      console.log(`[Extractor] Saved ${validEntries.length} memories from conversation`);
     }
   } catch (err) {
     if (config.debug) {
@@ -4123,7 +6427,7 @@ function discoverSkillFiles(rootDir) {
       continue;
     }
     for (const entry of entries) {
-      const abs = path.join(current.dir, entry.name);
+      const abs = path$1.join(current.dir, entry.name);
       if (entry.isFile() && entry.name === SKILL_FILE_NAME) {
         files.push(abs);
         continue;
@@ -4154,7 +6458,7 @@ function parseSkillFile(skillFile, displayPath, source) {
     tags,
     triggers,
     path: displayPath,
-    dir: path.dirname(skillFile),
+    dir: path$1.dirname(skillFile),
     source,
     content
   };
@@ -4170,34 +6474,34 @@ function inferCategory(name, description) {
   return "General";
 }
 function loadBuiltinSkills() {
-  const skillsRoot = _builtinSkillsRoot ?? path.dirname(fileURLToPath(import.meta.url));
+  const skillsRoot = _builtinSkillsRoot ?? path$1.dirname(fileURLToPath(import.meta.url));
   if (!fs.existsSync(skillsRoot) || !fs.statSync(skillsRoot).isDirectory()) {
     return [];
   }
   const files = discoverSkillFiles(skillsRoot);
   const byName = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const entry = parseSkillFile(file, `[builtin] ${path.relative(skillsRoot, file)}`, "builtin");
+    const entry = parseSkillFile(file, `[builtin] ${path$1.relative(skillsRoot, file)}`, "builtin");
     if (entry) byName.set(entry.name, entry);
   }
   return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
 }
 function loadWorkspaceSkills(workspacePath) {
-  const skillRoot = path.resolve(workspacePath, ".research-pilot", "skills");
+  const skillRoot = path$1.resolve(workspacePath, ".research-pilot", "skills");
   if (!fs.existsSync(skillRoot) || !fs.statSync(skillRoot).isDirectory()) {
     return [];
   }
   const files = discoverSkillFiles(skillRoot);
-  const entries = files.map((file) => parseSkillFile(file, path.relative(workspacePath, file), "workspace")).filter((entry) => entry !== null);
+  const entries = files.map((file) => parseSkillFile(file, path$1.relative(workspacePath, file), "workspace")).filter((entry) => entry !== null);
   return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
 function loadUserSkills() {
-  const userRoot = path.resolve(os.homedir(), ".research-pilot", "skills");
+  const userRoot = path$1.resolve(os.homedir(), ".research-pilot", "skills");
   if (!fs.existsSync(userRoot) || !fs.statSync(userRoot).isDirectory()) {
     return [];
   }
   const files = discoverSkillFiles(userRoot);
-  const entries = files.map((file) => parseSkillFile(file, `[user] ~/.research-pilot/skills/${path.relative(userRoot, file)}`, "user")).filter((entry) => entry !== null);
+  const entries = files.map((file) => parseSkillFile(file, `[user] ~/.research-pilot/skills/${path$1.relative(userRoot, file)}`, "user")).filter((entry) => entry !== null);
   return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
 function loadAllSkills(workspacePath) {
@@ -4242,7 +6546,7 @@ function resolveSkillDependencies(allSkills, directSelection) {
   return result;
 }
 function readEnabledSkills(workspacePath) {
-  const configPath = path.resolve(workspacePath, ".research-pilot", "skills-config.json");
+  const configPath = path$1.resolve(workspacePath, ".research-pilot", "skills-config.json");
   try {
     const raw = fs.readFileSync(configPath, "utf8");
     const config = JSON.parse(raw);
@@ -4252,9 +6556,9 @@ function readEnabledSkills(workspacePath) {
   return null;
 }
 function writeEnabledSkills(workspacePath, enabledSkills) {
-  const configDir = path.resolve(workspacePath, ".research-pilot");
+  const configDir = path$1.resolve(workspacePath, ".research-pilot");
   if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
-  const configPath = path.join(configDir, "skills-config.json");
+  const configPath = path$1.join(configDir, "skills-config.json");
   fs.writeFileSync(configPath, JSON.stringify({ enabledSkills }, null, 2), "utf8");
 }
 function buildSkillManifests(workspacePath) {
@@ -4278,15 +6582,15 @@ function buildSkillManifests(workspacePath) {
   });
 }
 function installSkillToWorkspace(workspacePath, skillName, skillDir) {
-  const destDir = path.resolve(workspacePath, ".research-pilot", "skills", skillName);
+  const destDir = path$1.resolve(workspacePath, ".research-pilot", "skills", skillName);
   if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
   copyDirSync(skillDir, destDir);
 }
 function copyDirSync(src, dest) {
   const entries = fs.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
+    const srcPath = path$1.join(src, entry.name);
+    const destPath = path$1.join(dest, entry.name);
     if (entry.isDirectory()) {
       if (!fs.existsSync(destPath)) fs.mkdirSync(destPath, { recursive: true });
       copyDirSync(srcPath, destPath);
@@ -4479,6 +6783,7 @@ function writeExplainSnapshot(projectPath, snapshot) {
 async function createCoordinator(config) {
   const {
     apiKey,
+    getApiKeyOverride,
     model: modelId,
     projectPath = process.cwd(),
     debug = false,
@@ -4487,9 +6792,11 @@ async function createCoordinator(config) {
     onStream,
     onToolCall,
     onToolResult,
+    onToolProgress,
     onUsage,
     onSkillLoaded
   } = config;
+  const resolveApiKey = getApiKeyOverride ?? (async () => apiKey);
   let turnCount = 0;
   let activeTurnToolCallCount = null;
   const turnHistory = [];
@@ -4534,13 +6841,14 @@ async function createCoordinator(config) {
     const routerByProvider = {
       anthropic: "claude-haiku-4-5-20251001",
       openai: "gpt-5.4-nano",
+      "openai-codex": "gpt-5.4-nano",
       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;
       }
@@ -4558,11 +6866,11 @@ async function createCoordinator(config) {
       }
     }
   }
-  const wrappedOnToolResult = (tool, result, args) => {
+  const wrappedOnToolResult = (tool, result, args, toolCallId) => {
     if (activeTurnToolCallCount !== null) {
       activeTurnToolCallCount++;
     }
-    onToolResult?.(tool, result, args);
+    onToolResult?.(tool, result, args, toolCallId);
   };
   const toolCtx = {
     workspacePath: projectPath,
@@ -4570,17 +6878,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);
@@ -4603,17 +6912,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.
@@ -4652,11 +6961,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
@@ -4685,14 +6995,14 @@ The conversation continues below.`,
       }
     },
     beforeToolCall: async (ctx) => {
-      onToolCall?.(ctx.toolCall.name, ctx.args);
+      onToolCall?.(ctx.toolCall.name, ctx.args, ctx.toolCall.id);
       if (debug) {
         console.log(`  [Tool] ${ctx.toolCall.name}(${JSON.stringify(ctx.args).slice(0, 120)}...)`);
       }
       return void 0;
     },
     afterToolCall: async (ctx) => {
-      wrappedOnToolResult(ctx.toolCall.name, ctx.result, ctx.args);
+      wrappedOnToolResult(ctx.toolCall.name, ctx.result, ctx.args, ctx.toolCall.id);
       if (ctx.toolCall.name === "load_skill" && onSkillLoaded) {
         const args = ctx.args;
         const result = ctx.result;
@@ -4703,7 +7013,7 @@ The conversation continues below.`,
       return void 0;
     }
   });
-  if (onStream || onUsage) {
+  if (onStream || onUsage || onToolProgress) {
     agent.subscribe((event) => {
       if (event.type === "message_update" && onStream) {
         if (event.assistantMessageEvent.type === "text_delta") {
@@ -4717,6 +7027,15 @@ The conversation continues below.`,
           onUsage(usage, usage.cost);
         }
       }
+      if (onToolProgress) {
+        if (event.type === "tool_execution_start") {
+          onToolProgress(event.toolName, event.toolCallId, "start", { args: event.args });
+        } else if (event.type === "tool_execution_update") {
+          onToolProgress(event.toolName, event.toolCallId, "update", { partialResult: event.partialResult });
+        } else if (event.type === "tool_execution_end") {
+          onToolProgress(event.toolName, event.toolCallId, "end", { result: event.result, isError: event.isError });
+        }
+      }
     });
   }
   async function clearSessionMemory() {
@@ -4736,6 +7055,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: [{
@@ -4747,7 +7067,7 @@ ${historyText}`,
         }]
       }, {
         maxTokens: 512,
-        apiKey
+        apiKey: currentKey
       });
       const textContent = result.content.find((c) => c.type === "text");
       const text = textContent?.text?.trim() ?? "";
@@ -4773,12 +7093,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);
@@ -4819,31 +7147,24 @@ ${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}
 
 ## User Instructions (agent.md)
 
 ${agentMdContent}`;
-        }
-        if (skillSummariesPrompt) {
-          enrichedSystem = `${enrichedSystem}
-
-${skillSummariesPrompt}`;
         }
         agent.setSystemPrompt(enrichedSystem);
-        let userMessage = message;
-        if (mentionContext || summaryContext) {
-          const contextParts = [];
-          if (summaryContext) contextParts.push(summaryContext);
-          if (mentionContext) contextParts.push(mentionContext);
-          userMessage = `${contextParts.join("\n\n")}
+        const contextParts = [];
+        if (summaryContext) contextParts.push(summaryContext);
+        if (skillSummariesPrompt) contextParts.push(skillSummariesPrompt);
+        if (mentionContext) contextParts.push(mentionContext);
+        let userMessage = contextParts.length > 0 ? `${contextParts.join("\n\n")}
 
 ---
 
-${message}`;
-        }
+${message}` : message;
         let perTurnToolCallCount = 0;
         activeTurnToolCallCount = 0;
         try {
@@ -4889,8 +7210,9 @@ ${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
         );
@@ -4913,6 +7235,7 @@ ${message}`;
     clearSessionMemory,
     async destroy() {
       agent.abort();
+      await destroyResearchTools();
     }
   };
 }
@@ -4949,10 +7272,10 @@ function sessionSummaryGet(projectPath, sessionId) {
   }
 }
 class RateLimiter {
-  constructor(configs) {
+  constructor(configs2) {
     this.timestamps = /* @__PURE__ */ new Map();
     this.activeCounts = /* @__PURE__ */ new Map();
-    this.configs = configs;
+    this.configs = configs2;
   }
   /**
    * Wait until a request slot is available for the given source.
@@ -5565,7 +7888,7 @@ function parseMentions(message) {
   return { cleanMessage, mentions };
 }
 function getCacheKey(filePath, mtime) {
-  const hash = createHash$1("sha256").update(`${filePath}:${mtime}`).digest("hex").slice(0, 16);
+  const hash = createHash("sha256").update(`${filePath}:${mtime}`).digest("hex").slice(0, 16);
   const name = basename(filePath).replace(/[^a-zA-Z0-9.-]/g, "_");
   return `${name}-${hash}.json`;
 }
@@ -6037,6 +8360,10 @@ class RealtimeBuffer {
   isStreaming = false;
   progressItems = [];
   activityEvents = [];
+  /** Tool events for chat-inline rendering (mirrors tool-events-store) */
+  toolEvents = [];
+  /** Track tool-call start times keyed by toolCallId for duration computation */
+  toolCallStartTimes = /* @__PURE__ */ new Map();
   /** Append a streaming text chunk (called from onStream callback) */
   appendChunk(chunk) {
     this.streamingText += chunk;
@@ -6051,18 +8378,45 @@ class RealtimeBuffer {
       this.progressItems.push(item);
     }
   }
-  /** Record an activity event */
+  /** Record an activity event and track tool-call start times */
   pushActivity(event) {
+    if (event.type === "tool-call" && event.toolCallId) {
+      this.toolCallStartTimes.set(event.toolCallId, Date.now());
+    }
     this.activityEvents.push(event);
   }
+  /** Record a tool event for chat-inline rendering */
+  pushToolEvent(event) {
+    this.toolEvents.push(event);
+  }
+  /** Update a tool event by toolCallId (for tool-result merge) */
+  updateToolEvent(toolCallId, patch) {
+    const idx = this.toolEvents.findLastIndex((e) => e.toolCallId === toolCallId);
+    if (idx !== -1) {
+      this.toolEvents[idx] = { ...this.toolEvents[idx], ...patch };
+    }
+  }
+  /** Clear tool events (on new run or finalize) */
+  clearToolEvents() {
+    this.toolEvents = [];
+  }
+  /** Pop and return the start time for a tool-call, or undefined if not found */
+  popToolCallStartTime(toolCallId) {
+    const t = this.toolCallStartTimes.get(toolCallId);
+    if (t !== void 0) this.toolCallStartTimes.delete(toolCallId);
+    return t;
+  }
   /** Clear progress and activity (called on project close or explicit reset) */
   clearRun() {
     this.progressItems = [];
     this.activityEvents = [];
+    this.toolEvents = [];
   }
   /** Clear only activity events (called on new agent run) */
   clearActivity() {
     this.activityEvents = [];
+    this.toolEvents = [];
+    this.toolCallStartTimes.clear();
   }
   /** Mark streaming finished (called on agent:done) */
   finishStreaming() {
@@ -6075,6 +8429,8 @@ class RealtimeBuffer {
     this.isStreaming = false;
     this.progressItems = [];
     this.activityEvents = [];
+    this.toolEvents = [];
+    this.toolCallStartTimes.clear();
   }
   /** Return a snapshot the renderer can use to hydrate stores */
   getSnapshot() {
@@ -6082,17 +8438,366 @@ class RealtimeBuffer {
       streamingText: this.streamingText,
       isStreaming: this.isStreaming,
       progressItems: [...this.progressItems],
-      activityEvents: [...this.activityEvents]
+      activityEvents: [...this.activityEvents],
+      toolEvents: [...this.toolEvents]
     };
   }
 }
 function createRealtimeBuffer() {
   return new RealtimeBuffer();
 }
+function getFileName(path2) {
+  if (!path2) return "";
+  const parts = path2.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1] || path2;
+}
+function truncStr(s, max) {
+  if (!s) return "";
+  return s.length > max ? s.slice(0, max - 3) + "..." : s;
+}
+function safeRecord(obj) {
+  return obj && typeof obj === "object" ? obj : {};
+}
+function extractResultText(result) {
+  const r = safeRecord(result);
+  const content = r.content;
+  return content?.[0]?.text || "";
+}
+function lastNLines(text, n) {
+  const lines = text.split("\n").filter(Boolean);
+  return lines.slice(-n).join("\n");
+}
+const configs = [
+  // ── File tools ────────────────────────
+  {
+    name: "read",
+    displayName: "Read",
+    icon: "FileText",
+    category: "file",
+    formatCallSummary: (a) => {
+      const path2 = a.path || "";
+      const offset = a.offset;
+      const limit = a.limit;
+      const suffix = offset ? ` · lines ${offset}-${offset + (limit || 2e3)}` : "";
+      return `${getFileName(path2)}${suffix}`;
+    },
+    formatCallDetail: (a) => ({ path: a.path, offset: a.offset, limit: a.limit }),
+    formatResultSummary: (result) => {
+      const text = extractResultText(result);
+      const lineCount = text ? text.split("\n").length : 0;
+      return lineCount ? `${lineCount} lines` : "Read completed";
+    },
+    formatResultDetail: (result) => {
+      const text = extractResultText(result);
+      return { lineCount: text ? text.split("\n").length : 0 };
+    }
+  },
+  {
+    name: "write",
+    displayName: "Write",
+    icon: "FileText",
+    category: "file",
+    formatCallSummary: (a) => getFileName(a.path || ""),
+    formatCallDetail: (a) => ({ path: a.path }),
+    formatResultSummary: (_, a) => `Written: ${getFileName(a?.path || "")}`,
+    formatResultDetail: (_, a) => ({ path: a?.path })
+  },
+  {
+    name: "edit",
+    displayName: "Edit",
+    icon: "FileText",
+    category: "file",
+    formatCallSummary: (a) => getFileName(a.path || ""),
+    formatCallDetail: (a) => ({ path: a.path }),
+    formatResultSummary: (_, a) => `Edited: ${getFileName(a?.path || "")}`,
+    formatResultDetail: (_, a) => ({ path: a?.path })
+  },
+  // ── Code tools ────────────────────────
+  {
+    name: "bash",
+    displayName: "Bash",
+    icon: "Terminal",
+    category: "code",
+    formatCallSummary: (a) => {
+      const cmd = a.command || "";
+      return cmd.length > 60 ? `$ ${cmd.slice(0, 57)}...` : `$ ${cmd}`;
+    },
+    formatCallDetail: (a) => ({ command: truncStr(a.command, 200) }),
+    formatResultSummary: () => "Command completed",
+    formatResultDetail: (result) => {
+      const text = extractResultText(result);
+      const lines = text.split("\n").filter(Boolean);
+      return { outputLines: lines.length, outputPreview: truncStr(lastNLines(text, 3), 200) };
+    },
+    formatProgress: (partial) => {
+      const text = partial?.content?.[0]?.text;
+      if (typeof text === "string" && text.length > 0) {
+        return lastNLines(text, 5);
+      }
+      return void 0;
+    }
+  },
+  // ── Search tools ────────────────────────
+  {
+    name: "grep",
+    displayName: "Search",
+    icon: "Search",
+    category: "search",
+    formatCallSummary: (a) => `"${truncStr(a.pattern, 30)}"${a.path ? ` in ${a.path}` : ""}`,
+    formatCallDetail: (a) => ({ pattern: a.pattern, path: a.path, glob: a.glob }),
+    formatResultSummary: (result) => {
+      const text = extractResultText(result);
+      const count = text.split("\n").filter(Boolean).length;
+      return `${count} results`;
+    },
+    formatResultDetail: (result) => {
+      const text = extractResultText(result);
+      return { matchCount: text.split("\n").filter(Boolean).length };
+    }
+  },
+  {
+    name: "glob",
+    displayName: "Find Files",
+    icon: "Search",
+    category: "search",
+    formatCallSummary: (a) => a.pattern || "",
+    formatCallDetail: (a) => ({ pattern: a.pattern, path: a.path }),
+    formatResultSummary: (result) => {
+      const text = extractResultText(result);
+      const count = text.split("\n").filter(Boolean).length;
+      return `${count} files`;
+    },
+    formatResultDetail: (result) => {
+      const text = extractResultText(result);
+      return { fileCount: text.split("\n").filter(Boolean).length };
+    }
+  },
+  {
+    name: "find",
+    displayName: "Find",
+    icon: "Search",
+    category: "search",
+    formatCallSummary: (a) => truncStr(a.pattern || a.path, 40),
+    formatCallDetail: (a) => ({ pattern: a.pattern, path: a.path }),
+    formatResultSummary: () => "Find completed",
+    formatResultDetail: () => ({})
+  },
+  {
+    name: "ls",
+    displayName: "List",
+    icon: "FileText",
+    category: "file",
+    formatCallSummary: (a) => a.path || ".",
+    formatCallDetail: (a) => ({ path: a.path }),
+    formatResultSummary: () => "Listed",
+    formatResultDetail: () => ({})
+  },
+  // ── Web tools ────────────────────────
+  {
+    name: "fetch",
+    displayName: "Fetch",
+    icon: "Globe",
+    category: "web",
+    formatCallSummary: (a) => truncStr(a.url, 50),
+    formatCallDetail: (a) => ({ url: a.url }),
+    formatResultSummary: (result) => {
+      const text = extractResultText(result);
+      const kb = (text.length / 1024).toFixed(1);
+      return `${kb}KB received`;
+    },
+    formatResultDetail: (result) => {
+      const text = extractResultText(result);
+      return { sizeKB: parseFloat((text.length / 1024).toFixed(1)) };
+    }
+  },
+  {
+    name: "web_fetch",
+    displayName: "Web Fetch",
+    icon: "Globe",
+    category: "web",
+    formatCallSummary: (a) => truncStr(a.url, 50),
+    formatCallDetail: (a) => ({ url: a.url }),
+    formatResultSummary: (result) => {
+      const r = safeRecord(result);
+      const data = safeRecord(r.data);
+      const charCount = data.charCount;
+      if (charCount) return `${(charCount / 1024).toFixed(1)}KB received`;
+      return "Fetch completed";
+    },
+    formatResultDetail: (result) => {
+      const r = safeRecord(result);
+      const data = safeRecord(r.data);
+      return { charCount: data.charCount, url: data.url };
+    }
+  },
+  {
+    name: "web_search",
+    displayName: "Web Search",
+    icon: "Globe",
+    category: "web",
+    formatCallSummary: (a) => truncStr(a.query, 50),
+    formatCallDetail: (a) => ({ query: a.query }),
+    formatResultSummary: () => "Search completed",
+    formatResultDetail: () => ({})
+  },
+  // ── Research tools ────────────────────────
+  {
+    name: "literature-search",
+    displayName: "Literature Search",
+    icon: "BookOpen",
+    category: "research",
+    formatCallSummary: (a) => truncStr(a.query, 40),
+    formatCallDetail: (a) => ({ query: a.query, maxResults: a.max_results }),
+    formatResultSummary: (result) => {
+      const r = safeRecord(result);
+      const data = safeRecord(r.data);
+      const totalFound = data.totalPapersFound ?? 0;
+      const saved = data.papersAutoSaved ?? 0;
+      const coverage = data.coverage;
+      if (totalFound > 0) {
+        let s = `Found ${totalFound} papers`;
+        if (coverage?.score != null) s += ` (${Math.round(coverage.score * 100)}%)`;
+        if (saved > 0) s += `, saved ${saved}`;
+        return s;
+      }
+      const local = data.localPapersUsed ?? 0;
+      const external = data.externalPapersUsed ?? 0;
+      return `Found ${local + external} papers`;
+    },
+    formatResultDetail: (result) => {
+      const r = safeRecord(result);
+      const data = safeRecord(r.data);
+      return {
+        papersFound: data.totalPapersFound ?? 0,
+        papersSaved: data.papersAutoSaved ?? 0,
+        coverage: data.coverage?.score
+      };
+    }
+  },
+  {
+    name: "lit-subtopic",
+    displayName: "Sub-topic Search",
+    icon: "BookOpen",
+    category: "research",
+    formatCallSummary: (a) => a._summary || "Searching sub-topic",
+    formatCallDetail: (a) => ({ summary: a._summary }),
+    formatResultSummary: (result) => safeRecord(result).data || "Search completed",
+    formatResultDetail: () => ({})
+  },
+  {
+    name: "lit-enrich",
+    displayName: "Enrich Papers",
+    icon: "BookOpen",
+    category: "research",
+    formatCallSummary: (a) => a._summary || "Enriching paper metadata",
+    formatCallDetail: (a) => ({ summary: a._summary }),
+    formatResultSummary: (result) => safeRecord(result).data || "Enriched metadata",
+    formatResultDetail: () => ({})
+  },
+  {
+    name: "lit-autosave",
+    displayName: "Save Papers",
+    icon: "BookOpen",
+    category: "research",
+    formatCallSummary: (a) => a._summary || "Saving papers",
+    formatCallDetail: (a) => ({ summary: a._summary }),
+    formatResultSummary: (result) => safeRecord(result).data || "Saved papers",
+    formatResultDetail: () => ({})
+  },
+  {
+    name: "data_analyze",
+    displayName: "Data Analysis",
+    icon: "Database",
+    category: "research",
+    formatCallSummary: (a) => getFileName(a.file_path || "") || "data",
+    formatCallDetail: (a) => ({ file_path: a.file_path }),
+    formatResultSummary: () => "Analysis completed",
+    formatResultDetail: () => ({})
+  },
+  // ── Artifact tools ────────────────────────
+  {
+    name: "artifact-create",
+    displayName: "Create Artifact",
+    icon: "Sparkles",
+    category: "memory",
+    formatCallSummary: (a) => {
+      const type = (a.type || "artifact").toLowerCase();
+      const title = truncStr(a.title, 35);
+      return `${type}: ${title}`;
+    },
+    formatCallDetail: (a) => ({ type: a.type, title: a.title }),
+    formatResultSummary: (result) => {
+      const data = safeRecord(safeRecord(result).data);
+      const type = data.type || "artifact";
+      const title = truncStr(data.title, 30);
+      return title ? `Created ${type}: ${title}` : `Created ${type}`;
+    },
+    formatResultDetail: (result) => {
+      const data = safeRecord(safeRecord(result).data);
+      return { type: data.type, title: data.title };
+    }
+  },
+  {
+    name: "artifact-update",
+    displayName: "Update Artifact",
+    icon: "Sparkles",
+    category: "memory",
+    formatCallSummary: (a) => truncStr(a.id, 30),
+    formatCallDetail: (a) => ({ id: a.id }),
+    formatResultSummary: () => "Updated",
+    formatResultDetail: () => ({})
+  },
+  {
+    name: "artifact-search",
+    displayName: "Search Artifacts",
+    icon: "Search",
+    category: "memory",
+    formatCallSummary: (a) => truncStr(a.query, 40),
+    formatCallDetail: (a) => ({ query: a.query, types: a.types }),
+    formatResultSummary: () => "Search completed",
+    formatResultDetail: () => ({})
+  },
+  // ── System tools ────────────────────────
+  {
+    name: "convert_document",
+    displayName: "Convert Document",
+    icon: "FileText",
+    category: "system",
+    formatCallSummary: (a) => getFileName(a.source || ""),
+    formatCallDetail: (a) => ({ source: a.source }),
+    formatResultSummary: (result, a) => {
+      const data = safeRecord(safeRecord(result).data);
+      const skill = data.converterSkill;
+      const sourceName = getFileName(a?.source || "");
+      return skill ? `Converted ${sourceName} via ${skill}` : `Converted ${sourceName}`;
+    },
+    formatResultDetail: (result) => {
+      const data = safeRecord(safeRecord(result).data);
+      return { converterSkill: data.converterSkill, outputFile: data.outputFile };
+    }
+  },
+  {
+    name: "load_skill",
+    displayName: "Load Skill",
+    icon: "Sparkles",
+    category: "system",
+    formatCallSummary: (a) => a.name || "skill",
+    formatCallDetail: (a) => ({ name: a.name }),
+    formatResultSummary: (_, a) => `Loaded: ${a?.name || "skill"}`,
+    formatResultDetail: () => ({})
+  }
+];
+const registry = /* @__PURE__ */ new Map();
+for (const config of configs) {
+  registry.set(config.name, config);
+}
+function getToolRenderConfig(toolName) {
+  return registry.get(toolName);
+}
 const EMPTY = {
   version: 1,
   updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-  totals: { tokens: 0, promptTokens: 0, cachedTokens: 0, cost: 0, calls: 0 }
+  totals: { tokens: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cost: 0, calls: 0 }
 };
 function usagePath(baseDir) {
   return join(baseDir, "usage.json");
@@ -6102,6 +8807,9 @@ function loadUsageTotals(baseDir) {
     const raw = readFileSync(usagePath(baseDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.totals) return { ...EMPTY };
+    const t = parsed.totals;
+    t.completionTokens ??= 0;
+    t.cacheWriteTokens ??= 0;
     return parsed;
   } catch {
     return { ...EMPTY };
@@ -6130,15 +8838,17 @@ function writeAtomically(filePath, data) {
     }
   }
 }
-function accumulateUsage(baseDir, promptTokens, completionTokens, cachedTokens, cost) {
+function accumulateUsage(baseDir, promptTokens, completionTokens, cachedTokens, cacheWriteTokens, cost) {
   const existing = loadUsageTotals(baseDir);
   const next = {
     version: 1,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     totals: {
-      tokens: existing.totals.tokens + promptTokens + completionTokens,
+      tokens: existing.totals.tokens + promptTokens + completionTokens + cachedTokens,
       promptTokens: existing.totals.promptTokens + promptTokens,
+      completionTokens: existing.totals.completionTokens + completionTokens,
       cachedTokens: existing.totals.cachedTokens + cachedTokens,
+      cacheWriteTokens: existing.totals.cacheWriteTokens + cacheWriteTokens,
       cost: existing.totals.cost + cost,
       calls: existing.totals.calls + 1
     }
@@ -6150,105 +8860,52 @@ function resetUsageTotals(baseDir) {
   const cleared = {
     version: 1,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    totals: { tokens: 0, promptTokens: 0, cachedTokens: 0, cost: 0, calls: 0 }
+    totals: { tokens: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, cost: 0, calls: 0 }
   };
   writeAtomically(usagePath(baseDir), JSON.stringify(cleared, null, 2));
   return cleared;
 }
 function formatToolCall(tool, args) {
   const a = args && typeof args === "object" ? args : {};
-  switch (tool) {
-    case "literature-search":
-      return { label: `Search: ${(a.query || "").slice(0, 40)}${(a.query || "").length > 40 ? "..." : ""}`, icon: "search" };
-    case "lit-subtopic":
-      return { label: a._summary || "Searching sub-topic", icon: "search" };
-    case "lit-enrich":
-      return { label: a._summary || "Enriching paper metadata", icon: "search" };
-    case "lit-autosave":
-      return { label: a._summary || "Saving papers", icon: "file" };
-    case "data-analyze":
-      return { label: `Analyze: ${getFileName(a.filePath || "") || "data"}`, icon: "file" };
-    case "convert_to_markdown": {
-      const sourcePath = a.path || a.uri || "";
-      return { label: `Convert: ${getFileName(sourcePath)}`, icon: "file" };
-    }
-    case "artifact-create": {
-      const type = (a.type || "artifact").toLowerCase();
-      const title = (a.title || type).slice(0, 35);
-      return { label: `Create ${type}: ${title}`, icon: "file" };
-    }
-    case "read":
-      return { label: `Read: ${getFileName(a.path || "")}`, icon: "file" };
-    case "write":
-      return { label: `Write: ${getFileName(a.path || "")}`, icon: "file" };
-    case "edit":
-      return { label: `Edit: ${getFileName(a.path || "")}`, icon: "file" };
-    case "bash":
-      return { label: `Run command`, icon: "terminal" };
-    case "glob":
-      return { label: `Search files: ${a.pattern || ""}`, icon: "search" };
-    case "grep":
-      return { label: `Search content: ${(a.pattern || "").slice(0, 30)}`, icon: "search" };
-    case "fetch":
-      return { label: `Fetch: ${(a.url || "").slice(0, 40)}`, icon: "network" };
-    default:
-      return { label: `${tool}`, icon: "tool" };
+  const config = getToolRenderConfig(tool);
+  if (config) {
+    return {
+      label: `${config.displayName}: ${config.formatCallSummary(a)}`,
+      icon: config.icon,
+      detail: config.formatCallDetail(a)
+    };
   }
+  return { label: `${tool}`, icon: "tool" };
 }
 function formatToolResult(tool, result, args) {
-  const r = result && typeof result === "object" ? result : {};
   const a = args && typeof args === "object" ? args : {};
-  const data = r.data && typeof r.data === "object" ? r.data : {};
-  switch (tool) {
-    case "literature-search": {
-      const totalFound = data.totalPapersFound ?? 0;
-      const saved = data.papersAutoSaved ?? 0;
-      const coverage = data.coverage;
-      if (totalFound > 0) {
-        let summary2 = `Found ${totalFound} papers`;
-        if (coverage?.score != null) summary2 += ` (coverage: ${Math.round(coverage.score * 100)}%)`;
-        if (saved > 0) summary2 += `, saved ${saved}`;
-        return { label: summary2, icon: "search" };
-      }
-      const local = data.localPapersUsed ?? 0;
-      const external = data.externalPapersUsed ?? 0;
-      const savedV1 = data.savedPapers ?? 0;
-      let summary = `Found ${local + external} papers`;
-      if (local > 0) summary += ` (${local} local)`;
-      if (savedV1 > 0) summary += `, saved ${savedV1}`;
-      return { label: summary, icon: "search" };
-    }
-    case "lit-subtopic":
-      return { label: r.data || "Search completed", icon: "search" };
-    case "lit-enrich":
-      return { label: r.data || "Enriched metadata", icon: "search" };
-    case "lit-autosave":
-      return { label: r.data || "Saved papers", icon: "file" };
-    case "convert_to_markdown": {
-      const sourcePath = a.path || a.uri || "";
-      const skill = typeof data.converterSkill === "string" ? data.converterSkill : "";
-      const script = typeof data.converterScript === "string" ? data.converterScript : "";
-      if (skill && script) return { label: `Converted ${getFileName(sourcePath)} via ${skill}/${script}`, icon: "file" };
-      if (skill) return { label: `Converted ${getFileName(sourcePath)} via ${skill}`, icon: "file" };
-      return { label: `Converted ${getFileName(sourcePath)}`, icon: "file" };
-    }
-    case "artifact-create": {
-      const type = data.type || "artifact";
-      const title = data.title || "";
-      return { label: title ? `Created ${type}: ${title.slice(0, 30)}` : `Created ${type}`, icon: "file" };
-    }
-    default: {
-      const success2 = r.success !== false;
-      return { label: success2 ? `${tool} completed` : `${tool} failed`, icon: "tool" };
-    }
+  const r = result && typeof result === "object" ? result : {};
+  const success2 = r.success !== false;
+  const config = getToolRenderConfig(tool);
+  if (config && success2) {
+    return {
+      label: config.formatResultSummary(result, a),
+      icon: config.icon,
+      detail: config.formatResultDetail(result, a)
+    };
   }
+  if (config && !success2) {
+    const errorMsg = r.error || "";
+    const brief = errorMsg.length > 60 ? errorMsg.slice(0, 57) + "..." : errorMsg;
+    return {
+      label: brief ? `${config.displayName} failed: ${brief}` : `${config.displayName} failed`,
+      icon: config.icon,
+      detail: config.formatResultDetail(result, a)
+    };
+  }
+  return { label: success2 ? `${tool} completed` : `${tool} failed`, icon: "tool", detail: { success: success2 } };
 }
 const windowStates = /* @__PURE__ */ new Map();
 let ipcHandlersRegistered = false;
 function createWindowRuntimeState() {
   return {
     coordinator: null,
-    currentModel: "gpt-5.4",
+    currentModel: "openai:gpt-5.4",
     currentReasoningEffort: "medium",
     currentAuthMode: "none",
     projectPath: "",
@@ -6379,11 +9036,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,
@@ -6393,13 +9066,15 @@ async function ensureCoordinator(state, win, model, options) {
         state.realtimeBuffer.appendChunk(chunk);
         safeSend(win, "agent:stream-chunk", chunk);
       },
-      onToolCall: (tool, args) => {
-        const summary = formatToolCall(tool, args).label;
-        const event = { type: "tool-call", tool, summary };
+      onToolCall: (tool, args, toolCallId) => {
+        const id = toolCallId || randomUUID();
+        const { label, detail } = formatToolCall(tool, args);
+        const event = { type: "tool-call", tool, toolCallId: id, summary: label, detail };
         state.realtimeBuffer.pushActivity(event);
+        state.realtimeBuffer.pushToolEvent({ type: "tool-call", tool, toolCallId: id, summary: label, detail });
         safeSend(win, "agent:activity", event);
       },
-      onToolResult: (tool, result, args) => {
+      onToolResult: (tool, result, args, toolCallId) => {
         if (tool.startsWith("todo-") && result && typeof result === "object" && "success" in result) {
           const r2 = result;
           if (r2.success && r2.item) {
@@ -6414,16 +9089,16 @@ async function ensureCoordinator(state, win, model, options) {
             safeSend(win, "agent:file-created", absPath);
           }
         }
-        if (tool === "convert_to_markdown" && result && typeof result === "object" && "success" in result) {
+        if (tool === "convert_document" && result && typeof result === "object" && "success" in result) {
           const r2 = result;
           if (r2.success && r2.data?.outputFile) {
             safeSend(win, "agent:file-created", r2.data.outputFile);
           }
         }
-        if (tool === "convert_to_markdown" && result && typeof result === "object" && "success" in result) {
+        if (tool === "convert_document" && result && typeof result === "object" && "success" in result) {
           const r2 = result;
-          if (r2.success && r2.data?.outputFile && args && typeof args === "object" && "path" in args) {
-            const sourcePath = args.path;
+          if (r2.success && r2.data?.outputFile && args && typeof args === "object" && "source" in args) {
+            const sourcePath = args.source;
             const absSourcePath = isAbsolute(sourcePath) ? sourcePath : resolve(runProjectPath, sourcePath);
             const absOutputPath = resolve(runProjectPath, r2.data.outputFile);
             if (existsSync(absOutputPath)) {
@@ -6454,14 +9129,72 @@ 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;
-        const summary = formatToolResult(tool, result, args).label;
-        const actEvent = { type: "tool-result", tool, summary, success: success2, error };
+        const { label: resultLabel, detail: resultDetail } = formatToolResult(tool, result, args);
+        const startTime = toolCallId ? state.realtimeBuffer.popToolCallStartTime(toolCallId) : void 0;
+        const durationMs = startTime ? Date.now() - startTime : void 0;
+        const actEvent = { type: "tool-result", tool, toolCallId, summary: resultLabel, success: success2, error, resultDetail, durationMs };
         state.realtimeBuffer.pushActivity(actEvent);
+        if (toolCallId) {
+          state.realtimeBuffer.updateToolEvent(toolCallId, {
+            type: "tool-result",
+            summary: resultLabel,
+            success: success2,
+            resultDetail,
+            durationMs
+          });
+        }
         safeSend(win, "agent:activity", actEvent);
       },
+      // Tool execution progress (real-time updates during tool execution)
+      onToolProgress: (tool, toolCallId, phase, data) => {
+        safeSend(win, "agent:tool-progress", { tool, toolCallId, phase, data, timestamp: Date.now() });
+      },
       // Skill activation tracking
       onSkillLoaded: (skillName) => {
         safeSend(win, "agent:skill-loaded", skillName);
@@ -6473,12 +9206,14 @@ async function ensureCoordinator(state, win, model, options) {
         const promptTokens = usage.input ?? 0;
         const completionTokens = usage.output ?? 0;
         const cachedTokens = usage.cacheRead ?? 0;
+        const cacheWriteTokens = usage.cacheWrite ?? 0;
         const baseDir = join(runProjectPath, PATHS.root);
-        accumulateUsage(baseDir, promptTokens, completionTokens, cachedTokens, rawCost);
+        accumulateUsage(baseDir, promptTokens, completionTokens, cachedTokens, cacheWriteTokens, rawCost);
         const usageEvent = {
           promptTokens,
           completionTokens,
           cachedTokens,
+          cacheWriteTokens,
           cost: rawCost,
           rawCost,
           billableCost: rawCost,
@@ -6492,9 +9227,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;
@@ -6961,6 +9723,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"]
@@ -6985,11 +9765,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;
@@ -7015,7 +9817,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 {
@@ -7104,7 +9906,11 @@ function destroyAllTerminals() {
     terminals.delete(id);
   }
 }
+setMaxListeners(20);
 loadApiKeysFromConfig();
+if (!process.env.PI_CACHE_RETENTION) {
+  process.env.PI_CACHE_RETENTION = "long";
+}
 if (process.platform === "darwin" && !is.dev) {
   try {
     const shellPath = process.env.SHELL || "/bin/zsh";
@@ -7259,6 +10065,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);
+  });
 });