0agent 1.0.11 → 1.0.12

package/dist/daemon.mjs

@@ -1,6 +1,6 @@
 // packages/daemon/src/ZeroAgentDaemon.ts
-import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 
 // packages/core/src/graph/GraphNode.ts
@@ -1686,429 +1686,535 @@ 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";
+import { spawn as spawn2 } 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";
 
-// 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.",
+// packages/daemon/src/capabilities/WebSearchCapability.ts
+import { execSync, spawnSync } from "node:child_process";
+var WebSearchCapability = class {
+  name = "web_search";
+  description = "Search the web. Returns titles, URLs, and snippets. No API key needed.";
+  toolDefinition = {
+    name: "web_search",
+    description: "Search the web and return titles, URLs, and snippets. No API key needed. Use first to find pages, then scrape_url for full content.",
     input_schema: {
       type: "object",
       properties: {
-        command: { type: "string", description: "Shell command to execute" },
-        timeout_ms: { type: "number", description: "Timeout in milliseconds (default 30000)" }
+        query: { type: "string", description: "Search query" },
+        num_results: { type: "number", description: "Number of results (default 5, max 10)" }
       },
-      required: ["command"]
+      required: ["query"]
     }
-  },
-  {
-    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" }
+  };
+  async execute(input, _cwd) {
+    const query = String(input.query ?? "");
+    const n = Math.min(10, Number(input.num_results ?? 5));
+    const start = Date.now();
+    try {
+      const output = await this.ddgHtml(query, n);
+      if (output && output.length > 50) {
+        return { success: true, output, duration_ms: Date.now() - start };
+      }
+    } catch {
+    }
+    try {
+      const output = await this.browserSearch(query, n);
+      return { success: true, output, fallback_used: "browser", duration_ms: Date.now() - start };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
+        duration_ms: Date.now() - start
+      };
+    }
+  }
+  async ddgHtml(query, n) {
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}&kl=us-en`;
+    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",
+        "Accept-Language": "en-US,en;q=0.9"
       },
-      required: ["path", "content"]
+      signal: AbortSignal.timeout(1e4)
+    });
+    const html = await res.text();
+    const titleRe = /<a[^>]+class="result__a"[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g;
+    const snippetRe = /<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    const titles = [];
+    const snippets = [];
+    let m;
+    while ((m = titleRe.exec(html)) !== null && titles.length < n) {
+      let href = m[1];
+      const title = m[2].replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").trim();
+      const uddg = href.match(/[?&]uddg=([^&]+)/);
+      if (uddg) href = decodeURIComponent(uddg[1]);
+      if (href.startsWith("http") && title) titles.push({ url: href, title });
+    }
+    while ((m = snippetRe.exec(html)) !== null && snippets.length < n) {
+      snippets.push(m[1].replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim());
+    }
+    if (titles.length === 0) throw new Error("No results parsed from DDG");
+    return titles.map(
+      (t, i) => `${i + 1}. ${t.title}
+   URL: ${t.url}${snippets[i] ? `
+   ${snippets[i]}` : ""}`
+    ).join("\n\n");
+  }
+  async browserSearch(query, n) {
+    const searchUrl = `https://duckduckgo.com/?q=${encodeURIComponent(query)}`;
+    try {
+      const result = spawnSync("node", ["-e", `
+        const { chromium } = require('playwright');
+        (async () => {
+          const b = await chromium.launch({ headless: true });
+          const p = await b.newPage();
+          await p.goto('${searchUrl}', { timeout: 15000 });
+          await p.waitForSelector('[data-result]', { timeout: 8000 }).catch(() => {});
+          const results = await p.$$eval('[data-result]', els =>
+            els.slice(0, ${n}).map(el => ({
+              title: el.querySelector('h2')?.innerText ?? '',
+              url: el.querySelector('a')?.href ?? '',
+              snippet: el.querySelector('[data-result="snippet"]')?.innerText ?? ''
+            }))
+          );
+          await b.close();
+          console.log(JSON.stringify(results));
+        })();
+      `], { timeout: 25e3, encoding: "utf8" });
+      if (result.status === 0 && result.stdout) {
+        const results = JSON.parse(result.stdout);
+        return results.map(
+          (r, i) => `${i + 1}. ${r.title}
+   URL: ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`
+        ).join("\n\n");
+      }
+    } catch {
+    }
+    const chrome = this.findChrome();
+    if (chrome) {
+      const result = spawnSync(chrome, [
+        "--headless",
+        "--no-sandbox",
+        "--disable-gpu",
+        `--dump-dom`,
+        searchUrl
+      ], { timeout: 15e3, encoding: "utf8" });
+      if (result.stdout) {
+        const html = result.stdout;
+        const titles = [...html.matchAll(/<h2[^>]*>([\s\S]*?)<\/h2>/g)].map((m) => m[1].replace(/<[^>]+>/g, "").trim()).filter((t) => t.length > 5).slice(0, n);
+        if (titles.length > 0) return titles.map((t, i) => `${i + 1}. ${t}`).join("\n");
+      }
+    }
+    throw new Error("No browser available for fallback search");
+  }
+  findChrome() {
+    const candidates = [
+      "google-chrome",
+      "google-chrome-stable",
+      "chromium-browser",
+      "chromium",
+      "/usr/bin/google-chrome",
+      "/usr/bin/chromium-browser",
+      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+    ];
+    for (const c of candidates) {
+      try {
+        execSync(`which "${c}" 2>/dev/null || test -f "${c}"`, { stdio: "pipe" });
+        return c;
+      } catch {
+      }
     }
-  },
-  {
-    name: "read_file",
-    description: "Read a file's contents.",
+    return null;
+  }
+};
+
+// packages/daemon/src/capabilities/BrowserCapability.ts
+import { spawnSync as spawnSync2, execSync as execSync2 } from "node:child_process";
+var 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.";
+  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.",
     input_schema: {
       type: "object",
       properties: {
-        path: { type: "string", description: "File path relative to working directory" }
+        url: { type: "string", description: "URL to open" },
+        action: { type: "string", description: 'What to do: "read" (default), "screenshot", "click <selector>", "fill <selector> <value>"' },
+        wait_for: { type: "string", description: "CSS selector to wait for before extracting content" },
+        extract: { type: "string", description: "CSS selector to extract specific element text" }
       },
-      required: ["path"]
+      required: ["url"]
+    }
+  };
+  async execute(input, _cwd) {
+    const url = String(input.url ?? "");
+    const action = String(input.action ?? "read");
+    const waitFor = input.wait_for ? String(input.wait_for) : null;
+    const extract = input.extract ? String(input.extract) : null;
+    const start = Date.now();
+    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 {
+    }
+    try {
+      const output = await this.chromeFetch(url);
+      return { success: true, output, fallback_used: "system-chrome", 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"
+        },
+        signal: AbortSignal.timeout(15e3)
+      });
+      const text = await res.text();
+      const plain = text.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().slice(0, 5e3);
+      return { success: true, output: plain, fallback_used: "fetch", duration_ms: Date.now() - start };
+    } catch (err) {
+      return {
+        success: false,
+        output: `Browser unavailable. Install Playwright: npx playwright install chromium`,
+        error: 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'] });
+        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 });
+        ${waitLine}
+        const page_text = await p.evaluate(() => document.body.innerText ?? '');
+        ${extractLine}
+        console.log(text.slice(0, 6000));
+        await b.close();
+      })().catch(e => { console.error(e.message); process.exit(1); });
+    `;
+    const result = spawnSync2("node", ["-e", script], { timeout: 3e4, encoding: "utf8" });
+    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 {
+      }
     }
-  },
-  {
-    name: "list_dir",
-    description: "List files and directories.",
+    throw new Error("No system Chrome found");
+  }
+};
+
+// packages/daemon/src/capabilities/ScraperCapability.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+var ScraperCapability = class {
+  name = "scrape_url";
+  description = "Scrape a URL. Tries fast HTTP fetch, then Scrapling, then browser if needed.";
+  browser = new BrowserCapability();
+  toolDefinition = {
+    name: "scrape_url",
+    description: "Scrape a URL and return clean content. Handles JS-rendered pages. Fallback chain: HTTP \u2192 Scrapling \u2192 Browser.",
     input_schema: {
       type: "object",
       properties: {
-        path: { type: "string", description: 'Directory path relative to working directory (default: ".")' }
+        url: { type: "string", description: "URL to scrape" },
+        mode: { type: "string", description: '"text" (default), "links", "tables", "markdown"' },
+        selector: { type: "string", description: "Optional CSS selector to target element" }
+      },
+      required: ["url"]
+    }
+  };
+  async execute(input, cwd) {
+    const url = String(input.url ?? "");
+    const mode = String(input.mode ?? "text");
+    const selector = input.selector ? String(input.selector) : null;
+    const start = Date.now();
+    if (!url.startsWith("http")) {
+      return { success: false, output: "URL must start with http:// or https://", duration_ms: 0 };
+    }
+    try {
+      const output = await this.plainFetch(url, mode, selector);
+      if (output && output.length > 100) {
+        return { success: true, output, duration_ms: Date.now() - start };
       }
+    } catch {
     }
-  },
-  {
-    name: "web_search",
-    description: "Search the web and return titles, URLs, and snippets. No API key needed. Use this first to find relevant pages, then scrape_url for full content.",
+    try {
+      const output = await this.scraplingFetch(url, mode);
+      if (output && output.length > 100) {
+        return { success: true, output, fallback_used: "scrapling", duration_ms: Date.now() - start };
+      }
+    } catch {
+    }
+    const browserResult = await this.browser.execute({ url, extract: selector ?? void 0 }, cwd);
+    return { ...browserResult, fallback_used: "browser", duration_ms: Date.now() - start };
+  }
+  async plainFetch(url, mode, selector) {
+    const res = await fetch(url, {
+      headers: { "User-Agent": "Mozilla/5.0 AppleWebKit/537.36 Chrome/120.0" },
+      signal: AbortSignal.timeout(12e3)
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const html = await res.text();
+    if (mode === "links") {
+      const links = [...html.matchAll(/href="(https?:\/\/[^"]+)"/g)].map((m) => m[1]).filter((v, i, a) => a.indexOf(v) === i).slice(0, 30);
+      return links.join("\n");
+    }
+    if (mode === "tables") {
+      const tables = [...html.matchAll(/<table[\s\S]*?<\/table>/gi)].map(
+        (m) => m[0].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim()
+      ).slice(0, 5);
+      return tables.join("\n---\n");
+    }
+    const text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    return text.slice(0, 6e3) + (text.length > 6e3 ? "\n\u2026[truncated]" : "");
+  }
+  async scraplingFetch(url, mode) {
+    const extractLine = mode === "links" ? `result = [a.attrib.get('href','') for a in page.find_all('a') if a.attrib.get('href','').startswith('http')]` : `result = page.get_all_text()`;
+    const script = `
+import sys
+try:
+    from scrapling import Fetcher
+except ImportError:
+    import subprocess
+    subprocess.run([sys.executable,'-m','pip','install','scrapling','-q'],check=True)
+    from scrapling import Fetcher
+f = Fetcher(auto_match=False)
+page = f.get('${url}', timeout=20)
+${extractLine}
+if isinstance(result, list):
+    print('\\n'.join(str(r) for r in result[:30]))
+else:
+    t = str(result).strip()
+    print(t[:5000] + ('...' if len(t)>5000 else ''))
+`.trim();
+    const result = spawnSync3("python3", ["-c", script], { timeout: 35e3, encoding: "utf8" });
+    if (result.status !== 0) throw new Error(result.stderr || "Scrapling failed");
+    return result.stdout.trim();
+  }
+};
+
+// packages/daemon/src/capabilities/ShellCapability.ts
+import { spawn } from "node:child_process";
+var ShellCapability = class {
+  name = "shell_exec";
+  description = "Execute shell commands in the working directory.";
+  toolDefinition = {
+    name: "shell_exec",
+    description: "Execute a shell command. Use & for background processes. Returns stdout+stderr.",
     input_schema: {
       type: "object",
       properties: {
-        query: { type: "string", description: "Search query" },
-        num_results: { type: "number", description: "Number of results (default 5, max 10)" }
+        command: { type: "string", description: "Shell command to execute" },
+        timeout_ms: { type: "number", description: "Timeout (default 30000ms)" }
       },
-      required: ["query"]
+      required: ["command"]
     }
-  },
-  {
-    name: "scrape_url",
-    description: "Scrape a URL and return clean structured content. Handles JavaScript-rendered pages, auto-adapts to page structure, returns text/links/metadata. Better than shell curl for web pages.",
+  };
+  async execute(input, cwd) {
+    const command = String(input.command ?? "");
+    const timeout = Number(input.timeout_ms ?? 3e4);
+    const start = Date.now();
+    return new Promise((resolve_) => {
+      const chunks = [];
+      const proc = spawn("bash", ["-c", command], {
+        cwd,
+        env: { ...process.env, TERM: "dumb" },
+        timeout
+      });
+      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();
+        resolve_({
+          success: code === 0,
+          output: output || (code === 0 ? "(no output)" : `exit ${code}`),
+          duration_ms: Date.now() - start,
+          ...code !== 0 && { error: `exit code ${code}` }
+        });
+      });
+      proc.on("error", (err) => {
+        resolve_({ success: false, output: err.message, error: err.message, duration_ms: Date.now() - start });
+      });
+    });
+  }
+};
+
+// packages/daemon/src/capabilities/FileCapability.ts
+import { readFileSync as readFileSync2, writeFileSync, readdirSync, mkdirSync, existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve2, dirname } from "node:path";
+var FileCapability = class {
+  name = "file_op";
+  description = "Read, write, or list files. Scoped to working directory.";
+  toolDefinition = {
+    name: "file_op",
+    description: "Read, write, or list files in the working directory.",
     input_schema: {
       type: "object",
       properties: {
-        url: { type: "string", description: "URL to scrape" },
-        mode: { type: "string", description: 'What to extract: "text" (default), "links", "tables", "full", "markdown"' },
-        selector: { type: "string", description: "Optional CSS selector to target specific element" },
-        wait_ms: { type: "number", description: "Wait N ms after page load (for JS-heavy pages, default 0)" }
+        op: { type: "string", description: '"read", "write", or "list"' },
+        path: { type: "string", description: "File or directory path (relative to cwd)" },
+        content: { type: "string", description: "Content for write operation" }
       },
-      required: ["url"]
+      required: ["op", "path"]
+    }
+  };
+  async execute(input, cwd) {
+    const op = String(input.op ?? "read");
+    const rel = String(input.path ?? ".");
+    const safe = resolve2(cwd, rel);
+    const start = Date.now();
+    if (!safe.startsWith(cwd)) {
+      return { success: false, output: "Path outside working directory", duration_ms: 0 };
+    }
+    try {
+      if (op === "read") {
+        if (!existsSync2(safe)) return { success: false, output: `Not found: ${rel}`, duration_ms: Date.now() - start };
+        const content = readFileSync2(safe, "utf8");
+        return {
+          success: true,
+          output: content.length > 8e3 ? content.slice(0, 8e3) + "\n\u2026[truncated]" : content,
+          duration_ms: Date.now() - start
+        };
+      }
+      if (op === "write") {
+        mkdirSync(dirname(safe), { recursive: true });
+        writeFileSync(safe, String(input.content ?? ""), "utf8");
+        return { success: true, output: `Written: ${rel} (${String(input.content ?? "").length} bytes)`, duration_ms: Date.now() - start };
+      }
+      if (op === "list") {
+        if (!existsSync2(safe)) return { success: false, output: `Not found: ${rel}`, duration_ms: Date.now() - start };
+        const entries = readdirSync(safe, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => `${e.isDirectory() ? "d" : "f"}  ${e.name}`).join("\n");
+        return { success: true, output: entries || "(empty)", duration_ms: Date.now() - start };
+      }
+      return { success: false, output: `Unknown op: ${op}`, duration_ms: Date.now() - start };
+    } catch (err) {
+      return { success: false, output: `Error: ${err instanceof Error ? err.message : String(err)}`, duration_ms: Date.now() - start };
     }
   }
-];
-var LLMExecutor = class {
-  constructor(config) {
-    this.config = config;
+};
+
+// packages/daemon/src/capabilities/CapabilityRegistry.ts
+var CapabilityRegistry = class {
+  capabilities = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(new WebSearchCapability());
+    this.register(new BrowserCapability());
+    this.register(new ScraperCapability());
+    this.register(new ShellCapability());
+    this.register(new FileCapability());
   }
-  get isConfigured() {
-    if (this.config.provider === "ollama") return true;
-    return !!this.config.api_key?.trim();
+  register(cap) {
+    this.capabilities.set(cap.name, cap);
   }
-  // ─── 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 };
+  get(name) {
+    return this.capabilities.get(name);
   }
-  // ─── 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);
+  getToolDefinitions() {
+    return [...this.capabilities.values()].map((c) => c.toolDefinition);
+  }
+  async execute(toolName, input, cwd) {
+    const cap = this.capabilities.get(toolName);
+    if (!cap) {
+      return { success: false, output: `Unknown capability: ${toolName}`, duration_ms: 0 };
+    }
+    try {
+      return await cap.execute(input, cwd);
+    } catch (err) {
+      return {
+        success: false,
+        output: `Capability error: ${err instanceof Error ? err.message : String(err)}`,
+        duration_ms: 0
+      };
     }
   }
-  // ─── 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 }]
-        };
+  list() {
+    return [...this.capabilities.values()].map((c) => ({ name: c.name, description: c.description }));
+  }
+};
+
+// 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;
+    this.registry = new CapabilityRegistry();
+  }
+  cwd;
+  maxIterations;
+  maxCommandMs;
+  registry;
+  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,
+          this.registry.getToolDefinitions(),
+          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;
       }
-      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;
+      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({
@@ -2120,8 +2226,12 @@ var AgentExecutor = class {
         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) {
+          const capResult = await this.registry.execute(tc.name, tc.input, this.cwd);
+          result = capResult.output;
+          if (capResult.fallback_used) {
+            this.onStep(`  (used fallback: ${capResult.fallback_used})`);
+          }
+          if (tc.name === "file_op" && tc.input.op === "write" && tc.input.path) {
             filesWritten.push(String(tc.input.path));
           }
           if (tc.name === "shell_exec" && tc.input.command) {
@@ -2178,9 +2288,9 @@ var AgentExecutor = class {
     }
   }
   shellExec(command, timeoutMs) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const chunks = [];
-      const proc = spawn("bash", ["-c", command], {
+      const proc = spawn2("bash", ["-c", command], {
         cwd: this.cwd,
         env: { ...process.env, TERM: "dumb" },
         timeout: timeoutMs
@@ -2189,26 +2299,26 @@ var AgentExecutor = class {
       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}`));
+        resolve7(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
       });
       proc.on("error", (err) => {
-        resolve6(`Error: ${err.message}`);
+        resolve7(`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");
+    mkdirSync2(dirname2(safe), { recursive: true });
+    writeFileSync2(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");
+    if (!existsSync3(safe)) return `File not found: ${filePath}`;
+    const content = readFileSync3(safe, "utf8");
     return content.length > 8e3 ? content.slice(0, 8e3) + `
 \u2026[truncated, ${content.length} total bytes]` : content;
   }
@@ -2299,9 +2409,9 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
   listDir(dirPath) {
     const safe = this.safePath(dirPath ?? ".");
     if (!safe) return "Error: path outside working directory";
-    if (!existsSync2(safe)) return `Directory not found: ${dirPath}`;
+    if (!existsSync3(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");
+      const entries = readdirSync2(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)}`;
@@ -2309,7 +2419,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
   }
   // ─── Helpers ───────────────────────────────────────────────────────────────
   safePath(p) {
-    const resolved = resolve2(this.cwd, p);
+    const resolved = resolve3(this.cwd, p);
     return resolved.startsWith(this.cwd) ? resolved : null;
   }
   buildSystemPrompt(extra) {
@@ -2794,7 +2904,7 @@ var BackgroundWorkers = class {
 };
 
 // packages/daemon/src/SkillRegistry.ts
-import { readFileSync as readFileSync3, readdirSync as readdirSync2, existsSync as existsSync3, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { readFileSync as readFileSync4, readdirSync as readdirSync3, existsSync as existsSync4, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3 } from "node:fs";
 import { join } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import YAML2 from "yaml";
@@ -2817,11 +2927,11 @@ var SkillRegistry = class {
     this.loadFromDir(this.customDir, false);
   }
   loadFromDir(dir, isBuiltin) {
-    if (!existsSync3(dir)) return;
-    const files = readdirSync2(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    if (!existsSync4(dir)) return;
+    const files = readdirSync3(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     for (const file of files) {
       try {
-        const raw = readFileSync3(join(dir, file), "utf8");
+        const raw = readFileSync4(join(dir, file), "utf8");
         const skill = YAML2.parse(raw);
         if (skill.name) {
           this.skills.set(skill.name, skill);
@@ -2856,9 +2966,9 @@ var SkillRegistry = class {
     if (this.builtinNames.has(name)) {
       throw new Error(`Cannot override built-in skill: ${name}`);
     }
-    mkdirSync2(this.customDir, { recursive: true });
+    mkdirSync3(this.customDir, { recursive: true });
     const filePath = join(this.customDir, `${name}.yaml`);
-    writeFileSync2(filePath, yamlContent, "utf8");
+    writeFileSync3(filePath, yamlContent, "utf8");
     const skill = YAML2.parse(yamlContent);
     this.skills.set(name, skill);
     return skill;
@@ -2871,7 +2981,7 @@ var SkillRegistry = class {
       throw new Error(`Cannot delete built-in skill: ${name}`);
     }
     const filePath = join(this.customDir, `${name}.yaml`);
-    if (existsSync3(filePath)) {
+    if (existsSync4(filePath)) {
       unlinkSync(filePath);
     }
     this.skills.delete(name);
@@ -2884,8 +2994,8 @@ var SkillRegistry = class {
 // packages/daemon/src/HTTPServer.ts
 import { Hono as Hono8 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve as resolve3, dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { resolve as resolve4, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/daemon/src/routes/health.ts
@@ -3116,99 +3226,396 @@ function skillRoutes(deps) {
       const message = err instanceof Error ? err.message : String(err);
       return c.json({ error: message }, 500);
     }
-  });
-  app.delete("/:name", (c) => {
-    const name = c.req.param("name");
-    if (deps.skillRegistry.isBuiltin(name)) {
-      return c.json({ error: "Cannot delete built-in skill" }, 403);
+  });
+  app.delete("/:name", (c) => {
+    const name = c.req.param("name");
+    if (deps.skillRegistry.isBuiltin(name)) {
+      return c.json({ error: "Cannot delete built-in skill" }, 403);
+    }
+    const skill = deps.skillRegistry.get(name);
+    if (!skill) {
+      return c.json({ error: "Skill not found" }, 404);
+    }
+    try {
+      deps.skillRegistry.removeCustom(name);
+      return c.json({ ok: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+  return app;
+}
+
+// packages/daemon/src/HTTPServer.ts
+function findGraphHtml() {
+  const candidates = [
+    resolve4(dirname3(fileURLToPath(import.meta.url)), "graph.html"),
+    // dev (src/)
+    resolve4(dirname3(fileURLToPath(import.meta.url)), "..", "graph.html"),
+    // bundled (dist/../)
+    resolve4(dirname3(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
+  ];
+  for (const p of candidates) {
+    try {
+      readFileSync5(p);
+      return p;
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+var GRAPH_HTML_PATH = findGraphHtml();
+var HTTPServer = class {
+  app;
+  server = null;
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+    this.app = new Hono8();
+    this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
+    this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
+    this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
+    this.app.route("/api/entities", entityRoutes({ graph: deps.graph }));
+    this.app.route("/api/traces", traceRoutes({ traceStore: deps.traceStore }));
+    this.app.route("/api/subagents", subagentRoutes());
+    this.app.route("/api/skills", skillRoutes({ skillRegistry: deps.skillRegistry }));
+    const serveGraph = (c) => {
+      try {
+        const html = readFileSync5(GRAPH_HTML_PATH, "utf8");
+        return c.html(html);
+      } catch {
+        return c.html("<p>Graph UI not found. Run: pnpm build</p>");
+      }
+    };
+    this.app.get("/", serveGraph);
+    this.app.get("/graph", serveGraph);
+  }
+  start() {
+    return new Promise((resolve7) => {
+      this.server = serve(
+        {
+          fetch: this.app.fetch,
+          port: this.deps.port,
+          hostname: this.deps.host
+        },
+        () => {
+          resolve7();
+        }
+      );
+    });
+  }
+  stop() {
+    return new Promise((resolve7, reject) => {
+      if (!this.server) {
+        resolve7();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) reject(err);
+        else resolve7();
+      });
+    });
+  }
+  getApp() {
+    return this.app;
+  }
+};
+
+// packages/daemon/src/LLMExecutor.ts
+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 skill = deps.skillRegistry.get(name);
-    if (!skill) {
-      return c.json({ error: "Skill not found" }, 404);
+    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 }
+      }));
     }
-    try {
-      deps.skillRegistry.removeCustom(name);
-      return c.json({ ok: true });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return c.json({ error: message }, 500);
+    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}`);
     }
-  });
-  return app;
-}
-
-// packages/daemon/src/HTTPServer.ts
-function findGraphHtml() {
-  const candidates = [
-    resolve3(dirname2(fileURLToPath(import.meta.url)), "graph.html"),
-    // dev (src/)
-    resolve3(dirname2(fileURLToPath(import.meta.url)), "..", "graph.html"),
-    // bundled (dist/../)
-    resolve3(dirname2(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
-  ];
-  for (const p of candidates) {
-    try {
-      readFileSync4(p);
-      return p;
-    } catch {
+    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;
+          }
+        }
+      }
     }
-  }
-  return candidates[0];
-}
-var GRAPH_HTML_PATH = findGraphHtml();
-var HTTPServer = class {
-  app;
-  server = null;
-  deps;
-  constructor(deps) {
-    this.deps = deps;
-    this.app = new Hono8();
-    this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
-    this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
-    this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
-    this.app.route("/api/entities", entityRoutes({ graph: deps.graph }));
-    this.app.route("/api/traces", traceRoutes({ traceStore: deps.traceStore }));
-    this.app.route("/api/subagents", subagentRoutes());
-    this.app.route("/api/skills", skillRoutes({ skillRegistry: deps.skillRegistry }));
-    const serveGraph = (c) => {
+    const toolCalls = Object.values(toolCallMap).filter((tc) => tc.id && tc.name).map((tc) => {
+      let input = {};
       try {
-        const html = readFileSync4(GRAPH_HTML_PATH, "utf8");
-        return c.html(html);
+        input = JSON.parse(tc.args);
       } catch {
-        return c.html("<p>Graph UI not found. Run: pnpm build</p>");
       }
-    };
-    this.app.get("/", serveGraph);
-    this.app.get("/graph", serveGraph);
-  }
-  start() {
-    return new Promise((resolve6) => {
-      this.server = serve(
-        {
-          fetch: this.app.fetch,
-          port: this.deps.port,
-          hostname: this.deps.host
-        },
-        () => {
-          resolve6();
-        }
-      );
+      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
+    };
   }
-  stop() {
-    return new Promise((resolve6, reject) => {
-      if (!this.server) {
-        resolve6();
-        return;
-      }
-      this.server.close((err) => {
-        if (err) reject(err);
-        else resolve6();
-      });
+  // ─── 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 })
     });
-  }
-  getApp() {
-    return this.app;
+    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 };
   }
 };
 
@@ -3227,13 +3634,13 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve4(homedir3(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve5(homedir3(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve4(homedir3(), ".0agent");
-    if (!existsSync4(dotDir)) {
-      mkdirSync3(dotDir, { recursive: true });
+    const dotDir = resolve5(homedir3(), ".0agent");
+    if (!existsSync5(dotDir)) {
+      mkdirSync4(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
     this.graph = new KnowledgeGraph(this.adapter);
@@ -3284,7 +3691,7 @@ var ZeroAgentDaemon = class {
       getStatus: () => this.getStatus()
     });
     await this.httpServer.start();
-    writeFileSync3(this.pidFilePath, String(process.pid), "utf8");
+    writeFileSync4(this.pidFilePath, String(process.pid), "utf8");
     console.log(
       `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
     );
@@ -3318,7 +3725,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync4(this.pidFilePath)) {
+    if (existsSync5(this.pidFilePath)) {
       try {
         unlinkSync2(this.pidFilePath);
       } catch {
@@ -3348,11 +3755,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import { homedir as homedir4 } from "node:os";
-import { existsSync as existsSync5 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve5(homedir4(), ".0agent", "config.yaml");
-if (!existsSync5(CONFIG_PATH)) {
+import { existsSync as existsSync6 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve6(homedir4(), ".0agent", "config.yaml");
+if (!existsSync6(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.