0agent 1.0.39 → 1.0.41

package/bin/0agent.js

@@ -278,7 +278,16 @@ async function runInit() {
     }
   }
 
-  // ── Step 3: Embedding ────────────────────────────────────────────────────
+  // ── Step 3: Workspace folder ─────────────────────────────────────────────
+  const defaultWorkspace = resolve(homedir(), '0agent-workspace');
+  console.log(`\n  \x1b[1mWorkspace folder\x1b[0m`);
+  console.log(`  \x1b[2mAll files the agent creates will go here. You own it.\x1b[0m`);
+  const wsRaw = await ask(`  Path [${defaultWorkspace}]: `);
+  const workspacePath = wsRaw.trim() || defaultWorkspace;
+  mkdirSync(workspacePath, { recursive: true });
+  console.log(`  \x1b[32m✓\x1b[0m  Workspace: \x1b[36m${workspacePath}\x1b[0m`);
+
+  // ── Step 4: Embedding ────────────────────────────────────────────────────
   const embIdx = await arrowSelect('Embeddings (for semantic memory search)?', [
     'Local via Ollama (nomic-embed-text) — free, private',
     'OpenAI text-embedding-3-small — cloud',
@@ -286,12 +295,12 @@ async function runInit() {
   ], 0);
   const embeddingProvider = ['nomic-ollama', 'openai', 'none'][embIdx];
 
-  // ── Step 4: Sandbox ──────────────────────────────────────────────────────
+  // ── Step 5: Sandbox ──────────────────────────────────────────────────────
   const sandboxes = detectSandboxes();
   const sandboxChoice = sandboxes[0] ?? 'process';
   console.log(`\n  Sandbox: \x1b[32m${sandboxChoice}\x1b[0m detected`);
 
-  // ── Step 5: Seed graph ───────────────────────────────────────────────────
+  // ── Step 6: Seed graph ───────────────────────────────────────────────────
   const seedIdx = await arrowSelect('Starting knowledge?', [
     'software-engineering — sprint workflow + 15 skills  ← recommended',
     'Start from scratch',
@@ -300,11 +309,12 @@ async function runInit() {
 
   // ── Summary ───────────────────────────────────────────────────────────────
   console.log('\n  \x1b[1mReady to launch\x1b[0m\n');
-  console.log(`  LLM:     \x1b[36m${providerKey}/${model}\x1b[0m`);
-  console.log(`  API Key: ${apiKey ? '\x1b[32m✓ set\x1b[0m (' + apiKey.slice(0, 8) + '••••)' : '\x1b[33mnot set\x1b[0m'}`);
-  console.log(`  Memory:  ${ghToken ? `\x1b[32mgithub.com/${ghOwner}/0agent-memory\x1b[0m` : '\x1b[2mlocal only\x1b[0m'}`);
-  console.log(`  Sandbox: \x1b[36m${sandboxChoice}\x1b[0m`);
-  console.log(`  Seed:    \x1b[36m${seedName ?? 'scratch'}\x1b[0m\n`);
+  console.log(`  LLM:       \x1b[36m${providerKey}/${model}\x1b[0m`);
+  console.log(`  API Key:   ${apiKey ? '\x1b[32m✓ set\x1b[0m (' + apiKey.slice(0, 8) + '••••)' : '\x1b[33mnot set\x1b[0m'}`);
+  console.log(`  Memory:    ${ghToken ? `\x1b[32mgithub.com/${ghOwner}/0agent-memory\x1b[0m` : '\x1b[2mlocal only\x1b[0m'}`);
+  console.log(`  Workspace: \x1b[36m${workspacePath}\x1b[0m`);
+  console.log(`  Sandbox:   \x1b[36m${sandboxChoice}\x1b[0m`);
+  console.log(`  Seed:      \x1b[36m${seedName ?? 'scratch'}\x1b[0m\n`);
 
   // Write config
   const dbPath    = resolve(AGENT_DIR, 'graph.db');
@@ -329,6 +339,9 @@ embedding:
 sandbox:
   backend: ${sandboxChoice}
 
+workspace:
+  path: "${workspacePath}"
+
 mcp_servers: []
 
 server:

package/bin/chat.js

@@ -879,6 +879,64 @@ async function _safeJsonFetch(url, opts) {
     console.log(`  ${fmt(C.yellow, '⚠')} LLM check failed: ${e.message}\n`);
   }
 
+  // ── Step 3: Workspace folder check ───────────────────────────────────────
+  // If no workspace is configured, ask the user to set one now.
+  // Then export memory (graph nodes) to that folder.
+  await (async () => {
+    const wsPath = cfg?.workspace?.path;
+    if (wsPath) {
+      // Already configured — just ensure the folder exists
+      try { mkdirSync(wsPath, { recursive: true }); } catch {}
+      return;
+    }
+
+    // No workspace configured — ask inline
+    const { homedir: hd } = await import('node:os');
+    const defaultWs = resolve(hd(), '0agent-workspace');
+
+    process.stdout.write(`\n  ${fmt(C.yellow, '⚠')} No workspace folder configured.\n`);
+    process.stdout.write(`  ${fmt(C.dim, 'The agent needs a folder to create and store files.')}\n\n`);
+
+    // Temporarily close readline so we can read a raw line
+    const wsInput = await new Promise((res) => {
+      process.stdout.write(`  ${fmt(C.bold, 'Workspace path')} ${fmt(C.dim, `[${defaultWs}]`)}: `);
+      rl.once('line', (line) => res(line.trim() || defaultWs));
+    });
+
+    const chosenPath = resolve(wsInput.replace(/^~/, hd()));
+    try {
+      mkdirSync(chosenPath, { recursive: true });
+      process.stdout.write(`  ${fmt(C.green, '✓')} Created: ${fmt(C.cyan, chosenPath)}\n`);
+    } catch (e) {
+      process.stdout.write(`  ${fmt(C.red, '✗')} Could not create folder: ${e.message}\n`);
+      return;
+    }
+
+    // Save workspace path to config
+    if (!cfg) cfg = {};
+    cfg.workspace = { path: chosenPath };
+    saveConfig(cfg);
+    process.stdout.write(`  ${fmt(C.green, '✓')} Workspace saved to config\n`);
+
+    // Export memory (graph nodes) to workspace as a JSON snapshot
+    try {
+      const nodesRes = await fetch(`${BASE_URL}/api/graph/nodes?limit=9999`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      if (nodesRes.ok) {
+        const nodes = await nodesRes.json();
+        const count = Array.isArray(nodes) ? nodes.length : 0;
+        if (count > 0) {
+          const exportPath = resolve(chosenPath, '.0agent-memory.json');
+          writeFileSync(exportPath, JSON.stringify({ exported_at: new Date().toISOString(), nodes }, null, 2), 'utf8');
+          process.stdout.write(`  ${fmt(C.green, '✓')} Memory exported: ${fmt(C.dim, `${count} nodes → .0agent-memory.json`)}\n`);
+        }
+      }
+    } catch {}
+
+    process.stdout.write('\n');
+  })();
+
   // ── Auto-update: check npm, update silently, restart ─────────────────────
   // Runs in background after prompt — never blocks startup.
   // If update found: counts down 3s (press any key to skip), then auto-installs.
@@ -935,8 +993,8 @@ async function _safeJsonFetch(url, opts) {
 })();
 
 // Restart using the GLOBAL install, not the npx cache that's currently running.
-// After `npm install -g 0agent@latest`, the new binary is in npm's global bin dir.
-// Using process.argv would re-run the OLD npx-cached file → infinite loop.
+// After `npm install -g 0agent@latest`, use `npm root -g` to find the module root.
+// `npm bin -g` is deprecated and unreliable — use the module root instead.
 async function restartWithLatest() {
   try {
     const { execSync: ex } = await import('node:child_process');
@@ -944,22 +1002,39 @@ async function restartWithLatest() {
     const { existsSync: ef } = await import('node:fs');
     const { spawn: sp } = await import('node:child_process');
 
-    // Find the global npm bin directory (e.g. ~/.nvm/.../bin or /usr/local/bin)
-    const globalBin = ex('npm bin -g 2>/dev/null || true', { encoding: 'utf8' }).trim().split('\n')[0];
-    const newBin = globalBin ? res(globalBin, '0agent') : null;
+    // npm root -g → e.g. /Users/sahil/.nvm/versions/node/v20/lib/node_modules
+    // The 0agent entry is at {root}/0agent/bin/0agent.js
+    let newBin = null;
+    try {
+      const npmRoot = ex('npm root -g 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
+      if (npmRoot) {
+        const candidate = res(npmRoot, '0agent', 'bin', '0agent.js');
+        if (ef(candidate)) newBin = candidate;
+      }
+    } catch {}
+
+    if (!newBin) {
+      // Fallback: npm prefix -g gives the prefix, bin is {prefix}/bin/0agent
+      try {
+        const prefix = ex('npm prefix -g 2>/dev/null', { encoding: 'utf8' }).trim().split('\n')[0];
+        // The script wrapper lives in {prefix}/bin; the actual JS is in lib/node_modules
+        const candidate = prefix ? res(prefix, 'lib', 'node_modules', '0agent', 'bin', '0agent.js') : null;
+        if (candidate && ef(candidate)) newBin = candidate;
+      } catch {}
+    }
 
-    let child;
-    if (newBin && ef(newBin)) {
-      // Run the freshly installed global script
-      child = sp(process.execPath, [newBin], { stdio: 'inherit' });
-    } else {
-      // Fallback: let the shell find 0agent in PATH
-      child = sp('0agent', [], { stdio: 'inherit', shell: true });
+    if (!newBin) {
+      // Cannot locate the new binary — exit so user restarts manually
+      process.stdout.write(`  ${fmt(C.dim, 'Restart manually: 0agent')}\n`);
+      process.exit(0);
+      return;
     }
+
+    const child = sp(process.execPath, [newBin], { stdio: 'inherit' });
     child.on('close', (code) => process.exit(code ?? 0));
     process.stdin.pause();
   } catch {
-    process.exit(0); // just exit; user can re-open
+    process.exit(0);
   }
 }
 

package/dist/daemon.mjs

@@ -2111,22 +2111,39 @@ var init_WebSearchCapability = __esm({
 });
 
 // packages/daemon/src/capabilities/BrowserCapability.ts
-import { spawnSync as spawnSync2, execSync as execSync2 } from "node:child_process";
+import { spawnSync as spawnSync2, execSync as execSync2, spawn } from "node:child_process";
+import { platform } from "node:os";
+function findSystemChrome() {
+  const candidates = platform() === "darwin" ? [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+  ] : platform() === "linux" ? ["google-chrome", "chromium-browser", "chromium", "microsoft-edge", "brave-browser"] : ["C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"];
+  for (const c of candidates) {
+    try {
+      execSync2(`test -f "${c}" 2>/dev/null || which "${c}" 2>/dev/null`, { stdio: "pipe" });
+      return c;
+    } catch {
+    }
+  }
+  return null;
+}
 var BrowserCapability;
 var init_BrowserCapability = __esm({
   "packages/daemon/src/capabilities/BrowserCapability.ts"() {
     "use strict";
     BrowserCapability = class {
       name = "browser_open";
-      description = "Open a URL in a real browser. Returns page content, can take screenshots. Use when scrape_url fails on JS-heavy pages.";
+      description = "Open a URL in the system browser or extract page content. Use when scrape_url fails on JS-heavy pages.";
       toolDefinition = {
         name: "browser_open",
-        description: "Open a URL in a real headless browser. Handles JavaScript-rendered pages, SPAs, login flows. Use when scrape_url fails.",
+        description: `Open or read a URL using the system browser. Use action="open" to launch the URL visibly in the user's default browser. Use action="read" (default) to extract page content headlessly. Use when scrape_url fails on JS-heavy pages.`,
         input_schema: {
           type: "object",
           properties: {
             url: { type: "string", description: "URL to open" },
-            action: { type: "string", description: 'What to do: "read" (default), "screenshot", "click <selector>", "fill <selector> <value>"' },
+            action: { type: "string", description: '"open" \u2014 launch in system browser (visible); "read" \u2014 extract text content (default); "screenshot" \u2014 take screenshot' },
             wait_for: { type: "string", description: "CSS selector to wait for before extracting content" },
             extract: { type: "string", description: "CSS selector to extract specific element text" }
           },
@@ -2142,23 +2159,27 @@ var init_BrowserCapability = __esm({
         if (!url.startsWith("http")) {
           return { success: false, output: "URL must start with http:// or https://", duration_ms: 0 };
         }
-        try {
-          const output = await this.playwrightFetch(url, action, waitFor, extract);
-          return { success: true, output, duration_ms: Date.now() - start };
-        } catch {
+        if (action === "open") {
+          return this.openInSystemBrowser(url, start);
+        }
+        const sysChromeExe = findSystemChrome();
+        if (sysChromeExe) {
+          try {
+            const output = await this.chromeFetch(sysChromeExe, url);
+            return { success: true, output, duration_ms: Date.now() - start };
+          } catch {
+          }
         }
         try {
-          const output = await this.chromeFetch(url);
-          return { success: true, output, fallback_used: "system-chrome", duration_ms: Date.now() - start };
+          const output = await this.playwrightFetch(url, action, waitFor, extract);
+          return { success: true, output, fallback_used: "playwright", duration_ms: Date.now() - start };
         } catch {
         }
         try {
           const res = await fetch(url, {
             headers: {
               "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0 Safari/537.36",
-              "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-              "Accept-Language": "en-US,en;q=0.9",
-              "Accept-Encoding": "gzip, deflate, br"
+              "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
             },
             signal: AbortSignal.timeout(15e3)
           });
@@ -2168,19 +2189,33 @@ var init_BrowserCapability = __esm({
         } catch (err) {
           return {
             success: false,
-            output: `Browser unavailable. Install Playwright: npx playwright install chromium`,
+            output: `Browser unavailable. No system Chrome/Chromium found and Playwright not installed.`,
             error: err instanceof Error ? err.message : String(err),
             duration_ms: Date.now() - start
           };
         }
       }
+      openInSystemBrowser(url, start) {
+        try {
+          const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+          spawn(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+          return { success: true, output: `Opened in default browser: ${url}`, duration_ms: Date.now() - start };
+        } catch (err) {
+          return { success: false, output: `Failed to open browser: ${err instanceof Error ? err.message : String(err)}`, duration_ms: Date.now() - start };
+        }
+      }
       async playwrightFetch(url, action, waitFor, extract) {
         const waitLine = waitFor ? `await p.waitForSelector('${waitFor}', { timeout: 8000 }).catch(() => {});` : "";
         const extractLine = extract ? `const text = await p.$eval('${extract}', el => el.innerText).catch(() => page_text);` : `const text = page_text;`;
         const script = `
       const { chromium } = require('playwright');
       (async () => {
-        const b = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
+        let b;
+        try {
+          b = await chromium.launch({ channel: 'chrome', headless: true, args: ['--no-sandbox'] });
+        } catch {
+          b = await chromium.launch({ headless: true, args: ['--no-sandbox'] });
+        }
         const p = await b.newPage();
         await p.setUserAgent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36');
         await p.goto('${url}', { waitUntil: 'domcontentloaded', timeout: 20000 });
@@ -2195,27 +2230,17 @@ var init_BrowserCapability = __esm({
         if (result.status !== 0) throw new Error(result.stderr || "Playwright failed");
         return result.stdout.trim();
       }
-      async chromeFetch(url) {
-        const candidates = [
-          "google-chrome",
-          "chromium-browser",
-          "chromium",
-          "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
-        ];
-        for (const chrome of candidates) {
-          try {
-            execSync2(`which "${chrome}" 2>/dev/null || test -f "${chrome}"`, { stdio: "pipe" });
-            const result = spawnSync2(chrome, ["--headless", "--no-sandbox", "--disable-gpu", "--dump-dom", url], {
-              timeout: 15e3,
-              encoding: "utf8"
-            });
-            if (result.status === 0 && result.stdout) {
-              return result.stdout.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 5e3);
-            }
-          } catch {
-          }
-        }
-        throw new Error("No system Chrome found");
+      async chromeFetch(executablePath, url) {
+        const result = spawnSync2(executablePath, [
+          "--headless=new",
+          "--no-sandbox",
+          "--disable-gpu",
+          "--disable-dev-shm-usage",
+          "--dump-dom",
+          url
+        ], { timeout: 15e3, encoding: "utf8" });
+        if (result.status !== 0 || !result.stdout) throw new Error("Chrome headless failed");
+        return result.stdout.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 5e3);
       }
     };
   }
@@ -2318,7 +2343,7 @@ else:
 });
 
 // packages/daemon/src/capabilities/ShellCapability.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 var ShellCapability;
 var init_ShellCapability = __esm({
   "packages/daemon/src/capabilities/ShellCapability.ts"() {
@@ -2362,7 +2387,7 @@ var init_ShellCapability = __esm({
               ...!success && { error: `exit ${code ?? signal}` }
             });
           };
-          const proc = spawn("bash", ["-c", command], {
+          const proc = spawn2("bash", ["-c", command], {
             cwd,
             env: { ...process.env, TERM: "dumb" }
             // DO NOT set `timeout` here — we manage it manually via timer
@@ -2406,14 +2431,14 @@ var init_FileCapability = __esm({
     "use strict";
     FileCapability = class {
       name = "file_op";
-      description = "Read, write, or list files. Scoped to working directory.";
+      description = "Read, write, list files, or create directories. Scoped to working directory.";
       toolDefinition = {
         name: "file_op",
-        description: "Read, write, or list files in the working directory.",
+        description: "Read, write, list files, or create directories in the working directory.",
         input_schema: {
           type: "object",
           properties: {
-            op: { type: "string", description: '"read", "write", or "list"' },
+            op: { type: "string", description: '"read", "write", "list", or "mkdir"' },
             path: { type: "string", description: "File or directory path (relative to cwd)" },
             content: { type: "string", description: "Content for write operation" }
           },
@@ -2448,7 +2473,11 @@ var init_FileCapability = __esm({
             const entries = readdirSync(safe, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => `${e.isDirectory() ? "d" : "f"}  ${e.name}`).join("\n");
             return { success: true, output: entries || "(empty)", duration_ms: Date.now() - start };
           }
-          return { success: false, output: `Unknown op: ${op}`, duration_ms: Date.now() - start };
+          if (op === "mkdir") {
+            mkdirSync(safe, { recursive: true });
+            return { success: true, output: `Directory created: ${rel}`, duration_ms: Date.now() - start };
+          }
+          return { success: false, output: `Unknown op: ${op}. Use "read", "write", "list", or "mkdir"`, duration_ms: Date.now() - start };
         } catch (err) {
           return { success: false, output: `Error: ${err instanceof Error ? err.message : String(err)}`, duration_ms: Date.now() - start };
         }
@@ -2457,6 +2486,74 @@ var init_FileCapability = __esm({
   }
 });
 
+// packages/daemon/src/capabilities/MemoryCapability.ts
+var MemoryCapability;
+var init_MemoryCapability = __esm({
+  "packages/daemon/src/capabilities/MemoryCapability.ts"() {
+    "use strict";
+    init_src();
+    MemoryCapability = class {
+      constructor(graph) {
+        this.graph = graph;
+      }
+      name = "memory_write";
+      description = "Persist a discovered fact to long-term memory so it survives across sessions.";
+      toolDefinition = {
+        name: "memory_write",
+        description: 'Write an important fact to long-term memory. Call this whenever you discover something worth remembering: URLs (ngrok, live servers), file paths, port numbers, API endpoints, configuration values, decisions made, or task outcomes. Examples: memory_write({label:"ngrok_url", content:"https://abc.ngrok.io", type:"url"}) or memory_write({label:"project_port", content:"3000", type:"config"})',
+        input_schema: {
+          type: "object",
+          properties: {
+            label: { type: "string", description: 'Short name for this fact (e.g. "ngrok_url", "project_port")' },
+            content: { type: "string", description: "The value to remember" },
+            type: { type: "string", description: 'Category: "url", "path", "config", "note", "outcome"' }
+          },
+          required: ["label", "content"]
+        }
+      };
+      async execute(input, _cwd) {
+        const label = String(input.label ?? "").trim();
+        const content = String(input.content ?? "").trim();
+        const type = String(input.type ?? "note").trim();
+        const start = Date.now();
+        if (!label || !content) {
+          return { success: false, output: "label and content are required", duration_ms: 0 };
+        }
+        try {
+          const nodeId = `memory:${label.toLowerCase().replace(/[^a-z0-9_]/g, "_")}`;
+          const existing = this.graph.getNode(nodeId);
+          if (existing) {
+            this.graph.updateNode(nodeId, {
+              label,
+              metadata: { ...existing.metadata, content, type, updated_at: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          } else {
+            const node = createNode({
+              id: nodeId,
+              graph_id: "root",
+              label,
+              type: "context" /* CONTEXT */,
+              metadata: { content, type, saved_at: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+            this.graph.addNode(node);
+          }
+          return {
+            success: true,
+            output: `Remembered: "${label}" = ${content.slice(0, 120)}${content.length > 120 ? "\u2026" : ""}`,
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          return {
+            success: false,
+            output: `Memory write failed: ${err instanceof Error ? err.message : String(err)}`,
+            duration_ms: Date.now() - start
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
 var CodespaceBrowserCapability_exports = {};
 __export(CodespaceBrowserCapability_exports, {
@@ -2541,6 +2638,7 @@ var init_CapabilityRegistry = __esm({
     init_ScraperCapability();
     init_ShellCapability();
     init_FileCapability();
+    init_MemoryCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
       /**
@@ -2553,7 +2651,7 @@ var init_CapabilityRegistry = __esm({
        * task_type: browser_task). The main agent does NOT have direct access
        * to browser_open without going through a subagent spawn.
        */
-      constructor(codespaceManager) {
+      constructor(codespaceManager, graph) {
         this.register(new WebSearchCapability());
         if (codespaceManager) {
           try {
@@ -2568,6 +2666,9 @@ var init_CapabilityRegistry = __esm({
         this.register(new ScraperCapability());
         this.register(new ShellCapability());
         this.register(new FileCapability());
+        if (graph) {
+          this.register(new MemoryCapability(graph));
+        }
       }
       register(cap) {
         this.capabilities.set(cap.name, cap);
@@ -2614,7 +2715,7 @@ var init_capabilities = __esm({
 });
 
 // packages/daemon/src/AgentExecutor.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "node:fs";
 import { resolve as resolve3, dirname as dirname2, relative } from "node:path";
 var SELF_MOD_PATTERN, AgentExecutor;
@@ -2633,7 +2734,7 @@ var init_AgentExecutor = __esm({
         this.maxIterations = config.max_iterations ?? 20;
         this.maxCommandMs = config.max_command_ms ?? 3e4;
         this.agentRoot = config.agent_root;
-        this.registry = new CapabilityRegistry();
+        this.registry = new CapabilityRegistry(void 0, config.graph);
       }
       cwd;
       maxIterations;
@@ -2658,23 +2759,39 @@ var init_AgentExecutor = __esm({
         for (let i = 0; i < this.maxIterations; i++) {
           this.onStep(i === 0 ? "Thinking\u2026" : "Continuing\u2026");
           let response;
-          try {
-            response = await this.llm.completeWithTools(
-              messages,
-              this.registry.getToolDefinitions(),
-              systemPrompt,
-              // Only stream tokens on the final (non-tool) turn
-              (token) => {
-                this.onToken(token);
-                finalOutput += token;
+          let llmFailed = false;
+          {
+            let llmRetry = 0;
+            while (true) {
+              try {
+                response = await this.llm.completeWithTools(
+                  messages,
+                  this.registry.getToolDefinitions(),
+                  systemPrompt,
+                  // Only stream tokens on the final (non-tool) turn
+                  (token) => {
+                    this.onToken(token);
+                    finalOutput += token;
+                  }
+                );
+                break;
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                const isTimeout = /timeout|AbortError|aborted/i.test(msg);
+                if (isTimeout && llmRetry < 2) {
+                  llmRetry++;
+                  this.onStep(`LLM timeout \u2014 retrying (${llmRetry}/2)\u2026`);
+                  await new Promise((r) => setTimeout(r, 2e3 * llmRetry));
+                  continue;
+                }
+                this.onStep(`LLM error: ${msg}`);
+                finalOutput = `Error: ${msg}`;
+                llmFailed = true;
+                break;
               }
-            );
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.onStep(`LLM error: ${msg}`);
-            finalOutput = `Error: ${msg}`;
-            break;
+            }
           }
+          if (llmFailed) break;
           totalTokens += response.tokens_used;
           modelName = response.model;
           if (response.stop_reason === "end_turn" || !response.tool_calls?.length) {
@@ -2755,7 +2872,7 @@ var init_AgentExecutor = __esm({
       shellExec(command, timeoutMs) {
         return new Promise((resolve15) => {
           const chunks = [];
-          const proc = spawn2("bash", ["-c", command], {
+          const proc = spawn3("bash", ["-c", command], {
             cwd: this.cwd,
             env: { ...process.env, TERM: "dumb" },
             timeout: timeoutMs
@@ -2889,6 +3006,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
       }
       buildSystemPrompt(extra, task) {
         const isSelfMod = !!(task && SELF_MOD_PATTERN.test(task));
+        const hasMemory = !!this.config.graph;
         const lines = [
           `You are 0agent, an AI software engineer. You can execute shell commands and manage files.`,
           `Working directory: ${this.cwd}`,
@@ -2899,12 +3017,24 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           `  cmd > /tmp/0agent-server.log 2>&1 &`,
           `  Example: python3 -m http.server 3000 > /tmp/0agent-server.log 2>&1 &`,
           `  NEVER run background commands without redirecting output.`,
-          `- For npm/node projects: check package.json first with read_file or list_dir`,
-          `- After write_file, verify with read_file if needed`,
+          `- To create a folder: use file_op with op="mkdir" and path="folder/name"`,
+          `- To create a file (and its parent folders): use file_op with op="write" \u2014 parent dirs are created automatically`,
+          `- For npm/node projects: check package.json first with file_op op="list"`,
+          `- After writing files, verify with file_op op="read" if needed`,
           `- After shell_exec, check output for errors and retry if needed`,
           `- For research tasks: use web_search first, then scrape_url for full page content`,
           `- Use relative paths from the working directory`,
-          `- Be concise in your final response: state what was done and where to find it`
+          `- Be concise in your final response: state what was done and where to find it`,
+          ...hasMemory ? [
+            ``,
+            `Memory (IMPORTANT):`,
+            `- ALWAYS call memory_write after discovering important facts:`,
+            `  \xB7 Live URLs (ngrok, deployed apps, APIs): memory_write({label:"ngrok_url", content:"https://...", type:"url"})`,
+            `  \xB7 Server ports: memory_write({label:"dev_server_port", content:"3000", type:"config"})`,
+            `  \xB7 File paths of created projects: memory_write({label:"project_path", content:"/path/to/project", type:"path"})`,
+            `  \xB7 Task outcomes: memory_write({label:"last_task_result", content:"...", type:"outcome"})`,
+            `- Call memory_write immediately when you find the value, not just at the end`
+          ] : []
         ];
         if (isSelfMod && this.agentRoot) {
           lines.push(
@@ -3034,7 +3164,7 @@ var init_ExecutionVerifier = __esm({
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6 } from "node:fs";
 import { resolve as resolve5, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execSync as execSync4, spawn as spawn3 } from "node:child_process";
+import { execSync as execSync4, spawn as spawn4 } from "node:child_process";
 function isRuntimeBug(error) {
   if (TASK_FAILURE_PATTERNS.some((p) => p.test(error))) return false;
   return RUNTIME_BUG_PATTERNS.some((p) => p.test(error));
@@ -3269,7 +3399,7 @@ Rules:
       restartDaemon() {
         const bundlePath = resolve5(this.projectRoot, "dist", "daemon.mjs");
         if (existsSync6(bundlePath)) {
-          const child = spawn3(process.execPath, [bundlePath], {
+          const child = spawn4(process.execPath, [bundlePath], {
             detached: true,
             stdio: "ignore",
             env: process.env
@@ -4597,7 +4727,7 @@ var SessionManager = class {
       if (activeLLM?.isConfigured) {
         const executor = new AgentExecutor(
           activeLLM,
-          { cwd: this.cwd, agent_root: this.agentRoot },
+          { cwd: this.cwd, agent_root: this.agentRoot, graph: this.graph },
           // step callback → emit session.step events
           (step) => this.addStep(sessionId, step),
           // token callback → emit session.token events
@@ -6616,7 +6746,7 @@ git checkout <commit> graph/         # restore graph files
 };
 
 // packages/daemon/src/CodespaceManager.ts
-import { execSync as execSync5, spawn as spawn4 } from "node:child_process";
+import { execSync as execSync5, spawn as spawn5 } from "node:child_process";
 var BROWSER_PORT_REMOTE = 3e3;
 var BROWSER_PORT_LOCAL = 3001;
 var DISPLAY_NAME = "0agent-browser";
@@ -6711,7 +6841,7 @@ var CodespaceManager = class {
   async openTunnel(name) {
     this.closeTunnel();
     console.log(`[Codespace] Opening tunnel port ${BROWSER_PORT_REMOTE} \u2192 localhost:${BROWSER_PORT_LOCAL}...`);
-    this.forwardProcess = spawn4(
+    this.forwardProcess = spawn5(
       "gh",
       ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
       { stdio: ["ignore", "ignore", "ignore"] }
@@ -6871,7 +7001,14 @@ var ZeroAgentDaemon = class {
       }).catch(() => {
       });
     }
-    const cwd = process.env["ZEROAGENT_CWD"] ?? process.cwd();
+    const workspaceCfg = this.config["workspace"];
+    const configuredWorkspace = workspaceCfg?.path;
+    const cwd = process.env["ZEROAGENT_CWD"] ?? configuredWorkspace ?? process.cwd();
+    if (configuredWorkspace) {
+      const { mkdirSync: mks } = await import("node:fs");
+      mks(configuredWorkspace, { recursive: true });
+      console.log(`[0agent] Workspace: ${configuredWorkspace}`);
+    }
     const identityManager = new IdentityManager(this.graph);
     const identity = await identityManager.init().catch(() => null);
     if (identity) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",