open-agents-ai 0.8.0 → 0.9.0

package/README.md

@@ -221,6 +221,29 @@ Create a `.open-agents.md` file in your project root to give the agent project-s
 
 Context files are merged from parent → child directories, so you can set global defaults at `~/.open-agents.md` and override per-project.
 
+### `.oa/` Project Directory
+
+Each project gets a `.oa/` directory (similar to `.claude/` for Claude Code) that persists artifacts across sessions:
+
+```
+.oa/
+├── config.json              # Per-project configuration overrides
+├── memory/                  # Persistent memory store
+│   └── {topic}.json         # Topic-based key-value memories
+├── index/                   # Cached codebase index
+│   ├── repo-profile.json    # Repository metadata
+│   ├── file-summaries.json  # Per-file purpose, exports, domain, risk
+│   ├── symbols.json         # Symbol table cache
+│   ├── graph.json           # Import/dependency graph
+│   └── meta.json            # Index metadata (timestamp, hash)
+├── context/                 # Auto-generated project context
+│   └── project-map.md       # Generated overview for system prompt
+└── history/                 # Session history
+    └── {session-id}.json    # Per-session task log
+```
+
+The agent auto-discovers `AGENTS.md`, `OA.md`, `CLAUDE.md`, and `README.md` from the project root and parent directories, injecting them into the system prompt for project-specific awareness.
+
 ### Smart Context Compaction
 
 When conversations exceed the context window, the agent compacts older messages while preserving:

package/dist/index.js

@@ -1827,12 +1827,18 @@ var init_memory_read = __esm({
         const key = args["key"];
         const start = performance.now();
         try {
-          const memoryDir = resolve6(this.workingDir, ".open-agents", "memory");
-          const topicFile = join3(memoryDir, `${topic}.json`);
-          let raw;
-          try {
-            raw = await readFile3(topicFile, "utf-8");
-          } catch {
+          const oaMemDir = resolve6(this.workingDir, ".oa", "memory");
+          const legacyMemDir = resolve6(this.workingDir, ".open-agents", "memory");
+          let raw = null;
+          for (const memoryDir of [oaMemDir, legacyMemDir]) {
+            const topicFile = join3(memoryDir, `${topic}.json`);
+            try {
+              raw = await readFile3(topicFile, "utf-8");
+              break;
+            } catch {
+            }
+          }
+          if (raw === null) {
             return {
               success: true,
               output: "(no memories found)",
@@ -1910,20 +1916,23 @@ var init_memory_write = __esm({
         const value = args["value"];
         const start = performance.now();
         try {
-          const memoryDir = resolve7(this.workingDir, ".open-agents", "memory");
-          await mkdir2(memoryDir, { recursive: true });
-          const topicFile = join4(memoryDir, `${topic}.json`);
-          let entries = {};
-          try {
-            const raw = await readFile4(topicFile, "utf-8");
-            entries = JSON.parse(raw);
-          } catch {
+          const oaMemDir = resolve7(this.workingDir, ".oa", "memory");
+          const legacyMemDir = resolve7(this.workingDir, ".open-agents", "memory");
+          for (const memoryDir of [oaMemDir, legacyMemDir]) {
+            await mkdir2(memoryDir, { recursive: true });
+            const topicFile = join4(memoryDir, `${topic}.json`);
+            let entries = {};
+            try {
+              const raw = await readFile4(topicFile, "utf-8");
+              entries = JSON.parse(raw);
+            } catch {
+            }
+            entries[key] = {
+              value,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            await writeFile3(topicFile, JSON.stringify(entries, null, 2), "utf-8");
           }
-          entries[key] = {
-            value,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          await writeFile3(topicFile, JSON.stringify(entries, null, 2), "utf-8");
           return {
             success: true,
             output: `Stored memory: ${topic}.${key}`,
@@ -6463,6 +6472,18 @@ Use screenshot to capture visual state for debugging UI issues.
 - Keep tool calls focused \u2014 read only what you need
 - You MUST call task_complete when the task is done
 
+## Project Awareness
+
+Your system prompt is dynamically enriched with project context. Before each task:
+- AGENTS.md, OA.md, CLAUDE.md, and README.md are auto-discovered and loaded
+- The .oa/ directory stores per-project artifacts (memory, index, session history)
+- Git state (branch, dirty files, recent commits) is injected
+- Persistent memories from previous sessions are loaded
+- Recent session history shows what was worked on before
+
+When working in a new project, use codebase_map first to orient yourself.
+Store important discoveries with memory_write for future sessions.
+
 ## Self-Learning
 
 When you encounter an unfamiliar API, language feature, or runtime behavior:
@@ -6689,7 +6710,7 @@ ${result.output}`;
             });
             if (/task.?complete|all tests pass/i.test(content)) {
               completed = true;
-              summary = content.slice(0, 200);
+              summary = content;
               break;
             }
             messages.push({
@@ -7061,8 +7082,11 @@ function renderTaskComplete(summary, turns, toolCalls, durationMs) {
 ${c2.green("\u2714")} ${c2.bold("Task completed")} ${c2.dim(`(${turns} turns, ${toolCalls} tool calls, ${duration})`)}
 `);
   if (summary) {
-    process.stdout.write(`  ${summary}
+    const lines = summary.split("\n");
+    for (const line of lines) {
+      process.stdout.write(`  ${line}
 `);
+    }
   }
   process.stdout.write("\n");
 }
@@ -7519,17 +7543,17 @@ async function handleUpdate() {
   try {
     const { createRequire: createRequire3 } = await import("node:module");
     const { fileURLToPath: fileURLToPath2 } = await import("node:url");
-    const { dirname: dirname4, join: join20 } = await import("node:path");
-    const { existsSync: existsSync13 } = await import("node:fs");
+    const { dirname: dirname4, join: join21 } = await import("node:path");
+    const { existsSync: existsSync14 } = await import("node:fs");
     const req = createRequire3(import.meta.url);
     const thisDir = dirname4(fileURLToPath2(import.meta.url));
     const candidates = [
-      join20(thisDir, "..", "package.json"),
-      join20(thisDir, "..", "..", "package.json"),
-      join20(thisDir, "..", "..", "..", "package.json")
+      join21(thisDir, "..", "package.json"),
+      join21(thisDir, "..", "..", "package.json"),
+      join21(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync13(pkgPath)) {
+      if (existsSync14(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -7981,40 +8005,326 @@ var init_setup = __esm({
   }
 });
 
-// packages/cli/dist/tui/project-context.js
-import { existsSync as existsSync9, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
-import { join as join14, basename as basename2 } from "node:path";
-import { execSync as execSync9 } from "node:child_process";
-import { homedir as homedir4, platform, release } from "node:os";
-function loadProjectFiles(repoRoot) {
-  const sections = [];
+// packages/cli/dist/tui/oa-directory.js
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
+import { join as join14, relative as relative2, basename as basename2, extname as extname4 } from "node:path";
+function initOaDirectory(repoRoot) {
+  const oaPath = join14(repoRoot, OA_DIR);
+  for (const sub of SUBDIRS) {
+    mkdirSync4(join14(oaPath, sub), { recursive: true });
+  }
+  return oaPath;
+}
+function hasOaDirectory(repoRoot) {
+  return existsSync9(join14(repoRoot, OA_DIR, "index"));
+}
+function discoverContextFiles(repoRoot, maxContentLen = 8e3) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
   let dir = repoRoot;
   const visited = /* @__PURE__ */ new Set();
   while (dir && !visited.has(dir)) {
     visited.add(dir);
-    for (const name of CONTEXT_FILE_NAMES) {
+    for (const name of CONTEXT_FILES) {
       const filePath = join14(dir, name);
-      if (existsSync9(filePath)) {
+      const normalizedName = name.toLowerCase();
+      if (existsSync9(filePath) && !seen.has(filePath)) {
+        seen.add(filePath);
         try {
-          const content = readFileSync7(filePath, "utf-8").trim();
-          if (content) {
-            const relativePath = dir === repoRoot ? name : `${dir}/${name}`;
-            sections.push(`# Project Context (${relativePath})
-
-${content}`);
+          let content = readFileSync7(filePath, "utf-8");
+          if (content.length > maxContentLen) {
+            content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
           }
+          const type = normalizedName.includes("agents") ? "agents" : normalizedName === "oa.md" || normalizedName === ".open-agents.md" ? "oa" : normalizedName.includes("claude") ? "claude" : normalizedName.includes("readme") ? "readme" : normalizedName.includes("architect") ? "architecture" : normalizedName.includes("contribut") ? "contributing" : "other";
+          found.push({
+            path: relative2(repoRoot, filePath) || name,
+            content,
+            type
+          });
         } catch {
         }
       }
     }
+    const projectMap = join14(dir, OA_DIR, "context", "project-map.md");
+    if (existsSync9(projectMap) && !seen.has(projectMap)) {
+      seen.add(projectMap);
+      try {
+        let content = readFileSync7(projectMap, "utf-8");
+        if (content.length > maxContentLen) {
+          content = content.slice(0, maxContentLen) + "\n\n...(truncated)";
+        }
+        found.push({
+          path: relative2(repoRoot, projectMap),
+          content,
+          type: "oa"
+        });
+      } catch {
+      }
+    }
     const parent = join14(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
   }
-  sections.reverse();
+  const priority = {
+    agents: 0,
+    oa: 1,
+    claude: 2,
+    architecture: 3,
+    contributing: 4,
+    readme: 5,
+    other: 6
+  };
+  found.sort((a, b) => (priority[a.type] ?? 6) - (priority[b.type] ?? 6));
+  return found;
+}
+function readIndexMeta(repoRoot) {
+  const metaPath = join14(repoRoot, OA_DIR, "index", "meta.json");
+  try {
+    return JSON.parse(readFileSync7(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function generateProjectMap(repoRoot) {
+  const sections = [];
+  const repoName2 = basename2(repoRoot);
+  sections.push(`# Project Map: ${repoName2}
+`);
+  sections.push(`> Auto-generated by open-agents. Updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+`);
+  const manifests = detectManifests(repoRoot);
+  if (manifests.length > 0) {
+    sections.push(`## Project Type
+`);
+    for (const m of manifests) {
+      sections.push(`- ${m.type}: \`${m.file}\``);
+      if (m.name)
+        sections[sections.length - 1] += ` (${m.name})`;
+    }
+    sections.push("");
+  }
+  const tree = buildDirTree(repoRoot, 2);
+  if (tree) {
+    sections.push(`## Directory Structure
+
+\`\`\`
+${tree}\`\`\`
+`);
+  }
+  const keyFiles = findKeyFiles(repoRoot);
+  if (keyFiles.length > 0) {
+    sections.push(`## Key Files
+`);
+    for (const f of keyFiles) {
+      sections.push(`- \`${f.path}\` \u2014 ${f.description}`);
+    }
+    sections.push("");
+  }
+  const meta = readIndexMeta(repoRoot);
+  if (meta && Object.keys(meta.languages).length > 0) {
+    sections.push(`## Languages
+`);
+    const sorted = Object.entries(meta.languages).sort((a, b) => b[1] - a[1]);
+    for (const [lang, count] of sorted.slice(0, 8)) {
+      sections.push(`- ${lang}: ${count} files`);
+    }
+    sections.push("");
+  }
+  const content = sections.join("\n");
+  const contextDir = join14(repoRoot, OA_DIR, "context");
+  mkdirSync4(contextDir, { recursive: true });
+  writeFileSync4(join14(contextDir, "project-map.md"), content, "utf-8");
+  return content;
+}
+function saveSession(repoRoot, session) {
+  const historyDir = join14(repoRoot, OA_DIR, "history");
+  mkdirSync4(historyDir, { recursive: true });
+  writeFileSync4(join14(historyDir, `${session.id}.json`), JSON.stringify(session, null, 2), "utf-8");
+}
+function loadRecentSessions(repoRoot, limit = 5) {
+  const historyDir = join14(repoRoot, OA_DIR, "history");
+  if (!existsSync9(historyDir))
+    return [];
+  try {
+    const files = readdirSync4(historyDir).filter((f) => f.endsWith(".json")).map((f) => {
+      const stat3 = statSync5(join14(historyDir, f));
+      return { file: f, mtime: stat3.mtimeMs };
+    }).sort((a, b) => b.mtime - a.mtime).slice(0, limit);
+    return files.map((f) => {
+      try {
+        return JSON.parse(readFileSync7(join14(historyDir, f.file), "utf-8"));
+      } catch {
+        return null;
+      }
+    }).filter((s) => s !== null);
+  } catch {
+    return [];
+  }
+}
+function detectManifests(repoRoot) {
+  const manifests = [];
+  const checks = [
+    { file: "package.json", type: "Node.js", nameField: "name" },
+    { file: "pyproject.toml", type: "Python" },
+    { file: "Cargo.toml", type: "Rust" },
+    { file: "go.mod", type: "Go" },
+    { file: "pom.xml", type: "Java (Maven)" },
+    { file: "build.gradle", type: "Java (Gradle)" },
+    { file: "Gemfile", type: "Ruby" },
+    { file: "composer.json", type: "PHP" },
+    { file: "pnpm-workspace.yaml", type: "pnpm Monorepo" },
+    { file: "lerna.json", type: "Lerna Monorepo" },
+    { file: "Dockerfile", type: "Docker" },
+    { file: "docker-compose.yml", type: "Docker Compose" },
+    { file: "docker-compose.yaml", type: "Docker Compose" }
+  ];
+  for (const check of checks) {
+    const filePath = join14(repoRoot, check.file);
+    if (existsSync9(filePath)) {
+      let name;
+      if (check.nameField) {
+        try {
+          const data = JSON.parse(readFileSync7(filePath, "utf-8"));
+          name = data[check.nameField];
+        } catch {
+        }
+      }
+      manifests.push({ file: check.file, type: check.type, name });
+    }
+  }
+  return manifests;
+}
+function findKeyFiles(repoRoot) {
+  const keyFiles = [];
+  const checks = [
+    { pattern: "package.json", description: "Node.js project manifest" },
+    { pattern: "tsconfig.json", description: "TypeScript configuration" },
+    { pattern: ".eslintrc.json", description: "ESLint configuration" },
+    { pattern: ".prettierrc", description: "Prettier configuration" },
+    { pattern: "vitest.config.ts", description: "Vitest test config" },
+    { pattern: "jest.config.js", description: "Jest test config" },
+    { pattern: "Makefile", description: "Build automation" },
+    { pattern: ".github/workflows", description: "GitHub Actions CI/CD" },
+    { pattern: ".gitlab-ci.yml", description: "GitLab CI/CD" },
+    { pattern: "Dockerfile", description: "Container definition" },
+    { pattern: ".env.example", description: "Environment template" },
+    { pattern: "AGENTS.md", description: "Agent instructions" },
+    { pattern: "OA.md", description: "Open Agents context" },
+    { pattern: "CLAUDE.md", description: "Claude Code context" }
+  ];
+  for (const check of checks) {
+    if (existsSync9(join14(repoRoot, check.pattern))) {
+      keyFiles.push({ path: check.pattern, description: check.description });
+    }
+  }
+  return keyFiles;
+}
+function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
+  if (depth > maxDepth)
+    return "";
+  let result = "";
+  try {
+    const entries = readdirSync4(root, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") || e.name === ".github").filter((e) => !SKIP_DIRS.has(e.name)).sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory())
+        return -1;
+      if (!a.isDirectory() && b.isDirectory())
+        return 1;
+      return a.name.localeCompare(b.name);
+    });
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const isLast = i === entries.length - 1;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      if (entry.isDirectory()) {
+        let fileCount = 0;
+        try {
+          fileCount = readdirSync4(join14(root, entry.name)).filter((f) => !f.startsWith(".")).length;
+        } catch {
+        }
+        result += `${prefix}${connector}${entry.name}/ (${fileCount})
+`;
+        result += buildDirTree(join14(root, entry.name), maxDepth, childPrefix, depth + 1);
+      } else if (depth < maxDepth) {
+        result += `${prefix}${connector}${entry.name}
+`;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var OA_DIR, SUBDIRS, CONTEXT_FILES, SKIP_DIRS;
+var init_oa_directory = __esm({
+  "packages/cli/dist/tui/oa-directory.js"() {
+    "use strict";
+    OA_DIR = ".oa";
+    SUBDIRS = ["memory", "index", "context", "history"];
+    CONTEXT_FILES = [
+      "AGENTS.md",
+      "OA.md",
+      ".open-agents.md",
+      "CLAUDE.md",
+      "README.md",
+      "ARCHITECTURE.md",
+      "CONTRIBUTING.md",
+      "AGENTS.md"
+    ];
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      "build",
+      ".next",
+      "__pycache__",
+      ".venv",
+      "venv",
+      "coverage",
+      ".nyc_output",
+      ".oa",
+      ".open-agents",
+      ".claude",
+      "vendor",
+      "target",
+      ".idea",
+      ".vscode"
+    ]);
+  }
+});
+
+// packages/cli/dist/tui/project-context.js
+import { existsSync as existsSync10, readFileSync as readFileSync8, readdirSync as readdirSync5 } from "node:fs";
+import { join as join15, basename as basename3 } from "node:path";
+import { execSync as execSync9 } from "node:child_process";
+import { homedir as homedir4, platform, release } from "node:os";
+function loadProjectFiles(repoRoot) {
+  const discovered = discoverContextFiles(repoRoot);
+  if (discovered.length === 0)
+    return "";
+  const sections = [];
+  for (const ctx of discovered) {
+    const header = ctx.type === "agents" ? "Agent Instructions" : ctx.type === "oa" ? "Open Agents Context" : ctx.type === "claude" ? "Project Instructions" : ctx.type === "architecture" ? "Architecture" : ctx.type === "contributing" ? "Contributing Guidelines" : ctx.type === "readme" ? "Project Overview" : "Additional Context";
+    sections.push(`# ${header} (${ctx.path})
+
+${ctx.content}`);
+  }
   return sections.join("\n\n---\n\n");
 }
+function loadProjectMap(repoRoot) {
+  if (!hasOaDirectory(repoRoot)) {
+    initOaDirectory(repoRoot);
+  }
+  const mapPath = join15(repoRoot, OA_DIR, "context", "project-map.md");
+  if (existsSync10(mapPath)) {
+    try {
+      const content = readFileSync8(mapPath, "utf-8");
+      return content;
+    } catch {
+    }
+  }
+  return generateProjectMap(repoRoot);
+}
 function getGitInfo(repoRoot) {
   try {
     execSync9("git rev-parse --is-inside-work-tree", { cwd: repoRoot, stdio: "pipe" });
@@ -8049,29 +8359,33 @@ ${log}`);
 }
 function loadMemoryContext(repoRoot) {
   const sections = [];
-  const projectMemDir = join14(repoRoot, ".open-agents", "memory");
-  const projectEntries = loadMemoryDir(projectMemDir, "project");
-  if (projectEntries)
-    sections.push(projectEntries);
-  const globalMemDir = join14(homedir4(), ".open-agents", "memory");
-  if (globalMemDir !== projectMemDir) {
-    const globalEntries = loadMemoryDir(globalMemDir, "global");
-    if (globalEntries)
-      sections.push(globalEntries);
-  }
+  const oaMemDir = join15(repoRoot, OA_DIR, "memory");
+  const oaEntries = loadMemoryDir(oaMemDir, "project");
+  if (oaEntries)
+    sections.push(oaEntries);
+  const legacyMemDir = join15(repoRoot, ".open-agents", "memory");
+  if (legacyMemDir !== oaMemDir && existsSync10(legacyMemDir)) {
+    const legacyEntries = loadMemoryDir(legacyMemDir, "project/legacy");
+    if (legacyEntries)
+      sections.push(legacyEntries);
+  }
+  const globalMemDir = join15(homedir4(), ".open-agents", "memory");
+  const globalEntries = loadMemoryDir(globalMemDir, "global");
+  if (globalEntries)
+    sections.push(globalEntries);
   return sections.join("\n\n");
 }
 function loadMemoryDir(memDir, scope) {
-  if (!existsSync9(memDir))
+  if (!existsSync10(memDir))
     return "";
   const lines = [];
   try {
-    const files = readdirSync4(memDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync5(memDir).filter((f) => f.endsWith(".json"));
     for (const file of files.slice(0, 10)) {
       try {
-        const raw = readFileSync7(join14(memDir, file), "utf-8");
+        const raw = readFileSync8(join15(memDir, file), "utf-8");
         const entries = JSON.parse(raw);
-        const topic = basename2(file, ".json");
+        const topic = basename3(file, ".json");
         const keys = Object.keys(entries);
         if (keys.length === 0)
           continue;
@@ -8089,6 +8403,21 @@ function loadMemoryDir(memDir, scope) {
   }
   return lines.join("\n");
 }
+function loadSessionHistory(repoRoot) {
+  const sessions = loadRecentSessions(repoRoot, 5);
+  if (sessions.length === 0)
+    return "";
+  const lines = ["Recent tasks in this project:"];
+  for (const s of sessions) {
+    const status = s.completed ? "completed" : "incomplete";
+    const date = s.startedAt.split("T")[0];
+    lines.push(`- [${date}] ${s.task.slice(0, 80)} (${status}, ${s.turns} turns)`);
+    if (s.summary) {
+      lines.push(`  Summary: ${s.summary.slice(0, 120)}`);
+    }
+  }
+  return lines.join("\n");
+}
 function getEnvironment(repoRoot) {
   const lines = [
     `Working directory: ${repoRoot}`,
@@ -8101,8 +8430,10 @@ function getEnvironment(repoRoot) {
 function buildProjectContext(repoRoot) {
   return {
     projectInstructions: loadProjectFiles(repoRoot),
+    projectMap: loadProjectMap(repoRoot),
     gitInfo: getGitInfo(repoRoot),
     memoryContext: loadMemoryContext(repoRoot),
+    sessionHistory: loadSessionHistory(repoRoot),
     environment: getEnvironment(repoRoot)
   };
 }
@@ -8117,6 +8448,11 @@ ${ctx.environment}`);
     sections.push(`## Git State
 
 ${ctx.gitInfo}`);
+  }
+  if (ctx.projectMap) {
+    sections.push(`## Project Map
+
+${ctx.projectMap}`);
   }
   if (ctx.projectInstructions) {
     sections.push(ctx.projectInstructions);
@@ -8127,36 +8463,35 @@ ${ctx.gitInfo}`);
 ${ctx.memoryContext}
 
 Use this context to avoid re-learning known patterns. Update with memory_write if you discover new insights.`);
+  }
+  if (ctx.sessionHistory) {
+    sections.push(`## Session History
+
+${ctx.sessionHistory}`);
   }
   return sections.join("\n\n");
 }
-var CONTEXT_FILE_NAMES;
 var init_project_context = __esm({
   "packages/cli/dist/tui/project-context.js"() {
     "use strict";
-    CONTEXT_FILE_NAMES = [
-      ".open-agents.md",
-      "AGENTS.md",
-      ".open-agents/context.md",
-      ".open-agents/instructions.md"
-    ];
+    init_oa_directory();
   }
 });
 
 // packages/cli/dist/tui/voice.js
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync8, unlinkSync } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync9, unlinkSync } from "node:fs";
+import { join as join16 } from "node:path";
 import { homedir as homedir5, tmpdir as tmpdir2, platform as platform2 } from "node:os";
 import { execSync as execSync10, spawn as nodeSpawn } from "node:child_process";
 import { createRequire } from "node:module";
 function modelDir(id) {
-  return join15(MODELS_DIR, id);
+  return join16(MODELS_DIR, id);
 }
 function modelOnnxPath(id) {
-  return join15(modelDir(id), "model.onnx");
+  return join16(modelDir(id), "model.onnx");
 }
 function modelConfigPath(id) {
-  return join15(modelDir(id), "config.json");
+  return join16(modelDir(id), "config.json");
 }
 function describeToolCall(toolName, args) {
   const path = args["path"];
@@ -8265,8 +8600,8 @@ var init_voice = __esm({
         configUrl: "https://raw.githubusercontent.com/robit-man/combine_overwatch_onnx/main/overwatch.onnx.json"
       }
     };
-    VOICE_DIR = join15(homedir5(), ".open-agents", "voice");
-    MODELS_DIR = join15(VOICE_DIR, "models");
+    VOICE_DIR = join16(homedir5(), ".open-agents", "voice");
+    MODELS_DIR = join16(VOICE_DIR, "models");
     VoiceEngine = class {
       enabled = false;
       modelId = "glados";
@@ -8386,7 +8721,7 @@ var init_voice = __esm({
         const audioData = result["output"].data;
         if (audioData.length === 0)
           return;
-        const wavPath = join15(tmpdir2(), `oa-voice-${Date.now()}.wav`);
+        const wavPath = join16(tmpdir2(), `oa-voice-${Date.now()}.wav`);
         this.writeWav(audioData, this.config.audio.sample_rate, wavPath);
         await this.playWav(wavPath);
         try {
@@ -8466,7 +8801,7 @@ var init_voice = __esm({
         buffer.write("data", 36);
         buffer.writeUInt32LE(dataSize, 40);
         Buffer.from(int16.buffer, int16.byteOffset, int16.byteLength).copy(buffer, 44);
-        writeFileSync4(path, buffer);
+        writeFileSync5(path, buffer);
       }
       // -------------------------------------------------------------------------
       // Audio playback (system default speakers)
@@ -8533,30 +8868,30 @@ var init_voice = __esm({
       async ensureRuntime() {
         if (this.ort)
           return;
-        mkdirSync4(VOICE_DIR, { recursive: true });
-        const pkgPath = join15(VOICE_DIR, "package.json");
+        mkdirSync5(VOICE_DIR, { recursive: true });
+        const pkgPath = join16(VOICE_DIR, "package.json");
         const expectedDeps = {
           "onnxruntime-node": "^1.21.0",
           "phonemizer": "^1.2.1"
         };
-        if (existsSync10(pkgPath)) {
+        if (existsSync11(pkgPath)) {
           try {
-            const existing = JSON.parse(readFileSync8(pkgPath, "utf8"));
+            const existing = JSON.parse(readFileSync9(pkgPath, "utf8"));
             if (!existing.dependencies?.["phonemizer"]) {
               existing.dependencies = { ...existing.dependencies, ...expectedDeps };
-              writeFileSync4(pkgPath, JSON.stringify(existing, null, 2));
+              writeFileSync5(pkgPath, JSON.stringify(existing, null, 2));
             }
           } catch {
           }
         }
-        if (!existsSync10(pkgPath)) {
-          writeFileSync4(pkgPath, JSON.stringify({
+        if (!existsSync11(pkgPath)) {
+          writeFileSync5(pkgPath, JSON.stringify({
             name: "open-agents-voice",
             private: true,
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire(join15(VOICE_DIR, "index.js"));
+        const voiceRequire = createRequire(join16(VOICE_DIR, "index.js"));
         try {
           this.ort = voiceRequire("onnxruntime-node");
         } catch {
@@ -8602,18 +8937,18 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
         const dir = modelDir(id);
         const onnxPath = modelOnnxPath(id);
         const configPath = modelConfigPath(id);
-        if (existsSync10(onnxPath) && existsSync10(configPath))
+        if (existsSync11(onnxPath) && existsSync11(configPath))
           return;
-        mkdirSync4(dir, { recursive: true });
-        if (!existsSync10(configPath)) {
+        mkdirSync5(dir, { recursive: true });
+        if (!existsSync11(configPath)) {
           renderInfo(`Downloading ${model.label} voice config...`);
           const configResp = await fetch(model.configUrl);
           if (!configResp.ok)
             throw new Error(`Failed to download config: HTTP ${configResp.status}`);
           const configText = await configResp.text();
-          writeFileSync4(configPath, configText);
+          writeFileSync5(configPath, configText);
         }
-        if (!existsSync10(onnxPath)) {
+        if (!existsSync11(onnxPath)) {
           renderInfo(`Downloading ${model.label} voice model (this may take a minute)...`);
           const onnxResp = await fetch(model.onnxUrl);
           if (!onnxResp.ok)
@@ -8637,7 +8972,7 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           }
           process.stdout.write("\r" + " ".repeat(60) + "\r");
           const fullBuffer = Buffer.concat(chunks);
-          writeFileSync4(onnxPath, fullBuffer);
+          writeFileSync5(onnxPath, fullBuffer);
           renderInfo(`${model.label} model downloaded (${formatBytes2(fullBuffer.length)}).`);
         }
       }
@@ -8649,10 +8984,10 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
           throw new Error("ONNX runtime not loaded");
         const onnxPath = modelOnnxPath(this.modelId);
         const configPath = modelConfigPath(this.modelId);
-        if (!existsSync10(onnxPath) || !existsSync10(configPath)) {
+        if (!existsSync11(onnxPath) || !existsSync11(configPath)) {
           throw new Error(`Model files not found for ${this.modelId}`);
         }
-        this.config = JSON.parse(readFileSync8(configPath, "utf8"));
+        this.config = JSON.parse(readFileSync9(configPath, "utf8"));
         renderInfo("Loading voice model...");
         this.session = await this.ort.InferenceSession.create(onnxPath, {
           executionProviders: ["cpu"],
@@ -8668,9 +9003,9 @@ Error: ${err instanceof Error ? err.message : String(err)}`);
 import * as readline2 from "node:readline";
 import { cwd } from "node:process";
 import { resolve as resolve11 } from "node:path";
-import { readFileSync as readFileSync9 } from "node:fs";
-import { existsSync as existsSync11 } from "node:fs";
-import { extname as extname4 } from "node:path";
+import { readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
+import { extname as extname5 } from "node:path";
 function adaptTool(tool) {
   return {
     name: tool.name,
@@ -8859,12 +9194,26 @@ function startTask(task, config, repoRoot, voice) {
         break;
     }
   });
+  const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const promise = runner.run(task, `Working directory: ${repoRoot}`).then((result) => {
     if (result.completed) {
       renderTaskComplete(result.summary, result.turns, result.toolCalls, result.durationMs);
     } else {
       renderTaskIncomplete(result.turns, result.toolCalls, result.durationMs);
     }
+    try {
+      saveSession(repoRoot, {
+        id: sessionId,
+        startedAt: new Date(Date.now() - result.durationMs).toISOString(),
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        task,
+        turns: result.turns,
+        toolCalls: result.toolCalls,
+        completed: result.completed,
+        summary: result.summary.slice(0, 500)
+      });
+    } catch {
+    }
   });
   return { runner, promise };
 }
@@ -8968,14 +9317,14 @@ ${c2.dim("Goodbye!")}
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync11(resolve11(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync12(resolve11(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
           const imgPath = resolve11(repoRoot, cleanPath);
-          const imgBuffer = readFileSync9(imgPath);
+          const imgBuffer = readFileSync10(imgPath);
           const base64 = imgBuffer.toString("base64");
-          const ext = extname4(cleanPath).toLowerCase();
+          const ext = extname5(cleanPath).toLowerCase();
           const mime = ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : "image/jpeg";
           activeTask.runner.injectImage(base64, mime, `User shared image: ${cleanPath}`);
           renderUserInterrupt(`[Image: ${cleanPath}]`);
@@ -9071,6 +9420,7 @@ var init_interactive = __esm({
     init_commands();
     init_setup();
     init_project_context();
+    init_oa_directory();
     init_render();
     init_voice();
     taskManager = new BackgroundTaskManager();
@@ -9108,7 +9458,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile8, stat as stat2 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join16, relative as relative2, extname as extname5, basename as basename3 } from "node:path";
+import { join as join17, relative as relative3, extname as extname6, basename as basename4 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -9152,7 +9502,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile8(join16(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile8(join17(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -9167,14 +9517,14 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join16(this.config.rootDir, relativePath);
+          const fullPath = join17(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat2(fullPath);
             if (fileStat.size > this.config.maxFileSize)
               continue;
             const content = await readFile8(fullPath);
             const hash = createHash("sha256").update(content).digest("hex");
-            const ext = extname5(relativePath);
+            const ext = extname6(relativePath);
             indexed.push({
               path: fullPath,
               relativePath,
@@ -9190,7 +9540,7 @@ var init_codebase_indexer = __esm({
       }
       buildTree(files) {
         const root = {
-          name: basename3(this.config.rootDir),
+          name: basename4(this.config.rootDir),
           path: this.config.rootDir,
           type: "directory",
           children: []
@@ -9213,7 +9563,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join16(current.path, part),
+                  path: join17(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -9288,17 +9638,17 @@ __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
 import { resolve as resolve12 } from "node:path";
-import { existsSync as existsSync12, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync13, statSync as statSync6 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
   const repoRoot = resolve12(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync12(repoRoot)) {
+  if (!existsSync13(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat3 = statSync5(repoRoot);
+  const stat3 = statSync6(repoRoot);
   if (!stat3.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
@@ -9540,7 +9890,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 async function configCommand(opts, config) {
   if (opts.subCommand === "set") {
@@ -9563,7 +9913,7 @@ function handleShow(opts, config) {
   printKeyValue("verbose", String(config.verbose), 2);
   printKeyValue("dbPath", config.dbPath, 2);
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join17(homedir6(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join18(homedir6(), ".open-agents", "config.json")})`);
   printSection("Environment Variables");
   printInfo("OPEN_AGENTS_BACKEND_URL  \u2014 override backendUrl");
   printInfo("OPEN_AGENTS_MODEL        \u2014 override model");
@@ -9795,8 +10145,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir3 } from "node:os";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join19 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -9917,9 +10267,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join18(tmpdir3(), `open-agents-eval-${Date.now()}`);
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync5(join18(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join19(tmpdir3(), `open-agents-eval-${Date.now()}`);
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync6(join19(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -9979,7 +10329,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname3, join as join19 } from "node:path";
+import { dirname as dirname3, join as join20 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -10086,7 +10436,7 @@ init_output();
 function getVersion() {
   try {
     const require2 = createRequire2(import.meta.url);
-    const pkgPath = join19(dirname3(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkgPath = join20(dirname3(fileURLToPath(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — Claude Code-style TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",