open-research 0.1.7 → 0.1.9

package/dist/cli.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/cli.ts
 import React4 from "react";
-import path19 from "path";
+import path21 from "path";
 import { Command } from "commander";
 import { render } from "ink";
 
@@ -811,7 +811,7 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "0.1.7";
+var PACKAGE_VERSION = "0.1.9";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
@@ -860,7 +860,7 @@ async function ensureOpenResearchConfig(options) {
 }
 
 // src/tui/app.tsx
-import path18 from "path";
+import path20 from "path";
 import {
   startTransition,
   useDeferredValue,
@@ -1526,10 +1526,28 @@ var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".yml",
   ".csv"
 ]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".open-research",
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".cache",
+  "target",
+  ".tox",
+  "coverage",
+  ".nyc_output",
+  ".parcel-cache",
+  ".turbo"
+]);
 async function walkDir(rootDir, currentDir, out) {
   const entries = await fs8.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.name === ".open-research") {
+    if (IGNORED_DIRS.has(entry.name)) {
       continue;
     }
     const fullPath = path7.join(currentDir, entry.name);
@@ -2286,9 +2304,6 @@ function getToolsForMode(mode) {
 
 // src/lib/agent/prompts/planning.ts
 function buildPlanningSystemPrompt(ctx, activeSkills) {
-  const workspaceMap = ctx.availableKeys.map(
-    (key) => `- ${key}${ctx.fileLabels?.[key] ? ` \u2014 ${ctx.fileLabels[key]}` : ""}`
-  ).join("\n");
   const skillText = activeSkills.map((skill) => `## Active Skill: ${skill.name}
 ${skill.prompt}`).join("\n\n");
   return [
@@ -2354,8 +2369,9 @@ ${skill.prompt}`).join("\n\n");
     "- If the user's intent is already crystal clear, you can produce the charter after just 1 question or even immediately.",
     "- Ground your proposed steps in what you've learned from the workspace and external search results.",
     "",
-    workspaceMap ? `## Workspace Files
-${workspaceMap}` : "## Workspace Files\nnone",
+    `## Workspace
+Root: ${process.cwd()}
+Use list_directory to explore. Use search_workspace or read_file to read content.`,
     skillText
   ].filter(Boolean).join("\n");
 }
@@ -4913,6 +4929,72 @@ async function extractAndStoreMemories(input2) {
   return stored;
 }
 
+// src/lib/workspace/agents-md.ts
+import fs15 from "fs/promises";
+import path14 from "path";
+var AGENTS_MD_FILENAME = "AGENTS.md";
+async function readAgentsMd(workspaceDir) {
+  try {
+    return await fs15.readFile(path14.join(workspaceDir, AGENTS_MD_FILENAME), "utf8");
+  } catch {
+    return "";
+  }
+}
+async function writeAgentsMd(workspaceDir, content) {
+  await fs15.writeFile(path14.join(workspaceDir, AGENTS_MD_FILENAME), content, "utf8");
+}
+var UPDATE_SYSTEM_PROMPT = `You maintain an AGENTS.md file for a research workspace. This file gives future agent sessions instant context about the project \u2014 what it's about, what's been done, key files, and current direction.
+
+You will receive:
+1. The current AGENTS.md content (may be empty on first run)
+2. A summary of what just happened in the latest conversation turn
+
+Your job: decide if AGENTS.md should be updated based on the new information. If yes, output the FULL updated AGENTS.md content. If nothing meaningful changed, output exactly "NO_UPDATE".
+
+Rules:
+- Keep it concise \u2014 under 2000 characters. This gets injected into every system prompt.
+- Structure: Project overview \u2192 Key files \u2192 Current state \u2192 Research direction
+- Only include information that helps a NEW agent session pick up where this one left off
+- Don't include conversation-specific details \u2014 only durable project knowledge
+- Update incrementally \u2014 preserve existing content, add/modify what changed
+- Use markdown with ## headings`;
+var UPDATE_USER_TEMPLATE = `Current AGENTS.md:
+---
+{CURRENT_CONTENT}
+---
+
+Latest turn summary:
+User asked: {USER_MESSAGE}
+Agent did: {AGENT_SUMMARY}
+
+Should AGENTS.md be updated? If yes, output the full updated content. If no meaningful project-level changes, output exactly "NO_UPDATE".`;
+async function maybeUpdateAgentsMd(input2) {
+  if (input2.userMessage.length < 15) return false;
+  if (input2.userMessage.startsWith("/")) return false;
+  const currentContent = await readAgentsMd(input2.workspaceDir);
+  const userPrompt = UPDATE_USER_TEMPLATE.replace("{CURRENT_CONTENT}", currentContent || "(empty \u2014 first time)").replace("{USER_MESSAGE}", input2.userMessage.slice(0, 500)).replace("{AGENT_SUMMARY}", input2.agentResponse.slice(0, 1500));
+  try {
+    const response = await input2.provider.callLLM({
+      messages: [
+        { role: "system", content: UPDATE_SYSTEM_PROMPT },
+        { role: "user", content: userPrompt }
+      ],
+      model: input2.model ?? "gpt-5.4-mini",
+      maxTokens: 2048,
+      temperature: 0
+    });
+    const result = response.content.trim();
+    if (result === "NO_UPDATE" || result.length < 20) {
+      return false;
+    }
+    const cleaned = result.replace(/^```(?:markdown)?\n?/, "").replace(/\n?```$/, "").trim();
+    await writeAgentsMd(input2.workspaceDir, cleaned);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/agent/runtime.ts
 var TOOL_DESCRIPTIONS = {
   read_file: (a) => `Reading ${a.file_path ?? "file"}`,
@@ -4948,7 +5030,6 @@ function describeToolCall(name, args) {
   return fn ? fn(args) : `Running ${name}`;
 }
 function buildSystemPrompt(ctx, activeSkills) {
-  const workspaceMap = ctx.availableKeys.map((key) => `- ${key}${ctx.fileLabels?.[key] ? ` \u2014 ${ctx.fileLabels[key]}` : ""}`).join("\n");
   const skillText = activeSkills.map((skill) => `## Active Skill: ${skill.name}
 ${skill.prompt}`).join("\n\n");
   return [
@@ -4956,8 +5037,9 @@ ${skill.prompt}`).join("\n\n");
     "",
     "## Capabilities",
     "You have full access to the local filesystem and shell. You can:",
-    "- Read any file on disk with read_file (not limited to workspace files)",
-    "- List directories with list_directory to explore project structure",
+    "- Read any file on disk with read_file",
+    "- List directories with list_directory to explore the workspace and discover files",
+    "- Search file contents with search_workspace",
     "- Run shell commands with run_command (python, R, node, LaTeX, curl, git, etc.)",
     "- Write new workspace files or edit existing ones",
     "- Search academic papers across OpenAlex, Semantic Scholar, and arXiv",
@@ -4966,15 +5048,17 @@ ${skill.prompt}`).join("\n\n");
     "- Activate research skills for specialized workflows",
     "",
     "## Principles",
-    "- Read before writing. Understand the workspace before making changes.",
+    "- Start by exploring. Use list_directory and search_workspace to understand the workspace before acting.",
+    "- Read before writing. Understand existing files before making changes.",
     "- Ground claims in sources. Cite papers and data, not assumptions.",
     "- Run code to verify. When you write a script, run it and check the output.",
     "- Be transparent. Show the user what you're doing and why.",
     "- When unsure, ask. Use ask_user rather than guessing.",
     "- For large outputs, redirect to a file and read selectively.",
     "",
-    workspaceMap ? `## Workspace Files
-${workspaceMap}` : "## Workspace Files\nnone",
+    `## Workspace
+Root: ${process.cwd()}
+Use list_directory to explore. Use search_workspace or read_file to read content.`,
     skillText
   ].filter(Boolean).join("\n");
 }
@@ -5001,7 +5085,14 @@ async function runAgentTurn(input2) {
   const usage = input2.sessionUsage ?? createSessionUsage();
   const memories = await loadMemories({ homeDir: input2.homeDir });
   const memoryBlock = formatMemoriesForPrompt(memories);
-  const fullSystemPrompt = memoryBlock ? systemPrompt + "\n\n" + memoryBlock : systemPrompt;
+  const agentsMd = input2.workspace.workspaceDir ? await readAgentsMd(input2.workspace.workspaceDir).catch(() => "") : "";
+  const contextBlocks = [
+    systemPrompt,
+    memoryBlock ? 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,
@@ -5068,6 +5159,18 @@ async function runAgentTurn(input2) {
         }
       }).catch(() => {
       });
+      if (input2.workspace.workspaceDir) {
+        maybeUpdateAgentsMd({
+          workspaceDir: input2.workspace.workspaceDir,
+          userMessage: input2.message,
+          agentResponse: fullText,
+          provider: input2.provider,
+          model: "gpt-5.4-mini"
+        }).then((updated) => {
+          if (updated) input2.onAgentsMdUpdated?.();
+        }).catch(() => {
+        });
+      }
       return {
         text: fullText,
         proposedUpdates,
@@ -5159,8 +5262,8 @@ function classifyUpdateRisk(update) {
 }
 
 // src/lib/workspace/apply-update.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 function resolveRelativePath(update) {
   if (update.key.startsWith("path:")) {
     return update.key.slice(5);
@@ -5181,20 +5284,20 @@ function resolveRelativePath(update) {
 }
 async function applyProposedUpdate(workspaceDir, update) {
   const relativePath = resolveRelativePath(update);
-  const absolutePath = path14.join(workspaceDir, relativePath);
-  await fs15.mkdir(path14.dirname(absolutePath), { recursive: true });
-  await fs15.writeFile(absolutePath, update.content, "utf8");
+  const absolutePath = path15.join(workspaceDir, relativePath);
+  await fs16.mkdir(path15.dirname(absolutePath), { recursive: true });
+  await fs16.writeFile(absolutePath, update.content, "utf8");
   return absolutePath;
 }
 
 // src/lib/workspace/sessions.ts
-import fs16 from "fs/promises";
-import path15 from "path";
+import fs17 from "fs/promises";
+import path16 from "path";
 async function appendSessionEvent(workspaceDir, sessionId, event) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
-  await fs16.mkdir(sessionsDir, { recursive: true });
-  const sessionFile = path15.join(sessionsDir, `${sessionId}.jsonl`);
-  await fs16.appendFile(sessionFile, `${JSON.stringify(event)}
+  await fs17.mkdir(sessionsDir, { recursive: true });
+  const sessionFile = path16.join(sessionsDir, `${sessionId}.jsonl`);
+  await fs17.appendFile(sessionFile, `${JSON.stringify(event)}
 `, "utf8");
 }
 function parseEvents(raw) {
@@ -5210,7 +5313,7 @@ async function listSessions(workspaceDir) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
   let files;
   try {
-    files = await fs16.readdir(sessionsDir);
+    files = await fs17.readdir(sessionsDir);
   } catch {
     return [];
   }
@@ -5218,7 +5321,7 @@ async function listSessions(workspaceDir) {
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
     const id = file.replace(/\.jsonl$/, "");
-    const raw = await fs16.readFile(path15.join(sessionsDir, file), "utf8");
+    const raw = await fs17.readFile(path16.join(sessionsDir, file), "utf8");
     const events = parseEvents(raw);
     if (events.length === 0) continue;
     const chatTurns = events.filter((e) => e.type === "chat.turn");
@@ -5239,8 +5342,8 @@ async function listSessions(workspaceDir) {
 }
 async function loadSessionHistory(workspaceDir, sessionId) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
-  const sessionFile = path15.join(sessionsDir, `${sessionId}.jsonl`);
-  const raw = await fs16.readFile(sessionFile, "utf8");
+  const sessionFile = path16.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await fs17.readFile(sessionFile, "utf8");
   const events = parseEvents(raw);
   const messages = [];
   const llmHistory = [];
@@ -5352,15 +5455,15 @@ function ConfigScreen({ items, onUpdate, onClose }) {
 }
 
 // src/lib/cli/update-check.ts
-import fs17 from "fs/promises";
-import path16 from "path";
+import fs18 from "fs/promises";
+import path17 from "path";
 import os4 from "os";
 var PACKAGE_NAME = "open-research";
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
-var STATE_FILE = path16.join(os4.homedir(), ".open-research", "update-check.json");
+var STATE_FILE = path17.join(os4.homedir(), ".open-research", "update-check.json");
 async function readState() {
   try {
-    const raw = await fs17.readFile(STATE_FILE, "utf8");
+    const raw = await fs18.readFile(STATE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       lastCheck: typeof parsed.lastCheck === "number" ? parsed.lastCheck : 0,
@@ -5372,8 +5475,8 @@ async function readState() {
   }
 }
 async function writeState(state) {
-  await fs17.mkdir(path16.dirname(STATE_FILE), { recursive: true });
-  await fs17.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
+  await fs18.mkdir(path17.dirname(STATE_FILE), { recursive: true });
+  await fs18.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
 }
 function getCurrentVersion() {
   return getPackageVersion();
@@ -5425,10 +5528,136 @@ async function checkForUpdate() {
   }
 }
 
+// src/lib/workspace/init-agents-md.ts
+import fs19 from "fs/promises";
+import path18 from "path";
+var IGNORED_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".cache",
+  "target",
+  ".open-research",
+  "coverage"
+]);
+var INTERESTING_FILES = /* @__PURE__ */ new Set([
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "requirements.txt",
+  "setup.py",
+  "setup.cfg",
+  "README.md",
+  "README.txt",
+  "readme.md",
+  "Makefile",
+  "Dockerfile",
+  "docker-compose.yml",
+  ".env.example",
+  "tsconfig.json",
+  "vitest.config.ts",
+  "jest.config.js"
+]);
+async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
+  const results = [];
+  if (depth > maxDepth) return results;
+  try {
+    const entries = await fs19.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      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);
+      if (entry.isDirectory()) {
+        results.push({ path: relativePath + "/", size: 0, isDir: true });
+        const children = await scanDirectoryShallow(fullPath, maxDepth, depth + 1);
+        results.push(...children);
+      } else {
+        const stat = await fs19.stat(fullPath).catch(() => null);
+        results.push({ path: relativePath, size: stat?.size ?? 0, isDir: false });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+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");
+      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.
+
+Based on the directory structure and key file contents below, write a concise AGENTS.md that covers:
+
+## Project Overview
+What is this project about? What type of research?
+
+## Structure
+Key directories and what they contain (only the important ones).
+
+## Key Files
+Important files and what they do (only the notable ones).
+
+## Research Context
+What research appears to be in progress based on the files?
+
+## Development
+How to build/run/test (if applicable, based on package.json or similar).
+
+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")`;
+async function generateInitialAgentsMd(input2) {
+  const dir = input2.workspaceDir;
+  const files = await scanDirectoryShallow(dir);
+  const tree = files.slice(0, 100).map((f) => `${f.isDir ? "d" : "f"} ${f.path}${f.size > 0 ? ` (${(f.size / 1024).toFixed(1)}KB)` : ""}`).join("\n");
+  const keyFiles = await readKeyFiles(dir);
+  const keyFileText = Object.entries(keyFiles).map(([name, content2]) => `### ${name}
+\`\`\`
+${content2}
+\`\`\``).join("\n\n");
+  const userMessage = `Directory: ${dir}
+
+File tree:
+${tree}
+
+${keyFileText ? `Key files:
+${keyFileText}` : "No recognizable key files found."}`;
+  const response = await input2.provider.callLLM({
+    messages: [
+      { role: "system", content: INIT_PROMPT },
+      { role: "user", content: userMessage.slice(0, 3e4) }
+    ],
+    model: input2.model ?? "gpt-5.4-mini",
+    maxTokens: 2048,
+    temperature: 0
+  });
+  const content = response.content.replace(/^```(?:markdown)?\n?/, "").replace(/\n?```$/, "").trim();
+  await writeAgentsMd(dir, content);
+  return content;
+}
+
 // src/lib/preview/server.ts
 import http2 from "http";
-import fs18 from "fs";
-import path17 from "path";
+import fs20 from "fs";
+import path19 from "path";
 
 // src/lib/preview/latex-to-html.ts
 function latexToHtml(latex) {
@@ -5695,11 +5924,11 @@ var HTML_TEMPLATE = `<!DOCTYPE html>
 </body>
 </html>`;
 function startPreviewServer(texPath) {
-  const resolved = path17.resolve(texPath);
+  const resolved = path19.resolve(texPath);
   let currentHash = "";
   function getContentHash() {
     try {
-      const content = fs18.readFileSync(resolved, "utf8");
+      const content = fs20.readFileSync(resolved, "utf8");
       return `${content.length}-${content.slice(0, 100)}-${content.slice(-100)}`;
     } catch {
       return "error";
@@ -5707,7 +5936,7 @@ function startPreviewServer(texPath) {
   }
   function renderPage() {
     try {
-      const latex = fs18.readFileSync(resolved, "utf8");
+      const latex = fs20.readFileSync(resolved, "utf8");
       const htmlContent = latexToHtml(latex);
       currentHash = getContentHash();
       return HTML_TEMPLATE.replace("{{CONTENT}}", htmlContent);
@@ -6466,6 +6695,20 @@ function App({
             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 {
@@ -6983,6 +7226,7 @@ ${msg.text}
       const provider = await createProviderFromStoredAuth({ homeDir });
       const workspace = await scanWorkspace(workspacePath);
       const workspaceContext = {
+        workspaceDir: workspacePath,
         runId: sessionId,
         workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
         availableKeys: workspace.files.map((f) => f.key),
@@ -7115,6 +7359,7 @@ ${msg.text}
       const provider = await createProviderFromStoredAuth({ homeDir });
       const workspace = await scanWorkspace(workspacePath);
       const workspaceContext = {
+        workspaceDir: workspacePath,
         runId: sessionId,
         workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
         availableKeys: workspace.files.map((f) => f.key),
@@ -7460,7 +7705,7 @@ ${msg.text}
         statusParts,
         statusColor,
         tokenDisplay,
-        workspaceName: hasWorkspace ? path18.basename(workspacePath) : process.cwd(),
+        workspaceName: hasWorkspace ? path20.basename(workspacePath) : process.cwd(),
         mode: agentMode,
         planningStatus: planningState.status
       }
@@ -7472,7 +7717,7 @@ ${msg.text}
 var program = new Command();
 program.name("open-research").version(getPackageVersion()).description("Local-first research CLI powered by ChatGPT/Codex auth.").argument("[workspacePath]", "Optional workspace path to open").action(async (workspacePath) => {
   await ensureOpenResearchConfig();
-  const target = workspacePath ? path19.resolve(workspacePath) : process.cwd();
+  const target = workspacePath ? path21.resolve(workspacePath) : process.cwd();
   const project = await loadWorkspaceProject(target);
   const auth2 = await loadStoredAuth();
   render(
@@ -7488,7 +7733,7 @@ program.name("open-research").version(getPackageVersion()).description("Local-fi
 });
 program.command("init").argument("[workspacePath]").description("Initialize an Open Research workspace.").action(async (workspacePath) => {
   await ensureOpenResearchConfig();
-  const target = path19.resolve(workspacePath ?? process.cwd());
+  const target = path21.resolve(workspacePath ?? process.cwd());
   const project = await initWorkspace({ workspaceDir: target });
   console.log(`Initialized workspace: ${target}`);
   console.log(`Title: ${project.title}`);
@@ -7557,8 +7802,8 @@ skills.command("create").argument("[name]").description("Scaffold a new user ski
 });
 skills.command("edit").argument("<name>").description("Open a user skill in $EDITOR.").action(async (name) => {
   await ensureOpenResearchConfig();
-  const skillDir = path19.join(getOpenResearchSkillsDir(), name);
-  openInEditor(path19.join(skillDir, "SKILL.md"));
+  const skillDir = path21.join(getOpenResearchSkillsDir(), name);
+  openInEditor(path21.join(skillDir, "SKILL.md"));
   const validation = await validateSkillDirectory({ skillDir });
   if (!validation.ok) {
     console.error(validation.errors.join("\n"));
@@ -7569,9 +7814,9 @@ skills.command("edit").argument("<name>").description("Open a user skill in $EDI
 });
 skills.command("validate").argument("[nameOrPath]").description("Validate one user skill.").action(async (nameOrPath) => {
   await ensureOpenResearchConfig();
-  const skillDir = nameOrPath ? path19.isAbsolute(nameOrPath) ? nameOrPath : path19.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
+  const skillDir = nameOrPath ? path21.isAbsolute(nameOrPath) ? nameOrPath : path21.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
   const stat = await import("fs/promises").then(
-    (fs19) => fs19.stat(skillDir).catch(() => null)
+    (fs21) => fs21.stat(skillDir).catch(() => null)
   );
   if (!stat) {
     throw new Error(`Skill path not found: ${skillDir}`);

package/package.json

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