research-copilot 0.2.0 → 0.2.1

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 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 { 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";
@@ -576,13 +574,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 +631,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 }
   };
 }
@@ -1255,7 +1280,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 +1297,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 +1387,24 @@ function listMemoryFiles(projectPath) {
     return [];
   }
 }
-function findMemoryByName(projectPath, name) {
+function findMemoryByName(projectPath, name, type) {
   const lower = name.toLowerCase();
-  return listMemoryFiles(projectPath).find((e) => e.frontmatter.name.toLowerCase() === lower) ?? null;
+  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).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 +1444,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 +1501,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 +1617,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 +1868,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 +1911,6 @@ function createWebSearchTool(ctx) {
         count: results.length,
         results
       };
-      ctx.onToolResult?.("web_search", payload);
       return toAgentResult("web_search", {
         success: true,
         data: payload
@@ -1830,7 +1922,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 +1951,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 +1988,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 +2886,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 +3062,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 +3073,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,7 +3096,6 @@ 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));
     }
   };
@@ -3028,16 +3138,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 +3167,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 +3177,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) {
@@ -3301,15 +3411,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 +3499,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 +3513,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 +3703,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 +3736,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);
@@ -3765,7 +3875,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 +3885,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,7 +3943,7 @@ 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], {
@@ -3861,7 +3970,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 +3983,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
           }
         }));
@@ -3941,7 +4049,7 @@ function wrapResearchTool(tool) {
 }
 function createResearchTools(ctx) {
   const tools = [];
-  tools.push(createWebSearchTool(ctx));
+  tools.push(createWebSearchTool());
   tools.push(createWebFetchTool(ctx));
   tools.push(createLiteratureSearchTool(ctx));
   tools.push(createConvertDocumentTool(ctx));
@@ -4021,7 +4129,7 @@ function agentCalledSaveMemoryThisTurn(messages) {
   return false;
 }
 async function maybeExtractMemories(config, messages, turnCount, extractEveryN = 3) {
-  if (process.env.RESEARCH_COPILOT_AUTO_EXTRACT === "0") return;
+  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");
@@ -4045,33 +4153,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 +4255,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 +4286,7 @@ function parseSkillFile(skillFile, displayPath, source) {
     tags,
     triggers,
     path: displayPath,
-    dir: path.dirname(skillFile),
+    dir: path$1.dirname(skillFile),
     source,
     content
   };
@@ -4170,34 +4302,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 +4374,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 +4384,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 +4410,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);
@@ -4487,6 +4619,7 @@ async function createCoordinator(config) {
     onStream,
     onToolCall,
     onToolResult,
+    onToolProgress,
     onUsage,
     onSkillLoaded
   } = config;
@@ -4558,11 +4691,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,
@@ -4685,14 +4818,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 +4836,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 +4850,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() {
@@ -4826,24 +4968,17 @@ ${historyText}`,
 ## 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 {
@@ -4949,10 +5084,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 +5700,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 +6172,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 +6190,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 +6241,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 +6250,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 +6619,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 +6650,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,98 +6672,45 @@ 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;
@@ -6393,13 +6862,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 +6885,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)) {
@@ -6457,11 +6928,26 @@ async function ensureCoordinator(state, win, model, options) {
         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 +6959,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,
@@ -7104,7 +7592,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";