0agent 1.0.7 → 1.0.9

package/bin/0agent.js

@@ -86,6 +86,14 @@ switch (cmd) {
     showLogs(args.slice(1));
     break;
 
+  case 'team':
+    await runTeamCommand(args.slice(1));
+    break;
+
+  case 'serve':
+    await runServe(args.slice(1));
+    break;
+
   default:
     showHelp();
     break;
@@ -415,6 +423,7 @@ async function streamSession(sessionId) {
 
   return new Promise((resolve) => {
     const ws = new WS(`ws://localhost:4200/ws`);
+    let streaming = false;  // true when mid-token-stream
 
     ws.on('open', () => {
       ws.send(JSON.stringify({ type: 'subscribe', topics: ['sessions'] }));
@@ -427,18 +436,30 @@ async function streamSession(sessionId) {
 
         switch (event.type) {
           case 'session.step':
-            console.log(`  › ${event.step}`);
+            // Newline before step if we were mid-stream
+            if (streaming) { process.stdout.write('\n'); streaming = false; }
+            console.log(`  \x1b[2m›\x1b[0m ${event.step}`);
+            break;
+          case 'session.token':
+            // Token-by-token streaming — print without newline
+            if (!streaming) { process.stdout.write('\n  '); streaming = true; }
+            process.stdout.write(event.token);
             break;
           case 'session.completed': {
-            console.log('\n  ✓ Done\n');
-            const out = event.result?.output ?? event.result;
-            if (out && typeof out === 'string') console.log(`  ${out}\n`);
+            if (streaming) { process.stdout.write('\n'); streaming = false; }
+            // Show files written + commands run
+            const r = event.result ?? {};
+            if (r.files_written?.length) console.log(`\n  \x1b[32m✓\x1b[0m Files: ${r.files_written.join(', ')}`);
+            if (r.commands_run?.length) console.log(`  \x1b[32m✓\x1b[0m Commands run: ${r.commands_run.length}`);
+            if (r.tokens_used) console.log(`  \x1b[2m${r.tokens_used} tokens · ${r.model}\x1b[0m`);
+            console.log('\n  \x1b[32m✓ Done\x1b[0m\n');
             ws.close();
             resolve();
             break;
           }
           case 'session.failed':
-            console.log(`\n  ✗ Failed: ${event.error}\n`);
+            if (streaming) { process.stdout.write('\n'); streaming = false; }
+            console.log(`\n  \x1b[31m✗ Failed:\x1b[0m ${event.error}\n`);
             ws.close();
             resolve();
             break;
@@ -601,6 +622,183 @@ function showLogs(logArgs) {
 
 // ─── Help ─────────────────────────────────────────────────────────────────
 
+// ─── Team commands ────────────────────────────────────────────────────────────
+
+async function runTeamCommand(teamArgs) {
+  const sub = teamArgs[0];
+  const SYNC_URL = process.env['ZEROAGENT_SYNC'] ?? 'http://localhost:4201';
+
+  switch (sub) {
+    case 'create': {
+      const name = teamArgs.slice(1).join(' ');
+      if (!name) { console.log('  Usage: 0agent team create "<name>"'); break; }
+      const res = await fetch(`${SYNC_URL}/api/teams`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name,
+          creator_entity_id: crypto.randomUUID(),
+          creator_name: process.env['USER'] ?? 'User',
+        }),
+      }).catch(() => null);
+      if (!res?.ok) { console.log(`  Sync server not running. Start it with: 0agent serve`); break; }
+      const team = await res.json();
+      console.log(`\n  ✓ Team created: ${team.name}`);
+      console.log(`  Invite code:   \x1b[1m${team.invite_code}\x1b[0m`);
+      console.log(`\n  Share with teammates:`);
+      console.log(`    0agent team join ${team.invite_code} --server ${SYNC_URL}\n`);
+      break;
+    }
+
+    case 'join': {
+      const code = teamArgs[1]?.toUpperCase();
+      const serverIdx = teamArgs.indexOf('--server');
+      const serverUrl = serverIdx >= 0 ? teamArgs[serverIdx + 1] : SYNC_URL;
+      if (!code) { console.log('  Usage: 0agent team join <CODE> [--server <url>]'); break; }
+      const res = await fetch(`${serverUrl}/api/teams/by-code/${code}`).catch(() => null);
+      if (!res?.ok) { console.log(`  Invalid code or sync server unreachable: ${serverUrl}`); break; }
+      const team = await res.json();
+      const joinRes = await fetch(`${serverUrl}/api/teams/${team.id}/join`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          entity_node_id: crypto.randomUUID(),
+          name: process.env['USER'] ?? 'User',
+        }),
+      });
+      if (!joinRes.ok) { console.log('  Failed to join team.'); break; }
+      console.log(`\n  ✓ Joined: ${team.name}`);
+      console.log(`  Members: ${team.members?.length ?? '?'}`);
+      console.log(`  Sync server: ${serverUrl}\n`);
+      break;
+    }
+
+    case 'list': {
+      // Show teams from local teams.yaml
+      const { readFileSync, existsSync } = await import('node:fs');
+      const { resolve } = await import('node:path');
+      const { homedir } = await import('node:os');
+      const teamsPath = resolve(homedir(), '.0agent', 'teams.yaml');
+      if (!existsSync(teamsPath)) { console.log('\n  No teams joined yet. Use: 0agent team join <CODE>\n'); break; }
+      const YAML = await import('yaml');
+      const config = YAML.parse(readFileSync(teamsPath, 'utf8'));
+      console.log('\n  Your teams:\n');
+      for (const m of (config.memberships ?? [])) {
+        const ago = m.last_synced_at ? `synced ${Math.round((Date.now() - m.last_synced_at) / 60000)}m ago` : 'never synced';
+        console.log(`  ${m.team_name.padEnd(24)} ${m.invite_code}  ${ago}`);
+        console.log(`  ${' '.repeat(24)} ${m.server_url}`);
+      }
+      console.log();
+      break;
+    }
+
+    default:
+      console.log('  Usage: 0agent team create "<name>" | join <CODE> [--server <url>] | list');
+  }
+}
+
+// ─── Serve command (sync server + optional tunnel) ────────────────────────────
+
+async function runServe(serveArgs) {
+  const hasTunnel = serveArgs.includes('--tunnel');
+  const port = parseInt(serveArgs.find(a => a.match(/^\d+$/)) ?? '4201', 10);
+
+  console.log(`\n  Starting 0agent sync server on port ${port}...\n`);
+
+  // Find sync server entry point
+  const { resolve, dirname } = await import('node:path');
+  const { existsSync } = await import('node:fs');
+  const { spawn } = await import('node:child_process');
+  const { networkInterfaces } = await import('node:os');
+
+  const pkgRoot = resolve(dirname(new URL(import.meta.url).pathname), '..');
+  const serverScript = resolve(pkgRoot, 'packages', 'sync-server', 'src', 'index.ts');
+
+  if (!existsSync(serverScript)) {
+    console.log('  Sync server not found in package. Install with: npm install -g 0agent');
+    return;
+  }
+
+  // Start sync server
+  const proc = spawn(process.execPath, ['--experimental-specifier-resolution=node', serverScript], {
+    env: { ...process.env, SYNC_PORT: String(port), SYNC_HOST: '0.0.0.0' },
+    stdio: 'inherit',
+    detached: false,
+  });
+
+  // Get LAN IP
+  const nets = networkInterfaces();
+  let lanIp = '127.0.0.1';
+  for (const iface of Object.values(nets)) {
+    if (!iface) continue;
+    for (const net of iface) {
+      if (net.family === 'IPv4' && !net.internal) { lanIp = net.address; break; }
+    }
+  }
+
+  await sleep(1500);
+
+  const localUrl = `http://localhost:${port}`;
+  const lanUrl   = `http://${lanIp}:${port}`;
+
+  console.log(`\n  ✓ Sync server running`);
+  console.log(`  Local:  ${localUrl}`);
+  console.log(`  LAN:    ${lanUrl}  ← share with teammates on same WiFi`);
+
+  if (hasTunnel) {
+    console.log('\n  Opening public tunnel...');
+    let tunnelUrl = null;
+
+    // Try cloudflared
+    try {
+      const { execSync: es } = await import('node:child_process');
+      es('which cloudflared', { stdio: 'ignore' });
+      const cf = spawn('cloudflared', ['tunnel', '--url', localUrl], { stdio: ['ignore', 'pipe', 'pipe'] });
+      cf.unref();
+      tunnelUrl = await waitForTunnelUrl(cf, /https:\/\/[a-z0-9\-]+\.trycloudflare\.com/i, 12000);
+    } catch {}
+
+    // Try ngrok
+    if (!tunnelUrl) {
+      try {
+        const { execSync: es } = await import('node:child_process');
+        es('which ngrok', { stdio: 'ignore' });
+        const ng = spawn('ngrok', ['http', String(port), '--log=stdout'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        ng.unref();
+        tunnelUrl = await waitForTunnelUrl(ng, /https:\/\/[a-z0-9\-]+\.ngrok/i, 8000);
+      } catch {}
+    }
+
+    if (tunnelUrl) {
+      console.log(`  Public: \x1b[1m${tunnelUrl}\x1b[0m  ← share with anyone`);
+      const code = Math.random().toString(36).slice(2,5).toUpperCase() + '-' + Math.floor(1000+Math.random()*9000);
+      console.log(`\n  Share this with teammates:`);
+      console.log(`    0agent team join <CODE> --server ${tunnelUrl}\n`);
+    } else {
+      console.log('  No tunnel tool found. Install cloudflared: brew install cloudflared');
+      console.log('  Using LAN only.');
+    }
+  }
+
+  console.log('\n  Press Ctrl+C to stop.\n');
+  proc.on('close', () => process.exit(0));
+}
+
+async function waitForTunnelUrl(proc, pattern, timeout) {
+  return new Promise(resolve => {
+    const chunks = [];
+    const onData = d => {
+      const s = d.toString(); chunks.push(s);
+      const match = chunks.join('').match(pattern);
+      if (match) { cleanup(); resolve(match[0]); }
+    };
+    proc.stdout?.on('data', onData);
+    proc.stderr?.on('data', onData);
+    const timer = setTimeout(() => { cleanup(); resolve(null); }, timeout);
+    const cleanup = () => { clearTimeout(timer); proc.stdout?.removeListener('data', onData); proc.stderr?.removeListener('data', onData); };
+  });
+}
+
 function showHelp() {
   console.log(`
   0agent — An agent that learns.
@@ -619,6 +817,13 @@ function showHelp() {
     0agent improve                 Self-improvement analysis
     0agent logs                    Tail daemon logs
 
+  Team collaboration:
+    0agent serve                   Start sync server (LAN)
+    0agent serve --tunnel          Start sync server + public tunnel
+    0agent team create "<name>"    Create a team, get invite code
+    0agent team join <CODE>        Join a team by invite code
+    0agent team list               List your teams
+
   Dashboard:
     http://localhost:4200           Web UI (after starting daemon)
 
@@ -627,6 +832,7 @@ function showHelp() {
     0agent /research "Acme Corp funding"
     0agent /build --task next
     0agent /qa --url https://staging.myapp.com
+    0agent serve --tunnel          # then share the URL + 0agent team join <CODE>
 `);
 }
 

package/dist/daemon.mjs

@@ -1,6 +1,6 @@
 // packages/daemon/src/ZeroAgentDaemon.ts
-import { writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
-import { resolve as resolve3 } from "node:path";
+import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 
 // packages/core/src/graph/GraphNode.ts
@@ -1685,6 +1685,537 @@ var EntityScopedContextLoader = class {
   }
 };
 
+// packages/daemon/src/AgentExecutor.ts
+import { spawn } from "node:child_process";
+import { writeFileSync, readFileSync as readFileSync2, readdirSync, mkdirSync, existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve2, dirname, relative } from "node:path";
+
+// packages/daemon/src/LLMExecutor.ts
+var AGENT_TOOLS = [
+  {
+    name: "shell_exec",
+    description: "Execute a shell command in the working directory. Use for running servers (with & for background), installing packages, running tests, git operations, etc. Returns stdout + stderr.",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "Shell command to execute" },
+        timeout_ms: { type: "number", description: "Timeout in milliseconds (default 30000)" }
+      },
+      required: ["command"]
+    }
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file. Creates parent directories if needed. Use for creating HTML, CSS, JS, config files, etc.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path relative to working directory" },
+        content: { type: "string", description: "Full file content to write" }
+      },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "read_file",
+    description: "Read a file's contents.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path relative to working directory" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "list_dir",
+    description: "List files and directories.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: 'Directory path relative to working directory (default: ".")' }
+      }
+    }
+  }
+];
+var LLMExecutor = class {
+  constructor(config) {
+    this.config = config;
+  }
+  get isConfigured() {
+    if (this.config.provider === "ollama") return true;
+    return !!this.config.api_key?.trim();
+  }
+  // ─── Single completion (no tools, no streaming) ──────────────────────────
+  async complete(messages, system) {
+    const res = await this.completeWithTools(messages, [], system, void 0);
+    return { content: res.content, tokens_used: res.tokens_used, model: res.model };
+  }
+  // ─── Tool-calling completion with optional streaming ─────────────────────
+  async completeWithTools(messages, tools, system, onToken) {
+    switch (this.config.provider) {
+      case "anthropic":
+        return this.anthropic(messages, tools, system, onToken);
+      case "openai":
+        return this.openai(messages, tools, system, onToken);
+      case "xai":
+        return this.openai(messages, tools, system, onToken, "https://api.x.ai/v1");
+      case "gemini":
+        return this.openai(messages, tools, system, onToken, "https://generativelanguage.googleapis.com/v1beta/openai");
+      case "ollama":
+        return this.ollama(messages, system, onToken);
+      default:
+        return this.openai(messages, tools, system, onToken);
+    }
+  }
+  // ─── Anthropic ───────────────────────────────────────────────────────────
+  async anthropic(messages, tools, system, onToken) {
+    const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
+    const filtered = messages.filter((m) => m.role !== "system");
+    const anthropicMsgs = filtered.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: m.tool_call_id, content: m.content }]
+        };
+      }
+      if (m.role === "assistant" && m.tool_calls?.length) {
+        return {
+          role: "assistant",
+          content: [
+            ...m.content ? [{ type: "text", text: m.content }] : [],
+            ...m.tool_calls.map((tc) => ({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.name,
+              input: tc.input
+            }))
+          ]
+        };
+      }
+      return { role: m.role, content: m.content };
+    });
+    const body = {
+      model: this.config.model,
+      max_tokens: 8192,
+      messages: anthropicMsgs,
+      stream: true
+    };
+    if (sysContent) body.system = sysContent;
+    if (tools.length > 0) {
+      body.tools = tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.input_schema
+      }));
+    }
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.config.api_key,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`Anthropic ${res.status}: ${err}`);
+    }
+    let textContent = "";
+    let stopReason = "end_turn";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let modelName = this.config.model;
+    const toolCalls = [];
+    const toolInputBuffers = {};
+    let currentToolId = "";
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]" || data === "") continue;
+        let evt;
+        try {
+          evt = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const type = evt.type;
+        if (type === "message_start") {
+          const usage = evt.message?.usage;
+          inputTokens = usage?.input_tokens ?? 0;
+          modelName = evt.message?.model ?? modelName;
+        } else if (type === "content_block_start") {
+          const block = evt.content_block;
+          if (block?.type === "tool_use") {
+            currentToolId = block.id;
+            toolInputBuffers[currentToolId] = "";
+            toolCalls.push({ id: currentToolId, name: block.name, input: {} });
+          }
+        } else if (type === "content_block_delta") {
+          const delta = evt.delta;
+          if (delta?.type === "text_delta") {
+            const token = delta.text ?? "";
+            textContent += token;
+            if (onToken && token) onToken(token);
+          } else if (delta?.type === "input_json_delta") {
+            toolInputBuffers[currentToolId] = (toolInputBuffers[currentToolId] ?? "") + (delta.partial_json ?? "");
+          }
+        } else if (type === "content_block_stop") {
+          if (currentToolId && toolInputBuffers[currentToolId]) {
+            const tc = toolCalls.find((t) => t.id === currentToolId);
+            if (tc) {
+              try {
+                tc.input = JSON.parse(toolInputBuffers[currentToolId]);
+              } catch {
+              }
+            }
+          }
+        } else if (type === "message_delta") {
+          const usage = evt.usage;
+          outputTokens = usage?.output_tokens ?? 0;
+          const stop = evt.delta?.stop_reason;
+          if (stop === "tool_use") stopReason = "tool_use";
+          else if (stop === "end_turn") stopReason = "end_turn";
+          else if (stop === "max_tokens") stopReason = "max_tokens";
+        }
+      }
+    }
+    return {
+      content: textContent,
+      tool_calls: toolCalls.length > 0 ? toolCalls : null,
+      stop_reason: stopReason,
+      tokens_used: inputTokens + outputTokens,
+      model: modelName
+    };
+  }
+  // ─── OpenAI (also xAI, Gemini) ───────────────────────────────────────────
+  async openai(messages, tools, system, onToken, baseUrl = "https://api.openai.com/v1") {
+    const allMessages = [];
+    const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
+    if (sysContent) allMessages.push({ role: "system", content: sysContent });
+    for (const m of messages.filter((m2) => m2.role !== "system")) {
+      if (m.role === "tool") {
+        allMessages.push({ role: "tool", tool_call_id: m.tool_call_id, content: m.content });
+      } else if (m.role === "assistant" && m.tool_calls?.length) {
+        allMessages.push({
+          role: "assistant",
+          content: m.content || null,
+          tool_calls: m.tool_calls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.input) }
+          }))
+        });
+      } else {
+        allMessages.push({ role: m.role, content: m.content });
+      }
+    }
+    const body = {
+      model: this.config.model,
+      messages: allMessages,
+      max_tokens: 8192,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (tools.length > 0) {
+      body.tools = tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.input_schema }
+      }));
+    }
+    const res = await fetch(`${this.config.base_url ?? baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.api_key}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`OpenAI ${res.status}: ${err}`);
+    }
+    let textContent = "";
+    let tokensUsed = 0;
+    let modelName = this.config.model;
+    let stopReason = "end_turn";
+    const toolCallMap = {};
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") continue;
+        let evt;
+        try {
+          evt = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        modelName = evt.model ?? modelName;
+        const usage = evt.usage;
+        if (usage?.total_tokens) tokensUsed = usage.total_tokens;
+        const choices = evt.choices;
+        if (!choices?.length) continue;
+        const delta = choices[0].delta;
+        if (!delta) continue;
+        const finish = choices[0].finish_reason;
+        if (finish === "tool_calls") stopReason = "tool_use";
+        else if (finish === "stop") stopReason = "end_turn";
+        const token = delta.content;
+        if (token) {
+          textContent += token;
+          if (onToken) onToken(token);
+        }
+        const toolCallDeltas = delta.tool_calls;
+        if (toolCallDeltas) {
+          for (const tc of toolCallDeltas) {
+            const idx = tc.index;
+            if (!toolCallMap[idx]) {
+              toolCallMap[idx] = { id: "", name: "", args: "" };
+            }
+            const fn = tc.function;
+            if (tc.id) toolCallMap[idx].id = tc.id;
+            if (fn?.name) toolCallMap[idx].name = fn.name;
+            if (fn?.arguments) toolCallMap[idx].args += fn.arguments;
+          }
+        }
+      }
+    }
+    const toolCalls = Object.values(toolCallMap).filter((tc) => tc.id && tc.name).map((tc) => {
+      let input = {};
+      try {
+        input = JSON.parse(tc.args);
+      } catch {
+      }
+      return { id: tc.id, name: tc.name, input };
+    });
+    return {
+      content: textContent,
+      tool_calls: toolCalls.length > 0 ? toolCalls : null,
+      stop_reason: stopReason,
+      tokens_used: tokensUsed,
+      model: modelName
+    };
+  }
+  // ─── Ollama (no streaming for simplicity) ────────────────────────────────
+  async ollama(messages, system, onToken) {
+    const baseUrl = this.config.base_url ?? "http://localhost:11434";
+    const allMessages = [];
+    const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
+    if (sysContent) allMessages.push({ role: "system", content: sysContent });
+    allMessages.push(...messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content })));
+    const res = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.config.model, messages: allMessages, stream: false })
+    });
+    if (!res.ok) throw new Error(`Ollama error ${res.status}`);
+    const data = await res.json();
+    if (onToken) onToken(data.message.content);
+    return { content: data.message.content, tool_calls: null, stop_reason: "end_turn", tokens_used: data.eval_count ?? 0, model: this.config.model };
+  }
+};
+
+// packages/daemon/src/AgentExecutor.ts
+var AgentExecutor = class {
+  constructor(llm, config, onStep, onToken) {
+    this.llm = llm;
+    this.config = config;
+    this.onStep = onStep;
+    this.onToken = onToken;
+    this.cwd = config.cwd;
+    this.maxIterations = config.max_iterations ?? 20;
+    this.maxCommandMs = config.max_command_ms ?? 3e4;
+  }
+  cwd;
+  maxIterations;
+  maxCommandMs;
+  async execute(task, systemContext) {
+    const filesWritten = [];
+    const commandsRun = [];
+    let totalTokens = 0;
+    let modelName = "";
+    const systemPrompt = this.buildSystemPrompt(systemContext);
+    const messages = [
+      { role: "user", content: task }
+    ];
+    let finalOutput = "";
+    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,
+          AGENT_TOOLS,
+          systemPrompt,
+          // Only stream tokens on the final (non-tool) turn
+          (token) => {
+            this.onToken(token);
+            finalOutput += token;
+          }
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.onStep(`LLM error: ${msg}`);
+        finalOutput = `Error: ${msg}`;
+        break;
+      }
+      totalTokens += response.tokens_used;
+      modelName = response.model;
+      if (response.stop_reason === "end_turn" || !response.tool_calls?.length) {
+        if (!finalOutput && response.content) finalOutput = response.content;
+        break;
+      }
+      finalOutput = "";
+      messages.push({
+        role: "assistant",
+        content: response.content,
+        tool_calls: response.tool_calls
+      });
+      for (const tc of response.tool_calls) {
+        this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})`);
+        let result;
+        try {
+          result = await this.executeTool(tc.name, tc.input);
+          if (tc.name === "write_file" && tc.input.path) {
+            filesWritten.push(String(tc.input.path));
+          }
+          if (tc.name === "shell_exec" && tc.input.command) {
+            commandsRun.push(String(tc.input.command));
+          }
+        } catch (err) {
+          result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        this.onStep(`  \u21B3 ${result.slice(0, 120)}${result.length > 120 ? "\u2026" : ""}`);
+        messages.push({
+          role: "tool",
+          content: result,
+          tool_call_id: tc.id
+        });
+      }
+    }
+    return {
+      output: finalOutput || "(no output)",
+      files_written: filesWritten,
+      commands_run: commandsRun,
+      tokens_used: totalTokens,
+      model: modelName,
+      iterations: messages.filter((m) => m.role === "assistant").length
+    };
+  }
+  // ─── Tool execution ────────────────────────────────────────────────────────
+  async executeTool(name, input) {
+    switch (name) {
+      case "shell_exec":
+        return this.shellExec(
+          String(input.command ?? ""),
+          Number(input.timeout_ms ?? this.maxCommandMs)
+        );
+      case "write_file":
+        return this.writeFile(String(input.path ?? ""), String(input.content ?? ""));
+      case "read_file":
+        return this.readFile(String(input.path ?? ""));
+      case "list_dir":
+        return this.listDir(input.path ? String(input.path) : void 0);
+      default:
+        return `Unknown tool: ${name}`;
+    }
+  }
+  shellExec(command, timeoutMs) {
+    return new Promise((resolve6) => {
+      const chunks = [];
+      const proc = spawn("bash", ["-c", command], {
+        cwd: this.cwd,
+        env: { ...process.env, TERM: "dumb" },
+        timeout: timeoutMs
+      });
+      proc.stdout.on("data", (d) => chunks.push(d.toString()));
+      proc.stderr.on("data", (d) => chunks.push(d.toString()));
+      proc.on("close", (code) => {
+        const output = chunks.join("").trim();
+        resolve6(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+      });
+      proc.on("error", (err) => {
+        resolve6(`Error: ${err.message}`);
+      });
+    });
+  }
+  writeFile(filePath, content) {
+    const safe = this.safePath(filePath);
+    if (!safe) return "Error: path outside working directory";
+    mkdirSync(dirname(safe), { recursive: true });
+    writeFileSync(safe, content, "utf8");
+    const rel = relative(this.cwd, safe);
+    return `Written: ${rel} (${content.length} bytes)`;
+  }
+  readFile(filePath) {
+    const safe = this.safePath(filePath);
+    if (!safe) return "Error: path outside working directory";
+    if (!existsSync2(safe)) return `File not found: ${filePath}`;
+    const content = readFileSync2(safe, "utf8");
+    return content.length > 8e3 ? content.slice(0, 8e3) + `
+\u2026[truncated, ${content.length} total bytes]` : content;
+  }
+  listDir(dirPath) {
+    const safe = this.safePath(dirPath ?? ".");
+    if (!safe) return "Error: path outside working directory";
+    if (!existsSync2(safe)) return `Directory not found: ${dirPath}`;
+    try {
+      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 entries || "(empty directory)";
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+  safePath(p) {
+    const resolved = resolve2(this.cwd, p);
+    return resolved.startsWith(this.cwd) ? resolved : null;
+  }
+  buildSystemPrompt(extra) {
+    const lines = [
+      `You are 0agent, an AI software engineer. You can execute shell commands and manage files.`,
+      `Working directory: ${this.cwd}`,
+      ``,
+      `Instructions:`,
+      `- Use tools to actually accomplish tasks, don't just describe what to do`,
+      `- For web servers: write the files, then start the server with & (background)`,
+      `- For npm/node projects: check package.json first with read_file or list_dir`,
+      `- After write_file, verify with read_file if needed`,
+      `- After shell_exec, check output for errors and retry if needed`,
+      `- Use relative paths from the working directory`,
+      `- Be concise in your final response: state what was done and where to find it`
+    ];
+    if (extra) lines.push(``, `Context:`, extra);
+    return lines.join("\n");
+  }
+  summariseInput(toolName, input) {
+    if (toolName === "shell_exec") return `"${String(input.command ?? "").slice(0, 60)}"`;
+    if (toolName === "write_file") return `"${input.path}"`;
+    if (toolName === "read_file") return `"${input.path}"`;
+    if (toolName === "list_dir") return `"${input.path ?? "."}"`;
+    return JSON.stringify(input).slice(0, 60);
+  }
+};
+
 // packages/daemon/src/SessionManager.ts
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
@@ -1692,11 +2223,13 @@ var SessionManager = class {
   eventBus;
   graph;
   llm;
+  cwd;
   constructor(deps = {}) {
     this.inferenceEngine = deps.inferenceEngine;
     this.eventBus = deps.eventBus;
     this.graph = deps.graph;
     this.llm = deps.llm;
+    this.cwd = deps.cwd ?? process.cwd();
   }
   /**
    * Create a new session with status 'pending'.
@@ -1864,30 +2397,36 @@ var SessionManager = class {
       } else {
         this.addStep(session.id, "No inference engine connected \u2014 executing task directly");
       }
-      this.addStep(session.id, "Calling LLM\u2026");
-      let output = "";
       if (this.llm?.isConfigured) {
-        try {
-          const systemPrompt = enrichedReq.context?.system_context ? String(enrichedReq.context.system_context) : `You are 0agent, a helpful AI assistant. Complete the user's task directly and concisely. If the task involves creating files, writing code, or running commands, provide the exact output needed.`;
-          const llmRes = await this.llm.complete([
-            { role: "user", content: enrichedReq.task }
-          ], systemPrompt);
-          output = llmRes.content;
-          this.addStep(session.id, `LLM responded (${llmRes.tokens_used} tokens, ${llmRes.model})`);
-        } catch (llmErr) {
-          const msg = llmErr instanceof Error ? llmErr.message : String(llmErr);
-          this.addStep(session.id, `LLM error: ${msg}`);
-          output = `Error calling LLM: ${msg}`;
+        const executor = new AgentExecutor(
+          this.llm,
+          { cwd: this.cwd },
+          // step callback → emit session.step events
+          (step) => this.addStep(session.id, step),
+          // token callback → emit session.token events
+          (token) => this.emit({ type: "session.token", session_id: session.id, token })
+        );
+        const systemContext = enrichedReq.context?.system_context ? String(enrichedReq.context.system_context) : void 0;
+        const agentResult = await executor.execute(enrichedReq.task, systemContext);
+        if (agentResult.files_written.length > 0) {
+          this.addStep(session.id, `Files written: ${agentResult.files_written.join(", ")}`);
+        }
+        if (agentResult.commands_run.length > 0) {
+          this.addStep(session.id, `Commands run: ${agentResult.commands_run.length}`);
         }
+        this.addStep(session.id, `Done (${agentResult.tokens_used} tokens, ${agentResult.iterations} LLM turns)`);
+        this.completeSession(session.id, {
+          output: agentResult.output,
+          files_written: agentResult.files_written,
+          commands_run: agentResult.commands_run,
+          tokens_used: agentResult.tokens_used,
+          model: agentResult.model
+        });
       } else {
-        output = session.plan?.reasoning ?? "No LLM configured \u2014 add API key to ~/.0agent/config.yaml";
-        this.addStep(session.id, "No LLM configured (set api_key in ~/.0agent/config.yaml)");
+        const output = session.plan?.reasoning ?? "No LLM configured \u2014 add api_key to ~/.0agent/config.yaml";
+        this.addStep(session.id, "No LLM API key configured");
+        this.completeSession(session.id, { output });
       }
-      this.completeSession(session.id, {
-        output,
-        plan: session.plan ?? null,
-        steps: session.steps.length
-      });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       this.failSession(session.id, message);
@@ -2130,7 +2669,7 @@ var BackgroundWorkers = class {
 };
 
 // packages/daemon/src/SkillRegistry.ts
-import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync2, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, existsSync as existsSync3, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "node:fs";
 import { join } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import YAML2 from "yaml";
@@ -2153,11 +2692,11 @@ var SkillRegistry = class {
     this.loadFromDir(this.customDir, false);
   }
   loadFromDir(dir, isBuiltin) {
-    if (!existsSync2(dir)) return;
-    const files = readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    if (!existsSync3(dir)) return;
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     for (const file of files) {
       try {
-        const raw = readFileSync2(join(dir, file), "utf8");
+        const raw = readFileSync3(join(dir, file), "utf8");
         const skill = YAML2.parse(raw);
         if (skill.name) {
           this.skills.set(skill.name, skill);
@@ -2192,9 +2731,9 @@ var SkillRegistry = class {
     if (this.builtinNames.has(name)) {
       throw new Error(`Cannot override built-in skill: ${name}`);
     }
-    mkdirSync(this.customDir, { recursive: true });
+    mkdirSync2(this.customDir, { recursive: true });
     const filePath = join(this.customDir, `${name}.yaml`);
-    writeFileSync(filePath, yamlContent, "utf8");
+    writeFileSync2(filePath, yamlContent, "utf8");
     const skill = YAML2.parse(yamlContent);
     this.skills.set(name, skill);
     return skill;
@@ -2207,7 +2746,7 @@ var SkillRegistry = class {
       throw new Error(`Cannot delete built-in skill: ${name}`);
     }
     const filePath = join(this.customDir, `${name}.yaml`);
-    if (existsSync2(filePath)) {
+    if (existsSync3(filePath)) {
       unlinkSync(filePath);
     }
     this.skills.delete(name);
@@ -2220,8 +2759,8 @@ var SkillRegistry = class {
 // packages/daemon/src/HTTPServer.ts
 import { Hono as Hono8 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync3 } from "node:fs";
-import { resolve as resolve2, dirname } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { resolve as resolve3, dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/daemon/src/routes/health.ts
@@ -2476,15 +3015,15 @@ function skillRoutes(deps) {
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
-    resolve2(dirname(fileURLToPath(import.meta.url)), "graph.html"),
+    resolve3(dirname2(fileURLToPath(import.meta.url)), "graph.html"),
     // dev (src/)
-    resolve2(dirname(fileURLToPath(import.meta.url)), "..", "graph.html"),
+    resolve3(dirname2(fileURLToPath(import.meta.url)), "..", "graph.html"),
     // bundled (dist/../)
-    resolve2(dirname(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
+    resolve3(dirname2(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
   ];
   for (const p of candidates) {
     try {
-      readFileSync3(p);
+      readFileSync4(p);
       return p;
     } catch {
     }
@@ -2508,7 +3047,7 @@ var HTTPServer = class {
     this.app.route("/api/skills", skillRoutes({ skillRegistry: deps.skillRegistry }));
     const serveGraph = (c) => {
       try {
-        const html = readFileSync3(GRAPH_HTML_PATH, "utf8");
+        const html = readFileSync4(GRAPH_HTML_PATH, "utf8");
         return c.html(html);
       } catch {
         return c.html("<p>Graph UI not found. Run: pnpm build</p>");
@@ -2518,7 +3057,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -2526,20 +3065,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve5();
+          resolve6();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (!this.server) {
-        resolve5();
+        resolve6();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve5();
+        else resolve6();
       });
     });
   }
@@ -2548,107 +3087,6 @@ var HTTPServer = class {
   }
 };
 
-// packages/daemon/src/LLMExecutor.ts
-var LLMExecutor = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async complete(messages, system) {
-    switch (this.config.provider) {
-      case "anthropic":
-        return this.callAnthropic(messages, system);
-      case "openai":
-        return this.callOpenAI(messages, system);
-      case "xai":
-        return this.callOpenAI(messages, system, "https://api.x.ai/v1");
-      case "gemini":
-        return this.callOpenAI(messages, system, "https://generativelanguage.googleapis.com/v1beta/openai");
-      case "ollama":
-        return this.callOllama(messages, system);
-      default:
-        return this.callOpenAI(messages, system);
-    }
-  }
-  async callAnthropic(messages, system) {
-    const body = {
-      model: this.config.model,
-      max_tokens: 8192,
-      messages: messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }))
-    };
-    if (system) body.system = system;
-    else {
-      const sysMsg = messages.find((m) => m.role === "system");
-      if (sysMsg) body.system = sysMsg.content;
-    }
-    const res = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.config.api_key,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const err = await res.text();
-      throw new Error(`Anthropic API error ${res.status}: ${err}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.content.filter((c) => c.type === "text").map((c) => c.text).join(""),
-      tokens_used: (data.usage?.input_tokens ?? 0) + (data.usage?.output_tokens ?? 0),
-      model: data.model
-    };
-  }
-  async callOpenAI(messages, system, baseUrl = "https://api.openai.com/v1") {
-    const allMessages = [];
-    const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
-    if (sysContent) allMessages.push({ role: "system", content: sysContent });
-    allMessages.push(...messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content })));
-    const res = await fetch(`${this.config.base_url ?? baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.config.api_key}`
-      },
-      body: JSON.stringify({
-        model: this.config.model,
-        messages: allMessages,
-        max_tokens: 8192
-      })
-    });
-    if (!res.ok) {
-      const err = await res.text();
-      throw new Error(`OpenAI API error ${res.status}: ${err}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content ?? "",
-      tokens_used: data.usage?.total_tokens ?? 0,
-      model: data.model
-    };
-  }
-  async callOllama(messages, system) {
-    const baseUrl = this.config.base_url ?? "http://localhost:11434";
-    const allMessages = [];
-    const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
-    if (sysContent) allMessages.push({ role: "system", content: sysContent });
-    allMessages.push(...messages.filter((m) => m.role !== "system"));
-    const res = await fetch(`${baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ model: this.config.model, messages: allMessages, stream: false })
-    });
-    if (!res.ok) throw new Error(`Ollama error ${res.status}`);
-    const data = await res.json();
-    return { content: data.message.content, tokens_used: data.eval_count ?? 0, model: this.config.model };
-  }
-  get isConfigured() {
-    if (this.config.provider === "ollama") return true;
-    return !!this.config.api_key?.trim();
-  }
-};
-
 // packages/daemon/src/ZeroAgentDaemon.ts
 var ZeroAgentDaemon = class {
   config = null;
@@ -2664,13 +3102,13 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve3(homedir3(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve4(homedir3(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve3(homedir3(), ".0agent");
-    if (!existsSync3(dotDir)) {
-      mkdirSync2(dotDir, { recursive: true });
+    const dotDir = resolve4(homedir3(), ".0agent");
+    if (!existsSync4(dotDir)) {
+      mkdirSync3(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
     this.graph = new KnowledgeGraph(this.adapter);
@@ -2698,7 +3136,8 @@ var ZeroAgentDaemon = class {
       inferenceEngine: this.inferenceEngine,
       eventBus: this.eventBus,
       graph: this.graph,
-      llm: llmExecutor
+      llm: llmExecutor,
+      cwd: process.env["ZEROAGENT_CWD"] ?? process.cwd()
     });
     this.backgroundWorkers = new BackgroundWorkers({
       graph: this.graph,
@@ -2720,7 +3159,7 @@ var ZeroAgentDaemon = class {
       getStatus: () => this.getStatus()
     });
     await this.httpServer.start();
-    writeFileSync2(this.pidFilePath, String(process.pid), "utf8");
+    writeFileSync3(this.pidFilePath, String(process.pid), "utf8");
     console.log(
       `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
     );
@@ -2754,7 +3193,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync3(this.pidFilePath)) {
+    if (existsSync4(this.pidFilePath)) {
       try {
         unlinkSync2(this.pidFilePath);
       } catch {
@@ -2784,11 +3223,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 import { homedir as homedir4 } from "node:os";
-import { existsSync as existsSync4 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve4(homedir4(), ".0agent", "config.yaml");
-if (!existsSync4(CONFIG_PATH)) {
+import { existsSync as existsSync5 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve5(homedir4(), ".0agent", "config.yaml");
+if (!existsSync5(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.
 

package/package.json

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