open-research 0.1.26 → 1.0.0

package/dist/cli.js

@@ -1,64 +1,59 @@
 #!/usr/bin/env node
 import {
-  __require,
   appendSessionEvent,
+  loadSessionHistory
+} from "./chunk-ZUSIRA5S.js";
+import {
+  ensureOpenResearchConfig,
+  executeFetchUrl,
+  extractBatch,
+  extractPdfText,
+  fetchAndParseContent,
+  formatExtractionResults,
+  getBraveApiKey,
+  getConfiguredOpenAIApiKey,
+  getOpenAlexApiKey,
+  getSemanticScholarApiKey,
+  loadOpenResearchConfig,
+  readJsonFile,
+  saveOpenResearchConfig,
+  themeValues,
+  writeJsonFile
+} from "./chunk-TQSQRNX6.js";
+import {
   getOpenResearchAuthFile,
-  getOpenResearchConfigFile,
   getOpenResearchRoot,
   getOpenResearchSkillsDir,
   getWorkspaceMetaDir,
   getWorkspaceProjectFile,
-  getWorkspaceSessionsDir,
-  loadSessionHistory
-} from "./chunk-AYB7CAO5.js";
+  getWorkspaceSessionsDir
+} from "./chunk-I5NVYKG7.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
 
 // src/cli.ts
 import React6 from "react";
-import path20 from "path";
+import path19 from "path";
 import { Command } from "commander";
 import { render } from "ink";
 
 // src/lib/workspace/project.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-
-// src/lib/fs/json.ts
 import fs from "fs/promises";
 import path from "path";
-async function readJsonFile(filePath, fallback) {
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
-    if (code === "ENOENT") {
-      return fallback;
-    }
-    throw error;
-  }
-}
-async function writeJsonFile(filePath, value, mode) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(value, null, 2), {
-    encoding: "utf8",
-    mode
-  });
-}
-
-// src/lib/workspace/project.ts
 var MANAGED_DIRS = ["sources", "notes", "artifacts", "papers", "experiments"];
 async function initWorkspace(options) {
-  const workspaceDir = path2.resolve(options.workspaceDir);
-  await fs2.mkdir(workspaceDir, { recursive: true });
+  const workspaceDir = path.resolve(options.workspaceDir);
+  await fs.mkdir(workspaceDir, { recursive: true });
   for (const dir of MANAGED_DIRS) {
-    await fs2.mkdir(path2.join(workspaceDir, dir), { recursive: true });
+    await fs.mkdir(path.join(workspaceDir, dir), { recursive: true });
   }
-  await fs2.mkdir(getWorkspaceMetaDir(workspaceDir), { recursive: true });
-  await fs2.mkdir(getWorkspaceSessionsDir(workspaceDir), { recursive: true });
+  await fs.mkdir(getWorkspaceMetaDir(workspaceDir), { recursive: true });
+  await fs.mkdir(getWorkspaceSessionsDir(workspaceDir), { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const project = {
     version: 1,
-    title: options.title?.trim() || path2.basename(workspaceDir),
+    title: options.title?.trim() || path.basename(workspaceDir),
     createdAt: timestamp,
     updatedAt: timestamp,
     defaults: {
@@ -74,36 +69,15 @@ async function initWorkspace(options) {
 }
 async function loadWorkspaceProject(workspaceDir) {
   return readJsonFile(
-    getWorkspaceProjectFile(path2.resolve(workspaceDir)),
+    getWorkspaceProjectFile(path.resolve(workspaceDir)),
     null
   );
 }
 
 // src/lib/workspace/sources.ts
-import fs4 from "fs/promises";
-import path3 from "path";
+import fs2 from "fs/promises";
+import path2 from "path";
 import { load } from "cheerio";
-
-// src/lib/fs/pdf.ts
-import fs3 from "fs/promises";
-async function extractPdfText(filePath, options) {
-  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
-  const buffer = await fs3.readFile(filePath);
-  const document = await pdfjs.getDocument({ data: new Uint8Array(buffer) }).promise;
-  const totalPages = document.numPages;
-  const start = Math.max(1, options?.startPage ?? 1);
-  const end = Math.min(totalPages, options?.endPage ?? totalPages);
-  const pages = [];
-  for (let pageNumber = start; pageNumber <= end; pageNumber += 1) {
-    const page = await document.getPage(pageNumber);
-    const content = await page.getTextContent();
-    const text = content.items.map((item) => "str" in item ? String(item.str) : "").join(" ").replace(/\s+/g, " ").trim();
-    if (text) pages.push(text);
-  }
-  return { text: pages.join("\n\n"), totalPages };
-}
-
-// src/lib/workspace/sources.ts
 function slugify(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "source";
 }
@@ -138,10 +112,10 @@ async function addUrlSource(input2) {
   const titleMatch = markdown.match(/^#\s+(.+)$/m);
   const label = titleMatch?.[1]?.trim() || new URL(input2.url).hostname;
   const fileName = `${slugify(label)}.md`;
-  const relativePath = path3.join("sources", fileName);
-  const absolutePath = path3.join(input2.workspaceDir, relativePath);
-  await fs4.mkdir(path3.dirname(absolutePath), { recursive: true });
-  await fs4.writeFile(absolutePath, markdown, "utf8");
+  const relativePath = path2.join("sources", fileName);
+  const absolutePath = path2.join(input2.workspaceDir, relativePath);
+  await fs2.mkdir(path2.dirname(absolutePath), { recursive: true });
+  await fs2.writeFile(absolutePath, markdown, "utf8");
   const source2 = {
     id: crypto.randomUUID(),
     kind: "url",
@@ -153,31 +127,31 @@ async function addUrlSource(input2) {
   return source2;
 }
 async function addFileSource(input2) {
-  const absoluteInput = path3.resolve(input2.filePath);
-  const parsed = path3.parse(absoluteInput);
+  const absoluteInput = path2.resolve(input2.filePath);
+  const parsed = path2.parse(absoluteInput);
   const slug = slugify(parsed.name);
-  const markdownRelative = path3.join("sources", `${slug}.md`);
-  const markdownAbsolute = path3.join(input2.workspaceDir, markdownRelative);
+  const markdownRelative = path2.join("sources", `${slug}.md`);
+  const markdownAbsolute = path2.join(input2.workspaceDir, markdownRelative);
   let markdown = "";
   if (parsed.ext.toLowerCase() === ".pdf") {
-    const rawRelative = path3.join("sources", `${slug}.pdf`);
-    const rawAbsolute = path3.join(input2.workspaceDir, rawRelative);
-    await fs4.mkdir(path3.dirname(rawAbsolute), { recursive: true });
-    await fs4.copyFile(absoluteInput, rawAbsolute);
+    const rawRelative = path2.join("sources", `${slug}.pdf`);
+    const rawAbsolute = path2.join(input2.workspaceDir, rawRelative);
+    await fs2.mkdir(path2.dirname(rawAbsolute), { recursive: true });
+    await fs2.copyFile(absoluteInput, rawAbsolute);
     const { text } = await extractPdfText(absoluteInput);
     markdown = `# ${parsed.name}
 
 ${text}`;
   } else {
-    markdown = await fs4.readFile(absoluteInput, "utf8");
+    markdown = await fs2.readFile(absoluteInput, "utf8");
     if (!markdown.startsWith("# ")) {
       markdown = `# ${parsed.name}
 
 ${markdown}`;
     }
   }
-  await fs4.mkdir(path3.dirname(markdownAbsolute), { recursive: true });
-  await fs4.writeFile(markdownAbsolute, markdown, "utf8");
+  await fs2.mkdir(path2.dirname(markdownAbsolute), { recursive: true });
+  await fs2.writeFile(markdownAbsolute, markdown, "utf8");
   const source2 = {
     id: crypto.randomUUID(),
     kind: parsed.ext.toLowerCase() === ".pdf" ? "pdf" : "file",
@@ -190,8 +164,8 @@ ${markdown}`;
 }
 
 // src/lib/auth/import-codex.ts
-import fs6 from "fs/promises";
-import path4 from "path";
+import fs4 from "fs/promises";
+import path3 from "path";
 
 // src/lib/storage/credential-types.ts
 function getDefaultCredentialCapabilities() {
@@ -220,18 +194,18 @@ function getBootstrapCredentialValidation() {
 }
 
 // src/lib/auth/store.ts
-import fs5 from "fs/promises";
+import fs3 from "fs/promises";
 var AUTH_FILE_MODE = 384;
 async function ensureCliHome(options) {
   const root = getOpenResearchRoot(options);
-  await fs5.mkdir(root, { recursive: true, mode: 448 });
+  await fs3.mkdir(root, { recursive: true, mode: 448 });
   return root;
 }
 async function saveStoredAuth(auth2, options) {
   await ensureCliHome(options);
   const authFile = getOpenResearchAuthFile(options);
   await writeJsonFile(authFile, auth2, AUTH_FILE_MODE);
-  await fs5.chmod(authFile, AUTH_FILE_MODE);
+  await fs3.chmod(authFile, AUTH_FILE_MODE);
   return authFile;
 }
 async function loadStoredAuth(options) {
@@ -240,7 +214,7 @@ async function loadStoredAuth(options) {
 }
 async function clearStoredAuth(options) {
   const authFile = getOpenResearchAuthFile(options);
-  await fs5.rm(authFile, { force: true });
+  await fs3.rm(authFile, { force: true });
 }
 
 // src/lib/auth/openai-oauth.ts
@@ -333,9 +307,9 @@ function getTokenExpiryMs(token) {
 }
 async function importCodexAuth(options = {}) {
   const now = options.now ?? Date.now;
-  const codexAuthPath = options.codexAuthFilePath ?? path4.join(options.homeDir ?? process.env.HOME ?? "", ".codex", "auth.json");
+  const codexAuthPath = options.codexAuthFilePath ?? path3.join(options.homeDir ?? process.env.HOME ?? "", ".codex", "auth.json");
   const parsed = JSON.parse(
-    await fs6.readFile(codexAuthPath, "utf8")
+    await fs4.readFile(codexAuthPath, "utf8")
   );
   if (parsed.auth_mode !== "chatgpt") {
     throw new Error("Codex is not signed in with OpenAI on this device.");
@@ -666,73 +640,6 @@ async function validateOpenAIConnection(input2) {
   }
 }
 
-// src/lib/config/store.ts
-import { z } from "zod";
-var themeValues = ["dark", "light"];
-var openAIProviderConfigSchema = z.object({
-  apiKey: z.string().optional()
-}).optional();
-var openResearchConfigSchema = z.object({
-  version: z.literal(1),
-  defaults: z.object({
-    model: z.string().min(1),
-    reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]),
-    editPolicy: z.literal("mixed")
-  }),
-  theme: z.enum(themeValues).default("dark"),
-  lastWorkspace: z.string().nullable(),
-  providers: z.object({
-    openai: openAIProviderConfigSchema
-  }).optional(),
-  apiKeys: z.object({
-    openai: z.string().optional(),
-    semanticScholar: z.string().optional(),
-    openAlex: z.string().optional()
-  }).optional()
-});
-var DEFAULT_OPEN_RESEARCH_CONFIG = {
-  version: 1,
-  defaults: {
-    model: "gpt-5.4",
-    reasoningEffort: "medium",
-    editPolicy: "mixed"
-  },
-  theme: "dark",
-  lastWorkspace: null,
-  providers: {
-    openai: {}
-  },
-  apiKeys: {}
-};
-function getConfiguredOpenAIApiKey(config) {
-  return config?.providers?.openai?.apiKey || config?.apiKeys?.openai;
-}
-function getSemanticScholarApiKey(config) {
-  return config?.apiKeys?.semanticScholar || process.env.SEMANTIC_SCHOLAR_API_KEY;
-}
-function getOpenAlexApiKey(config) {
-  return config?.apiKeys?.openAlex || process.env.OPENALEX_API_KEY;
-}
-async function loadOpenResearchConfig(options) {
-  const configFile = getOpenResearchConfigFile(options);
-  const config = await readJsonFile(configFile, null);
-  if (!config) {
-    return null;
-  }
-  return openResearchConfigSchema.parse(config);
-}
-async function saveOpenResearchConfig(config, options) {
-  await writeJsonFile(getOpenResearchConfigFile(options), config);
-}
-async function ensureOpenResearchConfig(options) {
-  const existing = await loadOpenResearchConfig(options);
-  if (existing) {
-    return existing;
-  }
-  await writeJsonFile(getOpenResearchConfigFile(options), DEFAULT_OPEN_RESEARCH_CONFIG);
-  return DEFAULT_OPEN_RESEARCH_CONFIG;
-}
-
 // src/lib/llm/provider-resolution.ts
 function trimCredential(value) {
   const trimmed = value?.trim();
@@ -836,26 +743,26 @@ async function getAuthStatus(options) {
 }
 
 // src/lib/skills/registry.ts
-import fs7 from "fs/promises";
+import fs5 from "fs/promises";
 import fsSync from "fs";
-import path5 from "path";
+import path4 from "path";
 import matter from "gray-matter";
 var BUILTIN_SKILLS_DIR = [
-  path5.resolve(path5.join(import.meta.dirname, "../../../builtin-skills")),
-  path5.resolve(path5.join(import.meta.dirname, "../builtin-skills"))
-].find((candidate) => fsSync.existsSync(candidate)) ?? path5.resolve(path5.join(import.meta.dirname, "../../../builtin-skills"));
+  path4.resolve(path4.join(import.meta.dirname, "../../../builtin-skills")),
+  path4.resolve(path4.join(import.meta.dirname, "../builtin-skills"))
+].find((candidate) => fsSync.existsSync(candidate)) ?? path4.resolve(path4.join(import.meta.dirname, "../../../builtin-skills"));
 function normalizeSkillName(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 async function ensureUserSkillsDir(options) {
   const dir = getOpenResearchSkillsDir(options);
-  await fs7.mkdir(dir, { recursive: true });
+  await fs5.mkdir(dir, { recursive: true });
   return dir;
 }
 async function readSkillSummary(skillDir, source2) {
-  const skillFile = path5.join(skillDir, "SKILL.md");
+  const skillFile = path4.join(skillDir, "SKILL.md");
   try {
-    const raw = await fs7.readFile(skillFile, "utf8");
+    const raw = await fs5.readFile(skillFile, "utf8");
     const parsed = matter(raw);
     const name = String(parsed.data.name ?? "").trim();
     const description = String(parsed.data.description ?? "").trim();
@@ -874,9 +781,9 @@ async function readSkillSummary(skillDir, source2) {
   }
 }
 async function listSkillsInDirectory(rootDir, source2) {
-  const entries = await fs7.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs5.readdir(rootDir, { withFileTypes: true }).catch(() => []);
   const results = await Promise.all(
-    entries.filter((entry) => entry.isDirectory()).map((entry) => readSkillSummary(path5.join(rootDir, entry.name), source2))
+    entries.filter((entry) => entry.isDirectory()).map((entry) => readSkillSummary(path4.join(rootDir, entry.name), source2))
   );
   return results.filter((value) => Boolean(value));
 }
@@ -890,15 +797,15 @@ async function listAvailableSkills(options) {
 }
 async function validateSkillDirectory(input2) {
   const errors = [];
-  const skillFile = path5.join(input2.skillDir, "SKILL.md");
-  const raw = await fs7.readFile(skillFile, "utf8").catch(() => "");
+  const skillFile = path4.join(input2.skillDir, "SKILL.md");
+  const raw = await fs5.readFile(skillFile, "utf8").catch(() => "");
   if (!raw) {
     return { ok: false, errors: ["SKILL.md is missing."] };
   }
   const parsed = matter(raw);
   const name = String(parsed.data.name ?? "").trim();
   const description = String(parsed.data.description ?? "").trim();
-  const normalizedDirName = path5.basename(input2.skillDir);
+  const normalizedDirName = path4.basename(input2.skillDir);
   const normalizedName = normalizeSkillName(name);
   if (!name) {
     errors.push("Skill frontmatter requires a name.");
@@ -921,10 +828,10 @@ async function validateSkillDirectory(input2) {
 async function createSkillScaffold(input2) {
   const skillsDir = await ensureUserSkillsDir({ homeDir: input2.homeDir });
   const name = normalizeSkillName(input2.name);
-  const skillDir = path5.join(skillsDir, name);
-  await fs7.mkdir(path5.join(skillDir, "scripts"), { recursive: true });
-  await fs7.mkdir(path5.join(skillDir, "references"), { recursive: true });
-  await fs7.mkdir(path5.join(skillDir, "assets"), { recursive: true });
+  const skillDir = path4.join(skillsDir, name);
+  await fs5.mkdir(path4.join(skillDir, "scripts"), { recursive: true });
+  await fs5.mkdir(path4.join(skillDir, "references"), { recursive: true });
+  await fs5.mkdir(path4.join(skillDir, "assets"), { recursive: true });
   const body = `---
 name: ${name}
 description: ${input2.description}
@@ -944,7 +851,7 @@ ${input2.examples.map((example) => `- ${example}`).join("\n")}
 
 ${input2.workflow}
 `;
-  await fs7.writeFile(path5.join(skillDir, "SKILL.md"), body, "utf8");
+  await fs5.writeFile(path4.join(skillDir, "SKILL.md"), body, "utf8");
   return skillDir;
 }
 
@@ -982,13 +889,13 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "0.1.26";
+var PACKAGE_VERSION = "1.0.0";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
 
 // src/tui/app.tsx
-import path19 from "path";
+import path18 from "path";
 import {
   startTransition as startTransition2,
   useDeferredValue,
@@ -2448,8 +2355,8 @@ function useTheme() {
 }
 
 // src/lib/workspace/scan.ts
-import fs8 from "fs/promises";
-import path6 from "path";
+import fs6 from "fs/promises";
+import path5 from "path";
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".md",
   ".markdown",
@@ -2479,30 +2386,30 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".turbo"
 ]);
 async function walkDir(rootDir, currentDir, out) {
-  const entries = await fs8.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs6.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (IGNORED_DIRS.has(entry.name)) {
       continue;
     }
-    const fullPath = path6.join(currentDir, entry.name);
-    const relativePath = path6.relative(rootDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path5.join(currentDir, entry.name);
+    const relativePath = path5.relative(rootDir, fullPath).replace(/\\/g, "/");
     if (entry.isDirectory()) {
       await walkDir(rootDir, fullPath, out);
       continue;
     }
-    if (!TEXT_EXTENSIONS.has(path6.extname(entry.name).toLowerCase())) {
+    if (!TEXT_EXTENSIONS.has(path5.extname(entry.name).toLowerCase())) {
       continue;
     }
     out.push({
       key: `path:${relativePath}`,
       label: relativePath,
       path: relativePath,
-      content: await fs8.readFile(fullPath, "utf8")
+      content: await fs6.readFile(fullPath, "utf8")
     });
   }
 }
 async function scanWorkspace(workspaceDir) {
-  const resolved = path6.resolve(workspaceDir);
+  const resolved = path5.resolve(workspaceDir);
   const project = await loadWorkspaceProject(resolved);
   if (!project) {
     throw new Error("Not an Open Research workspace. Run `open-research init` first.");
@@ -3408,10 +3315,14 @@ var TOOL_SCHEMAS = [
     type: "function",
     function: {
       name: "search_external_sources",
-      description: "Search OpenAlex, Semantic Scholar, and arXiv for academic papers. Provide one or more search queries. The first query is the primary search; additional queries are variations to broaden coverage.",
+      description: "Search OpenAlex, Semantic Scholar, and arXiv for academic papers, then fetch content (PDFs, abstracts) and extract structured findings relative to the target. Returns supports/contradicts/related evidence for each source.",
       parameters: {
         type: "object",
         properties: {
+          target: {
+            type: "string",
+            description: "The research claim, hypothesis, or question to evaluate sources against. Each paper will be analyzed for evidence that supports, contradicts, or relates to this target. Be specific: 'What speedups do efficient attention methods achieve' not 'attention'."
+          },
           searches: {
             type: "array",
             items: {
@@ -3430,7 +3341,33 @@ var TOOL_SCHEMAS = [
             description: "Maximum number of results to return. Default: 8."
           }
         },
-        required: ["searches"],
+        required: ["target", "searches"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: "Search the web via DuckDuckGo, fetch top results, and extract structured findings relative to the target. Use for non-academic sources: documentation, blog posts, datasets, reports, news. For academic papers, use search_external_sources.",
+      parameters: {
+        type: "object",
+        properties: {
+          target: {
+            type: "string",
+            description: "The research claim or question to evaluate results against. Be specific: 'How to configure num_workers in PyTorch DataLoader for multi-GPU' not 'PyTorch'."
+          },
+          query: {
+            type: "string",
+            description: "The web search query."
+          },
+          num_results: {
+            type: "number",
+            description: "Maximum pages to fetch and analyze. Default: 5, max: 8."
+          }
+        },
+        required: ["target", "query"],
         additionalProperties: false
       }
     }
@@ -3602,6 +3539,42 @@ var TOOL_SCHEMAS = [
         additionalProperties: false
       }
     }
+  },
+  // ── Ontology ──────────────────────────────────────────────────────────
+  {
+    type: "function",
+    function: {
+      name: "query_ontology",
+      description: "Ask a question about your research knowledge. A query agent traverses the project's ontology (sources, findings, claims, contradictions, evidence chains) and returns a synthesized answer. Use for: finding evidence for/against a claim, checking what contradicts something, getting methodology details, or understanding how findings connect. Returns a natural language answer \u2014 not raw data.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Natural language research question. Be specific. Good: 'what evidence contradicts the transformer efficiency claim?' Good: 'what methods were used across the scaling studies?' Bad: 'tell me about transformers' (too vague)"
+          },
+          scope: {
+            type: "string",
+            enum: ["claims", "sources", "questions", "methods", "findings", "insights"],
+            description: "Narrow the search to a specific note kind. Omit to search everything."
+          }
+        },
+        required: ["query"],
+        additionalProperties: false
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "ontology_status",
+      description: "Get a snapshot of the research ontology: how many sources, findings, claims, methods, questions, and insights have been captured. Also shows contradiction count, unsupported claims, and open questions. Use to assess coverage, identify gaps, or decide what to investigate next.",
+      parameters: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }
+    }
   }
 ];
 var TOOL_META = {
@@ -3621,7 +3594,10 @@ var TOOL_META = {
   ask_user: { parallelSafe: false },
   create_paper: { parallelSafe: false },
   create_tasks: { parallelSafe: true },
-  update_task: { parallelSafe: true }
+  update_task: { parallelSafe: true },
+  web_search: { parallelSafe: true },
+  query_ontology: { parallelSafe: true },
+  ontology_status: { parallelSafe: true }
 };
 function isParallelSafe(toolName) {
   return TOOL_META[toolName]?.parallelSafe ?? false;
@@ -3633,6 +3609,7 @@ var PLANNING_TOOL_NAMES = /* @__PURE__ */ new Set([
   "search_workspace",
   "fetch_url",
   "search_external_sources",
+  "web_search",
   "load_skill",
   "read_skill_reference",
   "ask_user"
@@ -3691,9 +3668,9 @@ Root: ${process.cwd()}`,
 }
 
 // src/lib/agent/tools/read-file.ts
-import fs9 from "fs/promises";
+import fs7 from "fs/promises";
 import { createReadStream } from "fs";
-import path7 from "path";
+import path6 from "path";
 import os2 from "os";
 import readline2 from "readline";
 var MAX_OUTPUT_BYTES = 50 * 1024;
@@ -3752,10 +3729,10 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".eot"
 ]);
 function isBinaryByExtension(filePath) {
-  return BINARY_EXTENSIONS.has(path7.extname(filePath).toLowerCase());
+  return BINARY_EXTENSIONS.has(path6.extname(filePath).toLowerCase());
 }
 async function isBinaryByContent(filePath) {
-  const handle = await fs9.open(filePath, "r");
+  const handle = await fs7.open(filePath, "r");
   try {
     const buf = Buffer.alloc(4096);
     const { bytesRead } = await handle.read(buf, 0, 4096, 0);
@@ -3778,7 +3755,7 @@ function truncateLine(line) {
 }
 function expandHome(filePath) {
   if (filePath === "~") return os2.homedir();
-  if (filePath.startsWith("~/")) return path7.join(os2.homedir(), filePath.slice(2));
+  if (filePath.startsWith("~/")) return path6.join(os2.homedir(), filePath.slice(2));
   return filePath;
 }
 async function streamReadFile(resolved, offset, limit) {
@@ -3817,10 +3794,10 @@ async function executeReadFile(args, ctx) {
   if (filePath.startsWith("path:") && filePath in ctx.workspaceFiles) {
     return formatFromString(filePath, ctx.workspaceFiles[filePath], offset, limit);
   }
-  const resolved = path7.isAbsolute(filePath) ? filePath : path7.resolve(filePath);
+  const resolved = path6.isAbsolute(filePath) ? filePath : path6.resolve(filePath);
   let stat;
   try {
-    stat = await fs9.stat(resolved);
+    stat = await fs7.stat(resolved);
   } catch {
     if (filePath in ctx.workspaceFiles) {
       return formatFromString(filePath, ctx.workspaceFiles[filePath], offset, limit);
@@ -3828,7 +3805,7 @@ async function executeReadFile(args, ctx) {
     return `Error: File not found: ${args.file_path}`;
   }
   if (stat.isDirectory()) {
-    const entries = await fs9.readdir(resolved, { withFileTypes: true });
+    const entries = await fs7.readdir(resolved, { withFileTypes: true });
     const lines = entries.sort((a, b) => {
       if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
       return a.name.localeCompare(b.name);
@@ -3892,8 +3869,8 @@ ${outputLines.join("\n")}${footer}
 }
 
 // src/lib/agent/tools/list-directory.ts
-import fs10 from "fs/promises";
-import path8 from "path";
+import fs8 from "fs/promises";
+import path7 from "path";
 var MAX_ENTRIES = 200;
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
@@ -3910,7 +3887,7 @@ var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ".env"
 ]);
 async function listEntries(dirPath, ignore) {
-  const entries = await fs10.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs8.readdir(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (ignore.has(entry.name) || entry.name.startsWith(".") && DEFAULT_IGNORE.has(entry.name)) {
@@ -3919,7 +3896,7 @@ async function listEntries(dirPath, ignore) {
     let size = 0;
     if (!entry.isDirectory()) {
       try {
-        const stat = await fs10.stat(path8.join(dirPath, entry.name));
+        const stat = await fs8.stat(path7.join(dirPath, entry.name));
         size = stat.size;
       } catch {
       }
@@ -3957,7 +3934,7 @@ async function walkTree(rootDir, currentDir, depth, maxDepth, ignore, lines, ind
       if (depth < maxDepth) {
         await walkTree(
           rootDir,
-          path8.join(currentDir, entry.name),
+          path7.join(currentDir, entry.name),
           depth + 1,
           maxDepth,
           ignore,
@@ -3973,11 +3950,11 @@ async function walkTree(rootDir, currentDir, depth, maxDepth, ignore, lines, ind
   }
 }
 async function executeListDirectory(args) {
-  const dirPath = args.dir_path ? path8.isAbsolute(args.dir_path) ? args.dir_path : path8.resolve(args.dir_path) : process.cwd();
+  const dirPath = args.dir_path ? path7.isAbsolute(args.dir_path) ? args.dir_path : path7.resolve(args.dir_path) : process.cwd();
   const maxDepth = Math.min(args.depth ?? 2, 5);
   const ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...args.ignore ?? []]);
   try {
-    const stat = await fs10.stat(dirPath);
+    const stat = await fs8.stat(dirPath);
     if (!stat.isDirectory()) {
       return `Error: ${dirPath} is not a directory.`;
     }
@@ -3992,8 +3969,8 @@ async function executeListDirectory(args) {
 
 // src/lib/agent/tools/run-command.ts
 import { spawn } from "child_process";
-import fs11 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path8 from "path";
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1e3;
 var MAX_TIMEOUT_MS = 10 * 60 * 1e3;
 var MAX_OUTPUT_BYTES2 = 50 * 1024;
@@ -4002,9 +3979,9 @@ async function executeRunCommand(args, signal) {
   if (!command.trim()) {
     return "Error: command is required.";
   }
-  const workdir = args.workdir ? path9.isAbsolute(args.workdir) ? args.workdir : path9.resolve(args.workdir) : process.cwd();
+  const workdir = args.workdir ? path8.isAbsolute(args.workdir) ? args.workdir : path8.resolve(args.workdir) : process.cwd();
   try {
-    const stat = await fs11.stat(workdir);
+    const stat = await fs9.stat(workdir);
     if (!stat.isDirectory()) {
       return `Error: workdir is not a directory: ${workdir}`;
     }
@@ -4128,142 +4105,6 @@ ${stderr}${stderrTruncated ? `
   });
 }
 
-// src/lib/agent/tools/fetch-url.ts
-import { load as loadCheerio } from "cheerio";
-var MAX_RESPONSE_BYTES = 512 * 1024;
-var DEFAULT_TIMEOUT_MS2 = 3e4;
-var MAX_TIMEOUT_MS2 = 12e4;
-var USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
-function htmlToText(html) {
-  const $ = loadCheerio(html);
-  $("script, style, noscript, nav, footer, header, aside, iframe, svg").remove();
-  const title = $("title").first().text().trim();
-  const mainEl = $("main").length > 0 ? $("main") : $("article").length > 0 ? $("article") : $("body");
-  const sections = [];
-  if (title) sections.push(`# ${title}
-`);
-  mainEl.find("h1, h2, h3, h4, h5, h6, p, li, td, th, blockquote, pre, dd, dt, figcaption").each((_, el) => {
-    const tag = el.tagName?.toLowerCase() ?? "";
-    const text = $(el).text().replace(/\s+/g, " ").trim();
-    if (!text) return;
-    if (tag === "h1") sections.push(`
-# ${text}`);
-    else if (tag === "h2") sections.push(`
-## ${text}`);
-    else if (tag === "h3") sections.push(`
-### ${text}`);
-    else if (tag.startsWith("h")) sections.push(`
-#### ${text}`);
-    else if (tag === "li") sections.push(`- ${text}`);
-    else if (tag === "blockquote") sections.push(`> ${text}`);
-    else if (tag === "pre") sections.push(`\`\`\`
-${text}
-\`\`\``);
-    else sections.push(text);
-  });
-  if (sections.length <= 1) {
-    const bodyText = mainEl.text().replace(/\s+/g, " ").trim();
-    if (title) return `# ${title}
-
-${bodyText}`;
-    return bodyText;
-  }
-  return sections.join("\n");
-}
-async function executeFetchUrl(args, signal) {
-  const url = args.url.trim();
-  if (!url) return "Error: url is required.";
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return `Error: Invalid URL: ${url}`;
-  }
-  if (!["http:", "https:"].includes(parsed.protocol)) {
-    return `Error: Only http and https URLs are supported.`;
-  }
-  const timeout = Math.min(
-    Math.max(args.timeout ?? DEFAULT_TIMEOUT_MS2, 5e3),
-    MAX_TIMEOUT_MS2
-  );
-  const format = args.format ?? "text";
-  const timeoutController = new AbortController();
-  const timer = setTimeout(() => timeoutController.abort(), timeout);
-  const combinedSignal = signal ? AbortSignal.any([signal, timeoutController.signal]) : timeoutController.signal;
-  try {
-    let response = await fetch(url, {
-      headers: { "User-Agent": USER_AGENT, Accept: "text/html,application/json,text/plain,*/*" },
-      redirect: "follow",
-      signal: combinedSignal
-    });
-    if (response.status === 403 && response.headers.get("cf-mitigated") === "challenge") {
-      response = await fetch(url, {
-        headers: { "User-Agent": "open-research-cli/0.1", Accept: "text/html,application/json,text/plain,*/*" },
-        redirect: "follow",
-        signal: combinedSignal
-      });
-    }
-    if (!response.ok) {
-      return `Error: HTTP ${response.status} ${response.statusText}`;
-    }
-    const finalUrl = response.url;
-    const redirectNote = finalUrl && finalUrl !== url ? `(Redirected to: ${finalUrl})
-
-` : "";
-    const contentType = response.headers.get("content-type") ?? "";
-    if (contentType.includes("image/") || contentType.includes("audio/") || contentType.includes("video/") || contentType.includes("application/octet-stream") || contentType.includes("application/zip")) {
-      const length = response.headers.get("content-length");
-      return `${redirectNote}Binary content: ${contentType}${length ? ` (${(Number(length) / 1024).toFixed(1)} KB)` : ""}. Use run_command with curl to download.`;
-    }
-    const reader = response.body?.getReader();
-    if (!reader) return "Error: No response body.";
-    const chunks = [];
-    let totalBytes = 0;
-    let truncated = false;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (totalBytes + value.length > MAX_RESPONSE_BYTES) {
-        const remaining = MAX_RESPONSE_BYTES - totalBytes;
-        if (remaining > 0) chunks.push(value.subarray(0, remaining));
-        totalBytes = MAX_RESPONSE_BYTES;
-        truncated = true;
-        reader.cancel();
-        break;
-      }
-      chunks.push(value);
-      totalBytes += value.length;
-    }
-    const raw = new TextDecoder().decode(
-      chunks.length === 1 ? chunks[0] : Buffer.concat(chunks)
-    );
-    const truncSuffix = truncated ? "\n\n(Response truncated to 512 KB)" : "";
-    if (contentType.includes("application/json")) {
-      try {
-        const obj = JSON.parse(raw);
-        return redirectNote + JSON.stringify(obj, null, 2) + truncSuffix;
-      } catch {
-      }
-    }
-    if (contentType.includes("text/html")) {
-      if (format === "html") {
-        return redirectNote + raw + truncSuffix;
-      }
-      const text = htmlToText(raw);
-      return redirectNote + text + truncSuffix;
-    }
-    return redirectNote + raw + truncSuffix;
-  } catch (err) {
-    if (signal?.aborted) return "Fetch aborted by user.";
-    if (err instanceof Error && err.name === "AbortError") {
-      return `Fetch timed out after ${(timeout / 1e3).toFixed(0)}s.`;
-    }
-    return `Fetch error: ${err instanceof Error ? err.message : String(err)}`;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 // src/lib/agent/tools/ask-user.ts
 var pendingQuestions = [];
 function getPendingQuestion() {
@@ -4549,8 +4390,8 @@ function executeCreatePaper(args, ctx) {
 }
 
 // src/lib/agent/tools/read-pdf.ts
-import path10 from "path";
-import fs12 from "fs/promises";
+import path9 from "path";
+import fs10 from "fs/promises";
 var MAX_OUTPUT_BYTES3 = 5e4;
 function parsePages(pages) {
   const range = pages.match(/^(\d+)\s*-\s*(\d+)$/);
@@ -4560,8 +4401,8 @@ function parsePages(pages) {
   return null;
 }
 async function executeReadPdf(args) {
-  const resolved = path10.resolve(args.file_path);
-  const stat = await fs12.stat(resolved).catch(() => null);
+  const resolved = path9.resolve(args.file_path);
+  const stat = await fs10.stat(resolved).catch(() => null);
   if (!stat || !stat.isFile()) {
     return `Error: file not found: ${resolved}`;
   }
@@ -5381,6 +5222,7 @@ function normalizeArxivPaper(paper) {
     title: paper.title,
     url: sourceUrl ?? pdfUrl ?? "",
     pdfUrl,
+    abstract: paper.summary?.trim() || void 0,
     publishedDate: normalizeDatePrefix(paper.published),
     author: paper.authors[0],
     provider: "arxiv",
@@ -5662,11 +5504,14 @@ async function discoverScholarlySources({
 }
 
 // src/lib/agent/search-external-sources.ts
-async function executeSearchExternalSources(args, ctx) {
+async function executeSearchExternalSources(args, ctx, provider) {
   const searches = args.searches ?? [];
   if (searches.length === 0) {
     return { result: "Error: no search queries provided.", sources: [] };
   }
+  if (!args.target) {
+    return { result: "Error: target is required. Specify what information you need from the papers.", sources: [] };
+  }
   const primary = searches[0];
   const variations = searches.slice(1).map((item) => item.query);
   const config = await loadOpenResearchConfig().catch(() => null);
@@ -5678,16 +5523,74 @@ async function executeSearchExternalSources(args, ctx) {
     semanticScholarApiKey: getSemanticScholarApiKey(config),
     openAlexApiKey: getOpenAlexApiKey(config)
   });
-  const summary = results.map((result, index) => `${index + 1}. ${result.title} [${result.provider}] ${result.url}`).join("\n");
+  if (results.length === 0) {
+    return { result: "No papers found.", sources: [] };
+  }
+  if (!provider) {
+    const summary = results.map((r, i) => `${i + 1}. ${r.title} [${r.provider}] ${r.url}`).join("\n");
+    return { result: summary || "No papers found.", sources: results };
+  }
+  const contentResults = await Promise.allSettled(
+    results.map(async (source2) => {
+      if (source2.abstract) {
+        return { source: source2, text: source2.abstract };
+      }
+      if (source2.pdfUrl) {
+        const content = await fetchAndParseContent(source2.pdfUrl);
+        if (content) return { source: source2, text: content.text };
+      }
+      if (source2.url) {
+        const content = await fetchAndParseContent(source2.url);
+        if (content) return { source: source2, text: content.text };
+      }
+      return null;
+    })
+  );
+  const extractionInputs = [];
+  const sourceMap = /* @__PURE__ */ new Map();
+  for (const result of contentResults) {
+    if (result.status === "fulfilled" && result.value) {
+      const { source: source2, text } = result.value;
+      extractionInputs.push({
+        title: source2.title,
+        content: text,
+        url: source2.url,
+        target: args.target
+      });
+      sourceMap.set(source2.url, source2);
+    }
+  }
+  if (extractionInputs.length === 0) {
+    const summary = results.map((r, i) => `${i + 1}. ${r.title} [${r.provider}] ${r.url}`).join("\n");
+    return {
+      result: `Could not fetch content from any papers. Metadata only:
+${summary}`,
+      sources: results
+    };
+  }
+  const extractions = await extractBatch(extractionInputs, provider);
+  const extracted = [];
+  for (const [url, extraction] of extractions) {
+    const source2 = sourceMap.get(url);
+    if (source2 && extraction.relevanceScore >= 2) {
+      extracted.push({
+        title: source2.title,
+        url: source2.url,
+        provider: source2.provider,
+        extraction
+      });
+    }
+  }
+  const formatted = formatExtractionResults(extracted);
   return {
-    result: summary || "No external sources found.",
+    result: formatted,
     sources: results
   };
 }
 
 // src/lib/skills/runtime.ts
-import fs13 from "fs/promises";
-import path11 from "path";
+import fs11 from "fs/promises";
+import path10 from "path";
 import matter2 from "gray-matter";
 async function loadRuntimeSkillByName(input2) {
   const skills2 = await listAvailableSkills({ homeDir: input2.homeDir });
@@ -5695,7 +5598,7 @@ async function loadRuntimeSkillByName(input2) {
   if (!match) {
     return null;
   }
-  const raw = await fs13.readFile(path11.join(match.skillDir, "SKILL.md"), "utf8");
+  const raw = await fs11.readFile(path10.join(match.skillDir, "SKILL.md"), "utf8");
   const parsed = matter2(raw);
   return {
     id: match.name,
@@ -5706,8 +5609,8 @@ async function loadRuntimeSkillByName(input2) {
   };
 }
 async function readSkillReferenceFile(skillDir, referencePath) {
-  const fullPath = path11.join(skillDir, "references", referencePath);
-  return fs13.readFile(fullPath, "utf8");
+  const fullPath = path10.join(skillDir, "references", referencePath);
+  return fs11.readFile(fullPath, "utf8");
 }
 
 // src/lib/agent/subagent/configs.ts
@@ -5912,8 +5815,8 @@ function describeSubAgentTool(name, args) {
 }
 
 // src/lib/agent/tools/tasks.ts
-import path12 from "path";
-import fs14 from "fs/promises";
+import path11 from "path";
+import fs12 from "fs/promises";
 var tasks = [];
 var storePath = null;
 function shortId() {
@@ -5923,12 +5826,12 @@ async function persist() {
   if (!storePath) return;
   const live = tasks.filter((t) => t.status !== "deleted");
   const tmpPath = storePath + ".tmp";
-  await fs14.mkdir(path12.dirname(storePath), { recursive: true });
-  await fs14.writeFile(tmpPath, JSON.stringify({ version: 1, tasks: live }, null, 2));
-  await fs14.rename(tmpPath, storePath);
+  await fs12.mkdir(path11.dirname(storePath), { recursive: true });
+  await fs12.writeFile(tmpPath, JSON.stringify({ version: 1, tasks: live }, null, 2));
+  await fs12.rename(tmpPath, storePath);
 }
 async function initTaskStore(workspaceDir) {
-  storePath = path12.join(workspaceDir, ".open-research", "tasks.json");
+  storePath = path11.join(workspaceDir, ".open-research", "tasks.json");
   const data = await readJsonFile(storePath, { version: 1, tasks: [] });
   tasks = data.tasks ?? [];
 }
@@ -6051,10 +5954,19 @@ async function executeTool(name, args, ctx, activeSkills, homeDir, signal, provi
     case "search_external_sources": {
       const out = await executeSearchExternalSources(
         args,
-        ctx
+        ctx,
+        provider
       );
       return { result: out.result, searchResults: out.sources };
     }
+    case "web_search": {
+      const { executeWebSearch } = await import("./web-search-B7D5WMHU.js");
+      const out = await executeWebSearch(
+        args,
+        provider
+      );
+      return { result: out.result };
+    }
     // ── User Interaction ────────────────────────────────────────────────
     case "ask_user":
       return {
@@ -6122,6 +6034,28 @@ ${meta}` };
       return {
         result: executeUpdateTask(args)
       };
+    // ── Ontology ──────────────────────────────────────────────────────────
+    case "query_ontology": {
+      if (!provider) {
+        return { result: "Error: query_ontology requires an LLM provider." };
+      }
+      const { runQueryAgent } = await import("./query-agent-LRUUJR4F.js");
+      const workspaceDir = ctx.workspaceDir ?? process.cwd();
+      const answer = await runQueryAgent({
+        query: String(args.query ?? ""),
+        scope: args.scope ? String(args.scope) : void 0,
+        provider,
+        workspaceDir
+      });
+      return { result: answer };
+    }
+    case "ontology_status": {
+      const { loadOntology } = await import("./store-LT5EGDOI.js");
+      const { getOntologyStatus } = await import("./status-GEEAGLPF.js");
+      const workspaceDir = ctx.workspaceDir ?? process.cwd();
+      const ontology = await loadOntology(workspaceDir);
+      return { result: getOntologyStatus(ontology) };
+    }
     default:
       return { result: `Unknown tool: "${name}"` };
   }
@@ -6381,17 +6315,17 @@ async function manualCompact(messages, model, provider, usage, customInstruction
 }
 
 // src/lib/memory/store.ts
-import fs15 from "fs/promises";
-import path13 from "path";
+import fs13 from "fs/promises";
+import path12 from "path";
 function getGlobalMemoryFile(options) {
-  return path13.join(getOpenResearchRoot(options), "memory.json");
+  return path12.join(getOpenResearchRoot(options), "memory.json");
 }
 function getProjectMemoryFile(workspaceDir) {
-  return path13.join(workspaceDir, ".open-research", "memory.json");
+  return path12.join(workspaceDir, ".open-research", "memory.json");
 }
 async function loadMemoryFile(filePath) {
   try {
-    const raw = await fs15.readFile(filePath, "utf8");
+    const raw = await fs13.readFile(filePath, "utf8");
     const store = JSON.parse(raw);
     return store.memories ?? [];
   } catch {
@@ -6399,9 +6333,9 @@ async function loadMemoryFile(filePath) {
   }
 }
 async function saveMemoryFile(filePath, memories) {
-  await fs15.mkdir(path13.dirname(filePath), { recursive: true });
+  await fs13.mkdir(path12.dirname(filePath), { recursive: true });
   const store = { version: 2, memories };
-  await fs15.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
+  await fs13.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 async function loadGlobalMemories(options) {
   const mems = await loadMemoryFile(getGlobalMemoryFile(options));
@@ -6437,7 +6371,7 @@ function evictIfNeeded(memories) {
   memories.length = MAX_MEMORIES_PER_STORE;
 }
 async function addMemory(memory, options) {
-  const scope = memory.scope ?? (memory.category === "project" || memory.category === "context" ? "project" : "global");
+  const scope = memory.scope ?? (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);
@@ -6630,12 +6564,17 @@ CRITICAL RULES:
 - Maximum 3 actions per exchange
 - If nothing meaningful to remember, return an empty array
 
+IMPORTANT \u2014 what NOT to store as memories:
+- Research findings, claims, hypotheses, evidence, or source details \u2014 these belong in the ontology, not memory
+- Specific paper results, data points, or analytical conclusions \u2014 ontology handles these
+- Connections between findings, contradictions, or evidence chains \u2014 ontology handles these
+Memory is for WHO the researcher is and HOW they work. The ontology handles WHAT they know.
+
 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)
+- "preference" \u2014 tools, citation style, writing preferences (\u2192 stored globally)
+- "methodology" \u2014 statistical approaches, frameworks, analytical habits (\u2192 stored globally)
+- "context" \u2014 deadlines, collaborators, target venues, project constraints (\u2192 stored per-project)
 
 Existing memories:
 {EXISTING_MEMORIES}
@@ -6681,7 +6620,7 @@ 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) && ["create", "update"].includes(item.action)) {
+      if (typeof item.content === "string" && item.content.length > 5 && ["user", "preference", "methodology", "context"].includes(item.category) && ["create", "update"].includes(item.action)) {
         valid.push({
           action: item.action,
           content: item.content,
@@ -6716,7 +6655,7 @@ async function extractAndStoreMemories(input2) {
         results.push(saved);
       }
     } else {
-      const scope = action.category === "project" || action.category === "context" ? "project" : "global";
+      const scope = action.category === "context" ? "project" : "global";
       const saved = await addMemory(
         { content: action.content, category: action.category, scope },
         { homeDir: input2.homeDir, workspaceDir: input2.workspaceDir }
@@ -6728,18 +6667,18 @@ async function extractAndStoreMemories(input2) {
 }
 
 // src/lib/workspace/agents-md.ts
-import fs16 from "fs/promises";
-import path14 from "path";
+import fs14 from "fs/promises";
+import path13 from "path";
 var AGENTS_MD_FILENAME = "AGENTS.md";
 async function readAgentsMd(workspaceDir) {
   try {
-    return await fs16.readFile(path14.join(workspaceDir, AGENTS_MD_FILENAME), "utf8");
+    return await fs14.readFile(path13.join(workspaceDir, AGENTS_MD_FILENAME), "utf8");
   } catch {
     return "";
   }
 }
 async function writeAgentsMd(workspaceDir, content) {
-  await fs16.writeFile(path14.join(workspaceDir, AGENTS_MD_FILENAME), content, "utf8");
+  await fs14.writeFile(path13.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.
 
@@ -6817,7 +6756,14 @@ var TOOL_DESCRIPTIONS = {
       return `Fetching URL`;
     }
   },
-  search_external_sources: () => "Searching academic papers",
+  search_external_sources: (a) => {
+    const target = a.target;
+    return target ? `Searching papers: "${target.slice(0, 50)}"` : "Searching academic papers";
+  },
+  web_search: (a) => {
+    const query = a.query;
+    return `Web search: "${query?.slice(0, 50) ?? ""}"`;
+  },
   ask_user: (a) => `Asking: ${a.question?.slice(0, 50) ?? "question"}`,
   load_skill: (a) => `Loading skill: ${a.skill_id ?? ""}`,
   read_skill_reference: (a) => `Reading skill reference: ${a.path ?? ""}`,
@@ -6884,8 +6830,9 @@ ${skill.prompt}`).join("\n\n");
     "- `read_file` / `list_directory` / `search_workspace` \u2014 explore and read",
     "- `run_command` \u2014 execute python, R, node, LaTeX, curl, git, etc.",
     "- `write_new_file` / `update_existing_file` \u2014 create and edit workspace files",
-    "- `search_external_sources` \u2014 search OpenAlex, Semantic Scholar, arXiv",
-    "- `fetch_url` \u2014 fetch web pages and API responses",
+    "- `search_external_sources` \u2014 search academic papers and extract evidence for/against a target (arXiv, Semantic Scholar, OpenAlex)",
+    "- `web_search` \u2014 search the web and extract evidence for/against a target (docs, blogs, datasets, news)",
+    "- `fetch_url` \u2014 fetch a specific URL when you already know the address",
     "- `ask_user` \u2014 ask clarifying questions when genuinely needed",
     "- `load_skill` \u2014 activate specialized research workflows",
     "- `launch_subagent` \u2014 delegate exploration to a lightweight sub-agent that runs on its own context window",
@@ -6944,11 +6891,28 @@ async function runAgentTurn(input2) {
   const memoryBlock = formatMemoriesForPrompt(relevantMemories);
   const agentsMd = input2.workspace.workspaceDir ? await readAgentsMd(input2.workspace.workspaceDir).catch(() => "") : "";
   const taskBlock = getTaskContextBlock();
+  let ontologyBlock = null;
+  if (input2.workspace.workspaceDir) {
+    try {
+      const { loadOntology } = await import("./store-LT5EGDOI.js");
+      const { runRelevanceAgent } = await import("./relevance-agent-CCN7JGTM.js");
+      const { buildScaffoldingContext } = await import("./scaffolding-MSAICMWV.js");
+      const ontology = await loadOntology(input2.workspace.workspaceDir);
+      const relevantIds = await runRelevanceAgent({
+        userMessage: input2.message,
+        ontology,
+        provider: input2.provider
+      });
+      ontologyBlock = buildScaffoldingContext(ontology, relevantIds);
+    } catch {
+    }
+  }
   const fullSystemPrompt = [
     systemPrompt,
     memoryBlock || null,
     agentsMd ? `## Project Context (from AGENTS.md)
 ${agentsMd}` : null,
+    ontologyBlock || null,
     taskBlock || null
   ].filter(Boolean).join("\n\n");
   let messages = [
@@ -6958,6 +6922,7 @@ ${agentsMd}` : null,
   ];
   const proposedUpdates = [];
   const searchResults = [];
+  const collectedToolOutputs = [];
   const signal = input2.signal;
   for (; ; ) {
     if (signal?.aborted) break;
@@ -7030,6 +6995,22 @@ ${agentsMd}` : null,
         }).catch(() => {
         });
       }
+      if (input2.workspace.workspaceDir) {
+        import("./manager-queue-F4VVZMTE.js").then(({ enqueueOntologyManager }) => {
+          enqueueOntologyManager({
+            userMessage: input2.message,
+            agentResponse: fullText,
+            toolOutputs: collectedToolOutputs,
+            sessionId: "",
+            // optional tracking
+            turnIndex: 0,
+            provider: input2.provider,
+            workspaceDir: input2.workspace.workspaceDir,
+            onOntologyUpdated: input2.onOntologyUpdated
+          });
+        }).catch(() => {
+        });
+      }
       return {
         text: fullText,
         proposedUpdates,
@@ -7137,6 +7118,11 @@ ${agentsMd}` : null,
           tool_call_id: toolCall.id,
           content: result.result
         });
+        collectedToolOutputs.push({
+          tool: toolCall.name,
+          input: toolCall.arguments,
+          output: result.result
+        });
       }
     }
   }
@@ -7169,8 +7155,8 @@ function classifyUpdateRisk(update) {
 }
 
 // src/lib/workspace/apply-update.ts
-import fs17 from "fs/promises";
-import path15 from "path";
+import fs15 from "fs/promises";
+import path14 from "path";
 function resolveRelativePath(update) {
   if (update.key.startsWith("path:")) {
     return update.key.slice(5);
@@ -7191,9 +7177,9 @@ function resolveRelativePath(update) {
 }
 async function applyProposedUpdate(workspaceDir, update) {
   const relativePath = resolveRelativePath(update);
-  const absolutePath = path15.join(workspaceDir, relativePath);
-  await fs17.mkdir(path15.dirname(absolutePath), { recursive: true });
-  await fs17.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;
 }
 
@@ -7411,15 +7397,15 @@ function SessionPicker({ sessions, onSelect, onCancel }) {
 }
 
 // src/lib/cli/update-check.ts
-import fs18 from "fs/promises";
-import path16 from "path";
+import fs16 from "fs/promises";
+import path15 from "path";
 import os3 from "os";
 var PACKAGE_NAME = "open-research";
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
-var STATE_FILE = path16.join(os3.homedir(), ".open-research", "update-check.json");
+var STATE_FILE = path15.join(os3.homedir(), ".open-research", "update-check.json");
 async function readState() {
   try {
-    const raw = await fs18.readFile(STATE_FILE, "utf8");
+    const raw = await fs16.readFile(STATE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       lastCheck: typeof parsed.lastCheck === "number" ? parsed.lastCheck : 0,
@@ -7431,8 +7417,8 @@ async function readState() {
   }
 }
 async function writeState(state) {
-  await fs18.mkdir(path16.dirname(STATE_FILE), { recursive: true });
-  await fs18.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
+  await fs16.mkdir(path15.dirname(STATE_FILE), { recursive: true });
+  await fs16.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
 }
 function getCurrentVersion() {
   return getPackageVersion();
@@ -7506,6 +7492,7 @@ var SLASH_COMMANDS = [
   { name: "doctor", aliases: [], description: "Diagnose auth, connectivity, and tool availability", category: "system" },
   { name: "preview", aliases: [], description: "Live preview a LaTeX file in browser (e.g. /preview papers/draft.tex)", category: "workspace" },
   { name: "memory", aliases: ["/memories"], description: "View or clear stored memories about you", category: "system" },
+  { name: "ontology", aliases: ["/onto"], description: "View or manage the research ontology", category: "workspace" },
   { name: "exit", aliases: ["/quit", "/q"], description: "Exit Open Research", category: "system" }
 ];
 function matchSlashCommand(input2) {
@@ -7524,7 +7511,8 @@ function matchSlashCommand(input2) {
 var SUBCOMMAND_HINTS = {
   "api-keys": [
     { name: "api-keys semantic-scholar <key>", description: "Set your Semantic Scholar API key" },
-    { name: "api-keys openalex <key>", description: "Set your OpenAlex API key" }
+    { name: "api-keys openalex <key>", description: "Set your OpenAlex API key" },
+    { name: "api-keys brave <key>", description: "Set Brave Search API key for better web search" }
   ],
   "config": [
     { name: "config theme dark|light", description: "Set color theme" },
@@ -8048,60 +8036,64 @@ function HomeScreen({
   hasWorkspace,
   fileCount,
   skillCount,
+  version,
+  model,
+  contextWindow,
+  workspacePath,
   width
 }) {
   const theme = useTheme();
   const contentWidth = resolveWidth(width);
   const bodyWidth = indentedWidth(contentWidth);
+  const ctxLabel = contextWindow >= 1e3 ? `${Math.round(contextWindow / 1e3)}k` : String(contextWindow);
+  const shortPath = workspacePath ? workspacePath.replace(process.env.HOME ?? "", "~") : process.cwd().replace(process.env.HOME ?? "", "~");
   return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginBottom: 1, width: contentWidth, children: [
-    /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginBottom: 1, width: contentWidth, children: [
+    /* @__PURE__ */ jsxs3(Box4, { width: contentWidth, children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.accent, children: "\u26A1 " }),
       /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.accent, children: "Open Research" }),
-      /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "Local-first research agent" })
-    ] }),
-    !hasAuth && /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: contentWidth, children: [
-      /* @__PURE__ */ jsxs3(Box4, { width: contentWidth, children: [
-        /* @__PURE__ */ jsxs3(Text4, { color: theme.warning, children: [
-          GUTTER.pending,
-          " "
-        ] }),
-        /* @__PURE__ */ jsx4(Text4, { color: theme.warning, children: "Connect or add OpenAI credentials to get started" })
+      /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, children: [
+        " v",
+        version
       ] }),
-      /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: "/config apikey sk-...  \xB7  /auth \u2014 browser login  \xB7  /auth-codex \u2014 import existing session" }) })
-    ] }),
-    hasAuth && !hasWorkspace && /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: contentWidth, children: [
-      /* @__PURE__ */ jsxs3(Box4, { width: contentWidth, children: [
-        /* @__PURE__ */ jsxs3(Text4, { color: theme.secondary, children: [
-          GUTTER.success,
-          " "
-        ] }),
-        /* @__PURE__ */ jsx4(Text4, { color: theme.secondary, children: "Connected" })
+      /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: " | " }),
+      /* @__PURE__ */ jsxs3(Text4, { color: theme.text, children: [
+        "\u25C6 ",
+        model
       ] }),
+      /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: " | " }),
+      /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, children: [
+        ctxLabel,
+        " context"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box4, { marginLeft: 2, width: bodyWidth, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: shortPath }),
+      hasWorkspace && /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+        " \xB7 ",
+        fileCount,
+        " files \xB7 ",
+        skillCount,
+        " skills"
+      ] })
+    ] }),
+    !hasAuth && /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginTop: 1, width: contentWidth, children: [
       /* @__PURE__ */ jsxs3(Box4, { width: contentWidth, children: [
         /* @__PURE__ */ jsxs3(Text4, { color: theme.warning, children: [
           GUTTER.pending,
           " "
         ] }),
-        /* @__PURE__ */ jsx4(Text4, { color: theme.warning, children: "Create a workspace to begin" })
+        /* @__PURE__ */ jsx4(Text4, { color: theme.warning, children: "Connect OpenAI to get started" })
       ] }),
-      /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: "/init \u2014 initialize in current directory" }) })
+      /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: "/config apikey sk-...  \xB7  /auth  \xB7  /auth-codex" }) })
     ] }),
-    hasAuth && hasWorkspace && /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: contentWidth, children: [
-      /* @__PURE__ */ jsxs3(Box4, { width: contentWidth, children: [
-        /* @__PURE__ */ jsxs3(Text4, { color: theme.secondary, children: [
-          GUTTER.active,
-          " "
-        ] }),
-        /* @__PURE__ */ jsx4(Text4, { color: theme.secondary, children: "Ready" }),
-        /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
-          " \u2014 ",
-          fileCount,
-          " files \xB7 ",
-          skillCount,
-          " skills"
-        ] })
+    hasAuth && !hasWorkspace && /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginTop: 1, width: contentWidth, children: /* @__PURE__ */ jsxs3(Box4, { width: contentWidth, children: [
+      /* @__PURE__ */ jsxs3(Text4, { color: theme.warning, children: [
+        GUTTER.pending,
+        " "
       ] }),
-      /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: "Ask a question, @mention a file, or /help for commands" }) })
-    ] })
+      /* @__PURE__ */ jsx4(Text4, { color: theme.warning, children: "Run /init to create a workspace" })
+    ] }) }),
+    hasAuth && hasWorkspace && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, width: contentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "Ask a question, @mention a file, or type /help" }) })
   ] });
 }
 function SuggestionDropdown({
@@ -8339,8 +8331,8 @@ function useTerminalWidth() {
 import { startTransition } from "react";
 
 // src/lib/workspace/init-agents-md.ts
-import fs19 from "fs/promises";
-import path17 from "path";
+import fs17 from "fs/promises";
+import path16 from "path";
 var IGNORED_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -8379,18 +8371,18 @@ async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
   const results = [];
   if (depth > maxDepth) return results;
   try {
-    const entries = await fs19.readdir(dir, { withFileTypes: true });
+    const entries = await fs17.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 = path17.join(dir, entry.name);
-      const relativePath = path17.relative(dir, fullPath);
+      const fullPath = path16.join(dir, entry.name);
+      const relativePath = path16.relative(dir, 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);
+        const stat = await fs17.stat(fullPath).catch(() => null);
         results.push({ path: relativePath, size: stat?.size ?? 0, isDir: false });
       }
     }
@@ -8402,7 +8394,7 @@ async function readKeyFiles(dir) {
   const contents = {};
   for (const name of INTERESTING_FILES) {
     try {
-      const content = await fs19.readFile(path17.join(dir, name), "utf8");
+      const content = await fs17.readFile(path16.join(dir, name), "utf8");
       contents[name] = content.slice(0, 2e3);
     } catch {
     }
@@ -8488,8 +8480,8 @@ ${scanData.slice(0, 25e3)}`;
 
 // src/lib/preview/server.ts
 import http2 from "http";
-import fs20 from "fs";
-import path18 from "path";
+import fs18 from "fs";
+import path17 from "path";
 
 // src/lib/preview/latex-to-html.ts
 function latexToHtml(latex) {
@@ -8756,11 +8748,11 @@ var HTML_TEMPLATE = `<!DOCTYPE html>
 </body>
 </html>`;
 function startPreviewServer(texPath) {
-  const resolved = path18.resolve(texPath);
+  const resolved = path17.resolve(texPath);
   let currentHash = "";
   function getContentHash() {
     try {
-      const content = fs20.readFileSync(resolved, "utf8");
+      const content = fs18.readFileSync(resolved, "utf8");
       return `${content.length}-${content.slice(0, 100)}-${content.slice(-100)}`;
     } catch {
       return "error";
@@ -8768,7 +8760,7 @@ function startPreviewServer(texPath) {
   }
   function renderPage() {
     try {
-      const latex = fs20.readFileSync(resolved, "utf8");
+      const latex = fs18.readFileSync(resolved, "utf8");
       const htmlContent = latexToHtml(latex);
       currentHash = getContentHash();
       return HTML_TEMPLATE.replace("{{CONTENT}}", htmlContent);
@@ -8942,7 +8934,7 @@ async function executeSlashCommand(cmd, args, ctx) {
         addSystemMessage("No workspace. Run /init first.");
         break;
       }
-      const { listSessions: listSessions2 } = await import("./sessions-FMB5GHSR.js");
+      const { listSessions: listSessions2 } = await import("./sessions-GRES2MUV.js");
       const foundSessions = await listSessions2(workspacePath);
       if (foundSessions.length === 0) {
         addSystemMessage("No previous sessions found.");
@@ -9164,8 +9156,8 @@ async function executeSlashCommand(cmd, args, ctx) {
     }
     case "export": {
       const fileName = args?.trim() || "conversation-export.md";
-      const path21 = __require("path");
-      const exportPath = path21.resolve(workspacePath ?? process.cwd(), fileName);
+      const path20 = __require("path");
+      const exportPath = path20.resolve(workspacePath ?? process.cwd(), fileName);
       const lines = [`# Open Research \u2014 Conversation Export
 `];
       for (const msg of messages) {
@@ -9215,23 +9207,27 @@ ${msg.text}
       if (!args) {
         const ssKey = getSemanticScholarApiKey(config);
         const oaKey = getOpenAlexApiKey(config);
+        const braveKey = getBraveApiKey(config);
         addSystemMessage("API Keys:");
         addSystemMessage(`  Semantic Scholar: ${ssKey ? ssKey.slice(0, 8) + "..." : "not set"}`);
         addSystemMessage(`  OpenAlex: ${oaKey ? oaKey.slice(0, 8) + "..." : "not set"}`);
+        addSystemMessage(`  Brave Search: ${braveKey ? braveKey.slice(0, 8) + "..." : "not set (using DuckDuckGo)"}`);
         addSystemMessage("");
         addSystemMessage("Set via CLI:");
         addSystemMessage("  /api-keys semantic-scholar YOUR_KEY");
         addSystemMessage("  /api-keys openalex YOUR_KEY");
+        addSystemMessage("  /api-keys brave YOUR_KEY");
         addSystemMessage("");
         addSystemMessage("Or set environment variables:");
         addSystemMessage("  export SEMANTIC_SCHOLAR_API_KEY=your_key");
         addSystemMessage("  export OPENALEX_API_KEY=your_key");
+        addSystemMessage("  export BRAVE_API_KEY=your_key");
         break;
       }
       const [keyName, ...keyParts] = args.split(/\s+/);
       const keyValue = keyParts.join("").trim();
       if (!keyValue) {
-        addSystemMessage("Usage: /api-keys <semantic-scholar|openalex> <key>");
+        addSystemMessage("Usage: /api-keys <semantic-scholar|openalex|brave> <key>");
         break;
       }
       if (config) {
@@ -9240,8 +9236,10 @@ ${msg.text}
           apiKeys.semanticScholar = keyValue;
         } else if (keyName === "openalex" || keyName === "oa") {
           apiKeys.openAlex = keyValue;
+        } else if (keyName === "brave") {
+          apiKeys.brave = keyValue;
         } else {
-          addSystemMessage(`Unknown key: ${keyName}. Use semantic-scholar or openalex.`);
+          addSystemMessage(`Unknown key: ${keyName}. Use semantic-scholar, openalex, or brave.`);
           break;
         }
         const updated = { ...config, apiKeys };
@@ -9260,8 +9258,10 @@ ${msg.text}
       addSystemMessage(`  Skills: ${skills2.length} loaded`);
       const ssKey = getSemanticScholarApiKey(config);
       const oaKey = getOpenAlexApiKey(config);
+      const brKey = getBraveApiKey(config);
       addSystemMessage(`  Semantic Scholar API: ${ssKey ? "configured" : "not set (rate-limited)"}`);
       addSystemMessage(`  OpenAlex API: ${oaKey ? "configured" : "not set (limited)"}`);
+      addSystemMessage(`  Brave Search API: ${brKey ? "configured" : "not set (using DuckDuckGo)"}`);
       const mems = await loadAllMemories({ homeDir });
       addSystemMessage(`  Memories: ${mems.length} stored`);
       addSystemMessage(`  Node: ${process.version}`);
@@ -9329,6 +9329,76 @@ ${msg.text}
       }
       break;
     }
+    case "ontology": {
+      const workspaceDir = workspacePath;
+      if (!workspaceDir) {
+        addSystemMessage("No workspace. Run /init first.");
+        break;
+      }
+      const { loadOntology, saveOntology } = await import("./store-LT5EGDOI.js");
+      const ontology = await loadOntology(workspaceDir);
+      if (!args) {
+        const { getOntologyStatus } = await import("./status-GEEAGLPF.js");
+        addSystemMessage(getOntologyStatus(ontology));
+      } else if (args === "claims") {
+        const { formatClaims } = await import("./status-GEEAGLPF.js");
+        addSystemMessage(formatClaims(ontology));
+      } else if (args === "conflicts") {
+        const { formatConflicts } = await import("./status-GEEAGLPF.js");
+        addSystemMessage(formatConflicts(ontology));
+      } else if (args.startsWith("around ")) {
+        const term = args.slice(7).trim();
+        if (!term) {
+          addSystemMessage("Usage: /ontology around <term>");
+          break;
+        }
+        const { searchNotes, getConnections } = await import("./read-tools-GHBKBZFE.js");
+        const results = searchNotes(ontology, { queries: [term], limit: 5 });
+        if (results.length === 0) {
+          addSystemMessage(`No notes found matching "${term}".`);
+        } else {
+          for (const note of results) {
+            addSystemMessage(`[${note.id.slice(0, 8)}] "${note.content}" (${note.kind}, ${note.confidence})`);
+            const { connected } = getConnections(ontology, note.id, 1);
+            for (const conn of connected) {
+              const edge = note.edges.find((e) => e.targetId === conn.id);
+              const rel = edge ? `${edge.relation} \u2192` : "\u2190 connected";
+              addSystemMessage(`  ${rel} [${conn.id.slice(0, 8)}] "${conn.content}" (${conn.kind})`);
+            }
+          }
+        }
+      } else if (args.startsWith("delete ")) {
+        const noteId = args.slice(7).trim();
+        const note = ontology.notes.find((n) => n.id.startsWith(noteId));
+        if (!note) {
+          addSystemMessage(`Note not found: ${noteId}`);
+        } else {
+          ontology.notes = ontology.notes.filter((n) => n.id !== note.id);
+          for (const n of ontology.notes) {
+            n.edges = n.edges.filter((e) => e.targetId !== note.id);
+          }
+          await saveOntology(ontology, workspaceDir);
+          addSystemMessage(`Deleted note [${note.id.slice(0, 8)}] "${note.content}" and its edges.`);
+        }
+      } else if (args.startsWith("edit ")) {
+        const noteId = args.slice(5).trim();
+        const note = ontology.notes.find((n) => n.id.startsWith(noteId));
+        if (!note) {
+          addSystemMessage(`Note not found: ${noteId}`);
+        } else {
+          addSystemMessage(`Note [${note.id.slice(0, 8)}]:`);
+          addSystemMessage(`  Kind: ${note.kind}`);
+          addSystemMessage(`  Content: "${note.content}"`);
+          addSystemMessage(`  Confidence: ${note.confidence}`);
+          addSystemMessage(`  Edges: ${note.edges.length}`);
+          addSystemMessage("");
+          addSystemMessage('To edit, use the agent: "Update the ontology note about ..."');
+        }
+      } else {
+        addSystemMessage("Usage: /ontology [claims|conflicts|around <term>|delete <id>|edit <id>]");
+      }
+      break;
+    }
     case "exit": {
       exitApp();
       break;
@@ -9353,7 +9423,8 @@ var TOOL_GROUPS = {
   create_paper: "created paper",
   read_skill_reference: "read",
   create_tasks: "tasks",
-  update_task: "tasks"
+  update_task: "tasks",
+  web_search: "web searched"
 };
 function buildToolSummary(tools) {
   const groups = {};
@@ -9377,8 +9448,9 @@ function buildToolSummary(tools) {
   if (groups["created paper"]) parts.push("Created paper");
   if (groups["sub-agent"]) parts.push(`Ran ${groups["sub-agent"]} sub-agent${groups["sub-agent"] > 1 ? "s" : ""}`);
   if (groups["tasks"]) parts.push(`Updated tasks`);
+  if (groups["web searched"]) parts.push(`Web searched${groups["web searched"] > 1 ? ` (${groups["web searched"]}\xD7)` : ""}`);
   for (const [group, count] of Object.entries(groups)) {
-    if (!["read", "listed", "searched", "searched papers", "ran", "wrote", "edited", "fetched", "asked user", "loaded skill", "created paper", "sub-agent", "tasks"].includes(group)) {
+    if (!["read", "listed", "searched", "searched papers", "ran", "wrote", "edited", "fetched", "asked user", "loaded skill", "created paper", "sub-agent", "tasks", "web searched"].includes(group)) {
       parts.push(`${group} (${count})`);
     }
   }
@@ -10237,6 +10309,10 @@ ${error.stack}` : String(error)}` }
         hasWorkspace,
         fileCount: workspaceFiles.length,
         skillCount: skills2.length,
+        version: getPackageVersion(),
+        model: config?.defaults.model ?? "gpt-5.4",
+        contextWindow: getContextWindow(config?.defaults.model ?? "gpt-5.4"),
+        workspacePath,
         width: contentWidth
       }
     ),
@@ -10350,7 +10426,7 @@ ${error.stack}` : String(error)}` }
         statusParts,
         statusColor,
         tokenDisplay,
-        workspaceName: hasWorkspace ? path19.basename(workspacePath) : process.cwd(),
+        workspaceName: hasWorkspace ? path18.basename(workspacePath) : process.cwd(),
         mode: agentMode,
         planningStatus: planningState.status
       }
@@ -10362,7 +10438,7 @@ ${error.stack}` : String(error)}` }
 var program = new Command();
 program.name("open-research").version(getPackageVersion()).description("Local-first research CLI powered by OpenAI account auth or API keys.").argument("[workspacePath]", "Optional workspace path to open").action(async (workspacePath) => {
   await ensureOpenResearchConfig();
-  const target = workspacePath ? path20.resolve(workspacePath) : process.cwd();
+  const target = workspacePath ? path19.resolve(workspacePath) : process.cwd();
   const project = await loadWorkspaceProject(target);
   const hasProvider = await hasConfiguredProvider();
   render(
@@ -10379,7 +10455,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 = path20.resolve(workspacePath ?? process.cwd());
+  const target = path19.resolve(workspacePath ?? process.cwd());
   const project = await initWorkspace({ workspaceDir: target });
   console.log(`Initialized workspace: ${target}`);
   console.log(`Title: ${project.title}`);
@@ -10451,8 +10527,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 = path20.join(getOpenResearchSkillsDir(), name);
-  openInEditor(path20.join(skillDir, "SKILL.md"));
+  const skillDir = path19.join(getOpenResearchSkillsDir(), name);
+  openInEditor(path19.join(skillDir, "SKILL.md"));
   const validation = await validateSkillDirectory({ skillDir });
   if (!validation.ok) {
     console.error(validation.errors.join("\n"));
@@ -10463,9 +10539,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 ? path20.isAbsolute(nameOrPath) ? nameOrPath : path20.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
+  const skillDir = nameOrPath ? path19.isAbsolute(nameOrPath) ? nameOrPath : path19.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
   const stat = await import("fs/promises").then(
-    (fs21) => fs21.stat(skillDir).catch(() => null)
+    (fs19) => fs19.stat(skillDir).catch(() => null)
   );
   if (!stat) {
     throw new Error(`Skill path not found: ${skillDir}`);