open-research 0.1.9 → 0.1.11

package/dist/cli.js

@@ -811,7 +811,7 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "0.1.9";
+var PACKAGE_VERSION = "0.1.11";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
@@ -4761,131 +4761,283 @@ async function manualCompact(messages, model, provider, usage, customInstruction
 // src/lib/memory/store.ts
 import fs14 from "fs/promises";
 import path13 from "path";
-function getMemoryFile(options) {
+function getGlobalMemoryFile(options) {
   return path13.join(getOpenResearchRoot(options), "memory.json");
 }
-async function loadMemories(options) {
-  const file = getMemoryFile(options);
+function getProjectMemoryFile(workspaceDir) {
+  return path13.join(workspaceDir, ".open-research", "memory.json");
+}
+async function loadMemoryFile(filePath) {
   try {
-    const raw = await fs14.readFile(file, "utf8");
+    const raw = await fs14.readFile(filePath, "utf8");
     const store = JSON.parse(raw);
     return store.memories ?? [];
   } catch {
     return [];
   }
 }
-async function saveMemories(memories, options) {
-  const file = getMemoryFile(options);
-  await fs14.mkdir(path13.dirname(file), { recursive: true });
-  const store = { version: 1, memories };
-  await fs14.writeFile(file, JSON.stringify(store, null, 2), "utf8");
+async function saveMemoryFile(filePath, memories) {
+  await fs14.mkdir(path13.dirname(filePath), { recursive: true });
+  const store = { version: 2, memories };
+  await fs14.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
 }
-var MAX_MEMORIES = 100;
-async function addMemory(memory, options) {
-  const memories = await loadMemories(options);
-  const existing = memories.find((m) => {
+async function loadGlobalMemories(options) {
+  const mems = await loadMemoryFile(getGlobalMemoryFile(options));
+  return mems.map((m) => ({ ...m, scope: "global" }));
+}
+async function loadProjectMemories(workspaceDir) {
+  const mems = await loadMemoryFile(getProjectMemoryFile(workspaceDir));
+  return mems.map((m) => ({ ...m, scope: "project" }));
+}
+async function loadAllMemories(options) {
+  const global = await loadGlobalMemories(options);
+  const project = options?.workspaceDir ? await loadProjectMemories(options.workspaceDir) : [];
+  return [...global, ...project];
+}
+var MAX_MEMORIES_PER_STORE = 100;
+function findDuplicate(memories, content) {
+  const b = content.toLowerCase().replace(/\s+/g, " ");
+  const wordsB = new Set(b.split(" ").filter((w) => w.length > 2));
+  return memories.find((m) => {
     const a = m.content.toLowerCase().replace(/\s+/g, " ");
-    const b = memory.content.toLowerCase().replace(/\s+/g, " ");
-    const wordsA = new Set(a.split(" "));
-    const wordsB = new Set(b.split(" "));
+    const wordsA = new Set(a.split(" ").filter((w) => w.length > 2));
     const intersection = [...wordsA].filter((w) => wordsB.has(w));
-    const similarity = intersection.length / Math.max(wordsA.size, wordsB.size);
-    return similarity > 0.7;
+    return intersection.length / Math.max(wordsA.size, wordsB.size) > 0.7;
+  });
+}
+function evictIfNeeded(memories) {
+  if (memories.length <= MAX_MEMORIES_PER_STORE) return;
+  memories.sort((a, b) => {
+    const aScore = new Date(a.lastRelevantAt).getTime() + a.relevanceCount * 864e5;
+    const bScore = new Date(b.lastRelevantAt).getTime() + b.relevanceCount * 864e5;
+    return bScore - aScore;
   });
+  memories.length = MAX_MEMORIES_PER_STORE;
+}
+async function addMemory(memory, options) {
+  const scope = memory.scope ?? (memory.category === "project" || memory.category === "context" ? "project" : "global");
+  const filePath = scope === "project" && options?.workspaceDir ? getProjectMemoryFile(options.workspaceDir) : getGlobalMemoryFile(options);
+  const memories = await loadMemoryFile(filePath);
+  const existing = findDuplicate(memories, memory.content);
   if (existing) {
     existing.lastRelevantAt = (/* @__PURE__ */ new Date()).toISOString();
     existing.relevanceCount++;
     if (memory.content.length > existing.content.length) {
       existing.content = memory.content;
     }
-    await saveMemories(memories, options);
-    return existing;
+    await saveMemoryFile(filePath, memories);
+    return { ...existing, scope };
   }
   const newMemory = {
     id: crypto.randomUUID(),
     content: memory.content,
     category: memory.category,
+    scope,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     lastRelevantAt: (/* @__PURE__ */ new Date()).toISOString(),
     relevanceCount: 1
   };
   memories.push(newMemory);
-  if (memories.length > MAX_MEMORIES) {
-    memories.sort((a, b) => {
-      const aScore = new Date(a.lastRelevantAt).getTime() + a.relevanceCount * 864e5;
-      const bScore = new Date(b.lastRelevantAt).getTime() + b.relevanceCount * 864e5;
-      return bScore - aScore;
-    });
-    memories.length = MAX_MEMORIES;
-  }
-  await saveMemories(memories, options);
+  evictIfNeeded(memories);
+  await saveMemoryFile(filePath, memories);
   return newMemory;
 }
 async function deleteMemory(id, options) {
-  const memories = await loadMemories(options);
-  const idx = memories.findIndex((m) => m.id === id);
-  if (idx === -1) return false;
-  memories.splice(idx, 1);
-  await saveMemories(memories, options);
-  return true;
+  const globalFile = getGlobalMemoryFile(options);
+  const global = await loadMemoryFile(globalFile);
+  const gIdx = global.findIndex((m) => m.id === id);
+  if (gIdx !== -1) {
+    global.splice(gIdx, 1);
+    await saveMemoryFile(globalFile, global);
+    return true;
+  }
+  if (options?.workspaceDir) {
+    const projectFile = getProjectMemoryFile(options.workspaceDir);
+    const project = await loadMemoryFile(projectFile);
+    const pIdx = project.findIndex((m) => m.id === id);
+    if (pIdx !== -1) {
+      project.splice(pIdx, 1);
+      await saveMemoryFile(projectFile, project);
+      return true;
+    }
+  }
+  return false;
 }
 async function clearMemories(options) {
-  await saveMemories([], options);
+  if (!options?.scope || options.scope === "global") {
+    await saveMemoryFile(getGlobalMemoryFile(options), []);
+  }
+  if (options?.workspaceDir && (!options?.scope || options.scope === "project")) {
+    await saveMemoryFile(getProjectMemoryFile(options.workspaceDir), []);
+  }
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "can",
+  "shall",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "about",
+  "and",
+  "but",
+  "or",
+  "not",
+  "no",
+  "if",
+  "then",
+  "than",
+  "so",
+  "that",
+  "this",
+  "it",
+  "its",
+  "i",
+  "me",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "what",
+  "which",
+  "who",
+  "how",
+  "when",
+  "where",
+  "why"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w));
+}
+function scoreRelevance(memory, queryTokens) {
+  const memTokens = tokenize(memory.content);
+  if (memTokens.length === 0) return 0;
+  let matches = 0;
+  for (const token of memTokens) {
+    if (queryTokens.has(token)) matches++;
+  }
+  const overlapScore = matches / memTokens.length;
+  const categoryBoost = memory.category === "user" ? 0.3 : memory.category === "preference" ? 0.2 : memory.category === "methodology" ? 0.15 : 0;
+  const ageMs = Date.now() - new Date(memory.lastRelevantAt).getTime();
+  const ageDays = ageMs / 864e5;
+  const recencyBoost = Math.max(0, 0.1 - ageDays * 1e-3);
+  const freqBoost = Math.min(0.1, memory.relevanceCount * 0.02);
+  return overlapScore + categoryBoost + recencyBoost + freqBoost;
+}
+var MIN_RELEVANCE_SCORE = 0.15;
+var MAX_INJECTED_MEMORIES = 15;
+var ALWAYS_INCLUDE_CATEGORIES = ["user", "preference"];
+function selectRelevantMemories(allMemories, userQuery) {
+  if (allMemories.length === 0) return [];
+  const queryTokens = new Set(tokenize(userQuery));
+  const alwaysInclude = allMemories.filter(
+    (m) => ALWAYS_INCLUDE_CATEGORIES.includes(m.category)
+  );
+  const candidates = allMemories.filter((m) => !ALWAYS_INCLUDE_CATEGORIES.includes(m.category)).map((m) => ({ memory: m, score: scoreRelevance(m, queryTokens) })).filter((c) => c.score >= MIN_RELEVANCE_SCORE).sort((a, b) => b.score - a.score);
+  const selected = [
+    ...alwaysInclude.slice(0, 5),
+    // Max 5 identity memories
+    ...candidates.slice(0, MAX_INJECTED_MEMORIES - Math.min(alwaysInclude.length, 5)).map((c) => c.memory)
+  ];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const m of selected) {
+    m.lastRelevantAt = now;
+  }
+  return selected;
 }
 function formatMemoriesForPrompt(memories) {
   if (memories.length === 0) return "";
-  const grouped = {};
-  for (const m of memories) {
-    (grouped[m.category] ??= []).push(m);
-  }
-  const sections = ["## What I Remember About You"];
-  const categoryLabels = {
-    user: "About you",
-    preference: "Your preferences",
-    project: "Your projects",
-    methodology: "Methodology preferences",
-    context: "Context"
-  };
-  for (const [cat, mems] of Object.entries(grouped)) {
-    sections.push(`**${categoryLabels[cat] ?? cat}:**`);
-    for (const m of mems) {
-      sections.push(`- ${m.content}`);
-    }
+  const global = memories.filter((m) => m.scope === "global");
+  const project = memories.filter((m) => m.scope === "project");
+  const sections = ["## Relevant Context"];
+  if (global.length > 0) {
+    sections.push("**About you:**");
+    for (const m of global) sections.push(`- ${m.content}`);
+  }
+  if (project.length > 0) {
+    sections.push("**This project:**");
+    for (const m of project) sections.push(`- ${m.content}`);
   }
   return sections.join("\n");
 }
 
 // src/lib/memory/extractor.ts
-var EXTRACTION_PROMPT = `You are a memory extraction system. Your job is to identify facts worth remembering about the user from a conversation exchange.
+var EXTRACTION_PROMPT = `You are a memory management system. You decide what to remember about the user across sessions.
+
+You will receive:
+1. The current conversation exchange
+2. ALL existing memories (both global and project-level)
 
-Focus on:
-- Who they are (role, field, institution, expertise level)
-- What they're working on (current research projects, topics, deadlines)
-- How they prefer to work (preferred tools, languages, writing style, methodologies)
-- Methodological preferences (statistical approaches, theoretical frameworks, citation style)
-- Important context (collaborators, advisors, publication targets, funding constraints)
+Your job: decide if any NEW memories should be created OR if any existing memories need updating.
 
-Rules:
-- Only extract facts that would be useful in FUTURE conversations
-- Be specific and concise \u2014 each memory should be one clear fact
-- Do NOT extract task-specific details that only matter for the current conversation
-- Do NOT extract obvious things ("user asked about papers" is not useful)
-- If there is nothing meaningful to remember, return an empty array
-- Maximum 3 new memories per exchange
-
-Existing memories (do not duplicate these):
+CRITICAL RULES:
+- Do NOT create a memory if an existing memory already covers the same fact
+- If a fact has CHANGED (e.g., user switched from Python to R), output an UPDATE to the existing memory instead of creating a new one
+- Only create memories for facts useful in FUTURE sessions, not task-specific details
+- Maximum 3 actions per exchange
+- If nothing meaningful to remember, return an empty array
+
+Categories:
+- "user" \u2014 identity, role, field, institution (\u2192 stored globally)
+- "preference" \u2014 tools, style, methodology preferences (\u2192 stored globally)
+- "project" \u2014 current research topics, findings, hypotheses (\u2192 stored per-project)
+- "methodology" \u2014 statistical approaches, frameworks (\u2192 stored globally)
+- "context" \u2014 deadlines, collaborators, constraints (\u2192 stored per-project)
+
+Existing memories:
 {EXISTING_MEMORIES}
 
-Respond with a JSON array of objects, each with "content" (string) and "category" (one of: "user", "preference", "project", "methodology", "context"). If nothing worth remembering, respond with [].
+Respond with a JSON array. Each item has:
+- "action": "create" or "update"
+- "content": the memory text (for create: new content; for update: the updated content)
+- "category": one of the categories above
+- "updateId": (only for "update") the ID of the existing memory to update
 
-Example response:
-[{"content": "PhD student in computational neuroscience at MIT", "category": "user"}, {"content": "Prefers Python with statsmodels for statistical analysis over R", "category": "preference"}]`;
+If nothing to do, respond with [].
+
+Example:
+[{"action": "create", "content": "PhD student in neuroscience at MIT", "category": "user"}]
+[{"action": "update", "updateId": "abc123", "content": "Now using R instead of Python for analysis", "category": "preference"}]`;
 async function extractMemories(input2) {
-  const existing = await loadMemories({ homeDir: input2.homeDir });
+  const existing = await loadAllMemories({
+    homeDir: input2.homeDir,
+    workspaceDir: input2.workspaceDir
+  });
   if (input2.userMessage.startsWith("/") || input2.userMessage.length < 20) {
     return [];
   }
-  const existingList = existing.length > 0 ? existing.map((m) => `- [${m.category}] ${m.content}`).join("\n") : "(none)";
+  const existingList = existing.length > 0 ? existing.map((m) => `- [${m.scope}/${m.category}] (id: ${m.id.slice(0, 8)}) ${m.content}`).join("\n") : "(none)";
   const prompt2 = EXTRACTION_PROMPT.replace("{EXISTING_MEMORIES}", existingList);
   const conversationSnippet = [
     `User: ${input2.userMessage.slice(0, 2e3)}`,
@@ -4907,10 +5059,12 @@ async function extractMemories(input2) {
     if (!Array.isArray(parsed)) return [];
     const valid = [];
     for (const item of parsed) {
-      if (typeof item.content === "string" && item.content.length > 5 && ["user", "preference", "project", "methodology", "context"].includes(item.category)) {
+      if (typeof item.content === "string" && item.content.length > 5 && ["user", "preference", "project", "methodology", "context"].includes(item.category) && ["create", "update"].includes(item.action)) {
         valid.push({
+          action: item.action,
           content: item.content,
-          category: item.category
+          category: item.category,
+          updateId: typeof item.updateId === "string" ? item.updateId : void 0
         });
       }
     }
@@ -4920,13 +5074,35 @@ async function extractMemories(input2) {
   }
 }
 async function extractAndStoreMemories(input2) {
-  const extracted = await extractMemories(input2);
-  const stored = [];
-  for (const mem of extracted) {
-    const saved = await addMemory(mem, { homeDir: input2.homeDir });
-    stored.push(saved);
+  const actions = await extractMemories(input2);
+  const results = [];
+  const existing = await loadAllMemories({
+    homeDir: input2.homeDir,
+    workspaceDir: input2.workspaceDir
+  });
+  for (const action of actions) {
+    if (action.action === "update" && action.updateId) {
+      const target = existing.find((m) => m.id.startsWith(action.updateId));
+      if (target) {
+        target.content = action.content;
+        target.lastRelevantAt = (/* @__PURE__ */ new Date()).toISOString();
+        target.relevanceCount++;
+        const saved = await addMemory(
+          { content: action.content, category: action.category, scope: target.scope },
+          { homeDir: input2.homeDir, workspaceDir: input2.workspaceDir }
+        );
+        results.push(saved);
+      }
+    } else {
+      const scope = action.category === "project" || action.category === "context" ? "project" : "global";
+      const saved = await addMemory(
+        { content: action.content, category: action.category, scope },
+        { homeDir: input2.homeDir, workspaceDir: input2.workspaceDir }
+      );
+      results.push(saved);
+    }
   }
-  return stored;
+  return results;
 }
 
 // src/lib/workspace/agents-md.ts
@@ -5083,16 +5259,19 @@ async function runAgentTurn(input2) {
   const systemPrompt = isPlanning ? buildPlanningSystemPrompt(input2.workspace, activeSkills) : buildSystemPrompt(input2.workspace, activeSkills);
   const model = input2.model ?? "gpt-5.4";
   const usage = input2.sessionUsage ?? createSessionUsage();
-  const memories = await loadMemories({ homeDir: input2.homeDir });
-  const memoryBlock = formatMemoriesForPrompt(memories);
+  const allMemories = await loadAllMemories({
+    homeDir: input2.homeDir,
+    workspaceDir: input2.workspace.workspaceDir
+  });
+  const relevantMemories = selectRelevantMemories(allMemories, input2.message);
+  const memoryBlock = formatMemoriesForPrompt(relevantMemories);
   const agentsMd = input2.workspace.workspaceDir ? await readAgentsMd(input2.workspace.workspaceDir).catch(() => "") : "";
-  const contextBlocks = [
+  const fullSystemPrompt = [
     systemPrompt,
-    memoryBlock ? memoryBlock : null,
+    memoryBlock || null,
     agentsMd ? `## Project Context (from AGENTS.md)
 ${agentsMd}` : null
   ].filter(Boolean).join("\n\n");
-  const fullSystemPrompt = contextBlocks;
   let messages = [
     { role: "system", content: fullSystemPrompt },
     ...input2.history,
@@ -5152,7 +5331,8 @@ ${agentsMd}` : null
         agentResponse: fullText,
         provider: input2.provider,
         model: "gpt-5.4-mini",
-        homeDir: input2.homeDir
+        homeDir: input2.homeDir,
+        workspaceDir: input2.workspace.workspaceDir
       }).then((stored) => {
         if (stored.length > 0) {
           input2.onMemoryExtracted?.(stored.map((m) => m.content));
@@ -5562,7 +5742,8 @@ var INTERESTING_FILES = /* @__PURE__ */ new Set([
   ".env.example",
   "tsconfig.json",
   "vitest.config.ts",
-  "jest.config.js"
+  "jest.config.js",
+  "AGENTS.md"
 ]);
 async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
   const results = [];
@@ -5573,7 +5754,7 @@ async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
       if (IGNORED_DIRS2.has(entry.name)) continue;
       if (entry.name.startsWith(".") && depth === 0 && entry.isDirectory()) continue;
       const fullPath = path18.join(dir, entry.name);
-      const relativePath = path18.relative(process.cwd(), fullPath);
+      const relativePath = path18.relative(dir, fullPath);
       if (entry.isDirectory()) {
         results.push({ path: relativePath + "/", size: 0, isDir: true });
         const children = await scanDirectoryShallow(fullPath, maxDepth, depth + 1);
@@ -5590,40 +5771,46 @@ async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
 async function readKeyFiles(dir) {
   const contents = {};
   for (const name of INTERESTING_FILES) {
-    const filePath = path18.join(dir, name);
     try {
-      const content = await fs19.readFile(filePath, "utf8");
+      const content = await fs19.readFile(path18.join(dir, name), "utf8");
       contents[name] = content.slice(0, 2e3);
     } catch {
     }
   }
   return contents;
 }
-var INIT_PROMPT = `You are creating an AGENTS.md file for a research workspace. This file will be injected into an AI research agent's system prompt every session to give it instant project context.
+var CREATE_PROMPT = `You are creating an AGENTS.md file for a research workspace. This file is injected into an AI research agent's system prompt every session to give it instant project context.
 
-Based on the directory structure and key file contents below, write a concise AGENTS.md that covers:
+Write a concise AGENTS.md covering:
+## Project Overview \u2014 What is this project? What research?
+## Structure \u2014 Key directories and their purpose (only important ones)
+## Key Files \u2014 Notable files and what they do
+## Research Context \u2014 What research is in progress?
+## Development \u2014 How to build/run/test (if applicable)
 
-## Project Overview
-What is this project about? What type of research?
-
-## Structure
-Key directories and what they contain (only the important ones).
+Rules:
+- Under 1500 characters. This goes into every system prompt.
+- Specific to THIS project. No generic advice.
+- Markdown with ## headings.`;
+var UPDATE_PROMPT = `You are updating an existing AGENTS.md file for a research workspace. This file is injected into an AI research agent's system prompt every session.
 
-## Key Files
-Important files and what they do (only the notable ones).
+You have:
+1. The CURRENT AGENTS.md content
+2. A fresh scan of the workspace directory and key files
 
-## Research Context
-What research appears to be in progress based on the files?
+Your job: compare the current AGENTS.md against the actual workspace state. Update it to reflect reality:
+- Add new directories/files that appeared
+- Remove references to things that no longer exist
+- Update descriptions that are now outdated
+- Preserve any manually-added notes or context the user wrote
+- Keep the same ## heading structure
 
-## Development
-How to build/run/test (if applicable, based on package.json or similar).
+If AGENTS.md is already accurate, output it unchanged.
 
 Rules:
-- Keep it under 1500 characters total
-- Be specific to THIS project, not generic
-- If it's unclear what the project does, say so and note what you can see
-- Use markdown with ## headings
-- Don't include obvious things ("node_modules contains npm packages")`;
+- Under 1500 characters. This goes into every system prompt.
+- Output the FULL updated AGENTS.md content, not a diff.
+- Markdown with ## headings.`;
 async function generateInitialAgentsMd(input2) {
   const dir = input2.workspaceDir;
   const files = await scanDirectoryShallow(dir);
@@ -5633,17 +5820,32 @@ async function generateInitialAgentsMd(input2) {
 \`\`\`
 ${content2}
 \`\`\``).join("\n\n");
-  const userMessage = `Directory: ${dir}
+  const scanData = `Directory: ${dir}
 
 File tree:
 ${tree}
 
-${keyFileText ? `Key files:
-${keyFileText}` : "No recognizable key files found."}`;
+${keyFileText || "No recognizable key files found."}`;
+  const existing = await readAgentsMd(dir);
+  let systemPrompt;
+  let userMessage;
+  if (existing) {
+    systemPrompt = UPDATE_PROMPT;
+    userMessage = `Current AGENTS.md:
+---
+${existing}
+---
+
+Fresh workspace scan:
+${scanData.slice(0, 25e3)}`;
+  } else {
+    systemPrompt = CREATE_PROMPT;
+    userMessage = scanData.slice(0, 25e3);
+  }
   const response = await input2.provider.callLLM({
     messages: [
-      { role: "system", content: INIT_PROMPT },
-      { role: "user", content: userMessage.slice(0, 3e4) }
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
     ],
     model: input2.model ?? "gpt-5.4-mini",
     maxTokens: 2048,
@@ -6683,37 +6885,32 @@ function App({
       }
       case "init": {
         const target = process.cwd();
-        const existing = await loadWorkspaceProject(target);
-        if (existing) {
-          addSystemMessage(`Already a workspace: ${target}`);
+        setBusy(true);
+        try {
+          const existing = await loadWorkspaceProject(target);
+          if (!existing) {
+            await initWorkspace({ workspaceDir: target });
+            addSystemMessage(`Workspace initialized at ${target}`);
+          }
           setWorkspacePath(target);
-        } else {
-          setBusy(true);
-          try {
-            const project = await initWorkspace({ workspaceDir: target });
-            setWorkspacePath(target);
-            addSystemMessage(`Initialized workspace "${project.title}" at ${target}`);
-            const scanned = await scanWorkspace(target);
-            startTransition(() => setWorkspaceFiles(scanned.files));
-            if (hasAuth) {
-              addSystemMessage("Generating AGENTS.md...");
-              try {
-                const provider = await createProviderFromStoredAuth({ homeDir });
-                await generateInitialAgentsMd({
-                  workspaceDir: target,
-                  provider,
-                  model: "gpt-5.4-mini"
-                });
-                addSystemMessage("AGENTS.md created \u2014 project context will be loaded on every session.");
-              } catch {
-                addSystemMessage("AGENTS.md generation skipped (connect auth first).");
-              }
-            }
-          } catch (err) {
-            addSystemMessage(`Init failed: ${err instanceof Error ? err.message : String(err)}`);
-          } finally {
-            setBusy(false);
+          if (!hasAuth) {
+            addSystemMessage("Run /auth first \u2014 AGENTS.md generation requires auth.");
+            break;
           }
+          addSystemMessage("Scanning workspace and updating AGENTS.md...");
+          const provider = await createProviderFromStoredAuth({ homeDir });
+          const result = await generateInitialAgentsMd({
+            workspaceDir: target,
+            provider,
+            model: "gpt-5.4-mini"
+          });
+          addSystemMessage("AGENTS.md ready. Project context will load on every session.");
+          const scanned = await scanWorkspace(target);
+          startTransition(() => setWorkspaceFiles(scanned.files));
+        } catch (err) {
+          addSystemMessage(`Init failed: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+          setBusy(false);
         }
         break;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-research",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Local-first research CLI agent — discover papers, synthesize notes, run analysis, and draft artifacts from your terminal.",
   "type": "module",
   "license": "MIT",