0agent 1.0.40 → 1.0.42

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:
@@ -356,11 +369,20 @@ ${ghToken && ghOwner ? `\ngithub_memory:\n  enabled: true\n  token: "${ghToken}"
     console.log('  ✓ Built-in skills installed');
   }
 
-  // Always kill any existing daemon so the new config (with API key) is loaded
-  try { stopDaemon(); await sleep(800); } catch {}
+  // Force-kill any running daemon so new config is loaded fresh
+  await forceStopDaemon();
 
-  console.log('\n  Starting daemon...\n');
+  // Start fresh daemon with new config
+  console.log('\n  Starting...');
   await startDaemon();
+
+  // Open chat TUI immediately — no manual steps needed
+  const chatSc = resolve(dirname(new URL(import.meta.url).pathname), 'chat.js');
+  if (existsSync(chatSc)) {
+    const { spawn: sp } = await import('node:child_process');
+    const p = sp(process.execPath, [chatSc], { stdio: 'inherit' });
+    await new Promise(r => p.on('close', r));
+  }
 }
 
 function detectSandboxes() {
@@ -378,9 +400,17 @@ function detectSandboxes() {
 // ─── Daemon lifecycle ─────────────────────────────────────────────────────
 
 async function startDaemon() {
+  // If still running (e.g. stop was called just before), wait a bit
   if (await isDaemonRunning()) {
-    console.log('  Daemon already running on port 4200. Run `0agent status`.');
-    return;
+    // Give it up to 3s to die before giving up
+    for (let i = 0; i < 6; i++) {
+      await sleep(500);
+      if (!await isDaemonRunning()) break;
+    }
+    if (await isDaemonRunning()) {
+      console.log('  Daemon already running on port 4200. Run `0agent status`.');
+      return;
+    }
   }
 
   if (!existsSync(CONFIG_PATH)) {
@@ -410,33 +440,42 @@ async function startDaemon() {
   child.unref();
 
   // Wait for daemon to be ready (poll /api/health)
-  process.stdout.write('  Starting');
   for (let i = 0; i < 30; i++) {
     await sleep(500);
-    process.stdout.write('.');
     if (await isDaemonRunning()) {
-      console.log(' ✓\n');
-      console.log(`  Daemon running on http://localhost:4200`);
-      console.log(`  Dashboard: http://localhost:4200`);
-      console.log(`  Run: 0agent run "your task"\n`);
+      process.stdout.write(`  \x1b[32m✓\x1b[0m Daemon ready\n`);
       return;
     }
   }
-  console.log('\n  Daemon did not start. Check logs: 0agent logs');
+  console.log('  Daemon did not start in time. Check: 0agent logs');
 }
 
 function stopDaemon() {
-  if (!existsSync(PID_PATH)) {
+  // Try PID file first
+  if (existsSync(PID_PATH)) {
+    const pid = parseInt(readFileSync(PID_PATH, 'utf8').trim(), 10);
+    try { process.kill(pid, 'SIGTERM'); } catch {}
+  } else {
     console.log('  No daemon PID file found. Is it running?');
-    return;
   }
-  const pid = parseInt(readFileSync(PID_PATH, 'utf8').trim(), 10);
-  try {
-    process.kill(pid, 'SIGTERM');
-    console.log(`  Sent SIGTERM to daemon (pid ${pid}). Shutting down...`);
-  } catch (e) {
-    console.log(`  Could not stop daemon: ${e instanceof Error ? e.message : e}`);
+  // Also kill by process name as a fallback
+  try { execSync('pkill -f "daemon.mjs" 2>/dev/null; true', { stdio: 'ignore' }); } catch {}
+}
+
+// Forcefully kill any running daemon regardless of PID file state.
+// Used after init to ensure fresh config is picked up.
+async function forceStopDaemon() {
+  // Kill by PID file if present
+  if (existsSync(PID_PATH)) {
+    const pid = parseInt(readFileSync(PID_PATH, 'utf8').trim(), 10);
+    try { process.kill(pid, 'SIGTERM'); } catch {}
   }
+  // Kill by process name (catches daemons started by chat.js or other means)
+  try { execSync('pkill -f "daemon.mjs" 2>/dev/null; true', { stdio: 'ignore' }); } catch {}
+  // Kill by port 4200 (last resort)
+  try { execSync('lsof -ti:4200 | xargs kill -9 2>/dev/null; true', { stdio: 'ignore' }); } catch {}
+  // Wait for port to be free
+  await sleep(1200);
 }
 
 async function showStatus() {

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
@@ -2690,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;
@@ -2847,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
@@ -3139,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));
@@ -3374,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
@@ -6721,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";
@@ -6816,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"] }
@@ -6976,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.40",
+  "version": "1.0.42",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",