open-research 0.1.0 → 0.1.2

package/README.md

@@ -1,111 +1,109 @@
-# Open Research
+<p align="center">
+  <img src="assets/hero-banner.png" alt="Open Research" width="720" />
+</p>
 
-Local-first research CLI agent. Discover papers, synthesize notes, run analysis, and draft artifacts from your terminal.
+<h3 align="center">The research-native CLI agent.</h3>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/open-research"><img src="https://img.shields.io/npm/v/open-research.svg" alt="npm" /></a>
+  <a href="https://github.com/gangj277/open-research/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/open-research.svg" alt="license" /></a>
+</p>
+
+<p align="center">
+  <img src="assets/workflow-concept.png" alt="Papers → Analysis → Synthesis → Code" width="620" />
+</p>
 
 ## Install
 
 ```bash
+# curl
+curl -fsSL https://raw.githubusercontent.com/gangj277/open-research/main/install.sh | bash
+```
+
+```bash
+# npm
 npm install -g open-research
 ```
 
-Requires Node.js 20+.
+```bash
+# bun
+bun install -g open-research
+```
 
-## Quick Start
+```bash
+# pnpm
+pnpm add -g open-research
+```
 
 ```bash
-# Launch the TUI
-open-research
+# npx (no install)
+npx open-research
+```
 
-# Connect your OpenAI account (inside the TUI)
-/auth
+> [!TIP]
+> Requires Node.js 20+. Run `node -v` to check.
 
-# Initialize a workspace
-/init
+## Usage
 
-# Start researching
-> What are the latest advances in transformer attention mechanisms?
+```bash
+open-research
 ```
 
-## What It Does
+Inside the TUI:
 
-Open Research is an AI-powered research agent that runs in your terminal. It connects to OpenAI's API and gives you a full research workflow:
-
-- **Discover papers** across arXiv, Semantic Scholar, and OpenAlex
-- **Read and analyze** PDFs, datasets, and web pages
-- **Run code** — Python scripts, R analysis, LaTeX compilation, anything
-- **Write artifacts** — notes, syntheses, paper drafts grounded in sources
-- **Review changes** — risky edits go to a review queue for your approval
+```
+/auth          Connect your OpenAI account
+/init          Initialize a workspace
+/help          Show all commands
+```
 
-## Tools
+Then ask anything:
 
-The agent has access to:
+```
+> Find the most-cited papers on transformer attention since 2022
+  and identify gaps in the literature
+```
 
-| Tool | What it does |
-|---|---|
-| `read_file` | Read any file on disk (text, with binary detection) |
-| `read_pdf` | Extract text from PDFs |
-| `list_directory` | Explore directory trees |
-| `run_command` | Execute shell commands (python, R, LaTeX, curl, etc.) |
-| `search_workspace` | Search across workspace files |
-| `write_new_file` | Create new workspace files |
-| `update_existing_file` | Edit existing files |
-| `search_external_sources` | Search academic paper databases |
-| `fetch_url` | Fetch web pages and APIs |
-| `ask_user` | Ask you questions when clarification is needed |
-| `load_skill` | Activate research skills |
-| `create_paper` | Create LaTeX paper drafts |
+The agent searches arXiv, Semantic Scholar, and OpenAlex — reads papers, runs analysis scripts, writes source-grounded notes, and drafts artifacts in your local workspace.
 
-## Slash Commands
+## How is this different from Cursor / Claude Code?
 
-| Command | Description |
-|---|---|
-| `/auth` | Connect OpenAI account via browser |
-| `/auth-codex` | Import existing Codex CLI auth |
-| `/init` | Initialize workspace in current directory |
-| `/skills` | List available research skills |
-| `/config` | View or change settings |
-| `/clear` | Start a new conversation |
-| `/help` | Show all commands |
-| `/exit` | Quit |
+Those are coding agents. Open Research is a **research agent**.
 
-## Skills
+It has tools that coding agents don't: federated academic paper search, PDF extraction, source-grounded synthesis, and pluggable research skills (devil's advocate, methodology critic, experiment designer, etc.).
 
-Built-in research skills that guide the agent's methodology:
+Everything stays local. Your workspace is a directory with `sources/`, `notes/`, `papers/`, `experiments/`. The agent reads and writes to it. Risky edits go to a review queue.
 
-- **source-scout** — Find citation gaps and discover relevant papers
-- **devils-advocate** — Stress-test claims and assumptions
-- **methodology-critic** — Critique research methodology
-- **evidence-adjudicator** — Evaluate evidence quality
-- **experiment-designer** — Design experiments and studies
-- **draft-paper** — Draft LaTeX papers from workspace evidence
-- **paper-explainer** — Explain complex papers
-- **synthesis-updater** — Update research syntheses
-- **skill-creator** — Create custom skills
+## Skills
 
-Type `/skill-name` in the TUI to activate any skill, or create your own in `~/.open-research/skills/`.
+Built-in research methodologies. Type `/skill-name` to activate:
 
-## Workspace Structure
+- **source-scout** — find citation gaps, discover papers
+- **devils-advocate** — stress-test claims and assumptions
+- **methodology-critic** — critique research methodology
+- **evidence-adjudicator** — evaluate evidence quality
+- **experiment-designer** — design experiments
+- **draft-paper** — draft LaTeX papers from workspace evidence
+- **paper-explainer** — explain complex papers
+- **synthesis-updater** — update syntheses with new findings
 
-```
-my-research/
-  sources/       # PDFs, papers, raw data
-  notes/         # Research notes and briefs
-  artifacts/     # Generated outputs
-  papers/        # LaTeX paper drafts
-  experiments/   # Analysis scripts and results
-  .open-research/  # Workspace metadata
-```
+Create custom skills in `~/.open-research/skills/`.
 
-## Features
+## Tools
 
-- **Markdown rendering** in terminal output (bold, italic, code blocks, lists, headings)
-- **Slash command autocomplete** with arrow-key navigation
-- **@file mentions** to reference workspace files inline
-- **Shift+Enter** for multi-line input
-- **Context management** — automatic compaction when conversation gets long
-- **Token tracking** — see context usage in the status bar
-- **Tool activity streaming** — see what the agent is doing in real-time
-- **Review queue** — risky edits require your approval before applying
+| Tool | Description |
+|---|---|
+| `read_file` | Read any file with streaming, binary detection |
+| `read_pdf` | Extract text from PDFs |
+| `run_command` | Shell execution — Python, R, LaTeX, anything |
+| `list_directory` | Explore directory trees |
+| `search_external_sources` | arXiv + Semantic Scholar + OpenAlex |
+| `fetch_url` | Fetch web pages and APIs |
+| `write_new_file` | Create workspace files |
+| `update_existing_file` | Edit with review policy |
+| `ask_user` | Pause and ask for clarification |
+| `search_workspace` | Full-text search across files |
+| `create_paper` | Create LaTeX drafts |
 
 ## Development
 
@@ -113,9 +111,9 @@ my-research/
 git clone https://github.com/gangj277/open-research.git
 cd open-research
 npm install
-npm run dev        # Run in dev mode
-npm test           # Run tests
-npm run build      # Build for production
+npm run dev          # dev mode
+npm test             # 63 tests
+npm run build        # production build
 ```
 
 ## License

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import React4 from "react";
-import path16 from "path";
+import path18 from "path";
 import { Command } from "commander";
 import { render } from "ink";
 
@@ -848,7 +848,7 @@ async function ensureOpenResearchConfig(options) {
 }
 
 // src/tui/app.tsx
-import path15 from "path";
+import path17 from "path";
 import {
   startTransition,
   useDeferredValue,
@@ -4496,7 +4496,7 @@ var MODEL_CONTEXT_WINDOWS = {
   "gpt-5.1": 272e3,
   "gpt-5": 272e3,
   "gpt-4o": 128e3,
-  "gpt-4o-mini": 128e3,
+  "gpt-5.4-mini": 128e3,
   "o3": 2e5,
   "o4-mini": 2e5
 };
@@ -4610,6 +4610,177 @@ async function maybeCompact(messages, model, provider, usage, signal) {
   return { messages: compacted, didCompact: true };
 }
 
+// src/lib/memory/store.ts
+import fs14 from "fs/promises";
+import path13 from "path";
+function getMemoryFile(options) {
+  return path13.join(getOpenResearchRoot(options), "memory.json");
+}
+async function loadMemories(options) {
+  const file = getMemoryFile(options);
+  try {
+    const raw = await fs14.readFile(file, "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");
+}
+var MAX_MEMORIES = 100;
+async function addMemory(memory, options) {
+  const memories = await loadMemories(options);
+  const existing = 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 intersection = [...wordsA].filter((w) => wordsB.has(w));
+    const similarity = intersection.length / Math.max(wordsA.size, wordsB.size);
+    return similarity > 0.7;
+  });
+  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;
+  }
+  const newMemory = {
+    id: crypto.randomUUID(),
+    content: memory.content,
+    category: memory.category,
+    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);
+  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;
+}
+async function clearMemories(options) {
+  await saveMemories([], options);
+}
+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}`);
+    }
+  }
+  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.
+
+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)
+
+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):
+{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 [].
+
+Example response:
+[{"content": "PhD student in computational neuroscience at MIT", "category": "user"}, {"content": "Prefers Python with statsmodels for statistical analysis over R", "category": "preference"}]`;
+async function extractMemories(input2) {
+  const existing = await loadMemories({ homeDir: input2.homeDir });
+  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 prompt2 = EXTRACTION_PROMPT.replace("{EXISTING_MEMORIES}", existingList);
+  const conversationSnippet = [
+    `User: ${input2.userMessage.slice(0, 2e3)}`,
+    `Agent: ${input2.agentResponse.slice(0, 2e3)}`
+  ].join("\n\n");
+  try {
+    const response = await input2.provider.callLLM({
+      messages: [
+        { role: "system", content: prompt2 },
+        { role: "user", content: conversationSnippet }
+      ],
+      model: input2.model ?? "gpt-5.4-mini",
+      maxTokens: 500,
+      temperature: 0
+    });
+    const raw = response.content.trim();
+    const jsonStr = raw.startsWith("```") ? raw.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "") : raw;
+    const parsed = JSON.parse(jsonStr);
+    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)) {
+        valid.push({
+          content: item.content,
+          category: item.category
+        });
+      }
+    }
+    return valid.slice(0, 3);
+  } catch {
+    return [];
+  }
+}
+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);
+  }
+  return stored;
+}
+
 // src/lib/agent/runtime.ts
 var TOOL_DESCRIPTIONS = {
   read_file: (a) => `Reading ${a.file_path ?? "file"}`,
@@ -4696,8 +4867,11 @@ 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 fullSystemPrompt = memoryBlock ? systemPrompt + "\n\n" + memoryBlock : systemPrompt;
   let messages = [
-    { role: "system", content: systemPrompt },
+    { role: "system", content: fullSystemPrompt },
     ...input2.history,
     { role: "user", content: input2.message }
   ];
@@ -4750,6 +4924,18 @@ async function runAgentTurn(input2) {
           detectedCharter = charterMatch[1].trim();
         }
       }
+      extractAndStoreMemories({
+        userMessage: input2.message,
+        agentResponse: fullText,
+        provider: input2.provider,
+        model: "gpt-5.4-mini",
+        homeDir: input2.homeDir
+      }).then((stored) => {
+        if (stored.length > 0) {
+          input2.onMemoryExtracted?.(stored.map((m) => m.content));
+        }
+      }).catch(() => {
+      });
       return {
         text: fullText,
         proposedUpdates,
@@ -4841,8 +5027,8 @@ function classifyUpdateRisk(update) {
 }
 
 // src/lib/workspace/apply-update.ts
-import fs14 from "fs/promises";
-import path13 from "path";
+import fs15 from "fs/promises";
+import path14 from "path";
 function resolveRelativePath(update) {
   if (update.key.startsWith("path:")) {
     return update.key.slice(5);
@@ -4863,20 +5049,20 @@ function resolveRelativePath(update) {
 }
 async function applyProposedUpdate(workspaceDir, update) {
   const relativePath = resolveRelativePath(update);
-  const absolutePath = path13.join(workspaceDir, relativePath);
-  await fs14.mkdir(path13.dirname(absolutePath), { recursive: true });
-  await fs14.writeFile(absolutePath, update.content, "utf8");
+  const absolutePath = path14.join(workspaceDir, relativePath);
+  await fs15.mkdir(path14.dirname(absolutePath), { recursive: true });
+  await fs15.writeFile(absolutePath, update.content, "utf8");
   return absolutePath;
 }
 
 // src/lib/workspace/sessions.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 async function appendSessionEvent(workspaceDir, sessionId, event) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
-  await fs15.mkdir(sessionsDir, { recursive: true });
-  const sessionFile = path14.join(sessionsDir, `${sessionId}.jsonl`);
-  await fs15.appendFile(sessionFile, `${JSON.stringify(event)}
+  await fs16.mkdir(sessionsDir, { recursive: true });
+  const sessionFile = path15.join(sessionsDir, `${sessionId}.jsonl`);
+  await fs16.appendFile(sessionFile, `${JSON.stringify(event)}
 `, "utf8");
 }
 function parseEvents(raw) {
@@ -4892,7 +5078,7 @@ async function listSessions(workspaceDir) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
   let files;
   try {
-    files = await fs15.readdir(sessionsDir);
+    files = await fs16.readdir(sessionsDir);
   } catch {
     return [];
   }
@@ -4900,7 +5086,7 @@ async function listSessions(workspaceDir) {
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
     const id = file.replace(/\.jsonl$/, "");
-    const raw = await fs15.readFile(path14.join(sessionsDir, file), "utf8");
+    const raw = await fs16.readFile(path15.join(sessionsDir, file), "utf8");
     const events = parseEvents(raw);
     if (events.length === 0) continue;
     const chatTurns = events.filter((e) => e.type === "chat.turn");
@@ -4921,8 +5107,8 @@ async function listSessions(workspaceDir) {
 }
 async function loadSessionHistory(workspaceDir, sessionId) {
   const sessionsDir = getWorkspaceSessionsDir(workspaceDir);
-  const sessionFile = path14.join(sessionsDir, `${sessionId}.jsonl`);
-  const raw = await fs15.readFile(sessionFile, "utf8");
+  const sessionFile = path15.join(sessionsDir, `${sessionId}.jsonl`);
+  const raw = await fs16.readFile(sessionFile, "utf8");
   const events = parseEvents(raw);
   const messages = [];
   const llmHistory = [];
@@ -5033,6 +5219,81 @@ function ConfigScreen({ items, onUpdate, onClose }) {
   ] });
 }
 
+// src/lib/cli/update-check.ts
+import fs17 from "fs/promises";
+import path16 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");
+async function readState() {
+  try {
+    const raw = await fs17.readFile(STATE_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { lastCheck: 0, latestVersion: null };
+  }
+}
+async function writeState(state) {
+  await fs17.mkdir(path16.dirname(STATE_FILE), { recursive: true });
+  await fs17.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
+}
+function getCurrentVersion() {
+  try {
+    const pkgPath = new URL("../../../package.json", import.meta.url);
+    return process.env.npm_package_version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+async function checkForUpdate() {
+  try {
+    const state = await readState();
+    const now = Date.now();
+    if (now - state.lastCheck < CHECK_INTERVAL_MS && state.latestVersion) {
+      const current2 = getCurrentVersion();
+      if (isNewer(state.latestVersion, current2)) {
+        return `Update available: ${current2} \u2192 ${state.latestVersion}. Run: npm update -g open-research`;
+      }
+      return null;
+    }
+    const latest = await fetchLatestVersion();
+    await writeState({ lastCheck: now, latestVersion: latest });
+    if (!latest) return null;
+    const current = getCurrentVersion();
+    if (isNewer(latest, current)) {
+      return `Update available: ${current} \u2192 ${latest}. Run: npm update -g open-research`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 // src/tui/commands.ts
 var SLASH_COMMANDS = [
   { name: "auth", aliases: ["/connect", "/login"], description: "Connect your OpenAI account via browser OAuth", category: "auth" },
@@ -5045,6 +5306,7 @@ var SLASH_COMMANDS = [
   { name: "clear", aliases: ["/new"], description: "Clear conversation and start fresh", category: "session" },
   { name: "help", aliases: ["/commands"], description: "Show available commands", category: "system" },
   { name: "config", aliases: ["/settings"], description: "View or change settings (e.g. /config theme dark)", category: "system" },
+  { name: "memory", aliases: ["/memories"], description: "View or clear stored memories about you", category: "system" },
   { name: "exit", aliases: ["/quit", "/q"], description: "Exit Open Research", category: "system" }
 ];
 function matchSlashCommand(input2) {
@@ -5605,6 +5867,9 @@ function App({
       setTheme(cfg.theme);
       const auth2 = await loadStoredAuth({ homeDir });
       setAuthStatus(auth2 ? "connected" : "missing");
+      checkForUpdate().then((msg) => {
+        if (msg) addSystemMessage(msg);
+      });
     })();
   }, [homeDir]);
   useEffect2(() => {
@@ -5867,6 +6132,33 @@ function App({
         addSystemMessage("  Esc  unfocus prompt");
         break;
       }
+      case "memory": {
+        if (args === "clear") {
+          await clearMemories({ homeDir });
+          addSystemMessage("All memories cleared.");
+          break;
+        }
+        if (args.startsWith("delete ")) {
+          const memId = args.slice(7).trim();
+          const deleted = await deleteMemory(memId, { homeDir });
+          addSystemMessage(deleted ? `Deleted memory ${memId.slice(0, 8)}...` : "Memory not found.");
+          break;
+        }
+        const mems = await loadMemories({ homeDir });
+        if (mems.length === 0) {
+          addSystemMessage("No memories stored yet. I'll learn about you as we talk.");
+        } else {
+          addSystemMessage(`${mems.length} memories:`);
+          for (const m of mems) {
+            addSystemMessage(`  [${m.category}] ${m.content}`);
+            addSystemMessage(`    id: ${m.id.slice(0, 8)}... \xB7 reinforced ${m.relevanceCount}x`);
+          }
+          addSystemMessage("");
+          addSystemMessage("  /memory clear \u2014 delete all");
+          addSystemMessage("  /memory delete <id> \u2014 delete one");
+        }
+        break;
+      }
       case "exit": {
         app.exit();
         break;
@@ -6078,6 +6370,11 @@ function App({
             addSystemMessage(`  \u2713 ${activity.description ?? activity.name}${dur}`);
           }
         },
+        onMemoryExtracted: (mems) => {
+          for (const m of mems) {
+            addSystemMessage(`  \u25CA remembered: ${m}`);
+          }
+        },
         onCompaction: () => {
           addSystemMessage("  \u25CA Context compacted \u2014 older messages summarized");
         },
@@ -6510,7 +6807,7 @@ function App({
         statusParts,
         statusColor,
         tokenDisplay,
-        workspaceName: hasWorkspace ? path15.basename(workspacePath) : process.cwd(),
+        workspaceName: hasWorkspace ? path17.basename(workspacePath) : process.cwd(),
         mode: agentMode,
         planningStatus: planningState.status
       }
@@ -6522,7 +6819,7 @@ function App({
 var program = new Command();
 program.name("open-research").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 ? path16.resolve(workspacePath) : process.cwd();
+  const target = workspacePath ? path18.resolve(workspacePath) : process.cwd();
   const project = await loadWorkspaceProject(target);
   const auth2 = await loadStoredAuth();
   render(
@@ -6544,7 +6841,7 @@ program.name("open-research").description("Local-first research CLI powered by C
 });
 program.command("init").argument("[workspacePath]").description("Initialize an Open Research workspace.").action(async (workspacePath) => {
   await ensureOpenResearchConfig();
-  const target = path16.resolve(workspacePath ?? process.cwd());
+  const target = path18.resolve(workspacePath ?? process.cwd());
   const project = await initWorkspace({ workspaceDir: target });
   console.log(`Initialized workspace: ${target}`);
   console.log(`Title: ${project.title}`);
@@ -6613,8 +6910,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 = path16.join(getOpenResearchSkillsDir(), name);
-  openInEditor(path16.join(skillDir, "SKILL.md"));
+  const skillDir = path18.join(getOpenResearchSkillsDir(), name);
+  openInEditor(path18.join(skillDir, "SKILL.md"));
   const validation = await validateSkillDirectory({ skillDir });
   if (!validation.ok) {
     console.error(validation.errors.join("\n"));
@@ -6625,9 +6922,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 ? path16.isAbsolute(nameOrPath) ? nameOrPath : path16.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
+  const skillDir = nameOrPath ? path18.isAbsolute(nameOrPath) ? nameOrPath : path18.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
   const stat = await import("fs/promises").then(
-    (fs16) => fs16.stat(skillDir).catch(() => null)
+    (fs18) => fs18.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.0",
+  "version": "0.1.2",
   "description": "Local-first research CLI agent — discover papers, synthesize notes, run analysis, and draft artifacts from your terminal.",
   "type": "module",
   "license": "MIT",