research-copilot 0.1.3 → 0.2.1

package/app/out/main/index.mjs

@@ -1,20 +1,23 @@
 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 { existsSync, statSync, readdirSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, rmSync, renameSync, unlinkSync } from "fs";
+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 { getModel, completeSimple } from "@mariozechner/pi-ai";
+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;
 const __dirname = import.meta.dirname;
@@ -232,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";
@@ -575,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);
     }
@@ -606,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 }
   };
 }
@@ -634,6 +660,8 @@ const PATHS = {
   memoryRoot: ".research-pilot/memory-v2",
   explainDir: ".research-pilot/memory-v2/explain",
   sessionSummaries: ".research-pilot/memory-v2/session-summaries",
+  // Structured long-term memory (auto-memory)
+  memory: ".research-pilot/memory",
   // Skills
   skills: ".research-pilot/skills",
   skillsConfig: ".research-pilot/skills-config.json"
@@ -1244,56 +1272,334 @@ function createArtifactSearchTool(projectPath) {
     }
   };
 }
-function createUpdateMemoryTool(projectPath) {
+function createResearchMemoryTools(params) {
+  return [
+    createArtifactCreateTool(params.sessionId, params.projectPath),
+    createArtifactUpdateTool(params.projectPath),
+    createArtifactSearchTool(params.projectPath)
+  ];
+}
+function slugify(text) {
+  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`;
+}
+function memoryDir(projectPath) {
+  return join(projectPath, PATHS.memory);
+}
+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: ${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]] = yamlUnescape(kv[2]);
+  }
+  if (!fm.name || !fm.type) return null;
+  const validTypes = ["user", "feedback", "project", "reference"];
+  if (!validTypes.includes(fm.type)) return null;
   return {
-    name: "update-memory",
-    description: 'Write to the "## Agent Memory" section of agent.md — your persistent memory across sessions. Use this to save: user preferences, project context, key decisions, important findings. The content you provide REPLACES the entire Agent Memory section (User Instructions section is preserved automatically). Keep it concise (<5000 chars total). Consolidate and remove outdated entries rather than appending.',
+    frontmatter: { name: fm.name, description: fm.description || "", type: fm.type },
+    body: match[2].trim()
+  };
+}
+function writeMemoryFile(projectPath, entry) {
+  ensureMemoryDir(projectPath);
+  const filePath = join(memoryDir(projectPath), entry.filename);
+  const content = `${formatFrontmatter(entry.frontmatter)}
+
+${entry.content}
+`;
+  writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function readMemoryFile(projectPath, filename) {
+  const filePath = join(memoryDir(projectPath), filename);
+  if (!existsSync(filePath)) return null;
+  try {
+    const text = readFileSync(filePath, "utf-8");
+    const parsed = parseFrontmatter(text);
+    if (!parsed) return null;
+    return { frontmatter: parsed.frontmatter, content: parsed.body, filename };
+  } catch {
+    return null;
+  }
+}
+function deleteMemoryFile(projectPath, filename) {
+  const filePath = join(memoryDir(projectPath), filename);
+  if (!existsSync(filePath)) return false;
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listMemoryFiles(projectPath) {
+  const dir = memoryDir(projectPath);
+  if (!existsSync(dir)) return [];
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+    const entries = [];
+    for (const filename of files) {
+      const entry = readMemoryFile(projectPath, filename);
+      if (entry) entries.push(entry);
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+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).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 "";
+  return entries.map((e) => {
+    const desc = e.frontmatter.description.slice(0, 100).replace(/\n/g, " ");
+    return `- [${e.frontmatter.name}](memory/${e.filename}) — ${desc}`;
+  }).join("\n");
+}
+function updateAgentMdIndex(projectPath, entries) {
+  const record = findArtifactById(projectPath, AGENT_MD_ID);
+  const currentContent = record?.artifact?.type === "note" ? record.artifact.content || "" : "";
+  const marker = "## Agent Memory";
+  const markerIdx = currentContent.indexOf(marker);
+  const userInstructions = markerIdx >= 0 ? currentContent.slice(0, markerIdx).trimEnd() : currentContent.trimEnd();
+  const indexContent = buildMemoryIndex(entries);
+  const newContent = indexContent ? `${userInstructions}
+
+${marker}
+
+${indexContent}
+` : `${userInstructions}
+
+${marker}
+`;
+  if (newContent.length > AGENT_MD_MAX_CHARS) {
+    return { success: false, charCount: newContent.length };
+  }
+  updateArtifact(projectPath, AGENT_MD_ID, { content: newContent });
+  return { success: true, charCount: newContent.length };
+}
+function migrateAgentMemoryToFile(projectPath) {
+  const record = findArtifactById(projectPath, AGENT_MD_ID);
+  if (!record) return false;
+  const content = record.artifact?.type === "note" ? record.artifact.content || "" : "";
+  const marker = "## Agent Memory";
+  const markerIdx = content.indexOf(marker);
+  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: {
+      name: "Legacy notes",
+      description: "Migrated from agent.md Agent Memory section",
+      type: "project"
+    },
+    content: agentMemory,
+    filename: memoryFilename("project", "legacy-notes")
+  };
+  writeMemoryFile(projectPath, entry);
+  const allEntries = listMemoryFiles(projectPath);
+  updateAgentMdIndex(projectPath, allEntries);
+  return true;
+}
+const VALID_TYPES$1 = ["user", "feedback", "project", "reference"];
+function createSaveMemoryTool(projectPath) {
+  return {
+    name: "save-memory",
+    description: 'Save a memory to long-term storage. Each memory becomes a file in .research-pilot/memory/ and an index entry in agent.md (visible every turn). Types: "user" (preferences/background), "feedback" (corrections to behavior), "project" (decisions/deadlines/context), "reference" (external pointers/reusable info). If a memory with the same name+type exists, it is updated.',
     parameters: {
       type: "object",
       properties: {
-        memory: {
+        type: {
+          type: "string",
+          enum: VALID_TYPES$1,
+          description: "Memory category"
+        },
+        name: {
           type: "string",
-          description: 'The full content for the "## Agent Memory" section. Markdown format.'
+          description: "Short identifier (used as title and filename slug)"
+        },
+        content: {
+          type: "string",
+          description: "The memory content (markdown). Keep it concise and focused."
         }
       },
-      required: ["memory"]
+      required: ["type", "name", "content"]
     },
     execute: async (input) => {
-      const args = input;
-      const memory = String(args.memory || "").trim();
-      if (!memory) return toolError("MISSING_PARAMETER", "memory content is required.", {
-        suggestions: ["Provide the content to save in the Agent Memory section."]
+      const type = String(input.type || "");
+      const name = String(input.name || "").trim();
+      const content = String(input.content || "").trim();
+      if (!VALID_TYPES$1.includes(type)) {
+        return toolError("INVALID_PARAMETER", `Invalid memory type: ${type}. Must be one of: ${VALID_TYPES$1.join(", ")}`, {
+          suggestions: ['Use "user", "feedback", "project", or "reference".']
+        });
+      }
+      if (!name) return toolError("MISSING_PARAMETER", "name is required.", {
+        suggestions: ["Provide a short descriptive name for this memory."]
       });
-      const record = findArtifactById(projectPath, AGENT_MD_ID);
-      const currentContent = record?.artifact?.type === "note" ? record.artifact.content || "" : "";
-      const agentMemoryMarker = "## Agent Memory";
-      const markerIdx = currentContent.indexOf(agentMemoryMarker);
-      const userInstructions = markerIdx >= 0 ? currentContent.slice(0, markerIdx).trimEnd() : currentContent.split("\n").filter((l) => !l.startsWith("## Agent Memory")).join("\n").trimEnd();
-      const newContent = `${userInstructions}
-
-${agentMemoryMarker}
-
-${memory}
-`;
-      const updated = updateArtifact(projectPath, AGENT_MD_ID, { content: newContent });
-      if (!updated) {
-        return toolError("UPDATE_FAILED", "Failed to update agent.md.", {
-          suggestions: ["agent.md may not exist. Try opening a project folder first."]
+      if (!content) return toolError("MISSING_PARAMETER", "content is required.", {
+        suggestions: ["Provide the memory content to save."]
+      });
+      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. 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 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."]
         });
       }
-      return {
-        success: true,
-        data: { message: "Agent memory updated.", charCount: newContent.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
+          }
+        };
+      });
     }
   };
 }
-function createResearchMemoryTools(params) {
+function createMemoryTools(projectPath) {
   return [
-    createArtifactCreateTool(params.sessionId, params.projectPath),
-    createArtifactUpdateTool(params.projectPath),
-    createArtifactSearchTool(params.projectPath),
-    createUpdateMemoryTool(params.projectPath)
+    createSaveMemoryTool(projectPath),
+    createDeleteMemoryTool(projectPath)
   ];
 }
 const WEB_DEFAULTS = {
@@ -1311,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) {
@@ -1559,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") {
@@ -1603,7 +1911,6 @@ function createWebSearchTool(ctx) {
         count: results.length,
         results
       };
-      ctx.onToolResult?.("web_search", payload);
       return toAgentResult("web_search", {
         success: true,
         data: payload
@@ -1615,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;
@@ -1644,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);
@@ -1682,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,
@@ -1741,11 +2068,20 @@ Memory model:
 - Session context is maintained automatically via periodic summaries.
 - For quick-reference info, create a note via artifact-create({ type: "note", ... }).
 
-Long-term memory:
-- Use the update-memory tool to persist information across sessions. It writes to the "## Agent Memory" section of agent.md, which is injected into your context every turn.
-- WHEN to save: user states a preference ("always do X", "I prefer Y"), a key project decision is made, you discover something important about the project that future sessions need.
-- WHEN NOT to save: routine task results, things already visible in files/git, ephemeral conversation details.
-- Keep it concise — consolidate and remove outdated entries. It's a living summary, not a log.
+Long-term memory (auto-memory):
+- Your agent.md "## Agent Memory" section shows an index of saved memories. It is injected into your context every turn, so you always see what is remembered.
+- Use save-memory to persist information across sessions. Each memory becomes a file in .research-pilot/memory/ with one of four types:
+  * user — who the user is: role, expertise, preferences, communication style
+  * feedback — corrections to your behavior: "don't do X", "when I say Y I mean Z"
+  * project — key decisions, deadlines, collaborators, research directions
+  * reference — pointers to external resources, reusable facts, definitions
+- Use delete-memory to remove outdated entries by name.
+- WHEN to save: user explicitly states a preference, corrects your behavior, a non-obvious project decision is made, or user points to an external resource. Most turns do NOT warrant saving a memory — only save when you learn something genuinely new that a future session would need.
+- WHEN NOT to save: routine task results, things already in workspace files or git, ephemeral conversation details, information derivable from the codebase, anything already captured in an existing memory.
+- Before saving, check agent.md index — if a similar memory exists, update it instead of creating a duplicate.
+- Keep each memory atomic (one concept) and concise.
+- Note: save-memory is for cross-session meta-information (preferences, context). Use artifact-create for work products (notes, analysis results, review memos).
+- You can read full memory files with the read tool at .research-pilot/memory/<filename>.
 
 Coding tasks:
 - For code implementation, follow test-first workflow: write/update test → confirm it fails → implement → confirm it passes.
@@ -2550,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}`;
@@ -2727,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,
@@ -2738,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,
@@ -2761,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));
     }
   };
@@ -2804,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 {
@@ -2833,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);
@@ -2843,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) {
@@ -3077,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,
@@ -3165,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);
@@ -3179,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 });
@@ -3369,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;
@@ -3402,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);
@@ -3541,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: [
@@ -3551,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.", {
@@ -3610,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], {
@@ -3637,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))
               });
             }
           }
@@ -3650,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
           }
         }));
@@ -3717,20 +4049,168 @@ 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));
   tools.push(createDataAnalyzeTool(ctx));
-  const memoryTools = createResearchMemoryTools({
+  const artifactTools = createResearchMemoryTools({
     sessionId: ctx.sessionId,
     projectPath: ctx.projectPath
   });
-  for (const tool of memoryTools) {
+  for (const tool of artifactTools) {
+    tools.push(wrapResearchTool(tool));
+  }
+  const structuredMemoryTools = createMemoryTools(ctx.projectPath);
+  for (const tool of structuredMemoryTools) {
     tools.push(wrapResearchTool(tool));
   }
   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}]
+`;
+          }
+        }
+      }
+    }
+    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({
+      role: "user",
+      content: EXTRACTION_PROMPT,
+      timestamp: Date.now()
+    });
+    const result = await completeSimple(config.model, {
+      systemPrompt: config.systemPrompt,
+      messages: simplified
+    }, {
+      maxTokens: 1024,
+      apiKey: config.apiKey
+    });
+    const textContent = result.content.find((c) => c.type === "text");
+    const text = textContent?.text?.trim() ?? "";
+    if (!text || text === "[]") return;
+    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);
+    const validEntries = [];
+    for (const mem of extracted) {
+      if (!mem.type || !mem.name || !mem.content) continue;
+      if (!VALID_TYPES.includes(mem.type)) continue;
+      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,
+          type: mem.type
+        },
+        content: mem.content,
+        filename: memoryFilename(mem.type, mem.name)
+      });
+    }
+    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 ${validEntries.length} memories from conversation`);
+    }
+  } catch (err) {
+    if (config.debug) {
+      console.warn("[Extractor] Failed:", err);
+    }
+  }
+}
 const SKILL_FILE_NAME = "SKILL.md";
 const MAX_SCAN_DEPTH = 3;
 let _builtinSkillsRoot = null;
@@ -3775,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;
@@ -3806,7 +4286,7 @@ function parseSkillFile(skillFile, displayPath, source) {
     tags,
     triggers,
     path: displayPath,
-    dir: path.dirname(skillFile),
+    dir: path$1.dirname(skillFile),
     source,
     content
   };
@@ -3822,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) {
@@ -3894,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);
@@ -3904,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) {
@@ -3930,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);
@@ -4139,6 +4619,7 @@ async function createCoordinator(config) {
     onStream,
     onToolCall,
     onToolResult,
+    onToolProgress,
     onUsage,
     onSkillLoaded
   } = config;
@@ -4210,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,
@@ -4337,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;
@@ -4355,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") {
@@ -4369,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() {
@@ -4478,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 {
@@ -4541,6 +5024,11 @@ ${message}`;
         });
         if (turnHistory.length > 8) turnHistory.shift();
         void maybeGenerateSummary();
+        void maybeExtractMemories(
+          { projectPath, model: piModel, apiKey, systemPrompt: enrichedSystem, debug },
+          agent.state.messages,
+          turnCount
+        );
         if (debug) {
           console.log(`[Chat] Result: success=true, hasOutput=${!!responseText}, turn=${turnCount}`);
         }
@@ -4596,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.
@@ -5200,11 +5688,11 @@ function searchEntities(projectPath, query, types) {
     score: hit.score
   }));
 }
-const MENTION_RE = /@(note|paper|data|file|url):(?:"([^"]+)"|(\S+))/g;
+const MENTION_RE = /@(note|paper|data|file|url):(?:"((?:[^"\\]|\\.)*)"|(\S+))/g;
 function parseMentions(message) {
   const mentions = [];
   const cleanMessage = message.replace(MENTION_RE, (_match, type, quoted, unquoted) => {
-    const key = quoted || unquoted;
+    const key = (quoted || unquoted).replace(/\\"/g, '"');
     const raw = _match;
     mentions.push({ type, key, raw });
     return `[${type}: ${key}]`;
@@ -5212,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`;
 }
@@ -5229,11 +5717,11 @@ function getCachedMarkdown(filePath, projectPath) {
     const mtime = stat.mtimeMs;
     const cacheDir = join(projectPath, PATHS.documentCache);
     const cacheKey2 = getCacheKey(filePath, mtime);
-    const cachePath = join(cacheDir, cacheKey2);
-    if (!existsSync(cachePath)) {
+    const cachePath2 = join(cacheDir, cacheKey2);
+    if (!existsSync(cachePath2)) {
       return null;
     }
-    const entry = JSON.parse(readFileSync(cachePath, "utf-8"));
+    const entry = JSON.parse(readFileSync(cachePath2, "utf-8"));
     if (entry.sourcePath !== filePath || entry.sourceMtime !== mtime) {
       return null;
     }
@@ -5248,14 +5736,14 @@ function setCachedMarkdown(filePath, markdown, projectPath) {
     const mtime = stat.mtimeMs;
     const cacheDir = ensureCacheDir(projectPath);
     const cacheKey2 = getCacheKey(filePath, mtime);
-    const cachePath = join(cacheDir, cacheKey2);
+    const cachePath2 = join(cacheDir, cacheKey2);
     const entry = {
       sourcePath: filePath,
       sourceMtime: mtime,
       markdown,
       cachedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    writeFileSync(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+    writeFileSync(cachePath2, JSON.stringify(entry, null, 2), "utf-8");
   } catch (err) {
     console.warn("[document-cache] Failed to cache markdown:", err);
   }
@@ -5315,6 +5803,10 @@ function resolveEntity(ref, dir, entityType, projectPath) {
 const DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".docx", ".xlsx", ".pptx", ".doc", ".xls", ".ppt", ".epub"]);
 function resolveFile(ref, projectPath) {
   const filePath = resolve(projectPath, ref.key);
+  const normalizedProject = resolve(projectPath);
+  if (!filePath.startsWith(normalizedProject + "/") && filePath !== normalizedProject) {
+    return { ref, label: `file: ${ref.key}`, content: "", error: `Path outside workspace: ${ref.key}` };
+  }
   if (!existsSync(filePath)) {
     return { ref, label: `file: ${ref.key}`, content: "", error: `File not found: ${ref.key}` };
   }
@@ -5427,6 +5919,9 @@ NOTE: This is a data entity. The actual data is in the file at the path above. U
   }
   return JSON.stringify(entity, null, 2);
 }
+const REFRESH_THROTTLE_MS = 5e3;
+const MAX_FILES = 5e3;
+const MAX_DEPTH = 8;
 const SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "__pycache__",
@@ -5439,10 +5934,58 @@ const SKIP_DIRS = /* @__PURE__ */ new Set([
   ".venv",
   "venv"
 ]);
-const MAX_FILE_CANDIDATES = 500;
-const MAX_DEPTH = 8;
-function walkFiles(root, rel, depth, out) {
-  if (depth > MAX_DEPTH || out.length >= MAX_FILE_CANDIDATES) return;
+let cachedFiles = [];
+let cachedProjectPath = "";
+let lastRefreshAt = 0;
+let refreshPromise = null;
+async function getFileList(projectPath) {
+  if (projectPath !== cachedProjectPath) {
+    cachedFiles = [];
+    cachedProjectPath = projectPath;
+    lastRefreshAt = 0;
+  }
+  const now = Date.now();
+  if (cachedFiles.length > 0 && now - lastRefreshAt < REFRESH_THROTTLE_MS) {
+    return cachedFiles;
+  }
+  if (refreshPromise) return refreshPromise;
+  refreshPromise = refreshFileList(projectPath).finally(() => {
+    refreshPromise = null;
+  });
+  return refreshPromise;
+}
+async function refreshFileList(projectPath) {
+  try {
+    const files = await gitLsFiles(projectPath);
+    cachedFiles = files.slice(0, MAX_FILES);
+  } catch {
+    cachedFiles = walkFilesSync(projectPath);
+  }
+  lastRefreshAt = Date.now();
+  return cachedFiles;
+}
+function gitLsFiles(cwd) {
+  return new Promise((resolve2, reject) => {
+    execFile$1(
+      "git",
+      ["ls-files", "-c", "-o", "--exclude-standard"],
+      { cwd, maxBuffer: 20 * 1024 * 1024, timeout: 5e3 },
+      (err, stdout) => {
+        if (err) return reject(err);
+        const files = stdout.split("\n").filter(Boolean);
+        if (files.length === 0) return reject(new Error("empty"));
+        resolve2(files);
+      }
+    );
+  });
+}
+function walkFilesSync(root) {
+  const out = [];
+  walk(root, "", 0, out);
+  return out;
+}
+function walk(root, rel, depth, out) {
+  if (depth > MAX_DEPTH || out.length >= MAX_FILES) return;
   const dir = rel ? join(root, rel) : root;
   let entries;
   try {
@@ -5452,7 +5995,7 @@ function walkFiles(root, rel, depth, out) {
   }
   for (const name of entries) {
     if (name.startsWith(".")) continue;
-    if (out.length >= MAX_FILE_CANDIDATES) return;
+    if (out.length >= MAX_FILES) return;
     const childRel = rel ? `${rel}/${name}` : name;
     const full = join(dir, name);
     let stat;
@@ -5463,22 +6006,107 @@ function walkFiles(root, rel, depth, out) {
     }
     if (stat.isDirectory()) {
       if (SKIP_DIRS.has(name)) continue;
-      walkFiles(root, childRel, depth + 1, out);
+      walk(root, childRel, depth + 1, out);
     } else {
-      out.push({
-        type: "file",
-        value: childRel,
-        label: childRel,
-        detail: `${(stat.size / 1024).toFixed(1)}KB`
-      });
+      out.push(childRel);
+    }
+  }
+}
+let cache = null;
+let cachePath = "";
+function getEntityCache(projectPath) {
+  if (cache && cachePath === projectPath) return cache;
+  cache = {
+    notes: listNotes(projectPath),
+    papers: listLiterature(projectPath),
+    data: listData(projectPath)
+  };
+  cachePath = projectPath;
+  return cache;
+}
+function invalidateEntityCache() {
+  cache = null;
+}
+const SCORE_MATCH = 16;
+const BONUS_FIRST_CHAR = 8;
+const BONUS_BOUNDARY = 8;
+const BONUS_CONSECUTIVE = 4;
+const PENALTY_GAP_START = 3;
+const PENALTY_GAP_EXT = 1;
+function fuzzyMatch(items, needle, getText, limit = 30) {
+  if (!needle) {
+    return items.slice(0, limit).map((item) => ({ item, score: 0 }));
+  }
+  const needleLower = needle.toLowerCase();
+  const results = [];
+  let worstInTopK = -Infinity;
+  for (const item of items) {
+    const haystack = getText(item);
+    const score = scoreMatch(needleLower, haystack.toLowerCase(), haystack);
+    if (score <= 0) continue;
+    if (results.length >= limit && score <= worstInTopK) continue;
+    insertSorted(results, { item, score }, limit);
+    if (results.length >= limit) {
+      worstInTopK = results[results.length - 1].score;
+    }
+  }
+  return results;
+}
+function scoreMatch(needle, haystackLower, haystack) {
+  let score = 0;
+  let ni = 0;
+  let consecutive = 0;
+  let lastMatchIdx = -1;
+  for (let hi = 0; hi < haystackLower.length && ni < needle.length; hi++) {
+    if (haystackLower[hi] === needle[ni]) {
+      score += SCORE_MATCH;
+      if (hi === 0) score += BONUS_FIRST_CHAR;
+      if (isBoundary(haystack, hi)) score += BONUS_BOUNDARY;
+      if (lastMatchIdx === hi - 1) {
+        consecutive++;
+        score += BONUS_CONSECUTIVE * consecutive;
+      } else {
+        const gap = lastMatchIdx >= 0 ? hi - lastMatchIdx - 1 : 0;
+        if (gap > 0) score -= PENALTY_GAP_START + PENALTY_GAP_EXT * (gap - 1);
+        consecutive = 1;
+      }
+      lastMatchIdx = hi;
+      ni++;
     }
   }
+  return ni === needle.length ? score : 0;
+}
+function isBoundary(s, i) {
+  if (i === 0) return true;
+  const prev = s.charCodeAt(i - 1);
+  const cur = s.charCodeAt(i);
+  if (prev === 47 || prev === 92 || prev === 45 || prev === 95 || prev === 46 || prev === 32) {
+    return true;
+  }
+  if (prev >= 97 && prev <= 122 && cur >= 65 && cur <= 90) return true;
+  return false;
 }
-function getCandidates(projectPath, typeFilter, query) {
+function insertSorted(arr, entry, limit) {
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (arr[mid].score >= entry.score) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  arr.splice(lo, 0, entry);
+  if (arr.length > limit) arr.pop();
+}
+const MAX_EMPTY_QUERY_FILES = 30;
+async function getCandidates(projectPath, typeFilter, query) {
   const candidates = [];
   const q = query?.toLowerCase() ?? "";
+  const entities = getEntityCache(projectPath);
   if (!typeFilter || typeFilter === "note") {
-    for (const n of listNotes(projectPath)) {
+    for (const n of entities.notes) {
       candidates.push({
         type: "note",
         value: n.id.slice(0, 8),
@@ -5488,7 +6116,7 @@ function getCandidates(projectPath, typeFilter, query) {
     }
   }
   if (!typeFilter || typeFilter === "paper") {
-    for (const l of listLiterature(projectPath)) {
+    for (const l of entities.papers) {
       candidates.push({
         type: "paper",
         value: l.citeKey,
@@ -5498,7 +6126,7 @@ function getCandidates(projectPath, typeFilter, query) {
     }
   }
   if (!typeFilter || typeFilter === "data") {
-    for (const d of listData(projectPath)) {
+    for (const d of entities.data) {
       candidates.push({
         type: "data",
         value: d.id.slice(0, 8),
@@ -5508,16 +6136,25 @@ function getCandidates(projectPath, typeFilter, query) {
     }
   }
   if (!typeFilter || typeFilter === "file") {
-    if (existsSync(projectPath)) {
-      walkFiles(projectPath, "", 0, candidates);
+    const files = await getFileList(projectPath);
+    for (const rel of files) {
+      let detail;
+      try {
+        const stat = statSync(join(projectPath, rel));
+        detail = `${(stat.size / 1024).toFixed(1)}KB`;
+      } catch {
+      }
+      candidates.push({ type: "file", value: rel, label: rel, detail });
     }
   }
   if (q) {
-    return candidates.filter(
-      (c) => c.label.toLowerCase().includes(q) || c.value.toLowerCase().includes(q) || c.detail?.toLowerCase().includes(q)
-    );
+    return fuzzyMatch(
+      candidates,
+      q,
+      (c) => `${c.label} ${c.value} ${c.detail ?? ""}`,
+      50
+    ).map((r) => r.item);
   }
-  const MAX_EMPTY_QUERY_FILES = 30;
   const fileCount = candidates.filter((c) => c.type === "file").length;
   if (fileCount > MAX_EMPTY_QUERY_FILES) {
     const nonFiles = candidates.filter((c) => c.type !== "file");
@@ -5535,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;
@@ -5549,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() {
@@ -5573,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() {
@@ -5580,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");
@@ -5600,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 };
@@ -5628,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
     }
@@ -5648,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;
@@ -5835,7 +6806,8 @@ function initializeProject(path2) {
     PATHS.memoryRoot,
     PATHS.explainDir,
     PATHS.sessionSummaries,
-    PATHS.skills
+    PATHS.skills,
+    PATHS.memory
   ];
   for (const dir of dirs) {
     const fullPath = join(path2, dir);
@@ -5856,6 +6828,7 @@ function initializeProject(path2) {
     writeFileSync(projectFile, JSON.stringify(defaultConfig, null, 2));
   }
   ensureAgentMd(path2);
+  migrateAgentMemoryToFile(path2);
   const migration = migrateLegacyArtifacts(path2);
   if (migration.updatedFiles > 0 && process.env.RESEARCH_COPILOT_DEBUG) {
     console.log(`[ResearchPilot] migrated legacy artifacts: files=${migration.updatedFiles}, literature->paper=${migration.convertedLiteratureType}, data.name removed=${migration.removedDataNameField}`);
@@ -5889,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) {
@@ -5910,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)) {
@@ -5933,28 +6908,46 @@ async function ensureCoordinator(state, win, model, options) {
             }
           }
         }
-        if (tool === "artifact-create" && result && typeof result === "object" && "success" in result) {
+        if ((tool === "artifact-create" || tool === "artifact-update") && result && typeof result === "object" && "success" in result) {
           const r2 = result;
           if (r2.success) {
-            safeSend(win, "agent:entity-created", {
-              type: r2.data?.type || "artifact",
-              id: r2.data?.id,
-              title: r2.data?.title
-            });
-            if (r2.data?.filePath) {
-              const absPath = isAbsolute(r2.data.filePath) ? r2.data.filePath : resolve(runProjectPath, r2.data.filePath);
-              safeSend(win, "agent:file-created", absPath);
+            invalidateEntityCache();
+            if (tool === "artifact-create") {
+              safeSend(win, "agent:entity-created", {
+                type: r2.data?.type || "artifact",
+                id: r2.data?.id,
+                title: r2.data?.title
+              });
+              if (r2.data?.filePath) {
+                const absPath = isAbsolute(r2.data.filePath) ? r2.data.filePath : resolve(runProjectPath, r2.data.filePath);
+                safeSend(win, "agent:file-created", absPath);
+              }
             }
           }
         }
         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);
@@ -5966,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,
@@ -6148,10 +7143,10 @@ function registerIpcHandlers() {
       }
     });
   });
-  handleWindow("mention:candidates", ({ state }, query, type) => {
+  handleWindow("mention:candidates", async ({ state }, query, type) => {
     if (!state.projectPath) return [];
     try {
-      return getCandidates(state.projectPath, type, query);
+      return await getCandidates(state.projectPath, type, query);
     } catch {
       return [];
     }
@@ -6597,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";