research-copilot 0.1.3 → 0.2.0

package/app/out/main/index.mjs

@@ -2,10 +2,10 @@ import { app, shell, ipcMain, BrowserWindow, dialog, Menu } from "electron";
 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 { existsSync, statSync, readdirSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, rmSync, unlinkSync, renameSync } from "fs";
 import os$1, { homedir } from "os";
 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";
@@ -15,6 +15,7 @@ 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;
@@ -634,6 +635,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 +1247,268 @@ function createArtifactSearchTool(projectPath) {
     }
   };
 }
-function createUpdateMemoryTool(projectPath) {
+function createResearchMemoryTools(params) {
+  return [
+    createArtifactCreateTool(params.sessionId, params.projectPath),
+    createArtifactUpdateTool(params.projectPath),
+    createArtifactSearchTool(params.projectPath)
+  ];
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+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 formatFrontmatter(fm) {
+  return [
+    "---",
+    `name: ${fm.name}`,
+    `description: ${fm.description}`,
+    `type: ${fm.type}`,
+    "---"
+  ].join("\n");
+}
+function parseFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  const fm = {};
+  for (const line of match[1].split("\n")) {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv) fm[kv[1]] = kv[2].trim();
+  }
+  if (!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) {
+  const lower = name.toLowerCase();
+  return listMemoryFiles(projectPath).find((e) => e.frontmatter.name.toLowerCase() === lower) ?? null;
+}
+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;
+  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."]
+      });
+      ensureMemoryDir(projectPath);
+      const filename = memoryFilename(type, name);
+      const description = content.split("\n")[0].replace(/^#+\s*/, "").slice(0, 120);
+      const entry = {
+        frontmatter: { name, description, type },
+        content,
+        filename
+      };
+      writeMemoryFile(projectPath, entry);
+      const allEntries = listMemoryFiles(projectPath);
+      const indexResult = updateAgentMdIndex(projectPath, allEntries);
+      if (!indexResult.success) {
+        return toolError(
+          "OUTPUT_TOO_LARGE",
+          "agent.md index exceeded size limit. Remove some memories first.",
+          {
+            suggestions: ["Use delete-memory to remove outdated entries before saving new ones."]
+          }
+        );
+      }
+      return {
+        success: true,
+        data: {
+          message: `Memory saved: ${name} (${type})`,
+          filename,
+          totalMemories: allEntries.length,
+          agentMdChars: indexResult.charCount
+        }
+      };
+    }
+  };
+}
+function createDeleteMemoryTool(projectPath) {
+  return {
+    name: "delete-memory",
+    description: "Delete a memory by name. Removes the file and its index entry in agent.md.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the memory to delete (case-insensitive match)"
+        }
+      },
+      required: ["name"]
+    },
+    execute: async (input) => {
+      const name = String(input.name || "").trim();
+      if (!name) return toolError("MISSING_PARAMETER", "name is required.", {
+        suggestions: ["Provide the name of the memory to delete."]
+      });
+      const existing = findMemoryByName(projectPath, name);
+      if (!existing) {
+        return toolError("NOT_FOUND", `Memory not found: "${name}"`, {
+          suggestions: ["Check the memory name — it is case-insensitive. Current memories are listed in agent.md."]
         });
       }
+      deleteMemoryFile(projectPath, existing.filename);
+      const allEntries = listMemoryFiles(projectPath);
+      updateAgentMdIndex(projectPath, allEntries);
       return {
         success: true,
-        data: { message: "Agent memory updated.", charCount: newContent.length }
+        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 = {
@@ -1741,11 +1956,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.
@@ -3722,15 +3946,139 @@ function createResearchTools(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 === "0") 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;
+    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? text.match(/(\[[\s\S]*?\])/);
+    const jsonStr = jsonMatch?.[1]?.trim() ?? text;
+    const extracted = JSON.parse(jsonStr);
+    if (!Array.isArray(extracted) || extracted.length === 0) return;
+    ensureMemoryDir(config.projectPath);
+    let written = 0;
+    for (const mem of extracted) {
+      if (!mem.type || !mem.name || !mem.content) continue;
+      if (!VALID_TYPES.includes(mem.type)) continue;
+      const entry = {
+        frontmatter: {
+          name: mem.name,
+          description: (mem.description || mem.content.slice(0, 120)).replace(/\n/g, " "),
+          type: mem.type
+        },
+        content: mem.content,
+        filename: memoryFilename(mem.type, mem.name)
+      };
+      writeMemoryFile(config.projectPath, entry);
+      written++;
+    }
+    if (written > 0) {
+      const allEntries = listMemoryFiles(config.projectPath);
+      updateAgentMdIndex(config.projectPath, allEntries);
+      if (config.debug) {
+        console.log(`[Extractor] Saved ${written} 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;
@@ -4541,6 +4889,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}`);
         }
@@ -5200,11 +5553,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}]`;
@@ -5229,11 +5582,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 +5601,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 +5668,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 +5784,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 +5799,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 +5860,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 +5871,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);
     }
   }
 }
-function getCandidates(projectPath, typeFilter, query) {
+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 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 +5981,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 +5991,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 +6001,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");
@@ -5835,7 +6337,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 +6359,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}`);
@@ -5933,17 +6437,20 @@ 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);
+              }
             }
           }
         }
@@ -6148,10 +6655,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 [];
     }