0agent 1.0.22 → 1.0.24

package/dist/daemon.mjs

@@ -1490,7 +1490,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve12) => setTimeout(resolve12, ms));
+        return new Promise((resolve13) => setTimeout(resolve13, ms));
       }
     };
   }
@@ -2613,7 +2613,7 @@ var init_AgentExecutor = __esm({
         }
       }
       shellExec(command, timeoutMs) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve13) => {
           const chunks = [];
           const proc = spawn2("bash", ["-c", command], {
             cwd: this.cwd,
@@ -2624,10 +2624,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve12(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve13(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve12(`Error: ${err.message}`);
+            resolve13(`Error: ${err.message}`);
           });
         });
       }
@@ -2933,8 +2933,8 @@ __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
 import { execSync as execSync4 } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync10, statSync, readdirSync as readdirSync5 } from "node:fs";
-import { resolve as resolve9, join as join3 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync11, statSync, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve10, join as join3 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -2983,7 +2983,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync10(resolve9(this.cwd, ".git"))) return;
+        if (!existsSync11(resolve10(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -3027,13 +3027,13 @@ var init_ProactiveSurface = __esm({
         ];
         for (const dir of outputPaths) {
           try {
-            if (!existsSync10(dir)) continue;
+            if (!existsSync11(dir)) continue;
             const xmlFiles = readdirSafe(dir).filter((f) => f.endsWith(".xml"));
             for (const xml of xmlFiles) {
               const path = join3(dir, xml);
               const stat = statSync(path);
               if (stat.mtimeMs < this.lastPollAt) continue;
-              const content = readFileSync10(path, "utf8");
+              const content = readFileSync11(path, "utf8");
               const failures = [...content.matchAll(/<failure[^>]*message="([^"]+)"/g)].length;
               if (failures > 0) {
                 return this.makeInsight(
@@ -3088,9 +3088,9 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, existsSync as existsSync12, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
 import { readFileSync, existsSync } from "node:fs";
@@ -3312,1669 +3312,1701 @@ var EntityScopedContextLoader = class {
   }
 };
 
-// packages/daemon/src/SessionManager.ts
-init_AgentExecutor();
-
-// packages/daemon/src/AnthropicSkillFetcher.ts
-var BASE_URL = "https://raw.githubusercontent.com/anthropics/skills/main";
-var CACHE_TTL_MS = 60 * 60 * 1e3;
-var ANTHROPIC_SKILLS = [
-  "algorithmic-art",
-  "brand-guidelines",
-  "canvas-design",
-  "claude-api",
-  "doc-coauthoring",
-  "docx",
-  "frontend-design",
-  "internal-comms",
-  "mcp-builder",
-  "pdf",
-  "pptx",
-  "skill-creator",
-  "slack-gif-creator",
-  "theme-factory",
-  "web-artifacts-builder",
-  "webapp-testing",
-  "xlsx"
-];
-var AnthropicSkillFetcher = class {
-  cache = /* @__PURE__ */ new Map();
-  /**
-   * Fetch a skill's instructions from the Anthropic repo.
-   * Returns the Markdown body as a role_prompt string.
-   * Caches for 1 hour.
-   */
-  async fetch(skillName) {
-    const cached = this.cache.get(skillName);
-    if (cached && Date.now() - cached.fetched_at < CACHE_TTL_MS) {
-      return this.parseSkillMd(skillName, cached.prompt, true);
-    }
-    const urls = [
-      `${BASE_URL}/skills/${skillName}/SKILL.md`,
-      `${BASE_URL}/${skillName}/SKILL.md`,
-      `${BASE_URL}/skills/${skillName}/README.md`
-    ];
-    for (const url of urls) {
-      try {
-        const res = await fetch(url, {
-          headers: { "User-Agent": "0agent/1.0" },
-          signal: AbortSignal.timeout(8e3)
-        });
-        if (res.ok) {
-          const text = await res.text();
-          this.cache.set(skillName, { prompt: text, fetched_at: Date.now() });
-          return this.parseSkillMd(skillName, text, false);
-        }
-      } catch {
-      }
-    }
-    return null;
-  }
-  /**
-   * Parse a SKILL.md file into a FetchedSkill.
-   * Extracts name/description from YAML frontmatter, instructions from body.
-   */
-  parseSkillMd(skillName, raw, cached) {
-    let name = skillName;
-    let description = "";
-    let instructions = raw;
-    const frontmatterMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-    if (frontmatterMatch) {
-      const frontmatter = frontmatterMatch[1];
-      instructions = frontmatterMatch[2].trim();
-      const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
-      if (nameMatch) name = nameMatch[1].trim().replace(/["']/g, "");
-      const descMatch = frontmatter.match(/^description:\s*([\s\S]*?)(?=^\w|\Z)/m);
-      if (descMatch) description = descMatch[1].replace(/\s+/g, " ").trim().replace(/["']/g, "");
-    }
-    return {
-      name,
-      description,
-      instructions,
-      source_url: `https://github.com/anthropics/skills/tree/main/skills/${skillName}`,
-      cached
-    };
-  }
-  /**
-   * Build a system prompt that injects the Anthropic skill instructions.
-   * This is what gets passed to the agent as context.
-   */
-  buildSystemPrompt(skill) {
-    return [
-      `You are using the "${skill.name}" skill from Anthropic's skill library.`,
-      ``,
-      `Skill description: ${skill.description}`,
-      ``,
-      `Instructions:`,
-      `---`,
-      skill.instructions,
-      `---`,
-      ``,
-      `Use the tools available to you (shell_exec, file_op, web_search, scrape_url, browser_open)`,
-      `to complete the task following these instructions.`
-    ].join("\n");
-  }
-  /**
-   * List all known Anthropic skills.
-   */
-  listAvailable() {
-    return [...ANTHROPIC_SKILLS];
-  }
-  /**
-   * Check if a skill name is a known Anthropic skill.
-   */
-  isAnthropicSkill(name) {
-    return ANTHROPIC_SKILLS.includes(name);
-  }
-  /**
-   * Clear the cache (force re-fetch on next request).
-   */
-  clearCache() {
-    this.cache.clear();
+// packages/daemon/src/LLMExecutor.ts
+var LLMExecutor = class {
+  constructor(config) {
+    this.config = config;
   }
-};
-
-// packages/daemon/src/ProjectScanner.ts
-import { execSync as execSync3 } from "node:child_process";
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
-import { join } from "node:path";
-import { createServer } from "node:net";
-var PORTS_TO_CHECK = [3e3, 3001, 4e3, 4200, 5e3, 5173, 8e3, 8080, 8888];
-var ProjectScanner = class {
-  constructor(cwd) {
-    this.cwd = cwd;
+  get isConfigured() {
+    if (this.config.provider === "ollama") return true;
+    return !!this.config.api_key?.trim();
   }
-  async scan() {
-    const [stack, name] = this.detectStack();
-    const recentCommits = this.getRecentCommits();
-    const dirtyFiles = this.getDirtyFiles();
-    const runningPorts = await this.getRunningPorts();
-    const readmeSummary = this.getReadmeSummary();
-    return {
-      cwd: this.cwd,
-      stack,
-      name,
-      recent_commits: recentCommits,
-      dirty_files: dirtyFiles,
-      running_ports: runningPorts,
-      readme_summary: readmeSummary
-    };
+  // ─── 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 };
   }
-  /**
-   * Build a compact system prompt injection from the context.
-   */
-  static buildContextPrompt(ctx) {
-    const lines = [`Working directory: ${ctx.cwd}`];
-    if (ctx.name) lines.push(`Project: ${ctx.name}`);
-    if (ctx.stack.length) lines.push(`Stack: ${ctx.stack.join(", ")}`);
-    if (ctx.recent_commits.length) {
-      lines.push(`Recent commits: ${ctx.recent_commits.slice(0, 3).join(" | ")}`);
-    }
-    if (ctx.dirty_files.length) {
-      lines.push(`Uncommitted changes: ${ctx.dirty_files.slice(0, 5).join(", ")}`);
-    }
-    if (ctx.running_ports.length) {
-      lines.push(`Running servers: ports ${ctx.running_ports.join(", ")}`);
-    }
-    if (ctx.readme_summary) {
-      lines.push(`README: ${ctx.readme_summary}`);
+  // ─── 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);
     }
-    return lines.join("\n");
   }
-  detectStack() {
-    const stack = [];
-    let name = "";
-    const pkgPath = join(this.cwd, "package.json");
-    if (existsSync4(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
-        name = pkg.name ?? "";
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        stack.push("node");
-        if (deps.typescript || existsSync4(join(this.cwd, "tsconfig.json"))) stack.push("typescript");
-        if (deps.react) stack.push("react");
-        if (deps.vue) stack.push("vue");
-        if (deps.svelte) stack.push("svelte");
-        if (deps.next) stack.push("next.js");
-        if (deps.express || deps.fastify || deps.hono) stack.push("backend");
-      } catch {
+  // ─── 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 (existsSync4(join(this.cwd, "Cargo.toml"))) {
-      stack.push("rust");
-      try {
-        const cargo = readFileSync4(join(this.cwd, "Cargo.toml"), "utf8");
-        const nameMatch = cargo.match(/^name\s*=\s*"([^"]+)"/m);
-        if (nameMatch && !name) name = nameMatch[1];
-      } catch {
+      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
+      }));
     }
-    if (existsSync4(join(this.cwd, "pyproject.toml")) || existsSync4(join(this.cwd, "requirements.txt"))) {
-      stack.push("python");
-    }
-    if (existsSync4(join(this.cwd, "go.mod"))) stack.push("go");
-    return [stack, name];
-  }
-  getRecentCommits() {
-    try {
-      const out = execSync3("git log --oneline -5 2>/dev/null", {
-        cwd: this.cwd,
-        timeout: 3e3,
-        encoding: "utf8"
-      }).trim();
-      return out ? out.split("\n").map((l) => l.trim()) : [];
-    } catch {
-      return [];
+    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}`);
     }
-  }
-  getDirtyFiles() {
-    try {
-      const out = execSync3("git status --short 2>/dev/null", {
-        cwd: this.cwd,
-        timeout: 3e3,
-        encoding: "utf8"
-      }).trim();
-      return out ? out.split("\n").map((l) => l.slice(3).trim()) : [];
-    } catch {
-      return [];
+    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
+    };
   }
-  async getRunningPorts() {
-    const open = [];
-    await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve12) => {
-        const s = createServer();
-        s.listen(port, "127.0.0.1", () => {
-          s.close();
-          resolve12();
-        });
-        s.on("error", () => {
-          open.push(port);
-          resolve12();
+  // ─── 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) }
+          }))
         });
-        setTimeout(() => {
-          s.close();
-          resolve12();
-        }, 200);
-      })
-    ));
-    return open;
-  }
-  getReadmeSummary() {
-    for (const name of ["README.md", "readme.md", "README.txt", "README"]) {
-      const p = join(this.cwd, name);
-      if (existsSync4(p)) {
+      } 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 {
-          return readFileSync4(p, "utf8").slice(0, 300).replace(/\n+/g, " ").trim();
+          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 "";
+    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
+    };
   }
-};
-
-// packages/daemon/src/ConversationStore.ts
-var CREATE_TABLE = `
-  CREATE TABLE IF NOT EXISTS conversations (
-    id TEXT PRIMARY KEY,
-    session_id TEXT NOT NULL,
-    user_entity_id TEXT NOT NULL,
-    role TEXT NOT NULL,
-    content TEXT NOT NULL,
-    created_at INTEGER NOT NULL
-  );
-  CREATE INDEX IF NOT EXISTS idx_conv_user ON conversations(user_entity_id, created_at);
-`;
-var ConversationStore = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  initialised = false;
-  init() {
-    if (this.initialised) return;
-    this.adapter.db.exec(CREATE_TABLE);
-    this.initialised = true;
-  }
-  append(msg) {
-    this.init();
-    const db = this.adapter.db;
-    db.prepare(
-      `INSERT INTO conversations (id, session_id, user_entity_id, role, content, created_at)
-       VALUES (?, ?, ?, ?, ?, ?)`
-    ).run(msg.id, msg.session_id, msg.user_entity_id, msg.role, msg.content, msg.created_at);
-  }
-  getHistory(userEntityId, limit = 20) {
-    this.init();
-    const db = this.adapter.db;
-    const rows = db.prepare(
-      `SELECT * FROM conversations WHERE user_entity_id = ?
-       ORDER BY created_at DESC LIMIT ?`
-    ).all(userEntityId, limit);
-    return rows.reverse();
-  }
-  /**
-   * Build conversation history as LLM messages for context injection.
-   */
-  buildContextMessages(userEntityId, limit = 10) {
-    return this.getHistory(userEntityId, limit).map((m) => ({
-      role: m.role,
-      content: m.content
-    }));
-  }
-  clearHistory(userEntityId) {
-    this.init();
-    const db = this.adapter.db;
-    db.prepare(`DELETE FROM conversations WHERE user_entity_id = ?`).run(userEntityId);
+  // ─── 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/SessionManager.ts
-var SessionManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  inferenceEngine;
-  eventBus;
-  graph;
-  llm;
-  cwd;
-  identity;
-  projectContext;
-  conversationStore;
-  weightUpdater;
-  anthropicFetcher = new AnthropicSkillFetcher();
-  constructor(deps = {}) {
-    this.inferenceEngine = deps.inferenceEngine;
-    this.eventBus = deps.eventBus;
-    this.graph = deps.graph;
-    this.llm = deps.llm;
-    this.cwd = deps.cwd ?? process.cwd();
-    this.identity = deps.identity;
-    this.projectContext = deps.projectContext;
-    if (deps.adapter) {
-      this.conversationStore = new ConversationStore(deps.adapter);
-      this.conversationStore.init();
-      const wLog = new WeightEventLog(deps.adapter);
-      this.weightUpdater = new EdgeWeightUpdater(deps.adapter, wLog);
-    }
-  }
-  /**
-   * Create a new session with status 'pending'.
-   */
-  createSession(req) {
-    const id = crypto.randomUUID();
-    const session = {
-      id,
-      task: req.task,
-      skill: req.skill,
-      entity_id: req.entity_id,
-      status: "pending",
-      created_at: Date.now(),
-      steps: []
-    };
-    this.sessions.set(id, session);
-    return session;
-  }
+init_AgentExecutor();
+
+// packages/daemon/src/AnthropicSkillFetcher.ts
+var BASE_URL = "https://raw.githubusercontent.com/anthropics/skills/main";
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+var ANTHROPIC_SKILLS = [
+  "algorithmic-art",
+  "brand-guidelines",
+  "canvas-design",
+  "claude-api",
+  "doc-coauthoring",
+  "docx",
+  "frontend-design",
+  "internal-comms",
+  "mcp-builder",
+  "pdf",
+  "pptx",
+  "skill-creator",
+  "slack-gif-creator",
+  "theme-factory",
+  "web-artifacts-builder",
+  "webapp-testing",
+  "xlsx"
+];
+var AnthropicSkillFetcher = class {
+  cache = /* @__PURE__ */ new Map();
   /**
-   * Transition session to 'running' and optionally invoke inference engine.
+   * Fetch a skill's instructions from the Anthropic repo.
+   * Returns the Markdown body as a role_prompt string.
+   * Caches for 1 hour.
    */
-  async startSession(id) {
-    const session = this.getSessionOrThrow(id);
-    session.status = "running";
-    session.started_at = Date.now();
-    this.emit({
-      type: "session.started",
-      session_id: session.id,
-      task: session.task
-    });
-    if (this.inferenceEngine) {
+  async fetch(skillName) {
+    const cached = this.cache.get(skillName);
+    if (cached && Date.now() - cached.fetched_at < CACHE_TTL_MS) {
+      return this.parseSkillMd(skillName, cached.prompt, true);
+    }
+    const urls = [
+      `${BASE_URL}/skills/${skillName}/SKILL.md`,
+      `${BASE_URL}/${skillName}/SKILL.md`,
+      `${BASE_URL}/skills/${skillName}/README.md`
+    ];
+    for (const url of urls) {
       try {
-        const plan = await this.inferenceEngine.resolve(session.task);
-        session.plan = plan;
-        if (plan.skill) {
-          session.skill = plan.skill;
+        const res = await fetch(url, {
+          headers: { "User-Agent": "0agent/1.0" },
+          signal: AbortSignal.timeout(8e3)
+        });
+        if (res.ok) {
+          const text = await res.text();
+          this.cache.set(skillName, { prompt: text, fetched_at: Date.now() });
+          return this.parseSkillMd(skillName, text, false);
         }
       } catch {
       }
     }
-    return session;
+    return null;
   }
   /**
-   * Append a step to a running session.
+   * Parse a SKILL.md file into a FetchedSkill.
+   * Extracts name/description from YAML frontmatter, instructions from body.
    */
-  addStep(id, description, result) {
-    const session = this.getSessionOrThrow(id);
-    const step = {
-      index: session.steps.length,
+  parseSkillMd(skillName, raw, cached) {
+    let name = skillName;
+    let description = "";
+    let instructions = raw;
+    const frontmatterMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (frontmatterMatch) {
+      const frontmatter = frontmatterMatch[1];
+      instructions = frontmatterMatch[2].trim();
+      const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+      if (nameMatch) name = nameMatch[1].trim().replace(/["']/g, "");
+      const descMatch = frontmatter.match(/^description:\s*([\s\S]*?)(?=^\w|\Z)/m);
+      if (descMatch) description = descMatch[1].replace(/\s+/g, " ").trim().replace(/["']/g, "");
+    }
+    return {
+      name,
       description,
-      result,
-      started_at: Date.now()
+      instructions,
+      source_url: `https://github.com/anthropics/skills/tree/main/skills/${skillName}`,
+      cached
     };
-    session.steps.push(step);
-    this.emit({
-      type: "session.step",
-      session_id: session.id,
-      step: description,
-      result: result ?? null
-    });
-    return step;
   }
   /**
-   * Mark session as completed with a result.
+   * Build a system prompt that injects the Anthropic skill instructions.
+   * This is what gets passed to the agent as context.
    */
-  completeSession(id, result) {
-    const session = this.getSessionOrThrow(id);
-    session.status = "completed";
-    session.completed_at = Date.now();
-    session.result = result;
-    this.emit({
-      type: "session.completed",
-      session_id: session.id,
-      result: result ?? null
-    });
-    return session;
+  buildSystemPrompt(skill) {
+    return [
+      `You are using the "${skill.name}" skill from Anthropic's skill library.`,
+      ``,
+      `Skill description: ${skill.description}`,
+      ``,
+      `Instructions:`,
+      `---`,
+      skill.instructions,
+      `---`,
+      ``,
+      `Use the tools available to you (shell_exec, file_op, web_search, scrape_url, browser_open)`,
+      `to complete the task following these instructions.`
+    ].join("\n");
   }
   /**
-   * Mark session as failed with an error message.
+   * List all known Anthropic skills.
    */
-  failSession(id, error) {
-    const session = this.getSessionOrThrow(id);
-    session.status = "failed";
-    session.completed_at = Date.now();
-    session.error = error;
-    this.emit({
-      type: "session.failed",
-      session_id: session.id,
-      error
-    });
-    return session;
+  listAvailable() {
+    return [...ANTHROPIC_SKILLS];
   }
   /**
-   * Cancel a session.
+   * Check if a skill name is a known Anthropic skill.
    */
-  cancelSession(id) {
-    const session = this.getSessionOrThrow(id);
-    session.status = "cancelled";
-    session.completed_at = Date.now();
-    session.error = "cancelled";
-    this.emit({
-      type: "session.failed",
-      session_id: session.id,
-      error: "cancelled"
-    });
-    return session;
+  isAnthropicSkill(name) {
+    return ANTHROPIC_SKILLS.includes(name);
   }
   /**
-   * Get session by ID, or null if not found.
+   * Clear the cache (force re-fetch on next request).
    */
-  getSession(id) {
-    return this.sessions.get(id) ?? null;
+  clearCache() {
+    this.cache.clear();
   }
-  /**
-   * List all sessions sorted by created_at descending.
-   */
-  listSessions() {
-    return [...this.sessions.values()].sort(
-      (a, b) => b.created_at - a.created_at
-    );
+};
+
+// packages/daemon/src/ProjectScanner.ts
+import { execSync as execSync3 } from "node:child_process";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
+import { join } from "node:path";
+import { createServer } from "node:net";
+var PORTS_TO_CHECK = [3e3, 3001, 4e3, 4200, 5e3, 5173, 8e3, 8080, 8888];
+var ProjectScanner = class {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async scan() {
+    const [stack, name] = this.detectStack();
+    const recentCommits = this.getRecentCommits();
+    const dirtyFiles = this.getDirtyFiles();
+    const runningPorts = await this.getRunningPorts();
+    const readmeSummary = this.getReadmeSummary();
+    return {
+      cwd: this.cwd,
+      stack,
+      name,
+      recent_commits: recentCommits,
+      dirty_files: dirtyFiles,
+      running_ports: runningPorts,
+      readme_summary: readmeSummary
+    };
   }
   /**
-   * End-to-end session run: create -> start -> resolve -> step -> complete.
-   * Wraps everything in try/catch to fail gracefully.
+   * Build a compact system prompt injection from the context.
    */
-  async runSession(req) {
-    let enrichedReq = req;
-    if (req.entity_id && this.graph) {
-      const loader = new EntityScopedContextLoader(this.graph);
-      const scopedCtx = loader.load(req.entity_id);
-      if (scopedCtx?.personality_prompt) {
-        enrichedReq = {
-          ...req,
-          context: {
-            ...req.context,
-            system_context: [
-              scopedCtx.personality_prompt,
-              ...req.context?.system_context != null ? [String(req.context.system_context)] : []
-            ].join("\n\n"),
-            entity_label: scopedCtx.entity_label,
-            parent_entity_labels: scopedCtx.parent_entity_labels
-          }
-        };
-      }
+  static buildContextPrompt(ctx) {
+    const lines = [`Working directory: ${ctx.cwd}`];
+    if (ctx.name) lines.push(`Project: ${ctx.name}`);
+    if (ctx.stack.length) lines.push(`Stack: ${ctx.stack.join(", ")}`);
+    if (ctx.recent_commits.length) {
+      lines.push(`Recent commits: ${ctx.recent_commits.slice(0, 3).join(" | ")}`);
     }
-    const session = this.createSession(enrichedReq);
-    try {
-      await this.startSession(session.id);
-      this.addStep(session.id, `Extracting entities from: "${req.task.slice(0, 60)}${req.task.length > 60 ? "\u2026" : ""}"`);
-      this.addStep(session.id, "Querying knowledge graph (structural + semantic)\u2026");
-      if (session.plan) {
-        const edge = session.plan.selected_edge;
-        if (edge) {
-          this.addStep(
-            session.id,
-            `Selected plan: ${edge.from_label} \u2192 ${edge.to_label} (weight: ${edge.weight.toFixed(2)}, mode: ${edge.mode})`,
-            session.plan
-          );
-        } else {
-          this.addStep(session.id, `No prior plan found \u2014 bootstrapping from scratch`, session.plan);
-        }
-        if (session.plan.skill) {
-          this.addStep(session.id, `Matched skill: /${session.plan.skill}`);
-        }
-      } else {
-        this.addStep(session.id, "No inference engine connected \u2014 executing task directly");
-      }
-      let anthropicContext;
-      if (enrichedReq.skill && this.anthropicFetcher.isAnthropicSkill(enrichedReq.skill)) {
-        this.addStep(session.id, `Fetching skill instructions: ${enrichedReq.skill}`);
-        const fetched = await this.anthropicFetcher.fetch(enrichedReq.skill);
-        if (fetched) {
-          anthropicContext = this.anthropicFetcher.buildSystemPrompt(fetched);
-          this.addStep(session.id, `Loaded skill: ${fetched.name} (${fetched.cached ? "cached" : "fresh"})`);
-        }
-      }
-      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 identityContext = this.identity ? `You are talking to ${this.identity.name} (device: ${this.identity.device_id}, timezone: ${this.identity.timezone}).` : void 0;
-        const projectCtx = this.projectContext ? ProjectScanner.buildContextPrompt(this.projectContext) : void 0;
-        const userEntityId = enrichedReq.entity_id ?? this.identity?.entity_node_id;
-        let conversationHistory;
-        if (this.conversationStore && userEntityId) {
-          const history = this.conversationStore.buildContextMessages(userEntityId, 8);
-          if (history.length > 0) {
-            const historyStr = history.map((m) => `${m.role === "user" ? "User" : "Agent"}: ${m.content.slice(0, 400)}`).join("\n");
-            conversationHistory = `CONVERSATION HISTORY (use this for context on follow-up requests):
-${historyStr}
-
-Current task:`;
-          }
-        }
-        const systemContext = [
-          identityContext,
-          projectCtx,
-          conversationHistory,
-          anthropicContext,
-          enrichedReq.context?.system_context ? String(enrichedReq.context.system_context) : void 0
-        ].filter(Boolean).join("\n\n") || void 0;
-        let agentResult;
-        try {
-          const { SelfHealLoop: SelfHealLoop2 } = await Promise.resolve().then(() => (init_SelfHealLoop(), SelfHealLoop_exports));
-          const healLoop = new SelfHealLoop2(
-            this.llm,
-            { cwd: this.cwd },
-            (step) => this.addStep(session.id, step),
-            (token) => this.emit({ type: "session.token", session_id: session.id, token })
-          );
-          agentResult = await healLoop.executeWithHealing(enrichedReq.task, systemContext);
-        } catch {
-          agentResult = await executor.execute(enrichedReq.task, systemContext);
-        }
-        if (this.conversationStore && userEntityId) {
-          const sessionId = session.id;
-          const now = Date.now();
-          this.conversationStore.append({
-            id: crypto.randomUUID(),
-            session_id: sessionId,
-            user_entity_id: userEntityId,
-            role: "user",
-            content: enrichedReq.task,
-            created_at: now
-          });
-          this.conversationStore.append({
-            id: crypto.randomUUID(),
-            session_id: sessionId,
-            user_entity_id: userEntityId,
-            role: "assistant",
-            content: agentResult.output.slice(0, 1e3),
-            // cap stored output length
-            created_at: now + 1
-          });
-        }
-        const selectedEdgeId = session.plan?.selected_edge?.edge_id;
-        if (selectedEdgeId && this.weightUpdater && this.graph) {
-          const outcomeSignal = this.computeOutcomeSignal(agentResult);
-          if (outcomeSignal !== 0) {
-            const edge = this.graph.getEdge(selectedEdgeId);
-            if (edge && !edge.locked) {
-              const newWeight = Math.max(0, Math.min(
-                1,
-                edge.weight + outcomeSignal * 0.1
-                // learning rate 0.1
-              ));
-              await this.weightUpdater.update(
-                edge.id,
-                edge.weight,
-                newWeight,
-                outcomeSignal > 0 ? "task_outcome_positive" : "task_outcome_negative",
-                session.id
-              );
-              this.emit({ type: "graph.weight_updated", edge_id: edge.id, old_weight: edge.weight, new_weight: newWeight });
-            }
-          }
-        }
-        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);
+    if (ctx.dirty_files.length) {
+      lines.push(`Uncommitted changes: ${ctx.dirty_files.slice(0, 5).join(", ")}`);
     }
-    return this.sessions.get(session.id);
-  }
-  /**
-   * Return the number of active (running) sessions.
-   */
-  activeSessionCount() {
-    let count = 0;
-    for (const s of this.sessions.values()) {
-      if (s.status === "running") count++;
+    if (ctx.running_ports.length) {
+      lines.push(`Running servers: ports ${ctx.running_ports.join(", ")}`);
     }
-    return count;
-  }
-  // ─── Private helpers ───────────────────────────────
-  getSessionOrThrow(id) {
-    const session = this.sessions.get(id);
-    if (!session) {
-      throw new Error(`Session not found: ${id}`);
+    if (ctx.readme_summary) {
+      lines.push(`README: ${ctx.readme_summary}`);
     }
-    return session;
+    return lines.join("\n");
   }
-  emit(event) {
-    if (this.eventBus) {
-      this.eventBus.emit(event);
+  detectStack() {
+    const stack = [];
+    let name = "";
+    const pkgPath = join(this.cwd, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+        name = pkg.name ?? "";
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        stack.push("node");
+        if (deps.typescript || existsSync4(join(this.cwd, "tsconfig.json"))) stack.push("typescript");
+        if (deps.react) stack.push("react");
+        if (deps.vue) stack.push("vue");
+        if (deps.svelte) stack.push("svelte");
+        if (deps.next) stack.push("next.js");
+        if (deps.express || deps.fastify || deps.hono) stack.push("backend");
+      } catch {
+      }
     }
-  }
-  /**
-   * Convert a task result into a weight signal for the knowledge graph.
-   *
-   * Signal scale: -0.3 (failed after retries) to +0.3 (verified success first try).
-   * Neutral (0) when no verification was possible — don't penalise unverifiable tasks.
-   */
-  computeOutcomeSignal(result) {
-    const healAttempts = result["heal_attempts"];
-    if (!healAttempts || healAttempts.length === 0) return 0;
-    const last = healAttempts[healAttempts.length - 1];
-    const verification = last?.["verification"];
-    if (!verification || verification["method"] === "none") return 0;
-    const success = verification["success"] === true;
-    const healed = result["healed"] === true;
-    if (success) return healed ? 0.1 : 0.3;
-    return -0.2;
+    if (existsSync4(join(this.cwd, "Cargo.toml"))) {
+      stack.push("rust");
+      try {
+        const cargo = readFileSync4(join(this.cwd, "Cargo.toml"), "utf8");
+        const nameMatch = cargo.match(/^name\s*=\s*"([^"]+)"/m);
+        if (nameMatch && !name) name = nameMatch[1];
+      } catch {
+      }
+    }
+    if (existsSync4(join(this.cwd, "pyproject.toml")) || existsSync4(join(this.cwd, "requirements.txt"))) {
+      stack.push("python");
+    }
+    if (existsSync4(join(this.cwd, "go.mod"))) stack.push("go");
+    return [stack, name];
+  }
+  getRecentCommits() {
+    try {
+      const out = execSync3("git log --oneline -5 2>/dev/null", {
+        cwd: this.cwd,
+        timeout: 3e3,
+        encoding: "utf8"
+      }).trim();
+      return out ? out.split("\n").map((l) => l.trim()) : [];
+    } catch {
+      return [];
+    }
+  }
+  getDirtyFiles() {
+    try {
+      const out = execSync3("git status --short 2>/dev/null", {
+        cwd: this.cwd,
+        timeout: 3e3,
+        encoding: "utf8"
+      }).trim();
+      return out ? out.split("\n").map((l) => l.slice(3).trim()) : [];
+    } catch {
+      return [];
+    }
+  }
+  async getRunningPorts() {
+    const open = [];
+    await Promise.all(PORTS_TO_CHECK.map(
+      (port) => new Promise((resolve13) => {
+        const s = createServer();
+        s.listen(port, "127.0.0.1", () => {
+          s.close();
+          resolve13();
+        });
+        s.on("error", () => {
+          open.push(port);
+          resolve13();
+        });
+        setTimeout(() => {
+          s.close();
+          resolve13();
+        }, 200);
+      })
+    ));
+    return open;
+  }
+  getReadmeSummary() {
+    for (const name of ["README.md", "readme.md", "README.txt", "README"]) {
+      const p = join(this.cwd, name);
+      if (existsSync4(p)) {
+        try {
+          return readFileSync4(p, "utf8").slice(0, 300).replace(/\n+/g, " ").trim();
+        } catch {
+        }
+      }
+    }
+    return "";
   }
 };
 
-// packages/daemon/src/WebSocketEvents.ts
-var WebSocketEventBus = class {
-  clients = /* @__PURE__ */ new Set();
-  handlers = /* @__PURE__ */ new Set();
-  heartbeatTimer = null;
-  /**
-   * Register a connected WebSocket client.
-   * Automatically removes on close.
-   */
-  addClient(ws) {
-    this.clients.add(ws);
-    ws.on("close", () => {
-      this.clients.delete(ws);
-    });
-    ws.on("error", () => {
-      this.clients.delete(ws);
-    });
+// packages/daemon/src/ConversationStore.ts
+var CREATE_TABLE = `
+  CREATE TABLE IF NOT EXISTS conversations (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    user_entity_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_conv_user ON conversations(user_entity_id, created_at);
+`;
+var ConversationStore = class {
+  constructor(adapter) {
+    this.adapter = adapter;
   }
-  /**
-   * Manually remove a WebSocket client.
-   */
-  removeClient(ws) {
-    this.clients.delete(ws);
+  initialised = false;
+  init() {
+    if (this.initialised) return;
+    this.adapter.db.exec(CREATE_TABLE);
+    this.initialised = true;
+  }
+  append(msg) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare(
+      `INSERT INTO conversations (id, session_id, user_entity_id, role, content, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(msg.id, msg.session_id, msg.user_entity_id, msg.role, msg.content, msg.created_at);
+  }
+  getHistory(userEntityId, limit = 20) {
+    this.init();
+    const db = this.adapter.db;
+    const rows = db.prepare(
+      `SELECT * FROM conversations WHERE user_entity_id = ?
+       ORDER BY created_at DESC LIMIT ?`
+    ).all(userEntityId, limit);
+    return rows.reverse();
   }
   /**
-   * Emit an event to all local handlers and broadcast to WS clients.
+   * Build conversation history as LLM messages for context injection.
    */
-  emit(event) {
-    const typed = event;
-    for (const handler of this.handlers) {
-      try {
-        handler(typed);
-      } catch {
-      }
+  buildContextMessages(userEntityId, limit = 10) {
+    return this.getHistory(userEntityId, limit).map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+  }
+  clearHistory(userEntityId) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare(`DELETE FROM conversations WHERE user_entity_id = ?`).run(userEntityId);
+  }
+};
+
+// packages/daemon/src/SessionManager.ts
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import YAML2 from "yaml";
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  inferenceEngine;
+  eventBus;
+  graph;
+  llm;
+  cwd;
+  identity;
+  projectContext;
+  conversationStore;
+  weightUpdater;
+  anthropicFetcher = new AnthropicSkillFetcher();
+  constructor(deps = {}) {
+    this.inferenceEngine = deps.inferenceEngine;
+    this.eventBus = deps.eventBus;
+    this.graph = deps.graph;
+    this.llm = deps.llm;
+    this.cwd = deps.cwd ?? process.cwd();
+    this.identity = deps.identity;
+    this.projectContext = deps.projectContext;
+    if (deps.adapter) {
+      this.conversationStore = new ConversationStore(deps.adapter);
+      this.conversationStore.init();
+      const wLog = new WeightEventLog(deps.adapter);
+      this.weightUpdater = new EdgeWeightUpdater(deps.adapter, wLog);
     }
-    this.broadcast(typed);
   }
   /**
-   * Register a local event handler.
-   * Returns an unsubscribe function.
+   * Create a new session with status 'pending'.
    */
-  onEvent(handler) {
-    this.handlers.add(handler);
-    return () => {
-      this.handlers.delete(handler);
+  createSession(req) {
+    const id = crypto.randomUUID();
+    const session = {
+      id,
+      task: req.task,
+      skill: req.skill,
+      entity_id: req.entity_id,
+      status: "pending",
+      created_at: Date.now(),
+      steps: []
     };
+    this.sessions.set(id, session);
+    return session;
   }
   /**
-   * Send an event to all connected WebSocket clients.
+   * Transition session to 'running' and optionally invoke inference engine.
    */
-  broadcast(event) {
-    if (this.clients.size === 0) return;
-    const data = JSON.stringify(event);
-    for (const ws of this.clients) {
+  async startSession(id) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "running";
+    session.started_at = Date.now();
+    this.emit({
+      type: "session.started",
+      session_id: session.id,
+      task: session.task
+    });
+    if (this.inferenceEngine) {
       try {
-        ws.send(data);
+        const plan = await this.inferenceEngine.resolve(session.task);
+        session.plan = plan;
+        if (plan.skill) {
+          session.skill = plan.skill;
+        }
       } catch {
-        this.clients.delete(ws);
       }
     }
+    return session;
   }
   /**
-   * Start a periodic heartbeat that emits daemon.stats events.
-   * Runs every 30 seconds.
-   */
-  startStatsHeartbeat(getStats) {
-    this.stopStatsHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      const stats = getStats();
-      this.emit({
-        type: "daemon.stats",
-        graph_nodes: stats.graph_nodes,
-        active_sessions: stats.active_sessions
-      });
-    }, 3e4);
-  }
-  /**
-   * Stop the stats heartbeat.
+   * Append a step to a running session.
    */
-  stopStatsHeartbeat() {
-    if (this.heartbeatTimer !== null) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  /**
-   * Get the number of connected WS clients.
-   */
-  clientCount() {
-    return this.clients.size;
+  addStep(id, description, result) {
+    const session = this.getSessionOrThrow(id);
+    const step = {
+      index: session.steps.length,
+      description,
+      result,
+      started_at: Date.now()
+    };
+    session.steps.push(step);
+    this.emit({
+      type: "session.step",
+      session_id: session.id,
+      step: description,
+      result: result ?? null
+    });
+    return step;
   }
   /**
-   * Get the number of registered local handlers.
+   * Mark session as completed with a result.
    */
-  handlerCount() {
-    return this.handlers.size;
-  }
-};
-
-// packages/daemon/src/BackgroundWorkers.ts
-var DEFAULT_CONFIG2 = {
-  decay_interval_ms: 6 * 60 * 60 * 1e3,
-  // 6 hours
-  deferred_trace_interval_ms: 6e4,
-  // 60 seconds
-  compactor_interval_ms: 24 * 60 * 60 * 1e3,
-  // 24 hours
-  enrichment_interval_ms: 5 * 60 * 1e3
-  // 5 minutes
-};
-var BackgroundWorkers = class {
-  graph;
-  decayScheduler;
-  traceStore;
-  config;
-  proactiveSurface;
-  teamSync;
-  timers = /* @__PURE__ */ new Map();
-  lastRunTimes = /* @__PURE__ */ new Map();
-  running = false;
-  constructor(deps = {}) {
-    this.graph = deps.graph;
-    this.decayScheduler = deps.decayScheduler;
-    this.traceStore = deps.traceStore;
-    this.config = { ...DEFAULT_CONFIG2, ...deps.config };
-    this.proactiveSurface = deps.proactiveSurface;
-    this.teamSync = deps.teamSync;
+  completeSession(id, result) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "completed";
+    session.completed_at = Date.now();
+    session.result = result;
+    this.emit({
+      type: "session.completed",
+      session_id: session.id,
+      result: result ?? null
+    });
+    return session;
   }
   /**
-   * Start all background workers.
+   * Mark session as failed with an error message.
    */
-  start() {
-    if (this.running) return;
-    this.running = true;
-    if (this.decayScheduler) {
-      const timer = setInterval(async () => {
-        try {
-          await this.decayScheduler.runCycle();
-          this.lastRunTimes.set("decay", Date.now());
-        } catch (err) {
-          console.error("[BackgroundWorkers] Decay cycle failed:", err);
-        }
-      }, this.config.decay_interval_ms);
-      this.timers.set("decay", timer);
-    }
-    if (this.traceStore) {
-      const timer = setInterval(() => {
-        try {
-          this.resolveDeferredTraces();
-          this.lastRunTimes.set("deferred_traces", Date.now());
-        } catch (err) {
-          console.error("[BackgroundWorkers] Deferred trace resolution failed:", err);
-        }
-      }, this.config.deferred_trace_interval_ms);
-      this.timers.set("deferred_traces", timer);
-    }
-    {
-      const timer = setInterval(() => {
-        console.log("[BackgroundWorkers] compactor not yet implemented");
-        this.lastRunTimes.set("compactor", Date.now());
-      }, this.config.compactor_interval_ms);
-      this.timers.set("compactor", timer);
-    }
-    {
-      const timer = setInterval(() => {
-        this.lastRunTimes.set("enrichment", Date.now());
-      }, this.config.enrichment_interval_ms);
-      this.timers.set("enrichment", timer);
-    }
-    if (this.proactiveSurface) {
-      this.proactiveSurface.start();
-      this.lastRunTimes.set("proactive_surface", Date.now());
-    }
-    if (this.teamSync) {
-      this.teamSync.start();
-      this.lastRunTimes.set("team_sync", Date.now());
-    }
+  failSession(id, error) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "failed";
+    session.completed_at = Date.now();
+    session.error = error;
+    this.emit({
+      type: "session.failed",
+      session_id: session.id,
+      error
+    });
+    return session;
   }
   /**
-   * Stop all background workers and clear timers.
+   * Cancel a session.
    */
-  stop() {
-    for (const timer of this.timers.values()) {
-      clearInterval(timer);
-    }
-    this.timers.clear();
-    this.proactiveSurface?.stop();
-    this.teamSync?.stop();
-    this.running = false;
+  cancelSession(id) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "cancelled";
+    session.completed_at = Date.now();
+    session.error = "cancelled";
+    this.emit({
+      type: "session.failed",
+      session_id: session.id,
+      error: "cancelled"
+    });
+    return session;
   }
   /**
-   * Whether workers are currently running.
+   * Get session by ID, or null if not found.
    */
-  isRunning() {
-    return this.running;
+  getSession(id) {
+    return this.sessions.get(id) ?? null;
   }
   /**
-   * Get status of all registered workers.
+   * List all sessions sorted by created_at descending.
    */
-  getWorkerStatus() {
-    const workerNames = ["decay", "deferred_traces", "compactor", "enrichment", "proactive_surface", "team_sync"];
-    return workerNames.map((name) => ({
-      name,
-      active: this.timers.has(name),
-      last_run_at: this.lastRunTimes.get(name) ?? null
-    }));
+  listSessions() {
+    return [...this.sessions.values()].sort(
+      (a, b) => b.created_at - a.created_at
+    );
   }
-  // ─── Private ───────────────────────────────────────
   /**
-   * Find expired deferred traces and resolve them with signal 0.0.
+   * End-to-end session run: create -> start -> resolve -> step -> complete.
+   * Wraps everything in try/catch to fail gracefully.
    */
-  resolveDeferredTraces() {
-    if (!this.traceStore) return;
-    const now = Date.now();
-    const deferred = this.traceStore.query({ deferred: true, limit: 100 });
-    for (const trace of deferred) {
-      if (trace.deferred_until !== null && trace.deferred_until <= now) {
-        this.traceStore.updateOutcome(trace.id, 0, "timeout", now);
+  async runSession(req) {
+    let enrichedReq = req;
+    if (req.entity_id && this.graph) {
+      const loader = new EntityScopedContextLoader(this.graph);
+      const scopedCtx = loader.load(req.entity_id);
+      if (scopedCtx?.personality_prompt) {
+        enrichedReq = {
+          ...req,
+          context: {
+            ...req.context,
+            system_context: [
+              scopedCtx.personality_prompt,
+              ...req.context?.system_context != null ? [String(req.context.system_context)] : []
+            ].join("\n\n"),
+            entity_label: scopedCtx.entity_label,
+            parent_entity_labels: scopedCtx.parent_entity_labels
+          }
+        };
       }
     }
-  }
-};
-
-// packages/daemon/src/SkillRegistry.ts
-import { readFileSync as readFileSync5, readdirSync as readdirSync3, existsSync as existsSync6, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
-import YAML2 from "yaml";
-var SkillRegistry = class {
-  skills = /* @__PURE__ */ new Map();
-  builtinNames = /* @__PURE__ */ new Set();
-  builtinDir;
-  customDir;
-  constructor(opts) {
-    this.builtinDir = opts?.builtinDir ?? join2(homedir2(), ".0agent", "skills", "builtin");
-    this.customDir = opts?.customDir ?? join2(homedir2(), ".0agent", "skills", "custom");
-  }
-  /**
-   * Load all skills from builtin + custom directories.
-   */
-  async loadAll() {
-    this.skills.clear();
-    this.builtinNames.clear();
-    this.loadFromDir(this.builtinDir, true);
-    this.loadFromDir(this.customDir, false);
-  }
-  loadFromDir(dir, isBuiltin) {
-    if (!existsSync6(dir)) return;
-    const files = readdirSync3(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
-    for (const file of files) {
-      try {
-        const raw = readFileSync5(join2(dir, file), "utf8");
-        const skill = YAML2.parse(raw);
-        if (skill.name) {
-          this.skills.set(skill.name, skill);
-          if (isBuiltin) this.builtinNames.add(skill.name);
+    const session = this.createSession(enrichedReq);
+    try {
+      await this.startSession(session.id);
+      this.addStep(session.id, `Extracting entities from: "${req.task.slice(0, 60)}${req.task.length > 60 ? "\u2026" : ""}"`);
+      this.addStep(session.id, "Querying knowledge graph (structural + semantic)\u2026");
+      if (session.plan) {
+        const edge = session.plan.selected_edge;
+        if (edge) {
+          this.addStep(
+            session.id,
+            `Selected plan: ${edge.from_label} \u2192 ${edge.to_label} (weight: ${edge.weight.toFixed(2)}, mode: ${edge.mode})`,
+            session.plan
+          );
+        } else {
+          this.addStep(session.id, `No prior plan found \u2014 bootstrapping from scratch`, session.plan);
         }
-      } catch (err) {
-        console.warn(`Failed to load skill ${file}: ${err}`);
+        if (session.plan.skill) {
+          this.addStep(session.id, `Matched skill: /${session.plan.skill}`);
+        }
+      } else {
+        this.addStep(session.id, "No inference engine connected \u2014 executing task directly");
       }
-    }
-  }
-  /**
-   * Reload all skills (after create/delete).
-   */
-  async reload() {
-    await this.loadAll();
-  }
-  get(name) {
-    const normalized = name.replace(/^\//, "");
-    return this.skills.get(normalized);
-  }
-  list() {
-    return [...this.skills.values()];
-  }
-  isBuiltin(name) {
-    return this.builtinNames.has(name);
+      let anthropicContext;
+      if (enrichedReq.skill && this.anthropicFetcher.isAnthropicSkill(enrichedReq.skill)) {
+        this.addStep(session.id, `Fetching skill instructions: ${enrichedReq.skill}`);
+        const fetched = await this.anthropicFetcher.fetch(enrichedReq.skill);
+        if (fetched) {
+          anthropicContext = this.anthropicFetcher.buildSystemPrompt(fetched);
+          this.addStep(session.id, `Loaded skill: ${fetched.name} (${fetched.cached ? "cached" : "fresh"})`);
+        }
+      }
+      const activeLLM = this.getFreshLLM();
+      if (activeLLM?.isConfigured) {
+        const executor = new AgentExecutor(
+          activeLLM,
+          { 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 identityContext = this.identity ? `You are talking to ${this.identity.name} (device: ${this.identity.device_id}, timezone: ${this.identity.timezone}).` : void 0;
+        const projectCtx = this.projectContext ? ProjectScanner.buildContextPrompt(this.projectContext) : void 0;
+        const userEntityId = enrichedReq.entity_id ?? this.identity?.entity_node_id;
+        let conversationHistory;
+        if (this.conversationStore && userEntityId) {
+          const history = this.conversationStore.buildContextMessages(userEntityId, 8);
+          if (history.length > 0) {
+            const historyStr = history.map((m) => `${m.role === "user" ? "User" : "Agent"}: ${m.content.slice(0, 400)}`).join("\n");
+            conversationHistory = `CONVERSATION HISTORY (use this for context on follow-up requests):
+${historyStr}
+
+Current task:`;
+          }
+        }
+        const systemContext = [
+          identityContext,
+          projectCtx,
+          conversationHistory,
+          anthropicContext,
+          enrichedReq.context?.system_context ? String(enrichedReq.context.system_context) : void 0
+        ].filter(Boolean).join("\n\n") || void 0;
+        let agentResult;
+        try {
+          const { SelfHealLoop: SelfHealLoop2 } = await Promise.resolve().then(() => (init_SelfHealLoop(), SelfHealLoop_exports));
+          const healLoop = new SelfHealLoop2(
+            activeLLM,
+            { cwd: this.cwd },
+            (step) => this.addStep(session.id, step),
+            (token) => this.emit({ type: "session.token", session_id: session.id, token })
+          );
+          agentResult = await healLoop.executeWithHealing(enrichedReq.task, systemContext);
+        } catch {
+          agentResult = await executor.execute(enrichedReq.task, systemContext);
+        }
+        if (this.conversationStore && userEntityId) {
+          const sessionId = session.id;
+          const now = Date.now();
+          this.conversationStore.append({
+            id: crypto.randomUUID(),
+            session_id: sessionId,
+            user_entity_id: userEntityId,
+            role: "user",
+            content: enrichedReq.task,
+            created_at: now
+          });
+          this.conversationStore.append({
+            id: crypto.randomUUID(),
+            session_id: sessionId,
+            user_entity_id: userEntityId,
+            role: "assistant",
+            content: agentResult.output.slice(0, 1e3),
+            // cap stored output length
+            created_at: now + 1
+          });
+        }
+        const selectedEdgeId = session.plan?.selected_edge?.edge_id;
+        if (selectedEdgeId && this.weightUpdater && this.graph) {
+          const outcomeSignal = this.computeOutcomeSignal(agentResult);
+          if (outcomeSignal !== 0) {
+            const edge = this.graph.getEdge(selectedEdgeId);
+            if (edge && !edge.locked) {
+              const newWeight = Math.max(0, Math.min(
+                1,
+                edge.weight + outcomeSignal * 0.1
+                // learning rate 0.1
+              ));
+              await this.weightUpdater.update(
+                edge.id,
+                edge.weight,
+                newWeight,
+                outcomeSignal > 0 ? "task_outcome_positive" : "task_outcome_negative",
+                session.id
+              );
+              this.emit({ type: "graph.weight_updated", edge_id: edge.id, old_weight: edge.weight, new_weight: newWeight });
+            }
+          }
+        }
+        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 cfgPath = resolve5(homedir2(), ".0agent", "config.yaml");
+        const output = `No LLM API key found. Add one to ${cfgPath} or run: 0agent init`;
+        this.addStep(session.id, "\u26A0 No LLM API key configured \u2014 run: 0agent init");
+        this.completeSession(session.id, { output });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.failSession(session.id, message);
+    }
+    return this.sessions.get(session.id);
   }
   /**
-   * Create a custom skill. Returns the SkillDefinition.
-   * Throws if name conflicts with built-in.
+   * Return the number of active (running) sessions.
    */
-  createCustom(name, yamlContent) {
-    if (this.builtinNames.has(name)) {
-      throw new Error(`Cannot override built-in skill: ${name}`);
+  activeSessionCount() {
+    let count = 0;
+    for (const s of this.sessions.values()) {
+      if (s.status === "running") count++;
+    }
+    return count;
+  }
+  // ─── Private helpers ───────────────────────────────
+  getSessionOrThrow(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    return session;
+  }
+  emit(event) {
+    if (this.eventBus) {
+      this.eventBus.emit(event);
     }
-    mkdirSync3(this.customDir, { recursive: true });
-    const filePath = join2(this.customDir, `${name}.yaml`);
-    writeFileSync3(filePath, yamlContent, "utf8");
-    const skill = YAML2.parse(yamlContent);
-    this.skills.set(name, skill);
-    return skill;
   }
   /**
-   * Remove a custom skill. Throws if built-in.
+   * Always returns a fresh LLM executor with the latest API key from disk.
+   * Fixes stale-daemon problem: if the user sets their key AFTER the daemon
+   * started, the next session picks it up automatically.
    */
-  removeCustom(name) {
-    if (this.builtinNames.has(name)) {
-      throw new Error(`Cannot delete built-in skill: ${name}`);
-    }
-    const filePath = join2(this.customDir, `${name}.yaml`);
-    if (existsSync6(filePath)) {
-      unlinkSync(filePath);
+  getFreshLLM() {
+    try {
+      const configPath = resolve5(homedir2(), ".0agent", "config.yaml");
+      if (!existsSync6(configPath)) return this.llm;
+      const raw = readFileSync5(configPath, "utf8");
+      const cfg = YAML2.parse(raw);
+      const providers = cfg.llm_providers;
+      if (!providers?.length) return this.llm;
+      const def = providers.find((p) => p.is_default) ?? providers[0];
+      if (!def) return this.llm;
+      const freshExec = new LLMExecutor({
+        provider: String(def.provider ?? "anthropic"),
+        model: String(def.model ?? "claude-sonnet-4-6"),
+        api_key: String(def.api_key ?? ""),
+        base_url: def.base_url ? String(def.base_url) : void 0
+      });
+      if (freshExec.isConfigured) return freshExec;
+    } catch {
     }
-    this.skills.delete(name);
+    return this.llm;
   }
-  get size() {
-    return this.skills.size;
+  /**
+   * Convert a task result into a weight signal for the knowledge graph.
+   *
+   * Signal scale: -0.3 (failed after retries) to +0.3 (verified success first try).
+   * Neutral (0) when no verification was possible — don't penalise unverifiable tasks.
+   */
+  computeOutcomeSignal(result) {
+    const healAttempts = result["heal_attempts"];
+    if (!healAttempts || healAttempts.length === 0) return 0;
+    const last = healAttempts[healAttempts.length - 1];
+    const verification = last?.["verification"];
+    if (!verification || verification["method"] === "none") return 0;
+    const success = verification["success"] === true;
+    const healed = result["healed"] === true;
+    if (success) return healed ? 0.1 : 0.3;
+    return -0.2;
   }
 };
 
-// packages/daemon/src/HTTPServer.ts
-import { Hono as Hono10 } from "hono";
-import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync6 } from "node:fs";
-import { resolve as resolve5, dirname as dirname3 } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// packages/daemon/src/routes/health.ts
-import { Hono } from "hono";
-function healthRoutes(deps) {
-  const app = new Hono();
-  app.get("/", (c) => {
-    const status = deps.getStatus();
-    return c.json({ ok: true, timestamp: Date.now(), ...status });
-  });
-  return app;
-}
-
-// packages/daemon/src/routes/sessions.ts
-import { Hono as Hono2 } from "hono";
-function sessionRoutes(deps) {
-  const app = new Hono2();
-  app.post("/", async (c) => {
-    const body = await c.req.json();
-    if (!body.task || typeof body.task !== "string") {
-      return c.json({ error: "task is required and must be a string" }, 400);
-    }
-    const session = deps.sessions.createSession(body);
-    deps.sessions.runSession(body).catch(() => {
+// packages/daemon/src/WebSocketEvents.ts
+var WebSocketEventBus = class {
+  clients = /* @__PURE__ */ new Set();
+  handlers = /* @__PURE__ */ new Set();
+  heartbeatTimer = null;
+  /**
+   * Register a connected WebSocket client.
+   * Automatically removes on close.
+   */
+  addClient(ws) {
+    this.clients.add(ws);
+    ws.on("close", () => {
+      this.clients.delete(ws);
     });
-    return c.json({ session_id: session.id, status: "pending" }, 201);
-  });
-  app.get("/", (c) => {
-    const sessions = deps.sessions.listSessions();
-    return c.json(sessions);
-  });
-  app.get("/:id", (c) => {
-    const id = c.req.param("id");
-    const session = deps.sessions.getSession(id);
-    if (!session) {
-      return c.json({ error: "Session not found" }, 404);
+    ws.on("error", () => {
+      this.clients.delete(ws);
+    });
+  }
+  /**
+   * Manually remove a WebSocket client.
+   */
+  removeClient(ws) {
+    this.clients.delete(ws);
+  }
+  /**
+   * Emit an event to all local handlers and broadcast to WS clients.
+   */
+  emit(event) {
+    const typed = event;
+    for (const handler of this.handlers) {
+      try {
+        handler(typed);
+      } catch {
+      }
     }
-    return c.json(session);
-  });
-  app.delete("/:id", (c) => {
-    const id = c.req.param("id");
-    const session = deps.sessions.getSession(id);
-    if (!session) {
-      return c.json({ error: "Session not found" }, 404);
+    this.broadcast(typed);
+  }
+  /**
+   * Register a local event handler.
+   * Returns an unsubscribe function.
+   */
+  onEvent(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  /**
+   * Send an event to all connected WebSocket clients.
+   */
+  broadcast(event) {
+    if (this.clients.size === 0) return;
+    const data = JSON.stringify(event);
+    for (const ws of this.clients) {
+      try {
+        ws.send(data);
+      } catch {
+        this.clients.delete(ws);
+      }
     }
-    deps.sessions.cancelSession(id);
-    return c.json({ ok: true });
-  });
-  return app;
-}
+  }
+  /**
+   * Start a periodic heartbeat that emits daemon.stats events.
+   * Runs every 30 seconds.
+   */
+  startStatsHeartbeat(getStats) {
+    this.stopStatsHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      const stats = getStats();
+      this.emit({
+        type: "daemon.stats",
+        graph_nodes: stats.graph_nodes,
+        active_sessions: stats.active_sessions
+      });
+    }, 3e4);
+  }
+  /**
+   * Stop the stats heartbeat.
+   */
+  stopStatsHeartbeat() {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * Get the number of connected WS clients.
+   */
+  clientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Get the number of registered local handlers.
+   */
+  handlerCount() {
+    return this.handlers.size;
+  }
+};
 
-// packages/daemon/src/routes/graph.ts
-import { Hono as Hono3 } from "hono";
-function graphRoutes(deps) {
-  const app = new Hono3();
-  app.get("/nodes", (c) => {
-    const graph_id = c.req.query("graph_id");
-    const type = c.req.query("type");
-    const limitStr = c.req.query("limit");
-    const limit = limitStr ? parseInt(limitStr, 10) : 50;
-    const results = deps.graph.queryStructural({
-      graph_id: graph_id || void 0,
-      node_type: type || void 0,
-      limit
-    });
-    return c.json(results.map((r) => r.node));
-  });
-  app.get("/nodes/:id", (c) => {
-    const id = c.req.param("id");
-    const node = deps.graph.getNode(id);
-    if (!node) {
-      return c.json({ error: "Node not found" }, 404);
+// packages/daemon/src/BackgroundWorkers.ts
+var DEFAULT_CONFIG2 = {
+  decay_interval_ms: 6 * 60 * 60 * 1e3,
+  // 6 hours
+  deferred_trace_interval_ms: 6e4,
+  // 60 seconds
+  compactor_interval_ms: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  enrichment_interval_ms: 5 * 60 * 1e3
+  // 5 minutes
+};
+var BackgroundWorkers = class {
+  graph;
+  decayScheduler;
+  traceStore;
+  config;
+  proactiveSurface;
+  teamSync;
+  timers = /* @__PURE__ */ new Map();
+  lastRunTimes = /* @__PURE__ */ new Map();
+  running = false;
+  constructor(deps = {}) {
+    this.graph = deps.graph;
+    this.decayScheduler = deps.decayScheduler;
+    this.traceStore = deps.traceStore;
+    this.config = { ...DEFAULT_CONFIG2, ...deps.config };
+    this.proactiveSurface = deps.proactiveSurface;
+    this.teamSync = deps.teamSync;
+  }
+  /**
+   * Start all background workers.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    if (this.decayScheduler) {
+      const timer = setInterval(async () => {
+        try {
+          await this.decayScheduler.runCycle();
+          this.lastRunTimes.set("decay", Date.now());
+        } catch (err) {
+          console.error("[BackgroundWorkers] Decay cycle failed:", err);
+        }
+      }, this.config.decay_interval_ms);
+      this.timers.set("decay", timer);
     }
-    return c.json(node);
-  });
-  app.get("/edges", (c) => {
-    const from_node = c.req.query("from_node");
-    const to_node = c.req.query("to_node");
-    const type = c.req.query("type");
-    let edges;
-    if (from_node && to_node) {
-      edges = deps.graph.getEdgesBetween(from_node, to_node);
-    } else if (from_node) {
-      edges = deps.graph.getEdgesFrom(from_node);
-    } else if (to_node) {
-      edges = deps.graph.getEdgesTo(to_node);
-    } else {
-      edges = deps.graph.getAllEdges();
+    if (this.traceStore) {
+      const timer = setInterval(() => {
+        try {
+          this.resolveDeferredTraces();
+          this.lastRunTimes.set("deferred_traces", Date.now());
+        } catch (err) {
+          console.error("[BackgroundWorkers] Deferred trace resolution failed:", err);
+        }
+      }, this.config.deferred_trace_interval_ms);
+      this.timers.set("deferred_traces", timer);
     }
-    if (type) {
-      edges = edges.filter((e) => e.type === type);
+    {
+      const timer = setInterval(() => {
+        console.log("[BackgroundWorkers] compactor not yet implemented");
+        this.lastRunTimes.set("compactor", Date.now());
+      }, this.config.compactor_interval_ms);
+      this.timers.set("compactor", timer);
     }
-    return c.json(edges);
-  });
-  app.post("/query", async (c) => {
-    const body = await c.req.json();
-    const results = deps.graph.queryMerged({
-      structural: body.structural ?? {},
-      semantic: body.semantic,
-      limit: body.limit
-    });
-    return c.json(results);
-  });
-  return app;
-}
-
-// packages/daemon/src/routes/entities.ts
-import { Hono as Hono4 } from "hono";
-function entityRoutes(deps) {
-  const app = new Hono4();
-  app.get("/", (c) => {
-    const results = deps.graph.queryStructural({
-      node_type: "entity",
-      limit: 200
-    });
-    return c.json(results.map((r) => r.node));
-  });
-  app.get("/:id", (c) => {
-    const id = c.req.param("id");
-    const node = deps.graph.getNode(id);
-    if (!node) {
-      return c.json({ error: "Entity not found" }, 404);
+    {
+      const timer = setInterval(() => {
+        this.lastRunTimes.set("enrichment", Date.now());
+      }, this.config.enrichment_interval_ms);
+      this.timers.set("enrichment", timer);
     }
-    try {
-      const subgraph = deps.graph.getSubGraph(id, 2);
-      const nodes = subgraph.getNodes();
-      const edges = subgraph.getEdges();
-      let last_seen = node.last_seen;
-      for (const n of nodes) {
-        if (n.last_seen > last_seen) {
-          last_seen = n.last_seen;
-        }
+    if (this.proactiveSurface) {
+      this.proactiveSurface.start();
+      this.lastRunTimes.set("proactive_surface", Date.now());
+    }
+    if (this.teamSync) {
+      this.teamSync.start();
+      this.lastRunTimes.set("team_sync", Date.now());
+    }
+  }
+  /**
+   * Stop all background workers and clear timers.
+   */
+  stop() {
+    for (const timer of this.timers.values()) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+    this.proactiveSurface?.stop();
+    this.teamSync?.stop();
+    this.running = false;
+  }
+  /**
+   * Whether workers are currently running.
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get status of all registered workers.
+   */
+  getWorkerStatus() {
+    const workerNames = ["decay", "deferred_traces", "compactor", "enrichment", "proactive_surface", "team_sync"];
+    return workerNames.map((name) => ({
+      name,
+      active: this.timers.has(name),
+      last_run_at: this.lastRunTimes.get(name) ?? null
+    }));
+  }
+  // ─── Private ───────────────────────────────────────
+  /**
+   * Find expired deferred traces and resolve them with signal 0.0.
+   */
+  resolveDeferredTraces() {
+    if (!this.traceStore) return;
+    const now = Date.now();
+    const deferred = this.traceStore.query({ deferred: true, limit: 100 });
+    for (const trace of deferred) {
+      if (trace.deferred_until !== null && trace.deferred_until <= now) {
+        this.traceStore.updateOutcome(trace.id, 0, "timeout", now);
       }
-      return c.json({
-        ...node,
-        subgraph_summary: {
-          nodeCount: nodes.length,
-          edgeCount: edges.length,
-          last_seen
-        }
-      });
-    } catch {
-      return c.json({
-        ...node,
-        subgraph_summary: {
-          nodeCount: 1,
-          edgeCount: 0,
-          last_seen: node.last_seen
-        }
-      });
     }
-  });
-  return app;
-}
+  }
+};
 
-// packages/daemon/src/routes/traces.ts
-import { Hono as Hono5 } from "hono";
-function traceRoutes(deps) {
-  const app = new Hono5();
-  app.get("/", (c) => {
-    const session_id = c.req.query("session_id");
-    const deferredStr = c.req.query("deferred");
-    const limitStr = c.req.query("limit");
-    const deferred = deferredStr !== void 0 && deferredStr !== "" ? deferredStr === "true" : void 0;
-    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-    const traces = deps.traceStore.query({
-      session_id: session_id || void 0,
-      deferred,
-      limit
-    });
-    return c.json(traces);
-  });
-  app.get("/:id", (c) => {
-    const id = c.req.param("id");
-    const trace = deps.traceStore.get(id);
-    if (!trace) {
-      return c.json({ error: "Trace not found" }, 404);
+// packages/daemon/src/SkillRegistry.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync3, existsSync as existsSync7, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import YAML3 from "yaml";
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  builtinNames = /* @__PURE__ */ new Set();
+  builtinDir;
+  customDir;
+  constructor(opts) {
+    this.builtinDir = opts?.builtinDir ?? join2(homedir3(), ".0agent", "skills", "builtin");
+    this.customDir = opts?.customDir ?? join2(homedir3(), ".0agent", "skills", "custom");
+  }
+  /**
+   * Load all skills from builtin + custom directories.
+   */
+  async loadAll() {
+    this.skills.clear();
+    this.builtinNames.clear();
+    this.loadFromDir(this.builtinDir, true);
+    this.loadFromDir(this.customDir, false);
+  }
+  loadFromDir(dir, isBuiltin) {
+    if (!existsSync7(dir)) return;
+    const files = readdirSync3(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    for (const file of files) {
+      try {
+        const raw = readFileSync6(join2(dir, file), "utf8");
+        const skill = YAML3.parse(raw);
+        if (skill.name) {
+          this.skills.set(skill.name, skill);
+          if (isBuiltin) this.builtinNames.add(skill.name);
+        }
+      } catch (err) {
+        console.warn(`Failed to load skill ${file}: ${err}`);
+      }
     }
-    return c.json(trace);
-  });
-  return app;
-}
+  }
+  /**
+   * Reload all skills (after create/delete).
+   */
+  async reload() {
+    await this.loadAll();
+  }
+  get(name) {
+    const normalized = name.replace(/^\//, "");
+    return this.skills.get(normalized);
+  }
+  list() {
+    return [...this.skills.values()];
+  }
+  isBuiltin(name) {
+    return this.builtinNames.has(name);
+  }
+  /**
+   * Create a custom skill. Returns the SkillDefinition.
+   * Throws if name conflicts with built-in.
+   */
+  createCustom(name, yamlContent) {
+    if (this.builtinNames.has(name)) {
+      throw new Error(`Cannot override built-in skill: ${name}`);
+    }
+    mkdirSync3(this.customDir, { recursive: true });
+    const filePath = join2(this.customDir, `${name}.yaml`);
+    writeFileSync3(filePath, yamlContent, "utf8");
+    const skill = YAML3.parse(yamlContent);
+    this.skills.set(name, skill);
+    return skill;
+  }
+  /**
+   * Remove a custom skill. Throws if built-in.
+   */
+  removeCustom(name) {
+    if (this.builtinNames.has(name)) {
+      throw new Error(`Cannot delete built-in skill: ${name}`);
+    }
+    const filePath = join2(this.customDir, `${name}.yaml`);
+    if (existsSync7(filePath)) {
+      unlinkSync(filePath);
+    }
+    this.skills.delete(name);
+  }
+  get size() {
+    return this.skills.size;
+  }
+};
 
-// packages/daemon/src/routes/subagents.ts
-import { Hono as Hono6 } from "hono";
-function subagentRoutes() {
-  const app = new Hono6();
+// packages/daemon/src/HTTPServer.ts
+import { Hono as Hono10 } from "hono";
+import { serve } from "@hono/node-server";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { resolve as resolve6, dirname as dirname3 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/daemon/src/routes/health.ts
+import { Hono } from "hono";
+function healthRoutes(deps) {
+  const app = new Hono();
   app.get("/", (c) => {
-    return c.json([]);
-  });
-  app.delete("/:id", (c) => {
-    return c.json({ error: "No subagent system in Phase 2" }, 404);
+    const status = deps.getStatus();
+    return c.json({ ok: true, timestamp: Date.now(), ...status });
   });
   return app;
 }
 
-// packages/daemon/src/routes/skills.ts
-import { Hono as Hono7 } from "hono";
-function skillRoutes(deps) {
-  const app = new Hono7();
-  app.get("/", (c) => {
-    const skills = deps.skillRegistry.list();
-    return c.json(skills);
-  });
-  app.get("/:name", (c) => {
-    const name = c.req.param("name");
-    const skill = deps.skillRegistry.get(name);
-    if (!skill) {
-      return c.json({ error: "Skill not found" }, 404);
-    }
-    return c.json(skill);
-  });
+// packages/daemon/src/routes/sessions.ts
+import { Hono as Hono2 } from "hono";
+function sessionRoutes(deps) {
+  const app = new Hono2();
   app.post("/", async (c) => {
     const body = await c.req.json();
-    if (!body.name || typeof body.name !== "string") {
-      return c.json({ error: "name is required" }, 400);
-    }
-    if (!body.yaml || typeof body.yaml !== "string") {
-      return c.json({ error: "yaml is required" }, 400);
-    }
-    if (deps.skillRegistry.isBuiltin(body.name)) {
-      return c.json({ error: "Conflicts with built-in skill" }, 409);
-    }
-    try {
-      const skill = deps.skillRegistry.createCustom(body.name, body.yaml);
-      return c.json(skill, 201);
-    } catch (err) {
-      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);
-    }
-    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);
+    if (!body.task || typeof body.task !== "string") {
+      return c.json({ error: "task is required and must be a string" }, 400);
     }
+    const session = deps.sessions.createSession(body);
+    deps.sessions.runSession(body).catch(() => {
+    });
+    return c.json({ session_id: session.id, status: "pending" }, 201);
   });
-  return app;
-}
-
-// packages/daemon/src/routes/insights.ts
-import { Hono as Hono8 } from "hono";
-function insightsRoutes(deps) {
-  const app = new Hono8();
   app.get("/", (c) => {
-    if (!deps.proactiveSurface) return c.json([]);
-    const seen = c.req.query("seen");
-    const insights = seen === "false" ? deps.proactiveSurface.getUnseen() : deps.proactiveSurface.getAll();
-    return c.json(insights);
-  });
-  app.post("/:id/seen", (c) => {
-    if (!deps.proactiveSurface) return c.json({ ok: false, error: "not available" }, 404);
-    deps.proactiveSurface.markSeen(c.req.param("id"));
-    return c.json({ ok: true });
-  });
-  return app;
-}
-
-// packages/daemon/src/routes/memory.ts
-import { Hono as Hono9 } from "hono";
-function memoryRoutes(deps) {
-  const app = new Hono9();
-  app.post("/push", async (c) => {
-    const sync = deps.getSync();
-    if (!sync) return c.json({ error: "GitHub memory not configured. Run: 0agent memory connect github" }, 404);
-    const result = await sync.push();
-    return c.json(result);
+    const sessions = deps.sessions.listSessions();
+    return c.json(sessions);
   });
-  app.post("/pull", async (c) => {
-    const sync = deps.getSync();
-    if (!sync) return c.json({ error: "GitHub memory not configured." }, 404);
-    const result = await sync.pull();
-    return c.json(result);
+  app.get("/:id", (c) => {
+    const id = c.req.param("id");
+    const session = deps.sessions.getSession(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    return c.json(session);
   });
-  app.get("/status", (c) => {
-    const sync = deps.getSync();
-    if (!sync) return c.json({ configured: false });
-    return c.json({ configured: true, ...sync.getLastSyncTimes() });
+  app.delete("/:id", (c) => {
+    const id = c.req.param("id");
+    const session = deps.sessions.getSession(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    deps.sessions.cancelSession(id);
+    return c.json({ ok: true });
   });
   return app;
 }
 
-// packages/daemon/src/HTTPServer.ts
-function findGraphHtml() {
-  const candidates = [
-    resolve5(dirname3(fileURLToPath(import.meta.url)), "graph.html"),
-    // dev (src/)
-    resolve5(dirname3(fileURLToPath(import.meta.url)), "..", "graph.html"),
-    // bundled (dist/../)
-    resolve5(dirname3(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
-  ];
-  for (const p of candidates) {
-    try {
-      readFileSync6(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 Hono10();
-    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 }));
-    this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
-    this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
-    const serveGraph = (c) => {
-      try {
-        const html = readFileSync6(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((resolve12) => {
-      this.server = serve(
-        {
-          fetch: this.app.fetch,
-          port: this.deps.port,
-          hostname: this.deps.host
-        },
-        () => {
-          resolve12();
-        }
-      );
-    });
-  }
-  stop() {
-    return new Promise((resolve12, reject) => {
-      if (!this.server) {
-        resolve12();
-        return;
-      }
-      this.server.close((err) => {
-        if (err) reject(err);
-        else resolve12();
-      });
-    });
-  }
-  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 };
+// packages/daemon/src/routes/graph.ts
+import { Hono as Hono3 } from "hono";
+function graphRoutes(deps) {
+  const app = new Hono3();
+  app.get("/nodes", (c) => {
+    const graph_id = c.req.query("graph_id");
+    const type = c.req.query("type");
+    const limitStr = c.req.query("limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : 50;
+    const results = deps.graph.queryStructural({
+      graph_id: graph_id || void 0,
+      node_type: type || void 0,
+      limit
     });
-    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
-      }));
+    return c.json(results.map((r) => r.node));
+  });
+  app.get("/nodes/:id", (c) => {
+    const id = c.req.param("id");
+    const node = deps.graph.getNode(id);
+    if (!node) {
+      return c.json({ error: "Node not found" }, 404);
     }
-    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)
+    return c.json(node);
+  });
+  app.get("/edges", (c) => {
+    const from_node = c.req.query("from_node");
+    const to_node = c.req.query("to_node");
+    const type = c.req.query("type");
+    let edges;
+    if (from_node && to_node) {
+      edges = deps.graph.getEdgesBetween(from_node, to_node);
+    } else if (from_node) {
+      edges = deps.graph.getEdgesFrom(from_node);
+    } else if (to_node) {
+      edges = deps.graph.getEdgesTo(to_node);
+    } else {
+      edges = deps.graph.getAllEdges();
+    }
+    if (type) {
+      edges = edges.filter((e) => e.type === type);
+    }
+    return c.json(edges);
+  });
+  app.post("/query", async (c) => {
+    const body = await c.req.json();
+    const results = deps.graph.queryMerged({
+      structural: body.structural ?? {},
+      semantic: body.semantic,
+      limit: body.limit
     });
-    if (!res.ok) {
-      const err = await res.text();
-      throw new Error(`Anthropic ${res.status}: ${err}`);
+    return c.json(results);
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/entities.ts
+import { Hono as Hono4 } from "hono";
+function entityRoutes(deps) {
+  const app = new Hono4();
+  app.get("/", (c) => {
+    const results = deps.graph.queryStructural({
+      node_type: "entity",
+      limit: 200
+    });
+    return c.json(results.map((r) => r.node));
+  });
+  app.get("/:id", (c) => {
+    const id = c.req.param("id");
+    const node = deps.graph.getNode(id);
+    if (!node) {
+      return c.json({ error: "Entity not found" }, 404);
     }
-    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";
+    try {
+      const subgraph = deps.graph.getSubGraph(id, 2);
+      const nodes = subgraph.getNodes();
+      const edges = subgraph.getEdges();
+      let last_seen = node.last_seen;
+      for (const n of nodes) {
+        if (n.last_seen > last_seen) {
+          last_seen = n.last_seen;
         }
       }
+      return c.json({
+        ...node,
+        subgraph_summary: {
+          nodeCount: nodes.length,
+          edgeCount: edges.length,
+          last_seen
+        }
+      });
+    } catch {
+      return c.json({
+        ...node,
+        subgraph_summary: {
+          nodeCount: 1,
+          edgeCount: 0,
+          last_seen: node.last_seen
+        }
+      });
     }
-    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 });
-      }
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/traces.ts
+import { Hono as Hono5 } from "hono";
+function traceRoutes(deps) {
+  const app = new Hono5();
+  app.get("/", (c) => {
+    const session_id = c.req.query("session_id");
+    const deferredStr = c.req.query("deferred");
+    const limitStr = c.req.query("limit");
+    const deferred = deferredStr !== void 0 && deferredStr !== "" ? deferredStr === "true" : void 0;
+    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+    const traces = deps.traceStore.query({
+      session_id: session_id || void 0,
+      deferred,
+      limit
+    });
+    return c.json(traces);
+  });
+  app.get("/:id", (c) => {
+    const id = c.req.param("id");
+    const trace = deps.traceStore.get(id);
+    if (!trace) {
+      return c.json({ error: "Trace not found" }, 404);
+    }
+    return c.json(trace);
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/subagents.ts
+import { Hono as Hono6 } from "hono";
+function subagentRoutes() {
+  const app = new Hono6();
+  app.get("/", (c) => {
+    return c.json([]);
+  });
+  app.delete("/:id", (c) => {
+    return c.json({ error: "No subagent system in Phase 2" }, 404);
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/skills.ts
+import { Hono as Hono7 } from "hono";
+function skillRoutes(deps) {
+  const app = new Hono7();
+  app.get("/", (c) => {
+    const skills = deps.skillRegistry.list();
+    return c.json(skills);
+  });
+  app.get("/:name", (c) => {
+    const name = c.req.param("name");
+    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 }
-      }));
+    return c.json(skill);
+  });
+  app.post("/", async (c) => {
+    const body = await c.req.json();
+    if (!body.name || typeof body.name !== "string") {
+      return c.json({ error: "name is required" }, 400);
     }
-    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}`);
+    if (!body.yaml || typeof body.yaml !== "string") {
+      return c.json({ error: "yaml is required" }, 400);
     }
-    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;
-          }
-        }
-      }
+    if (deps.skillRegistry.isBuiltin(body.name)) {
+      return c.json({ error: "Conflicts with built-in skill" }, 409);
     }
-    const toolCalls = Object.values(toolCallMap).filter((tc) => tc.id && tc.name).map((tc) => {
-      let input = {};
+    try {
+      const skill = deps.skillRegistry.createCustom(body.name, body.yaml);
+      return c.json(skill, 201);
+    } catch (err) {
+      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);
+    }
+    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/routes/insights.ts
+import { Hono as Hono8 } from "hono";
+function insightsRoutes(deps) {
+  const app = new Hono8();
+  app.get("/", (c) => {
+    if (!deps.proactiveSurface) return c.json([]);
+    const seen = c.req.query("seen");
+    const insights = seen === "false" ? deps.proactiveSurface.getUnseen() : deps.proactiveSurface.getAll();
+    return c.json(insights);
+  });
+  app.post("/:id/seen", (c) => {
+    if (!deps.proactiveSurface) return c.json({ ok: false, error: "not available" }, 404);
+    deps.proactiveSurface.markSeen(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/memory.ts
+import { Hono as Hono9 } from "hono";
+function memoryRoutes(deps) {
+  const app = new Hono9();
+  app.post("/push", async (c) => {
+    const sync = deps.getSync();
+    if (!sync) return c.json({ error: "GitHub memory not configured. Run: 0agent memory connect github" }, 404);
+    const result = await sync.push();
+    return c.json(result);
+  });
+  app.post("/pull", async (c) => {
+    const sync = deps.getSync();
+    if (!sync) return c.json({ error: "GitHub memory not configured." }, 404);
+    const result = await sync.pull();
+    return c.json(result);
+  });
+  app.get("/status", (c) => {
+    const sync = deps.getSync();
+    if (!sync) return c.json({ configured: false });
+    return c.json({ configured: true, ...sync.getLastSyncTimes() });
+  });
+  return app;
+}
+
+// packages/daemon/src/HTTPServer.ts
+function findGraphHtml() {
+  const candidates = [
+    resolve6(dirname3(fileURLToPath(import.meta.url)), "graph.html"),
+    // dev (src/)
+    resolve6(dirname3(fileURLToPath(import.meta.url)), "..", "graph.html"),
+    // bundled (dist/../)
+    resolve6(dirname3(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
+  ];
+  for (const p of candidates) {
+    try {
+      readFileSync7(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 Hono10();
+    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 }));
+    this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
+    this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
+    const serveGraph = (c) => {
       try {
-        input = JSON.parse(tc.args);
+        const html = readFileSync7(GRAPH_HTML_PATH, "utf8");
+        return c.html(html);
       } catch {
+        return c.html("<p>Graph UI not found. Run: pnpm build</p>");
       }
-      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
     };
+    this.app.get("/", serveGraph);
+    this.app.get("/graph", serveGraph);
   }
-  // ─── 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 })
+  start() {
+    return new Promise((resolve13) => {
+      this.server = serve(
+        {
+          fetch: this.app.fetch,
+          port: this.deps.port,
+          hostname: this.deps.host
+        },
+        () => {
+          resolve13();
+        }
+      );
     });
-    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 };
+  }
+  stop() {
+    return new Promise((resolve13, reject) => {
+      if (!this.server) {
+        resolve13();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) reject(err);
+        else resolve13();
+      });
+    });
+  }
+  getApp() {
+    return this.app;
   }
 };
 
 // packages/daemon/src/IdentityManager.ts
 init_src();
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "node:fs";
-import { resolve as resolve6, dirname as dirname4 } from "node:path";
-import { homedir as homedir3, hostname } from "node:os";
-import YAML3 from "yaml";
-var IDENTITY_PATH = resolve6(homedir3(), ".0agent", "identity.yaml");
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve as resolve7, dirname as dirname4 } from "node:path";
+import { homedir as homedir4, hostname } from "node:os";
+import YAML4 from "yaml";
+var IDENTITY_PATH = resolve7(homedir4(), ".0agent", "identity.yaml");
 var DEFAULT_IDENTITY = {
   name: "User",
   device_id: `unknown-device`,
@@ -4990,9 +5022,9 @@ var IdentityManager = class {
    * Load or create identity. Call once at daemon startup.
    */
   async init() {
-    if (existsSync7(IDENTITY_PATH)) {
-      const raw = readFileSync7(IDENTITY_PATH, "utf8");
-      this.identity = YAML3.parse(raw);
+    if (existsSync8(IDENTITY_PATH)) {
+      const raw = readFileSync8(IDENTITY_PATH, "utf8");
+      this.identity = YAML4.parse(raw);
     } else {
       this.identity = {
         ...DEFAULT_IDENTITY,
@@ -5043,24 +5075,24 @@ var IdentityManager = class {
   }
   save() {
     const dir = dirname4(IDENTITY_PATH);
-    if (!existsSync7(dir)) {
+    if (!existsSync8(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync4(IDENTITY_PATH, YAML3.stringify(this.identity), "utf8");
+    writeFileSync4(IDENTITY_PATH, YAML4.stringify(this.identity), "utf8");
   }
 };
 
 // packages/daemon/src/TeamManager.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
-import { homedir as homedir4 } from "node:os";
-import YAML4 from "yaml";
-var TEAMS_PATH = resolve7(homedir4(), ".0agent", "teams.yaml");
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import YAML5 from "yaml";
+var TEAMS_PATH = resolve8(homedir5(), ".0agent", "teams.yaml");
 var TeamManager = class {
   config;
   constructor() {
-    if (existsSync8(TEAMS_PATH)) {
-      this.config = YAML4.parse(readFileSync8(TEAMS_PATH, "utf8"));
+    if (existsSync9(TEAMS_PATH)) {
+      this.config = YAML5.parse(readFileSync9(TEAMS_PATH, "utf8"));
     } else {
       this.config = { memberships: [] };
     }
@@ -5115,8 +5147,8 @@ var TeamManager = class {
     }
   }
   save() {
-    mkdirSync5(resolve7(homedir4(), ".0agent"), { recursive: true });
-    writeFileSync5(TEAMS_PATH, YAML4.stringify(this.config), "utf8");
+    mkdirSync5(resolve8(homedir5(), ".0agent"), { recursive: true });
+    writeFileSync5(TEAMS_PATH, YAML5.stringify(this.config), "utf8");
   }
 };
 
@@ -5199,9 +5231,9 @@ var TeamSync = class {
 };
 
 // packages/daemon/src/GitHubMemorySync.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 var GITHUB_API = "https://api.github.com";
 async function ghFetch(path, token, opts) {
   return fetch(`${GITHUB_API}${path}`, {
@@ -5320,10 +5352,10 @@ var GitHubMemorySync = class {
           )
         );
       }
-      const customSkillsDir = resolve8(homedir5(), ".0agent", "skills", "custom");
-      if (existsSync9(customSkillsDir)) {
+      const customSkillsDir = resolve9(homedir6(), ".0agent", "skills", "custom");
+      if (existsSync10(customSkillsDir)) {
         for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
-          const content = readFileSync9(resolve8(customSkillsDir, file), "utf8");
+          const content = readFileSync10(resolve9(customSkillsDir, file), "utf8");
           pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
         }
       }
@@ -5508,7 +5540,7 @@ var GitHubMemorySync = class {
   }
   async pullCustomSkills() {
     const { token, owner, repo } = this.config;
-    const dir = resolve8(homedir5(), ".0agent", "skills", "custom");
+    const dir = resolve9(homedir6(), ".0agent", "skills", "custom");
     try {
       const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
       if (!res.ok) return;
@@ -5518,7 +5550,7 @@ var GitHubMemorySync = class {
         if (content) {
           const { mkdirSync: mkdirSync7 } = await import("node:fs");
           mkdirSync7(dir, { recursive: true });
-          writeFileSync6(resolve8(dir, file.name), content, "utf8");
+          writeFileSync6(resolve9(dir, file.name), content, "utf8");
         }
       }
     } catch {
@@ -5582,12 +5614,12 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve10(homedir6(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve11(homedir7(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve10(homedir6(), ".0agent");
-    if (!existsSync11(dotDir)) {
+    const dotDir = resolve11(homedir7(), ".0agent");
+    if (!existsSync12(dotDir)) {
       mkdirSync6(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
@@ -5739,7 +5771,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync11(this.pidFilePath)) {
+    if (existsSync12(this.pidFilePath)) {
       try {
         unlinkSync2(this.pidFilePath);
       } catch {
@@ -5769,11 +5801,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve11 } from "node:path";
-import { homedir as homedir7 } from "node:os";
-import { existsSync as existsSync12 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve11(homedir7(), ".0agent", "config.yaml");
-if (!existsSync12(CONFIG_PATH)) {
+import { resolve as resolve12 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { existsSync as existsSync13 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve12(homedir8(), ".0agent", "config.yaml");
+if (!existsSync13(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.