0agent 1.0.6 → 1.0.8

package/bin/0agent.js

@@ -415,6 +415,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 +428,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;

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,16 +1685,551 @@ 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();
   inferenceEngine;
   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'.
@@ -1862,14 +2397,36 @@ var SessionManager = class {
       } else {
         this.addStep(session.id, "No inference engine connected \u2014 executing task directly");
       }
-      this.addStep(session.id, "Executing\u2026");
-      const output = session.plan?.reasoning ?? "Task queued \u2014 no plan selected";
-      this.addStep(session.id, `Completed: ${output}`);
-      this.completeSession(session.id, {
-        output,
-        plan: session.plan ?? null,
-        steps: session.steps.length
-      });
+      if (this.llm?.isConfigured) {
+        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 {
+        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 });
+      }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       this.failSession(session.id, message);
@@ -2112,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";
@@ -2135,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);
@@ -2174,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;
@@ -2189,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);
@@ -2202,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
@@ -2458,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 {
     }
@@ -2490,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>");
@@ -2500,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,
@@ -2508,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();
       });
     });
   }
@@ -2545,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);
@@ -2562,10 +3119,25 @@ var ZeroAgentDaemon = class {
     this.inferenceEngine = new InferenceEngine(this.graph, resolver, policy);
     this.skillRegistry = new SkillRegistry();
     await this.skillRegistry.loadAll();
+    const defaultLLM = this.config.llm_providers.find((p) => p.is_default) ?? this.config.llm_providers[0];
+    const llmExecutor = defaultLLM ? new LLMExecutor({
+      provider: defaultLLM.provider,
+      model: defaultLLM.model,
+      api_key: defaultLLM.api_key ?? "",
+      base_url: defaultLLM.base_url
+    }) : void 0;
+    if (llmExecutor?.isConfigured) {
+      console.log(`[0agent] LLM: ${defaultLLM?.provider}/${defaultLLM?.model}`);
+    } else {
+      console.warn("[0agent] No LLM API key configured \u2014 tasks will not call the LLM");
+    }
     this.eventBus = new WebSocketEventBus();
     this.sessionManager = new SessionManager({
       inferenceEngine: this.inferenceEngine,
-      eventBus: this.eventBus
+      eventBus: this.eventBus,
+      graph: this.graph,
+      llm: llmExecutor,
+      cwd: process.env["ZEROAGENT_CWD"] ?? process.cwd()
     });
     this.backgroundWorkers = new BackgroundWorkers({
       graph: this.graph,
@@ -2587,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})`
     );
@@ -2621,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 {
@@ -2651,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.6",
+  "version": "1.0.8",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",