0agent 1.0.77 → 1.0.81

package/dist/daemon.mjs

@@ -1507,7 +1507,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve17) => setTimeout(resolve17, ms));
+        return new Promise((resolve19) => setTimeout(resolve19, ms));
       }
     };
   }
@@ -1969,15 +1969,22 @@ var init_src = __esm({
   }
 });
 
-// packages/daemon/src/LLMExecutor.ts
+// packages/daemon/src/services/LLMExecutor.ts
 var LLMExecutor;
 var init_LLMExecutor = __esm({
-  "packages/daemon/src/LLMExecutor.ts"() {
+  "packages/daemon/src/services/LLMExecutor.ts"() {
     "use strict";
     LLMExecutor = class _LLMExecutor {
       constructor(config) {
         this.config = config;
       }
+      /**
+       * Create a new LLMExecutor with a different model but same provider/key.
+       * Used by SmartModelRouter to switch to a fast model for simple messages.
+       */
+      withModel(model) {
+        return new _LLMExecutor({ ...this.config, model });
+      }
       get isConfigured() {
         if (this.config.provider === "ollama") return true;
         return !!this.config.api_key?.trim();
@@ -2015,10 +2022,10 @@ var init_LLMExecutor = __esm({
         return { content: res.content, tokens_used: res.tokens_used, model: res.model };
       }
       // ─── Tool-calling completion with optional streaming ─────────────────────
-      async completeWithTools(messages, tools, system, onToken, signal) {
+      async completeWithTools(messages, tools, system, onToken, signal, onToolUseBlock) {
         switch (this.config.provider) {
           case "anthropic":
-            return this.anthropic(messages, tools, system, onToken, signal);
+            return this.anthropic(messages, tools, system, onToken, signal, onToolUseBlock);
           case "openai":
             return this.openai(messages, tools, system, onToken, void 0, signal);
           case "xai":
@@ -2032,7 +2039,7 @@ var init_LLMExecutor = __esm({
         }
       }
       // ─── Anthropic ───────────────────────────────────────────────────────────
-      async anthropic(messages, tools, system, onToken, signal) {
+      async anthropic(messages, tools, system, onToken, signal, onToolUseBlock) {
         const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
         const filtered = messages.filter((m) => m.role !== "system");
         const anthropicMsgs = filtered.map((m) => {
@@ -2146,6 +2153,9 @@ var init_LLMExecutor = __esm({
                     tc.input = JSON.parse(toolInputBuffers[currentToolId]);
                   } catch {
                   }
+                  if (onToolUseBlock && tc.input && Object.keys(tc.input).length > 0) {
+                    onToolUseBlock(tc);
+                  }
                 }
               }
             } else if (type === "message_delta") {
@@ -2320,11 +2330,11 @@ var init_LLMExecutor = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/WebSearchCapability.ts
+// packages/daemon/src/tools/WebSearchCapability.ts
 import { execSync, spawnSync } from "node:child_process";
 var WebSearchCapability;
 var init_WebSearchCapability = __esm({
-  "packages/daemon/src/capabilities/WebSearchCapability.ts"() {
+  "packages/daemon/src/tools/WebSearchCapability.ts"() {
     "use strict";
     WebSearchCapability = class {
       name = "web_search";
@@ -2467,7 +2477,7 @@ var init_WebSearchCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/BrowserCapability.ts
+// packages/daemon/src/tools/BrowserCapability.ts
 import { spawnSync as spawnSync2, execSync as execSync2, spawn } from "node:child_process";
 import { platform } from "node:os";
 function findSystemChrome() {
@@ -2488,7 +2498,7 @@ function findSystemChrome() {
 }
 var BrowserCapability;
 var init_BrowserCapability = __esm({
-  "packages/daemon/src/capabilities/BrowserCapability.ts"() {
+  "packages/daemon/src/tools/BrowserCapability.ts"() {
     "use strict";
     BrowserCapability = class {
       name = "browser_open";
@@ -2603,11 +2613,11 @@ var init_BrowserCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/ScraperCapability.ts
+// packages/daemon/src/tools/ScraperCapability.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 var ScraperCapability;
 var init_ScraperCapability = __esm({
-  "packages/daemon/src/capabilities/ScraperCapability.ts"() {
+  "packages/daemon/src/tools/ScraperCapability.ts"() {
     "use strict";
     init_BrowserCapability();
     ScraperCapability = class {
@@ -2699,11 +2709,11 @@ else:
   }
 });
 
-// packages/daemon/src/capabilities/ShellCapability.ts
+// packages/daemon/src/tools/ShellCapability.ts
 import { spawn as spawn2 } from "node:child_process";
 var ShellCapability;
 var init_ShellCapability = __esm({
-  "packages/daemon/src/capabilities/ShellCapability.ts"() {
+  "packages/daemon/src/tools/ShellCapability.ts"() {
     "use strict";
     ShellCapability = class _ShellCapability {
       name = "shell_exec";
@@ -2816,12 +2826,12 @@ var init_ShellCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/FileCapability.ts
+// packages/daemon/src/tools/FileCapability.ts
 import { readFileSync as readFileSync2, writeFileSync, readdirSync, mkdirSync, existsSync as existsSync2 } from "node:fs";
 import { resolve as resolve2, dirname } from "node:path";
 var FileCapability;
 var init_FileCapability = __esm({
-  "packages/daemon/src/capabilities/FileCapability.ts"() {
+  "packages/daemon/src/tools/FileCapability.ts"() {
     "use strict";
     FileCapability = class {
       name = "file_op";
@@ -2906,10 +2916,10 @@ var init_FileCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/MemoryCapability.ts
+// packages/daemon/src/tools/MemoryCapability.ts
 var MemoryCapability;
 var init_MemoryCapability = __esm({
-  "packages/daemon/src/capabilities/MemoryCapability.ts"() {
+  "packages/daemon/src/tools/MemoryCapability.ts"() {
     "use strict";
     init_src();
     MemoryCapability = class {
@@ -3007,14 +3017,14 @@ var init_MemoryCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/GUICapability.ts
+// packages/daemon/src/tools/GUICapability.ts
 import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
 import { writeFileSync as writeFileSync2, unlinkSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 import { tmpdir, platform as platform2 } from "node:os";
 var GUICapability;
 var init_GUICapability = __esm({
-  "packages/daemon/src/capabilities/GUICapability.ts"() {
+  "packages/daemon/src/tools/GUICapability.ts"() {
     "use strict";
     GUICapability = class {
       name = "gui_automation";
@@ -4005,14 +4015,14 @@ else:
   }
 });
 
-// packages/daemon/src/capabilities/OpenInterpreterCapability.ts
+// packages/daemon/src/tools/OpenInterpreterCapability.ts
 import { spawn as spawn4 } from "node:child_process";
 import { writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 var OI_SCRIPT, OpenInterpreterCapability;
 var init_OpenInterpreterCapability = __esm({
-  "packages/daemon/src/capabilities/OpenInterpreterCapability.ts"() {
+  "packages/daemon/src/tools/OpenInterpreterCapability.ts"() {
     "use strict";
     OI_SCRIPT = `
 import sys
@@ -4145,7 +4155,7 @@ Run manually: pip3 install open-interpreter`,
       }
       /** Async pip install — never blocks the event loop (unlike spawnSync). */
       _pipInstall(pkg, signal) {
-        return new Promise((resolve17) => {
+        return new Promise((resolve19) => {
           const proc = spawn4("pip3", ["install", pkg, "-q"], {
             env: process.env,
             stdio: "ignore"
@@ -4156,7 +4166,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve17(ok);
+            resolve19(ok);
           };
           const onAbort = () => {
             try {
@@ -4178,7 +4188,7 @@ Run manually: pip3 install open-interpreter`,
         });
       }
       _runScript(scriptPath, stdinData, signal) {
-        return new Promise((resolve17) => {
+        return new Promise((resolve19) => {
           const proc = spawn4("python3", [scriptPath], {
             env: process.env,
             stdio: ["pipe", "pipe", "pipe"]
@@ -4191,7 +4201,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve17({ stdout: out.join(""), stderr: err.join(""), code });
+            resolve19({ stdout: out.join(""), stderr: err.join(""), code });
           };
           const onAbort = () => {
             try {
@@ -4220,13 +4230,13 @@ Run manually: pip3 install open-interpreter`,
   }
 });
 
-// packages/daemon/src/capabilities/SurgeCapability.ts
+// packages/daemon/src/tools/SurgeCapability.ts
 import { execSync as execSync3 } from "node:child_process";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, copyFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 var SurgeCapability;
 var init_SurgeCapability = __esm({
-  "packages/daemon/src/capabilities/SurgeCapability.ts"() {
+  "packages/daemon/src/tools/SurgeCapability.ts"() {
     "use strict";
     SurgeCapability = class {
       name = "surge_publish";
@@ -4300,10 +4310,10 @@ ${out}`,
   }
 });
 
-// packages/daemon/src/capabilities/BrowserExecuteCapability.ts
+// packages/daemon/src/tools/BrowserExecuteCapability.ts
 var BrowserExecuteCapability;
 var init_BrowserExecuteCapability = __esm({
-  "packages/daemon/src/capabilities/BrowserExecuteCapability.ts"() {
+  "packages/daemon/src/tools/BrowserExecuteCapability.ts"() {
     "use strict";
     BrowserExecuteCapability = class {
       name = "browser_execute";
@@ -4577,11 +4587,11 @@ var init_BrowserExecuteCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/OCRExtractCapability.ts
+// packages/daemon/src/tools/OCRExtractCapability.ts
 import { readFileSync as readFileSync3, existsSync as existsSync4 } from "node:fs";
 var OCRExtractCapability;
 var init_OCRExtractCapability = __esm({
-  "packages/daemon/src/capabilities/OCRExtractCapability.ts"() {
+  "packages/daemon/src/tools/OCRExtractCapability.ts"() {
     "use strict";
     OCRExtractCapability = class {
       name = "ocr_extract";
@@ -4740,11 +4750,11 @@ ${JSON.stringify(result.fields, null, 2)}`,
   }
 });
 
-// packages/daemon/src/capabilities/CredentialVaultCapability.ts
+// packages/daemon/src/tools/CredentialVaultCapability.ts
 import { randomBytes, createCipheriv, createDecipheriv } from "node:crypto";
 var sessionKeys, credStore, CredentialVaultCapability;
 var init_CredentialVaultCapability = __esm({
-  "packages/daemon/src/capabilities/CredentialVaultCapability.ts"() {
+  "packages/daemon/src/tools/CredentialVaultCapability.ts"() {
     "use strict";
     sessionKeys = /* @__PURE__ */ new Map();
     credStore = /* @__PURE__ */ new Map();
@@ -4855,10 +4865,10 @@ var init_CredentialVaultCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/MonitorWatchCapability.ts
+// packages/daemon/src/tools/MonitorWatchCapability.ts
 var DAEMON_URL, MonitorWatchCapability;
 var init_MonitorWatchCapability = __esm({
-  "packages/daemon/src/capabilities/MonitorWatchCapability.ts"() {
+  "packages/daemon/src/tools/MonitorWatchCapability.ts"() {
     "use strict";
     DAEMON_URL = "http://localhost:4200";
     MonitorWatchCapability = class {
@@ -5043,14 +5053,425 @@ ${lines.join("\n")}`,
   }
 });
 
-// packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
+// packages/daemon/src/tools/SessionSearchCapability.ts
+var SessionSearchCapability;
+var init_SessionSearchCapability = __esm({
+  "packages/daemon/src/tools/SessionSearchCapability.ts"() {
+    "use strict";
+    SessionSearchCapability = class {
+      name = "session_search";
+      description = "Search across past conversation history to recall previous interactions and decisions.";
+      toolDefinition = {
+        name: "session_search",
+        description: "Search across all past conversations for relevant context. Use this when the user references something from a previous session, or when you need to recall past decisions, outcomes, or context. Returns matching conversation excerpts with timestamps.",
+        input_schema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query \u2014 keywords, phrases, or natural language question" },
+            max_results: { type: "string", description: "Maximum results to return (default 5)" }
+          },
+          required: ["query"]
+        }
+      };
+      getDbPath;
+      constructor(getDbPath) {
+        this.getDbPath = getDbPath;
+      }
+      async execute(input) {
+        const start = Date.now();
+        const query = String(input.query ?? "").trim();
+        const maxResults = Number(input.max_results ?? 5);
+        if (!query) return { success: false, output: "query is required", duration_ms: 0 };
+        try {
+          const Database2 = (await import("better-sqlite3")).default;
+          const db = new Database2(this.getDbPath());
+          const keywords = query.split(/\s+/).filter((w) => w.length > 2);
+          const likeClause = keywords.map(() => `content LIKE ?`).join(" OR ");
+          const likeParams = keywords.map((k) => `%${k}%`);
+          const rows = db.prepare(`
+        SELECT session_id, role, content, created_at
+        FROM conversations
+        WHERE ${likeClause || "1=1"}
+        ORDER BY created_at DESC
+        LIMIT ?
+      `).all(...likeParams, maxResults * 3);
+          db.close();
+          if (!rows.length) {
+            return {
+              success: true,
+              output: `No past conversations found matching "${query}".`,
+              duration_ms: Date.now() - start
+            };
+          }
+          const sessions = /* @__PURE__ */ new Map();
+          for (const row of rows) {
+            if (!sessions.has(row.session_id)) sessions.set(row.session_id, []);
+            sessions.get(row.session_id).push(row);
+          }
+          const results = [];
+          let count = 0;
+          for (const [sessionId, msgs] of sessions) {
+            if (count >= maxResults) break;
+            const date = new Date(msgs[0].created_at).toISOString().split("T")[0];
+            const excerpt = msgs.slice(0, 4).map((m) => `  ${m.role}: ${m.content.slice(0, 200)}${m.content.length > 200 ? "\u2026" : ""}`).join("\n");
+            results.push(`[${date}] Session ${sessionId.slice(0, 8)}:
+${excerpt}`);
+            count++;
+          }
+          return {
+            success: true,
+            output: `Found ${sessions.size} matching session(s):
+
+${results.join("\n\n")}`,
+            structured: { sessions: sessions.size, total_messages: rows.length },
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { success: false, output: `Session search failed: ${msg}`, duration_ms: Date.now() - start, error: msg };
+        }
+      }
+    };
+  }
+});
+
+// packages/daemon/src/tools/WorktreeCapability.ts
+import { execSync as execSync4 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { resolve as resolve5, basename } from "node:path";
+var activeWorktrees, WorktreeCapability;
+var init_WorktreeCapability = __esm({
+  "packages/daemon/src/tools/WorktreeCapability.ts"() {
+    "use strict";
+    activeWorktrees = /* @__PURE__ */ new Map();
+    WorktreeCapability = class {
+      name = "worktree";
+      description = "Create isolated git worktrees for safe parallel branch work.";
+      toolDefinition = {
+        name: "worktree",
+        description: 'Manage git worktrees for isolated parallel development. Operations: "enter" (create worktree + branch), "exit" (remove/keep), "list" (show active). Use this when you need to work on a separate branch without affecting the current working tree.',
+        input_schema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation: enter, exit, list" },
+            branch: { type: "string", description: "Branch name for new worktree (enter only). Auto-generated if omitted." },
+            keep: { type: "string", description: 'Set to "true" to keep worktree on exit (default: remove)' },
+            id: { type: "string", description: 'Worktree ID for exit (if multiple active). Use "list" to see IDs.' }
+          },
+          required: ["op"]
+        }
+      };
+      async execute(input, cwd) {
+        const start = Date.now();
+        const op = String(input.op ?? "");
+        switch (op) {
+          case "enter":
+            return this._enter(input, cwd, start);
+          case "exit":
+            return this._exit(input, cwd, start);
+          case "list":
+            return this._list(start);
+          default:
+            return { success: false, output: `Unknown op: ${op}. Use enter, exit, or list.`, duration_ms: 0 };
+        }
+      }
+      _enter(input, cwd, start) {
+        try {
+          execSync4("git rev-parse --git-dir", { cwd, stdio: "pipe" });
+        } catch {
+          return { success: false, output: "Not in a git repository.", duration_ms: 0 };
+        }
+        const branch = input.branch ? String(input.branch).replace(/[^a-zA-Z0-9\-_\/]/g, "-") : `0agent-wt-${Date.now().toString(36)}`;
+        const repoRoot = execSync4("git rev-parse --show-toplevel", { cwd, encoding: "utf8" }).trim();
+        const worktreePath = resolve5(repoRoot, "..", `${basename(repoRoot)}-${branch}`);
+        if (existsSync5(worktreePath)) {
+          return { success: false, output: `Worktree path already exists: ${worktreePath}`, duration_ms: 0 };
+        }
+        try {
+          execSync4(`git worktree add -b "${branch}" "${worktreePath}"`, { cwd, stdio: "pipe" });
+          const id = `wt-${Date.now().toString(36)}`;
+          activeWorktrees.set(id, { originalCwd: cwd, worktreePath, branch });
+          return {
+            success: true,
+            output: [
+              `Worktree created:`,
+              `  ID: ${id}`,
+              `  Branch: ${branch}`,
+              `  Path: ${worktreePath}`,
+              `  Original cwd: ${cwd}`,
+              ``,
+              `Switch to the worktree by running commands in: ${worktreePath}`,
+              `When done, call worktree(op:"exit", id:"${id}") to clean up.`
+            ].join("\n"),
+            structured: { id, branch, worktreePath, originalCwd: cwd },
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { success: false, output: `Failed to create worktree: ${msg}`, duration_ms: Date.now() - start };
+        }
+      }
+      _exit(input, _cwd, start) {
+        const id = String(input.id ?? "");
+        const keep = String(input.keep ?? "") === "true";
+        let entry;
+        let entryId = id;
+        if (id) {
+          entry = activeWorktrees.get(id);
+        } else {
+          const keys = [...activeWorktrees.keys()];
+          if (keys.length > 0) {
+            entryId = keys[keys.length - 1];
+            entry = activeWorktrees.get(entryId);
+          }
+        }
+        if (!entry) {
+          return { success: false, output: id ? `No worktree with ID: ${id}` : "No active worktrees.", duration_ms: 0 };
+        }
+        if (keep) {
+          activeWorktrees.delete(entryId);
+          return {
+            success: true,
+            output: `Worktree kept at: ${entry.worktreePath} (branch: ${entry.branch}). Original cwd: ${entry.originalCwd}`,
+            duration_ms: Date.now() - start
+          };
+        }
+        try {
+          execSync4(`git worktree remove "${entry.worktreePath}" --force`, {
+            cwd: entry.originalCwd,
+            stdio: "pipe"
+          });
+          try {
+            execSync4(`git branch -D "${entry.branch}"`, { cwd: entry.originalCwd, stdio: "pipe" });
+          } catch {
+          }
+          activeWorktrees.delete(entryId);
+          return {
+            success: true,
+            output: `Worktree removed. Branch "${entry.branch}" deleted. Restored to: ${entry.originalCwd}`,
+            duration_ms: Date.now() - start
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { success: false, output: `Failed to remove worktree: ${msg}`, duration_ms: Date.now() - start };
+        }
+      }
+      _list(start) {
+        if (activeWorktrees.size === 0) {
+          return { success: true, output: "No active worktrees.", duration_ms: Date.now() - start };
+        }
+        const lines = [...activeWorktrees.entries()].map(
+          ([id, wt]) => `  ${id}: ${wt.branch} \u2192 ${wt.worktreePath}`
+        );
+        return {
+          success: true,
+          output: `Active worktrees:
+${lines.join("\n")}`,
+          structured: [...activeWorktrees.entries()].map(([id, wt]) => ({ id, ...wt })),
+          duration_ms: Date.now() - start
+        };
+      }
+    };
+  }
+});
+
+// packages/daemon/src/tools/LSPCapability.ts
+import { execSync as execSync5 } from "node:child_process";
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve6, extname } from "node:path";
+var LSPCapability;
+var init_LSPCapability = __esm({
+  "packages/daemon/src/tools/LSPCapability.ts"() {
+    "use strict";
+    LSPCapability = class {
+      name = "lsp";
+      description = "Code intelligence: go-to-definition, find-references, hover, symbols via LSP.";
+      toolDefinition = {
+        name: "lsp",
+        description: 'Language Server Protocol code intelligence. Operations: "definition" (go to definition of symbol at position), "references" (find all references to symbol), "hover" (get type info and docs for symbol), "symbols" (list all symbols in a file). Requires a language server for the file type (auto-detected).',
+        input_schema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation: definition, references, hover, symbols" },
+            file: { type: "string", description: "Absolute or relative file path" },
+            line: { type: "string", description: "Line number (1-based) for definition/references/hover" },
+            column: { type: "string", description: "Column number (1-based) for definition/references/hover" },
+            symbol: { type: "string", description: "Symbol name to search for (alternative to line+column \u2014 uses grep to find position)" }
+          },
+          required: ["op", "file"]
+        }
+      };
+      async execute(input, cwd) {
+        const start = Date.now();
+        const op = String(input.op ?? "");
+        let file = String(input.file ?? "");
+        const line = Number(input.line ?? 1) - 1;
+        const column = Number(input.column ?? 1) - 1;
+        const symbol = input.symbol ? String(input.symbol) : void 0;
+        if (!file) return { success: false, output: "file is required", duration_ms: 0 };
+        if (!file.startsWith("/")) file = resolve6(cwd, file);
+        if (!existsSync6(file)) return { success: false, output: `File not found: ${file}`, duration_ms: 0 };
+        let actualLine = line;
+        let actualCol = column;
+        if (symbol) {
+          const pos = this._findSymbolPosition(file, symbol);
+          if (pos) {
+            actualLine = pos.line;
+            actualCol = pos.column;
+          } else {
+            return { success: false, output: `Symbol "${symbol}" not found in ${file}`, duration_ms: Date.now() - start };
+          }
+        }
+        const ext = extname(file).toLowerCase();
+        if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
+          return this._tsOperation(op, file, actualLine, actualCol, cwd, start);
+        }
+        return this._grepFallback(op, file, actualLine, actualCol, symbol, cwd, start);
+      }
+      /**
+       * TypeScript/JavaScript operations using tsserver protocol.
+       */
+      _tsOperation(op, file, line, column, cwd, start) {
+        try {
+          switch (op) {
+            case "definition": {
+              const content = readFileSync4(file, "utf8");
+              const lines = content.split("\n");
+              const targetLine = lines[line] ?? "";
+              const word = this._getWordAt(targetLine, column);
+              if (!word) return { success: false, output: "No symbol at that position", duration_ms: Date.now() - start };
+              const defPatterns = [
+                `(function|const|let|var|class|interface|type|enum)\\s+${word}\\b`,
+                `${word}\\s*[:=]\\s*(function|\\()`,
+                `export\\s+(default\\s+)?(function|class|const|let|var|type|interface)\\s+${word}`
+              ];
+              const results = [];
+              for (const pattern of defPatterns) {
+                try {
+                  const grep = execSync5(
+                    `rg -n "${pattern}" --type ts --type js "${cwd}" 2>/dev/null | head -10`,
+                    { encoding: "utf8", timeout: 5e3 }
+                  ).trim();
+                  if (grep) results.push(grep);
+                } catch {
+                }
+              }
+              if (!results.length) {
+                return { success: true, output: `No definition found for "${word}"`, duration_ms: Date.now() - start };
+              }
+              return {
+                success: true,
+                output: `Definition of "${word}":
+${results.join("\n")}`,
+                duration_ms: Date.now() - start
+              };
+            }
+            case "references": {
+              const content = readFileSync4(file, "utf8");
+              const lines = content.split("\n");
+              const word = this._getWordAt(lines[line] ?? "", column);
+              if (!word) return { success: false, output: "No symbol at that position", duration_ms: Date.now() - start };
+              try {
+                const grep = execSync5(
+                  `rg -n "\\b${word}\\b" --type ts --type js "${cwd}" 2>/dev/null | head -20`,
+                  { encoding: "utf8", timeout: 5e3 }
+                ).trim();
+                const refCount = grep.split("\n").filter(Boolean).length;
+                return {
+                  success: true,
+                  output: `References to "${word}" (${refCount} found):
+${grep}`,
+                  duration_ms: Date.now() - start
+                };
+              } catch {
+                return { success: true, output: `No references found for "${word}"`, duration_ms: Date.now() - start };
+              }
+            }
+            case "hover": {
+              const content = readFileSync4(file, "utf8");
+              const lines = content.split("\n");
+              const word = this._getWordAt(lines[line] ?? "", column);
+              if (!word) return { success: false, output: "No symbol at that position", duration_ms: Date.now() - start };
+              const surroundingLines = lines.slice(Math.max(0, line - 3), line + 4);
+              return {
+                success: true,
+                output: `Symbol: ${word}
+Context (${file}:${line + 1}:${column + 1}):
+${surroundingLines.join("\n")}`,
+                duration_ms: Date.now() - start
+              };
+            }
+            case "symbols": {
+              try {
+                const grep = execSync5(
+                  `rg -n "^\\s*(export\\s+)?(function|class|interface|type|enum|const|let|var)\\s+\\w+" "${file}" 2>/dev/null`,
+                  { encoding: "utf8", timeout: 5e3 }
+                ).trim();
+                return {
+                  success: true,
+                  output: `Symbols in ${file}:
+${grep || "(no symbols found)"}`,
+                  duration_ms: Date.now() - start
+                };
+              } catch {
+                return { success: true, output: `No symbols found in ${file}`, duration_ms: Date.now() - start };
+              }
+            }
+            default:
+              return { success: false, output: `Unknown op: ${op}`, duration_ms: 0 };
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { success: false, output: `LSP operation failed: ${msg}`, duration_ms: Date.now() - start };
+        }
+      }
+      _grepFallback(op, file, line, column, symbol, cwd, start) {
+        const content = readFileSync4(file, "utf8");
+        const lines = content.split("\n");
+        const word = symbol || this._getWordAt(lines[line] ?? "", column);
+        if (!word) return { success: false, output: "No symbol to search for", duration_ms: 0 };
+        try {
+          const grep = execSync5(
+            `rg -n "\\b${word}\\b" "${cwd}" 2>/dev/null | head -20`,
+            { encoding: "utf8", timeout: 5e3 }
+          ).trim();
+          return {
+            success: true,
+            output: `${op} for "${word}" (grep fallback):
+${grep || "(no results)"}`,
+            duration_ms: Date.now() - start
+          };
+        } catch {
+          return { success: true, output: `No results for "${word}"`, duration_ms: Date.now() - start };
+        }
+      }
+      _findSymbolPosition(file, symbol) {
+        const content = readFileSync4(file, "utf8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const col = lines[i].indexOf(symbol);
+          if (col !== -1) return { line: i, column: col };
+        }
+        return null;
+      }
+      _getWordAt(line, col) {
+        const before = line.slice(0, col + 1).match(/[\w$]+$/)?.[0] ?? "";
+        const after = line.slice(col + 1).match(/^[\w$]*/)?.[0] ?? "";
+        const word = before + after;
+        return word.length > 0 ? word : null;
+      }
+    };
+  }
+});
+
+// packages/daemon/src/tools/CodespaceBrowserCapability.ts
 var CodespaceBrowserCapability_exports = {};
 __export(CodespaceBrowserCapability_exports, {
   CodespaceBrowserCapability: () => CodespaceBrowserCapability
 });
 var CodespaceBrowserCapability;
 var init_CodespaceBrowserCapability = __esm({
-  "packages/daemon/src/capabilities/CodespaceBrowserCapability.ts"() {
+  "packages/daemon/src/tools/CodespaceBrowserCapability.ts"() {
     "use strict";
     init_BrowserCapability();
     CodespaceBrowserCapability = class {
@@ -5117,10 +5538,10 @@ var init_CodespaceBrowserCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/CapabilityRegistry.ts
+// packages/daemon/src/tools/CapabilityRegistry.ts
 var CapabilityRegistry;
 var init_CapabilityRegistry = __esm({
-  "packages/daemon/src/capabilities/CapabilityRegistry.ts"() {
+  "packages/daemon/src/tools/CapabilityRegistry.ts"() {
     "use strict";
     init_WebSearchCapability();
     init_BrowserCapability();
@@ -5135,6 +5556,9 @@ var init_CapabilityRegistry = __esm({
     init_OCRExtractCapability();
     init_CredentialVaultCapability();
     init_MonitorWatchCapability();
+    init_SessionSearchCapability();
+    init_WorktreeCapability();
+    init_LSPCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
       /**
@@ -5147,7 +5571,7 @@ var init_CapabilityRegistry = __esm({
        * task_type: browser_task). The main agent does NOT have direct access
        * to browser_open without going through a subagent spawn.
        */
-      constructor(codespaceManager, graph, onMemoryWrite) {
+      constructor(codespaceManager, graph, onMemoryWrite, dbPath) {
         this.register(new WebSearchCapability());
         if (codespaceManager) {
           try {
@@ -5169,6 +5593,11 @@ var init_CapabilityRegistry = __esm({
         this.register(new OCRExtractCapability());
         this.register(new CredentialVaultCapability());
         this.register(new MonitorWatchCapability());
+        if (dbPath) {
+          this.register(new SessionSearchCapability(() => dbPath));
+        }
+        this.register(new WorktreeCapability());
+        this.register(new LSPCapability());
         if (graph) {
           this.register(new MemoryCapability(graph, onMemoryWrite));
         }
@@ -5199,6 +5628,7 @@ var init_CapabilityRegistry = __esm({
         const lower = task.toLowerCase();
         const active = /* @__PURE__ */ new Set(["shell_exec", "file_op", "surge_publish"]);
         if (this.capabilities.has("memory_write")) active.add("memory_write");
+        if (this.capabilities.has("session_search")) active.add("session_search");
         if (/search|web|browse|scrape|research|website|url|http|google|fetch|crawl|find.*online/i.test(lower)) {
           active.add("web_search");
           active.add("scrape_url");
@@ -5208,6 +5638,10 @@ var init_CapabilityRegistry = __esm({
           active.add("computer_use");
           active.add("gui_automation");
         }
+        if (/implement|build|write|fix|refactor|debug|test|definition|reference|hover|symbol|branch|worktree|isolat|parallel.*work/i.test(lower)) {
+          active.add("lsp");
+          active.add("worktree");
+        }
         if (/book|file|itr|tax|irctc|train|ticket|flight|passport|appointment|login|portal|form.*fill|ocr|extract|document|pan.*card|aadhaar|credential|password|otp|monitor|watch|alert|notify.*when|price.*drop|slot.*available|justdo/i.test(lower)) {
           active.add("browser_execute");
           active.add("ocr_extract");
@@ -5238,9 +5672,9 @@ var init_CapabilityRegistry = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/index.ts
-var init_capabilities = __esm({
-  "packages/daemon/src/capabilities/index.ts"() {
+// packages/daemon/src/tools/index.ts
+var init_tools = __esm({
+  "packages/daemon/src/tools/index.ts"() {
     "use strict";
     init_CapabilityRegistry();
     init_WebSearchCapability();
@@ -5254,20 +5688,309 @@ var init_capabilities = __esm({
     init_OCRExtractCapability();
     init_CredentialVaultCapability();
     init_MonitorWatchCapability();
+    init_SessionSearchCapability();
+    init_WorktreeCapability();
+    init_LSPCapability();
+  }
+});
+
+// packages/daemon/src/utils/IterationBudget.ts
+var IterationBudget;
+var init_IterationBudget = __esm({
+  "packages/daemon/src/utils/IterationBudget.ts"() {
+    "use strict";
+    IterationBudget = class _IterationBudget {
+      constructor(maxIterations, parent, childAllocation) {
+        this.maxIterations = maxIterations;
+        this.parent = parent ?? null;
+        this.childAllocation = childAllocation ?? maxIterations;
+      }
+      used = 0;
+      parent;
+      childAllocation;
+      /**
+       * Consume N iterations. Returns true if budget remains, false if exhausted.
+       * Also consumes from parent budget if this is a child.
+       */
+      consume(n = 1) {
+        this.used += n;
+        if (this.parent) {
+          return this.parent.consume(n) && this.used <= this.maxIterations;
+        }
+        return this.used <= this.maxIterations;
+      }
+      /**
+       * Refund N iterations (e.g., for execute_code calls that don't count).
+       */
+      refund(n = 1) {
+        this.used = Math.max(0, this.used - n);
+        this.parent?.refund(n);
+      }
+      remaining() {
+        const local = this.maxIterations - this.used;
+        if (this.parent) {
+          return Math.min(local, this.parent.remaining());
+        }
+        return local;
+      }
+      exhausted() {
+        return this.remaining() <= 0;
+      }
+      /**
+       * Fork a child budget that draws from this parent's remaining pool.
+       * The child has its own max but also decrements the parent on each consume.
+       */
+      fork(childMax) {
+        const max = childMax ?? Math.min(30, this.remaining());
+        return new _IterationBudget(max, this, max);
+      }
+      /**
+       * Get a budget pressure message if running low.
+       * Returns null if budget is healthy.
+       */
+      pressureWarning() {
+        const rem = this.remaining();
+        const pct = rem / this.maxIterations;
+        if (pct <= 0) {
+          return "BUDGET EXHAUSTED: You have used all available iterations. Wrap up immediately.";
+        }
+        if (pct <= 0.1) {
+          return `BUDGET CRITICAL: Only ${rem} iteration(s) remaining. Finish the current task NOW.`;
+        }
+        if (pct <= 0.25) {
+          return `Budget warning: ${rem} iterations remaining (${Math.round(pct * 100)}%). Start wrapping up.`;
+        }
+        return null;
+      }
+      stats() {
+        return {
+          used: this.used,
+          max: this.maxIterations,
+          remaining: this.maxIterations - this.used,
+          ...this.parent ? { parentRemaining: this.parent.remaining() } : {}
+        };
+      }
+    };
+  }
+});
+
+// packages/daemon/src/utils/PromptInjectionScanner.ts
+function scanForInjection(content, source) {
+  const warnings = [];
+  let sanitized = content;
+  const invisibleMatches = content.match(INVISIBLE_CHARS);
+  if (invisibleMatches && invisibleMatches.length > 0) {
+    warnings.push(`${source || "content"}: ${invisibleMatches.length} invisible Unicode chars detected and stripped`);
+    sanitized = sanitized.replace(INVISIBLE_CHARS, "");
+  }
+  let hasBlock = false;
+  for (const { pattern, severity, label } of INJECTION_PATTERNS) {
+    if (pattern.test(content)) {
+      const msg = `${source || "content"}: ${label} detected (${severity})`;
+      warnings.push(msg);
+      if (severity === "block") hasBlock = true;
+    }
+  }
+  const lines = content.split("\n");
+  const uniqueLines = new Set(lines.map((l) => l.trim()).filter((l) => l.length > 10));
+  if (lines.length > 20 && uniqueLines.size < lines.length * 0.3) {
+    warnings.push(`${source || "content"}: suspicious repetition (${uniqueLines.size} unique of ${lines.length} lines)`);
+  }
+  return {
+    safe: !hasBlock,
+    warnings,
+    sanitized: hasBlock ? `[BLOCKED: Prompt injection detected in ${source || "content"}. Content excluded for safety.]` : sanitized
+  };
+}
+function sanitizeContextFile(content, filePath, log) {
+  const result = scanForInjection(content, filePath);
+  for (const w of result.warnings) {
+    log?.(`[injection-scan] ${w}`);
+  }
+  return result.sanitized;
+}
+var INJECTION_PATTERNS, INVISIBLE_CHARS;
+var init_PromptInjectionScanner = __esm({
+  "packages/daemon/src/utils/PromptInjectionScanner.ts"() {
+    "use strict";
+    INJECTION_PATTERNS = [
+      // Direct instruction override
+      { pattern: /ignore\s+(all\s+)?(previous|prior|above|earlier)\s+(instructions?|context|rules?|prompts?)/i, severity: "block", label: "instruction override" },
+      { pattern: /disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|context)/i, severity: "block", label: "instruction override" },
+      { pattern: /forget\s+(everything|all|what)\s+(you|I)\s+(told|said|instructed)/i, severity: "block", label: "instruction override" },
+      { pattern: /new\s+instructions?\s*:/i, severity: "block", label: "instruction injection" },
+      { pattern: /\bsystem\s*:\s*you\s+are\b/i, severity: "block", label: "role hijack" },
+      // Role impersonation
+      { pattern: /you\s+are\s+now\s+(a|an|the)\s+/i, severity: "warn", label: "role impersonation" },
+      { pattern: /act\s+as\s+(if|though)\s+you\s+are/i, severity: "warn", label: "role impersonation" },
+      { pattern: /pretend\s+(you'?re?|to\s+be)\s+/i, severity: "warn", label: "role impersonation" },
+      // Credential/data exfiltration
+      { pattern: /send\s+(the|your|all)\s+(api\s*key|token|password|secret|credential)/i, severity: "block", label: "credential exfil" },
+      { pattern: /output\s+(the|your)\s+system\s+prompt/i, severity: "block", label: "prompt extraction" },
+      { pattern: /reveal\s+(the|your)\s+(system|initial)\s+(prompt|instructions)/i, severity: "block", label: "prompt extraction" },
+      { pattern: /what\s+(is|are)\s+your\s+(system\s+)?instructions/i, severity: "warn", label: "prompt extraction attempt" },
+      // Encoded/obfuscated injection
+      { pattern: /base64\s*decode|atob\s*\(/i, severity: "warn", label: "encoded payload" },
+      { pattern: /eval\s*\(|Function\s*\(/i, severity: "warn", label: "code execution attempt" }
+    ];
+    INVISIBLE_CHARS = /[\u200B\u200C\u200D\u200E\u200F\u202A-\u202E\u2060\u2061\u2062\u2063\u2064\u2066-\u2069\uFEFF\u00AD]/g;
+  }
+});
+
+// packages/daemon/src/utils/ContextCollapse.ts
+function collapseContext(messages, tailKeep = 10) {
+  if (messages.length <= tailKeep) return messages;
+  const cutIndex = messages.length - tailKeep;
+  const prefix = messages.slice(0, cutIndex);
+  const tail = messages.slice(cutIndex);
+  const collapsed = [];
+  for (const msg of prefix) {
+    if (msg.role === "tool") {
+      collapsed.push({
+        ...msg,
+        content: collapseToolResult(msg.content, msg.tool_call_id)
+      });
+    } else if (msg.role === "assistant" && msg.tool_calls) {
+      collapsed.push({
+        ...msg,
+        content: msg.content.length > 200 ? msg.content.slice(0, 200) + "\u2026" : msg.content
+      });
+    } else {
+      collapsed.push(msg);
+    }
+  }
+  return [...collapsed, ...tail];
+}
+function collapseToolResult(content, toolCallId) {
+  const lineCount = content.split("\n").length;
+  const charCount = content.length;
+  if (charCount <= 200) return content;
+  if (/^(1\t|   1\t|\d+\|)/.test(content)) {
+    const lastLine = content.trim().split("\n").pop() ?? "";
+    const lineNum = lastLine.match(/^(\d+)/)?.[1] ?? String(lineCount);
+    return `[file content: ${lineNum} lines, ${charCount} chars \u2014 collapsed]`;
+  }
+  if (content.startsWith("(no output)") || content.startsWith("exit ")) {
+    return content.slice(0, 100);
+  }
+  if (/^(Error|FAIL|Traceback|SyntaxError|TypeError|ReferenceError)/i.test(content)) {
+    const lines = content.split("\n");
+    return lines.slice(0, 2).join("\n") + (lines.length > 2 ? `
+[...${lines.length - 2} more lines]` : "");
+  }
+  const fileMatches = content.match(/^[^\n]+:\d+:/gm);
+  if (fileMatches) {
+    const uniqueFiles = new Set(fileMatches.map((m) => m.split(":")[0]));
+    return `[search: ${fileMatches.length} matches in ${uniqueFiles.size} files \u2014 collapsed]`;
+  }
+  if (content.startsWith("{") || content.startsWith("[")) {
+    return `[JSON output: ${charCount} chars \u2014 collapsed]`;
+  }
+  const urlMatch = content.match(/https?:\/\/[^\s]+\.surge\.sh/);
+  if (urlMatch) {
+    return `[published: ${urlMatch[0]}]`;
+  }
+  const firstLine = content.split("\n")[0].slice(0, 100);
+  return `${firstLine}\u2026 [${lineCount} lines, ${charCount} chars \u2014 collapsed]`;
+}
+var init_ContextCollapse = __esm({
+  "packages/daemon/src/utils/ContextCollapse.ts"() {
+    "use strict";
+  }
+});
+
+// packages/daemon/src/services/StreamingToolExecutor.ts
+function isPreExecSafe(tc) {
+  if (PRE_EXEC_SAFE.has(tc.name)) return true;
+  if (tc.name === "file_op" && tc.input.op === "read") return true;
+  if (tc.name === "file_op" && tc.input.op === "list") return true;
+  if (tc.name === "ocr_extract") return true;
+  return false;
+}
+var PRE_EXEC_SAFE, StreamingToolExecutor;
+var init_StreamingToolExecutor = __esm({
+  "packages/daemon/src/services/StreamingToolExecutor.ts"() {
+    "use strict";
+    PRE_EXEC_SAFE = /* @__PURE__ */ new Set([
+      "web_search",
+      "scrape_url",
+      "session_search",
+      "lsp"
+    ]);
+    StreamingToolExecutor = class {
+      pending = /* @__PURE__ */ new Map();
+      registry;
+      cwd;
+      signal;
+      constructor(registry, cwd, signal) {
+        this.registry = registry;
+        this.cwd = cwd;
+        this.signal = signal;
+      }
+      /**
+       * Called by LLMExecutor's onToolUseBlock callback during streaming.
+       * Starts executing the tool immediately if it's safe to pre-execute.
+       */
+      onToolBlock(tc) {
+        if (!isPreExecSafe(tc)) return;
+        const promise = this.registry.execute(tc.name, tc.input, this.cwd, this.signal);
+        this.pending.set(tc.id, { promise, toolCall: tc, started: Date.now() });
+      }
+      /**
+       * Get a pre-executed result if available, or execute now.
+       * Returns the result string (same contract as _executeSingleTool).
+       */
+      async getOrExecute(tc, fallbackExecute) {
+        const pending = this.pending.get(tc.id);
+        if (pending) {
+          try {
+            const capResult = await pending.promise;
+            const MAX_TOOL_OUTPUT = 4e3;
+            let result = capResult.output;
+            if (result.length > MAX_TOOL_OUTPUT) {
+              result = result.slice(0, MAX_TOOL_OUTPUT) + `
+[...${result.length - MAX_TOOL_OUTPUT} chars truncated]`;
+            }
+            return { result, preExecuted: true };
+          } catch (err) {
+            return { result: `Error: ${err instanceof Error ? err.message : String(err)}`, preExecuted: true };
+          } finally {
+            this.pending.delete(tc.id);
+          }
+        }
+        return { result: await fallbackExecute(), preExecuted: false };
+      }
+      /**
+       * Number of tools currently pre-executing.
+       */
+      get activeCount() {
+        return this.pending.size;
+      }
+      /**
+       * Cancel all pending pre-executions.
+       */
+      clear() {
+        this.pending.clear();
+      }
+    };
   }
 });
 
 // packages/daemon/src/AgentExecutor.ts
-import { spawn as spawn5 } from "node:child_process";
-import { writeFileSync as writeFileSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "node:fs";
-import { resolve as resolve5, dirname as dirname2, relative } from "node:path";
+import { spawn as spawn6 } from "node:child_process";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, mkdirSync as mkdirSync3, existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve7, dirname as dirname2, relative } from "node:path";
 import { homedir as homedir2 } from "node:os";
 var SELF_MOD_PATTERN, AgentExecutor;
 var init_AgentExecutor = __esm({
   "packages/daemon/src/AgentExecutor.ts"() {
     "use strict";
     init_LLMExecutor();
-    init_capabilities();
+    init_tools();
+    init_IterationBudget();
+    init_PromptInjectionScanner();
+    init_ContextCollapse();
+    init_StreamingToolExecutor();
     SELF_MOD_PATTERN = /\b(yourself|the agent|this agent|this cli|0agent|your code|your source|agent cli|improve.*agent|update.*agent|add.*to.*agent|fix.*agent|self.?improv)\b/i;
     AgentExecutor = class {
       constructor(llm, config, onStep, onToken) {
@@ -5279,7 +6002,7 @@ var init_AgentExecutor = __esm({
         this.maxIterations = config.max_iterations ?? 50;
         this.maxCommandMs = config.max_command_ms ?? 3e4;
         this.agentRoot = config.agent_root;
-        this.registry = new CapabilityRegistry(void 0, config.graph, config.onMemoryWrite);
+        this.registry = new CapabilityRegistry(void 0, config.graph, config.onMemoryWrite, config.dbPath);
         if (config.entityNodeId) {
           this.registry.setEntityNodeId(config.entityNodeId);
         }
@@ -5299,6 +6022,7 @@ var init_AgentExecutor = __esm({
         const systemPrompt = this.buildSystemPrompt(systemContext, task);
         const activeTools = this.registry.getToolDefinitionsFor(task);
         let toolSet = activeTools;
+        const budget = new IterationBudget(this.maxIterations);
         const messages = [
           { role: "user", content: task }
         ];
@@ -5320,14 +6044,37 @@ var init_AgentExecutor = __esm({
             finalOutput = "Cancelled.";
             break;
           }
+          if (budget.exhausted()) {
+            this.onStep("Iteration budget exhausted \u2014 wrapping up.");
+            break;
+          }
+          budget.consume(1);
+          const pressureMsg = budget.pressureWarning();
+          if (pressureMsg && messages.length > 2) {
+            messages.push({ role: "user", content: `[SYSTEM] ${pressureMsg}` });
+          }
           this.onStep(i === 0 ? "Thinking\u2026" : "Continuing\u2026");
           const estimatedTokens = this._estimateTokens(messages);
-          if (estimatedTokens > contextLimit - 16384) {
-            this.onStep(`Compacting context (${Math.round(estimatedTokens / 1e3)}k tokens)\u2026`);
+          if (estimatedTokens > contextLimit * 0.6) {
+            const before = messages.length;
+            const collapsed = collapseContext(messages, 12);
+            if (collapsed !== messages) {
+              messages.length = 0;
+              messages.push(...collapsed);
+              const afterTokens = this._estimateTokens(messages);
+              if (afterTokens < estimatedTokens * 0.8) {
+                this.onStep(`Context collapsed (${Math.round(estimatedTokens / 1e3)}k \u2192 ${Math.round(afterTokens / 1e3)}k tokens)`);
+              }
+            }
+          }
+          const tokensAfterCollapse = this._estimateTokens(messages);
+          if (tokensAfterCollapse > contextLimit - 16384) {
+            this.onStep(`Compacting context (${Math.round(tokensAfterCollapse / 1e3)}k tokens)\u2026`);
             this._compactHistory(messages);
           }
           let response;
           let llmFailed = false;
+          const streamExec = new StreamingToolExecutor(this.registry, this.cwd, signal);
           {
             let llmRetry = 0;
             while (true) {
@@ -5341,7 +6088,9 @@ var init_AgentExecutor = __esm({
                     this.onToken(token);
                     finalOutput += token;
                   },
-                  signal
+                  signal,
+                  // Streaming tool execution: start safe tools as their blocks complete
+                  (tc) => streamExec.onToolBlock(tc)
                 );
                 break;
               } catch (err) {
@@ -5377,6 +6126,12 @@ var init_AgentExecutor = __esm({
           totalTokens += response.tokens_used;
           totalCost += response.cost_usd;
           modelName = response.model;
+          const maxBudget = this.config.max_budget_usd ?? Infinity;
+          if (totalCost >= maxBudget) {
+            this.onStep(`Budget limit reached: $${totalCost.toFixed(4)} \u2265 $${maxBudget} \u2014 stopping session.`);
+            finalOutput = `Session stopped: cost budget of $${maxBudget} exceeded ($${totalCost.toFixed(4)} used).`;
+            break;
+          }
           if (response.tool_calls?.some((tc) => !toolSet.find((t) => t.name === tc.name))) {
             toolSet = this.registry.getToolDefinitions();
           }
@@ -5390,35 +6145,31 @@ var init_AgentExecutor = __esm({
             content: response.content,
             tool_calls: response.tool_calls
           });
-          for (const tc of response.tool_calls) {
-            this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})`);
-            let result;
-            try {
-              const capResult = await this.registry.execute(tc.name, tc.input, this.cwd, signal);
-              result = capResult.output;
-              const MAX_TOOL_OUTPUT = 4e3;
-              if (result.length > MAX_TOOL_OUTPUT) {
-                result = result.slice(0, MAX_TOOL_OUTPUT) + `
-[...${result.length - MAX_TOOL_OUTPUT} chars truncated]`;
-              }
-              if (capResult.fallback_used) {
-                this.onStep(`  (used fallback: ${capResult.fallback_used})`);
-              }
-              if (tc.name === "file_op" && tc.input.op === "write" && tc.input.path) {
-                filesWritten.push(String(tc.input.path));
-              }
-              if (tc.name === "shell_exec" && tc.input.command) {
-                commandsRun.push(String(tc.input.command));
-              }
-            } catch (err) {
-              result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+          const toolCalls = response.tool_calls;
+          const { parallel, serial } = this._partitionToolCalls(toolCalls);
+          if (parallel.length > 0) {
+            const results = await Promise.all(parallel.map(async (tc) => {
+              const { result, preExecuted } = await streamExec.getOrExecute(
+                tc,
+                () => this._executeSingleTool(tc, signal, filesWritten, commandsRun)
+              );
+              const tag = preExecuted ? " [pre-exec]" : " [parallel]";
+              this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})${tag}`);
+              return { tc, result };
+            }));
+            for (const { tc, result } of results) {
+              this.onStep(`  \u21B3 ${result.slice(0, 120)}${result.length > 120 ? "\u2026" : ""}`);
+              messages.push({ role: "tool", content: result, tool_call_id: tc.id });
             }
+          }
+          for (const tc of serial) {
+            const { result, preExecuted } = await streamExec.getOrExecute(
+              tc,
+              () => this._executeSingleTool(tc, signal, filesWritten, commandsRun)
+            );
+            this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})${preExecuted ? " [pre-exec]" : ""}`);
             this.onStep(`  \u21B3 ${result.slice(0, 120)}${result.length > 120 ? "\u2026" : ""}`);
-            messages.push({
-              role: "tool",
-              content: result,
-              tool_call_id: tc.id
-            });
+            messages.push({ role: "tool", content: result, tool_call_id: tc.id });
           }
         }
         return {
@@ -5462,9 +6213,9 @@ var init_AgentExecutor = __esm({
         }
       }
       shellExec(command, timeoutMs) {
-        return new Promise((resolve17) => {
+        return new Promise((resolve19) => {
           const chunks = [];
-          const proc = spawn5("bash", ["-c", command], {
+          const proc = spawn6("bash", ["-c", command], {
             cwd: this.cwd,
             env: { ...process.env, TERM: "dumb" },
             timeout: timeoutMs
@@ -5473,10 +6224,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve17(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve19(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve17(`Error: ${err.message}`);
+            resolve19(`Error: ${err.message}`);
           });
         });
       }
@@ -5491,8 +6242,8 @@ var init_AgentExecutor = __esm({
       readFile(filePath) {
         const safe = this.safePath(filePath);
         if (!safe) return "Error: path outside working directory";
-        if (!existsSync5(safe)) return `File not found: ${filePath}`;
-        const content = readFileSync4(safe, "utf8");
+        if (!existsSync7(safe)) return `File not found: ${filePath}`;
+        const content = readFileSync5(safe, "utf8");
         return content.length > 8e3 ? content.slice(0, 8e3) + `
 \u2026[truncated, ${content.length} total bytes]` : content;
       }
@@ -5583,7 +6334,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
       listDir(dirPath) {
         const safe = this.safePath(dirPath ?? ".");
         if (!safe) return "Error: path outside working directory";
-        if (!existsSync5(safe)) return `Directory not found: ${dirPath}`;
+        if (!existsSync7(safe)) return `Directory not found: ${dirPath}`;
         try {
           const entries = readdirSync2(safe, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => `${e.isDirectory() ? "d" : "f"}  ${e.name}`).join("\n");
           return entries || "(empty directory)";
@@ -5593,7 +6344,7 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
       }
       // ─── Helpers ───────────────────────────────────────────────────────────────
       safePath(p) {
-        const resolved = resolve5(this.cwd, p);
+        const resolved = resolve7(this.cwd, p);
         return resolved.startsWith(this.cwd) ? resolved : null;
       }
       buildSystemPrompt(extra, task) {
@@ -5724,17 +6475,18 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           );
         }
         const agentsFiles = [
-          resolve5(this.cwd, "AGENTS.md"),
-          resolve5(this.cwd, ".0agent", "AGENTS.md"),
-          resolve5(this.cwd, "CLAUDE.md"),
-          resolve5(homedir2(), ".0agent", "AGENTS.md")
+          resolve7(this.cwd, "AGENTS.md"),
+          resolve7(this.cwd, ".0agent", "AGENTS.md"),
+          resolve7(this.cwd, "CLAUDE.md"),
+          resolve7(homedir2(), ".0agent", "AGENTS.md")
         ];
         for (const f of agentsFiles) {
           try {
-            if (existsSync5(f)) {
-              const content = readFileSync4(f, "utf8").trim();
+            if (existsSync7(f)) {
+              const content = readFileSync5(f, "utf8").trim();
               if (content && content.length < 4e3) {
-                lines.push(``, `Project instructions:`, content);
+                const sanitized = sanitizeContextFile(content, f);
+                lines.push(``, `Project instructions:`, sanitized);
                 break;
               }
             }
@@ -5839,13 +6591,82 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
         if (toolName === "scrape_url") return `"${String(input.url ?? "").slice(0, 60)}" mode=${input.mode ?? "text"}`;
         return JSON.stringify(input).slice(0, 60);
       }
+      /**
+       * Execute a single tool call. Returns the result string.
+       */
+      async _executeSingleTool(tc, signal, filesWritten, commandsRun) {
+        let result;
+        try {
+          const capResult = await this.registry.execute(tc.name, tc.input, this.cwd, signal);
+          result = capResult.output;
+          const MAX_TOOL_OUTPUT = 4e3;
+          if (result.length > MAX_TOOL_OUTPUT) {
+            result = result.slice(0, MAX_TOOL_OUTPUT) + `
+[...${result.length - MAX_TOOL_OUTPUT} chars truncated]`;
+          }
+          if (capResult.fallback_used) {
+            this.onStep(`  (used fallback: ${capResult.fallback_used})`);
+          }
+          if (tc.name === "file_op" && tc.input.op === "write" && tc.input.path) {
+            filesWritten.push(String(tc.input.path));
+          }
+          if (tc.name === "shell_exec" && tc.input.command) {
+            commandsRun.push(String(tc.input.command));
+          }
+        } catch (err) {
+          result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        return result;
+      }
+      /**
+       * Partition tool calls into parallelisable and serial groups.
+       * Inspired by Hermes Agent's path-overlap analysis.
+       *
+       * Tools are safe to parallelize when they don't share file paths
+       * and aren't in the never-parallel set (shell_exec, browser_execute).
+       */
+      _partitionToolCalls(calls) {
+        if (calls.length <= 1) return { parallel: [], serial: calls };
+        const NEVER_PARALLEL = /* @__PURE__ */ new Set(["shell_exec", "browser_execute", "credential_vault", "monitor_watch"]);
+        const parallel = [];
+        const serial = [];
+        const usedPaths = /* @__PURE__ */ new Set();
+        for (const tc of calls) {
+          if (NEVER_PARALLEL.has(tc.name)) {
+            serial.push(tc);
+            continue;
+          }
+          const paths = this._extractPaths(tc);
+          let hasOverlap = false;
+          for (const p of paths) {
+            if (usedPaths.has(p)) {
+              hasOverlap = true;
+              break;
+            }
+          }
+          if (hasOverlap) {
+            serial.push(tc);
+          } else {
+            parallel.push(tc);
+            for (const p of paths) usedPaths.add(p);
+          }
+        }
+        return { parallel, serial };
+      }
+      _extractPaths(tc) {
+        const paths = [];
+        if (tc.input.path) paths.push(String(tc.input.path));
+        if (tc.input.image_path) paths.push(String(tc.input.image_path));
+        if (tc.input.url) paths.push(String(tc.input.url));
+        return paths;
+      }
     };
   }
 });
 
 // packages/daemon/src/ExecutionVerifier.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
 var ExecutionVerifier;
 var init_ExecutionVerifier = __esm({
   "packages/daemon/src/ExecutionVerifier.ts"() {
@@ -5882,8 +6703,8 @@ var init_ExecutionVerifier = __esm({
           };
         }
         if (files.length > 0) {
-          const lastFile = resolve6(this.cwd, files[files.length - 1]);
-          const exists = existsSync7(lastFile);
+          const lastFile = resolve8(this.cwd, files[files.length - 1]);
+          const exists = existsSync9(lastFile);
           return {
             success: exists,
             method: "file_exists",
@@ -5922,10 +6743,10 @@ var init_ExecutionVerifier = __esm({
 });
 
 // packages/daemon/src/RuntimeSelfHeal.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "node:fs";
-import { resolve as resolve7, dirname as dirname3 } from "node:path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "node:fs";
+import { resolve as resolve9, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execSync as execSync5, spawn as spawn6 } from "node:child_process";
+import { execSync as execSync7, spawn as spawn7 } from "node:child_process";
 function isRuntimeBug(error) {
   if (TASK_FAILURE_PATTERNS.some((p) => p.test(error))) return false;
   return RUNTIME_BUG_PATTERNS.some((p) => p.test(error));
@@ -5949,8 +6770,8 @@ function parseStackTrace(stack) {
 }
 function extractContext(filePath, errorLine, contextLines = 30) {
   try {
-    if (!existsSync8(filePath)) return null;
-    const content = readFileSync6(filePath, "utf8");
+    if (!existsSync10(filePath)) return null;
+    const content = readFileSync7(filePath, "utf8");
     const lines = content.split("\n");
     const start = Math.max(0, errorLine - contextLines);
     const end = Math.min(lines.length, errorLine + contextLines);
@@ -5995,8 +6816,8 @@ var init_RuntimeSelfHeal = __esm({
         this.llm = llm;
         this.eventBus = eventBus;
         let dir = dirname3(fileURLToPath(import.meta.url));
-        while (dir !== "/" && !existsSync8(resolve7(dir, "package.json"))) {
-          dir = resolve7(dir, "..");
+        while (dir !== "/" && !existsSync10(resolve9(dir, "package.json"))) {
+          dir = resolve9(dir, "..");
         }
         this.projectRoot = dir;
       }
@@ -6032,7 +6853,7 @@ var init_RuntimeSelfHeal = __esm({
        */
       async applyPatch(proposal) {
         const tsPath = this.findSourceFile(proposal.location);
-        if (!tsPath || !existsSync8(tsPath)) {
+        if (!tsPath || !existsSync10(tsPath)) {
           return {
             applied: false,
             restarted: false,
@@ -6040,7 +6861,7 @@ var init_RuntimeSelfHeal = __esm({
           };
         }
         try {
-          const original = readFileSync6(tsPath, "utf8");
+          const original = readFileSync7(tsPath, "utf8");
           const backup = tsPath + ".bak";
           writeFileSync5(backup, original, "utf8");
           if (!original.includes(proposal.original_code.trim())) {
@@ -6052,10 +6873,10 @@ var init_RuntimeSelfHeal = __esm({
           }
           const patched = original.replace(proposal.original_code, proposal.proposed_code);
           writeFileSync5(tsPath, patched, "utf8");
-          const bundleScript = resolve7(this.projectRoot, "scripts", "bundle.mjs");
-          if (existsSync8(bundleScript)) {
+          const bundleScript = resolve9(this.projectRoot, "scripts", "bundle.mjs");
+          if (existsSync10(bundleScript)) {
             try {
-              execSync5(`node "${bundleScript}"`, {
+              execSync7(`node "${bundleScript}"`, {
                 cwd: this.projectRoot,
                 timeout: 6e4,
                 stdio: "ignore"
@@ -6086,14 +6907,14 @@ var init_RuntimeSelfHeal = __esm({
       // ─── Private helpers ───────────────────────────────────────────────────────
       findSourceFile(location) {
         const candidates = [
-          resolve7(this.projectRoot, location.relPath),
+          resolve9(this.projectRoot, location.relPath),
           // If relPath starts with dist/, look in src/
-          resolve7(this.projectRoot, location.relPath.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")),
-          resolve7(this.projectRoot, "packages", "daemon", "src", location.relPath.replace(/.*src\//, "")),
-          resolve7(this.projectRoot, "packages", "core", "src", location.relPath.replace(/.*src\//, ""))
+          resolve9(this.projectRoot, location.relPath.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")),
+          resolve9(this.projectRoot, "packages", "daemon", "src", location.relPath.replace(/.*src\//, "")),
+          resolve9(this.projectRoot, "packages", "core", "src", location.relPath.replace(/.*src\//, ""))
         ];
         for (const p of candidates) {
-          if (existsSync8(p)) return p;
+          if (existsSync10(p)) return p;
         }
         return null;
       }
@@ -6158,9 +6979,9 @@ Rules:
         }
       }
       restartDaemon() {
-        const bundlePath = resolve7(this.projectRoot, "dist", "daemon.mjs");
-        if (existsSync8(bundlePath)) {
-          const child = spawn6(process.execPath, [bundlePath], {
+        const bundlePath = resolve9(this.projectRoot, "dist", "daemon.mjs");
+        if (existsSync10(bundlePath)) {
+          const child = spawn7(process.execPath, [bundlePath], {
             detached: true,
             stdio: "ignore",
             env: process.env
@@ -6258,14 +7079,14 @@ var init_SelfHealLoop = __esm({
   }
 });
 
-// packages/daemon/src/ProactiveSurface.ts
+// packages/daemon/src/tasks/ProactiveSurface.ts
 var ProactiveSurface_exports = {};
 __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
-import { execSync as execSync8 } from "node:child_process";
-import { existsSync as existsSync18, readFileSync as readFileSync15, statSync as statSync2, readdirSync as readdirSync5 } from "node:fs";
-import { resolve as resolve14, join as join7 } from "node:path";
+import { execSync as execSync10 } from "node:child_process";
+import { existsSync as existsSync20, readFileSync as readFileSync16, statSync as statSync2, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve16, join as join7 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -6275,7 +7096,7 @@ function readdirSafe(dir) {
 }
 var ProactiveSurface;
 var init_ProactiveSurface = __esm({
-  "packages/daemon/src/ProactiveSurface.ts"() {
+  "packages/daemon/src/tasks/ProactiveSurface.ts"() {
     "use strict";
     init_src();
     ProactiveSurface = class {
@@ -6314,7 +7135,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync18(resolve14(this.cwd, ".git"))) return;
+        if (!existsSync20(resolve16(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -6332,7 +7153,7 @@ var init_ProactiveSurface = __esm({
         try {
           const currentHead = this.getGitHead();
           if (!currentHead || currentHead === this.lastKnownHead) return null;
-          const log = execSync8(
+          const log = execSync10(
             `git log ${this.lastKnownHead}..${currentHead} --oneline --stat`,
             { cwd: this.cwd, timeout: 3e3, encoding: "utf8" }
           ).trim();
@@ -6358,13 +7179,13 @@ var init_ProactiveSurface = __esm({
         ];
         for (const dir of outputPaths) {
           try {
-            if (!existsSync18(dir)) continue;
+            if (!existsSync20(dir)) continue;
             const xmlFiles = readdirSafe(dir).filter((f) => f.endsWith(".xml"));
             for (const xml of xmlFiles) {
               const path = join7(dir, xml);
               const stat = statSync2(path);
               if (stat.mtimeMs < this.lastPollAt) continue;
-              const content = readFileSync15(path, "utf8");
+              const content = readFileSync16(path, "utf8");
               const failures = [...content.matchAll(/<failure[^>]*message="([^"]+)"/g)].length;
               if (failures > 0) {
                 return this.makeInsight(
@@ -6408,7 +7229,7 @@ var init_ProactiveSurface = __esm({
       }
       getGitHead() {
         try {
-          return execSync8("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
+          return execSync10("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
         } catch {
           return "";
         }
@@ -6419,8 +7240,8 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync16 } from "node:fs";
-import { resolve as resolve15 } from "node:path";
+import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync17 } from "node:fs";
+import { resolve as resolve17 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
@@ -6618,7 +7439,7 @@ ${issues}`);
 // packages/daemon/src/SessionManager.ts
 init_src();
 
-// packages/daemon/src/EntityScopedContext.ts
+// packages/daemon/src/utils/EntityScopedContext.ts
 init_src();
 var EntityScopedContextLoader = class {
   constructor(graph) {
@@ -6695,7 +7516,7 @@ var EntityScopedContextLoader = class {
 init_LLMExecutor();
 init_AgentExecutor();
 
-// packages/daemon/src/AnthropicSkillFetcher.ts
+// packages/daemon/src/services/AnthropicSkillFetcher.ts
 var BASE_URL = "https://raw.githubusercontent.com/anthropics/skills/main";
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 var ANTHROPIC_SKILLS = [
@@ -6814,9 +7635,9 @@ var AnthropicSkillFetcher = class {
   }
 };
 
-// packages/daemon/src/ProjectScanner.ts
-import { execSync as execSync4 } from "node:child_process";
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
+// packages/daemon/src/utils/ProjectScanner.ts
+import { execSync as execSync6 } from "node:child_process";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "node:fs";
 import { join as join2 } from "node:path";
 import { createServer } from "node:net";
 var PORTS_TO_CHECK = [3e3, 3001, 4e3, 4200, 5e3, 5173, 8e3, 8080, 8888];
@@ -6865,13 +7686,13 @@ var ProjectScanner = class {
     const stack = [];
     let name = "";
     const pkgPath = join2(this.cwd, "package.json");
-    if (existsSync6(pkgPath)) {
+    if (existsSync8(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
         name = pkg.name ?? "";
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         stack.push("node");
-        if (deps.typescript || existsSync6(join2(this.cwd, "tsconfig.json"))) stack.push("typescript");
+        if (deps.typescript || existsSync8(join2(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");
@@ -6880,24 +7701,24 @@ var ProjectScanner = class {
       } catch {
       }
     }
-    if (existsSync6(join2(this.cwd, "Cargo.toml"))) {
+    if (existsSync8(join2(this.cwd, "Cargo.toml"))) {
       stack.push("rust");
       try {
-        const cargo = readFileSync5(join2(this.cwd, "Cargo.toml"), "utf8");
+        const cargo = readFileSync6(join2(this.cwd, "Cargo.toml"), "utf8");
         const nameMatch = cargo.match(/^name\s*=\s*"([^"]+)"/m);
         if (nameMatch && !name) name = nameMatch[1];
       } catch {
       }
     }
-    if (existsSync6(join2(this.cwd, "pyproject.toml")) || existsSync6(join2(this.cwd, "requirements.txt"))) {
+    if (existsSync8(join2(this.cwd, "pyproject.toml")) || existsSync8(join2(this.cwd, "requirements.txt"))) {
       stack.push("python");
     }
-    if (existsSync6(join2(this.cwd, "go.mod"))) stack.push("go");
+    if (existsSync8(join2(this.cwd, "go.mod"))) stack.push("go");
     return [stack, name];
   }
   getRecentCommits() {
     try {
-      const out = execSync4("git log --oneline -5 2>/dev/null", {
+      const out = execSync6("git log --oneline -5 2>/dev/null", {
         cwd: this.cwd,
         timeout: 3e3,
         encoding: "utf8"
@@ -6909,7 +7730,7 @@ var ProjectScanner = class {
   }
   getDirtyFiles() {
     try {
-      const out = execSync4("git status --short 2>/dev/null", {
+      const out = execSync6("git status --short 2>/dev/null", {
         cwd: this.cwd,
         timeout: 3e3,
         encoding: "utf8"
@@ -6922,19 +7743,19 @@ var ProjectScanner = class {
   async getRunningPorts() {
     const open = [];
     await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve17) => {
+      (port) => new Promise((resolve19) => {
         const s = createServer();
         s.listen(port, "127.0.0.1", () => {
           s.close();
-          resolve17();
+          resolve19();
         });
         s.on("error", () => {
           open.push(port);
-          resolve17();
+          resolve19();
         });
         setTimeout(() => {
           s.close();
-          resolve17();
+          resolve19();
         }, 200);
       })
     ));
@@ -6943,9 +7764,9 @@ var ProjectScanner = class {
   getReadmeSummary() {
     for (const name of ["README.md", "readme.md", "README.txt", "README"]) {
       const p = join2(this.cwd, name);
-      if (existsSync6(p)) {
+      if (existsSync8(p)) {
         try {
-          return readFileSync5(p, "utf8").slice(0, 300).replace(/\n+/g, " ").trim();
+          return readFileSync6(p, "utf8").slice(0, 300).replace(/\n+/g, " ").trim();
         } catch {
         }
       }
@@ -6954,7 +7775,7 @@ var ProjectScanner = class {
   }
 };
 
-// packages/daemon/src/ConversationStore.ts
+// packages/daemon/src/services/ConversationStore.ts
 var CREATE_TABLE = `
   CREATE TABLE IF NOT EXISTS conversations (
     id TEXT PRIMARY KEY,
@@ -7009,9 +7830,200 @@ var ConversationStore = class {
   }
 };
 
+// packages/daemon/src/services/SmartModelRouter.ts
+var COMPLEX_PATTERNS = [
+  // Code-related
+  /\b(implement|build|write|fix|refactor|debug|test|deploy|compile|lint|bundle|migrate)\b/i,
+  /\b(function|class|interface|module|component|endpoint|schema|type|hook|middleware)\b/i,
+  /\b(error|bug|crash|fail|broken|issue|stack\s*trace|exception|undefined|null)\b/i,
+  // Tool-heavy tasks
+  /\b(search|scrape|browse|download|install|create\s+file|delete|execute|run|shell|command)\b/i,
+  /\b(git|npm|pip|docker|kubectl|terraform|aws|gcp|azure)\b/i,
+  // Justdo / web tasks
+  /\b(book|file.*itr|irctc|train|ticket|flight|passport|appointment|monitor|watch|login|portal)\b/i,
+  // Long or detailed requests
+  /\b(explain|analyze|review|compare|design|plan|architect|optimise|optimize|improve)\b/i,
+  // URLs, code blocks, file paths
+  /https?:\/\//,
+  /```/,
+  /\/[\w\-]+\.[\w]+/,
+  // file paths like /foo/bar.ts
+  // Self-modification
+  /\b(yourself|agent|0agent|daemon|capability|skill)\b/i
+  // Multi-step or long messages (>200 chars likely complex)
+];
+var SIMPLE_PATTERNS = [
+  /^(hey|hi|hello|sup|yo|hola|namaste|what'?s?\s*up|how\s+are\s+you)[!?.\s,]*$/i,
+  /^(thanks|thank\s+you|thx|ok|okay|cool|great|nice|perfect|got\s+it|sure|yep|yeah|yes|no|nah)[!?.\s,]*$/i,
+  /^(bye|goodbye|see\s+ya|later|good\s*(morning|evening|afternoon|night))[!?.\s,]*$/i,
+  /^(what\s+is|who\s+is|when\s+was|where\s+is|how\s+do\s+you|what\s+does|can\s+you)\b.{0,80}$/i,
+  /^(tell\s+me\s+about|summarize|summarise|tldr|tl;dr)\b.{0,80}$/i
+];
+function routeMessage(task) {
+  const trimmed = task.trim();
+  if (trimmed.length < 5) {
+    return { decision: "skip", reason: "too short, likely noise" };
+  }
+  for (const p of SIMPLE_PATTERNS) {
+    if (p.test(trimmed)) {
+      return { decision: "fast", reason: `matches simple pattern: ${p.source.slice(0, 30)}` };
+    }
+  }
+  for (const p of COMPLEX_PATTERNS) {
+    if (p.test(trimmed)) {
+      return { decision: "primary", reason: `matches complex pattern: ${p.source.slice(0, 30)}` };
+    }
+  }
+  if (trimmed.length > 200) {
+    return { decision: "primary", reason: "long message (>200 chars)" };
+  }
+  const sentences = trimmed.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+  if (sentences.length > 2) {
+    return { decision: "primary", reason: "multi-sentence request" };
+  }
+  return { decision: "fast", reason: "short message, no complex indicators" };
+}
+function getFastModelId(provider, _currentModel) {
+  switch (provider) {
+    case "anthropic":
+      return "claude-haiku-4-5-20251001";
+    case "openai":
+      return "gpt-4o-mini";
+    case "gemini":
+      return "gemini-2.0-flash";
+    case "xai":
+      return "grok-3-mini";
+    case "groq":
+      return "llama-3.1-8b-instant";
+    default:
+      return null;
+  }
+}
+
+// packages/daemon/src/services/AutoMemoryExtractor.ts
+init_src();
+var state = {
+  lastMessageIndex: 0,
+  inProgress: false,
+  pendingRun: false,
+  turnsSinceExtraction: 0
+};
+var MIN_TURNS_BETWEEN = 3;
+var MAX_MESSAGES_PER_RUN = 20;
+var AutoMemoryExtractor = class {
+  constructor(llm, graph, entityNodeId) {
+    this.llm = llm;
+    this.graph = graph;
+    this.entityNodeId = entityNodeId;
+  }
+  /**
+   * Called after each session turn. Decides whether to extract memories
+   * and runs extraction in the background if needed.
+   *
+   * Fire-and-forget — never blocks the main session.
+   */
+  async maybeExtract(messages, memoryWritesSinceLast) {
+    state.turnsSinceExtraction++;
+    if (memoryWritesSinceLast) {
+      state.turnsSinceExtraction = 0;
+      return;
+    }
+    if (state.turnsSinceExtraction < MIN_TURNS_BETWEEN) return;
+    if (messages.length <= state.lastMessageIndex) return;
+    if (state.inProgress) {
+      state.pendingRun = true;
+      return;
+    }
+    await this._runExtraction(messages);
+    if (state.pendingRun) {
+      state.pendingRun = false;
+      await this._runExtraction(messages);
+    }
+  }
+  async _runExtraction(messages) {
+    if (!this.llm?.isConfigured) return;
+    state.inProgress = true;
+    try {
+      const newMessages = messages.slice(
+        state.lastMessageIndex,
+        state.lastMessageIndex + MAX_MESSAGES_PER_RUN
+      );
+      if (newMessages.length === 0) return;
+      const conversationText = newMessages.filter((m) => m.role === "user" || m.role === "assistant" && !m.tool_calls).map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("\n");
+      if (conversationText.length < 50) return;
+      const prompt = [
+        "Extract any durable facts from this conversation that are worth remembering across sessions.",
+        "Focus on: user preferences, project decisions, tool configurations, recurring patterns, names, roles.",
+        "Do NOT extract: greetings, transient task details, things already obvious from the code.",
+        "",
+        'Return a JSON array of facts. Each fact: {"label":"snake_case_key","content":"value","type":"identity|tech|preference|project|outcome"}',
+        "Return [] if nothing worth extracting.",
+        "",
+        "Conversation:",
+        conversationText
+      ].join("\n");
+      const resp = await this.llm.complete(
+        [{ role: "user", content: prompt }],
+        "You extract durable facts from conversations. Return ONLY a JSON array. No explanation."
+      );
+      const text = resp.content.trim();
+      const jsonMatch = text.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) return;
+      let facts;
+      try {
+        facts = JSON.parse(jsonMatch[0]);
+      } catch {
+        return;
+      }
+      if (!Array.isArray(facts) || facts.length === 0) return;
+      for (const fact of facts.slice(0, 5)) {
+        if (!fact.label || !fact.content) continue;
+        const nodeId = `memory:${fact.label}`;
+        const existing = this.graph.getNode(nodeId);
+        if (existing) {
+          this.graph.updateNode(nodeId, {
+            metadata: {
+              ...existing.metadata,
+              content: fact.content,
+              type: fact.type || "note",
+              updated_at: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+        } else {
+          const node = createNode({
+            id: nodeId,
+            graph_id: "root",
+            label: fact.label,
+            type: "context" /* CONTEXT */,
+            metadata: {
+              content: fact.content,
+              type: fact.type || "note",
+              saved_at: (/* @__PURE__ */ new Date()).toISOString(),
+              source: "auto_extract"
+            }
+          });
+          this.graph.addNode(node);
+        }
+      }
+      state.lastMessageIndex = messages.length;
+      state.turnsSinceExtraction = 0;
+    } catch {
+    } finally {
+      state.inProgress = false;
+    }
+  }
+  /** Reset state (e.g., on new session). */
+  reset() {
+    state.lastMessageIndex = 0;
+    state.inProgress = false;
+    state.pendingRun = false;
+    state.turnsSinceExtraction = 0;
+  }
+};
+
 // packages/daemon/src/SessionManager.ts
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { readFileSync as readFileSync8, existsSync as existsSync11 } from "node:fs";
+import { resolve as resolve10 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 import YAML2 from "yaml";
 var SessionManager = class {
@@ -7248,14 +8260,21 @@ var SessionManager = class {
       const activeLLM = this.getFreshLLM();
       if (activeLLM?.isConfigured) {
         const userEntityId = enrichedReq.entity_id ?? this.identity?.entity_node_id;
-        const isConversational = /^(hey|hi|hello|sup|yo|what'?s up|how are you|thanks|ok|cool|bye|good\s+(morning|evening|afternoon)|lol|nice)[!?.\s,]*$/i.test(enrichedReq.task.trim());
-        if (isConversational) {
-          const resp = await activeLLM.complete(
+        const routing = routeMessage(enrichedReq.task);
+        if (routing.decision === "skip") {
+          this.completeSession(sessionId, { output: "", files_written: [], commands_run: [], tokens_used: 0, model: "skip" });
+          return this.sessions.get(sessionId);
+        }
+        if (routing.decision === "fast") {
+          const provider = activeLLM["config"]?.provider ?? "anthropic";
+          const fastModel = getFastModelId(provider);
+          const llmToUse = fastModel ? activeLLM.withModel(fastModel) : activeLLM;
+          const resp = await llmToUse.complete(
             [{ role: "user", content: enrichedReq.task }],
-            "You are a helpful assistant."
+            this.identity ? `You are 0agent, a helpful AI assistant. You are talking to ${this.identity.name}. Be concise and friendly.` : "You are 0agent, a helpful AI assistant. Be concise and friendly."
           );
           this.emit({ type: "session.token", session_id: sessionId, token: resp.content });
-          this.addStep(sessionId, `Done (${resp.tokens_used} tokens, 1 LLM turns)`);
+          this.addStep(sessionId, `Done (${resp.tokens_used} tokens, fast model, reason: ${routing.reason})`);
           this.completeSession(sessionId, {
             output: resp.content,
             files_written: [],
@@ -7397,6 +8416,15 @@ Current task:`;
         this._extractAndPersistFacts(enrichedReq.task, agentResult.output, activeLLM, userEntityId).catch((err) => {
           console.warn("[0agent] Memory extraction outer error:", err instanceof Error ? err.message : err);
         });
+        if (this.graph && activeLLM) {
+          const extractor = new AutoMemoryExtractor(activeLLM, this.graph, userEntityId);
+          extractor.maybeExtract(
+            [{ role: "user", content: enrichedReq.task }, { role: "assistant", content: agentResult.output }],
+            false
+            // memoryWritesSinceLast — checked inside extractor
+          ).catch(() => {
+          });
+        }
         this.completeSession(sessionId, {
           output: agentResult.output,
           files_written: agentResult.files_written,
@@ -7405,7 +8433,7 @@ Current task:`;
           model: agentResult.model
         });
       } else {
-        const cfgPath = resolve8(homedir3(), ".0agent", "config.yaml");
+        const cfgPath = resolve10(homedir3(), ".0agent", "config.yaml");
         const output = `No LLM API key found. Add one to ${cfgPath} or run: 0agent init`;
         this.addStep(sessionId, "\u26A0 No LLM API key configured \u2014 run: 0agent init");
         this.completeSession(sessionId, { output });
@@ -7448,9 +8476,9 @@ Current task:`;
    */
   getFreshLLM() {
     try {
-      const configPath = resolve8(homedir3(), ".0agent", "config.yaml");
-      if (!existsSync9(configPath)) return this.llm;
-      const raw = readFileSync7(configPath, "utf8");
+      const configPath = resolve10(homedir3(), ".0agent", "config.yaml");
+      if (!existsSync11(configPath)) return this.llm;
+      const raw = readFileSync8(configPath, "utf8");
       const cfg = YAML2.parse(raw);
       const providers = cfg.llm_providers;
       if (!providers?.length) return this.llm;
@@ -7476,9 +8504,9 @@ Current task:`;
     if (!this.graph) return;
     let extractLLM;
     try {
-      const cfgPath = resolve8(homedir3(), ".0agent", "config.yaml");
-      if (existsSync9(cfgPath)) {
-        const raw = readFileSync7(cfgPath, "utf8");
+      const cfgPath = resolve10(homedir3(), ".0agent", "config.yaml");
+      if (existsSync11(cfgPath)) {
+        const raw = readFileSync8(cfgPath, "utf8");
         const cfg = YAML2.parse(raw);
         const prov = cfg.llm_providers?.find((p) => p.is_default) ?? cfg.llm_providers?.[0];
         if (prov?.api_key && prov.provider === "anthropic") {
@@ -7716,7 +8744,7 @@ var WebSocketEventBus = class {
   }
 };
 
-// packages/daemon/src/BackgroundWorkers.ts
+// packages/daemon/src/tasks/BackgroundWorkers.ts
 var DEFAULT_CONFIG2 = {
   decay_interval_ms: 6 * 60 * 60 * 1e3,
   // 6 hours
@@ -7840,8 +8868,8 @@ var BackgroundWorkers = class {
   }
 };
 
-// packages/daemon/src/SkillRegistry.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync3, existsSync as existsSync10, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4 } from "node:fs";
+// packages/daemon/src/skills/SkillRegistry.ts
+import { readFileSync as readFileSync9, readdirSync as readdirSync3, existsSync as existsSync12, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4 } from "node:fs";
 import { join as join3 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import YAML3 from "yaml";
@@ -7864,11 +8892,11 @@ var SkillRegistry = class {
     this.loadFromDir(this.customDir, false);
   }
   loadFromDir(dir, isBuiltin) {
-    if (!existsSync10(dir)) return;
+    if (!existsSync12(dir)) return;
     const files = readdirSync3(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     for (const file of files) {
       try {
-        const raw = readFileSync8(join3(dir, file), "utf8");
+        const raw = readFileSync9(join3(dir, file), "utf8");
         const skill = YAML3.parse(raw);
         if (skill.name) {
           this.skills.set(skill.name, skill);
@@ -7918,7 +8946,7 @@ var SkillRegistry = class {
       throw new Error(`Cannot delete built-in skill: ${name}`);
     }
     const filePath = join3(this.customDir, `${name}.yaml`);
-    if (existsSync10(filePath)) {
+    if (existsSync12(filePath)) {
       unlinkSync3(filePath);
     }
     this.skills.delete(name);
@@ -7931,8 +8959,8 @@ var SkillRegistry = class {
 // packages/daemon/src/HTTPServer.ts
 import { Hono as Hono14 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync10 } from "node:fs";
-import { resolve as resolve10, dirname as dirname4 } from "node:path";
+import { readFileSync as readFileSync11 } from "node:fs";
+import { resolve as resolve12, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/daemon/src/routes/health.ts
@@ -8224,8 +9252,8 @@ function memoryRoutes(deps) {
 // packages/daemon/src/routes/llm.ts
 init_LLMExecutor();
 import { Hono as Hono10 } from "hono";
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { readFileSync as readFileSync10, existsSync as existsSync13 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import YAML4 from "yaml";
 function llmRoutes() {
@@ -8233,11 +9261,11 @@ function llmRoutes() {
   app.post("/ping", async (c) => {
     const start = Date.now();
     try {
-      const configPath = resolve9(homedir5(), ".0agent", "config.yaml");
-      if (!existsSync11(configPath)) {
+      const configPath = resolve11(homedir5(), ".0agent", "config.yaml");
+      if (!existsSync13(configPath)) {
         return c.json({ ok: false, error: "Config not found. Run: 0agent init" });
       }
-      const cfg = YAML4.parse(readFileSync9(configPath, "utf8"));
+      const cfg = YAML4.parse(readFileSync10(configPath, "utf8"));
       const providers = cfg.llm_providers;
       const def = providers?.find((p) => p.is_default) ?? providers?.[0];
       if (!def) {
@@ -8322,7 +9350,7 @@ function codespaceRoutes(deps) {
 // packages/daemon/src/routes/schedule.ts
 import { Hono as Hono12 } from "hono";
 
-// packages/daemon/src/SchedulerManager.ts
+// packages/daemon/src/tasks/SchedulerManager.ts
 var DAYS = {
   sunday: 0,
   sun: 0,
@@ -8752,15 +9780,15 @@ function runtimeRoutes(deps) {
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
-    resolve10(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
+    resolve12(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
     // dev (src/)
-    resolve10(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
+    resolve12(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
     // bundled (dist/../)
-    resolve10(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
+    resolve12(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
   ];
   for (const p of candidates) {
     try {
-      readFileSync10(p);
+      readFileSync11(p);
       return p;
     } catch {
     }
@@ -8796,7 +9824,7 @@ var HTTPServer = class {
     }
     const serveGraph = (c) => {
       try {
-        const html = readFileSync10(GRAPH_HTML_PATH, "utf8");
+        const html = readFileSync11(GRAPH_HTML_PATH, "utf8");
         return c.html(html);
       } catch {
         return c.html("<p>Graph UI not found. Run: pnpm build</p>");
@@ -8806,7 +9834,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve17) => {
+    return new Promise((resolve19) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -8814,20 +9842,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve17();
+          resolve19();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve19, reject) => {
       if (!this.server) {
-        resolve17();
+        resolve19();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve17();
+        else resolve19();
       });
     });
   }
@@ -8839,13 +9867,13 @@ var HTTPServer = class {
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_LLMExecutor();
 
-// packages/daemon/src/IdentityManager.ts
+// packages/daemon/src/utils/IdentityManager.ts
 init_src();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync12, mkdirSync as mkdirSync5 } from "node:fs";
-import { resolve as resolve11, dirname as dirname5 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, existsSync as existsSync14, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve13, dirname as dirname5 } from "node:path";
 import { homedir as homedir6, hostname } from "node:os";
 import YAML5 from "yaml";
-var IDENTITY_PATH = resolve11(homedir6(), ".0agent", "identity.yaml");
+var IDENTITY_PATH = resolve13(homedir6(), ".0agent", "identity.yaml");
 var DEFAULT_IDENTITY = {
   name: "User",
   device_id: `unknown-device`,
@@ -8861,8 +9889,8 @@ var IdentityManager = class {
    * Load or create identity. Call once at daemon startup.
    */
   async init() {
-    if (existsSync12(IDENTITY_PATH)) {
-      const raw = readFileSync11(IDENTITY_PATH, "utf8");
+    if (existsSync14(IDENTITY_PATH)) {
+      const raw = readFileSync12(IDENTITY_PATH, "utf8");
       this.identity = YAML5.parse(raw);
     } else {
       this.identity = {
@@ -8914,24 +9942,24 @@ var IdentityManager = class {
   }
   save() {
     const dir = dirname5(IDENTITY_PATH);
-    if (!existsSync12(dir)) {
+    if (!existsSync14(dir)) {
       mkdirSync5(dir, { recursive: true });
     }
     writeFileSync7(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
   }
 };
 
-// packages/daemon/src/TeamManager.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "node:fs";
-import { resolve as resolve12 } from "node:path";
+// packages/daemon/src/services/TeamManager.ts
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve14 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 import YAML6 from "yaml";
-var TEAMS_PATH = resolve12(homedir7(), ".0agent", "teams.yaml");
+var TEAMS_PATH = resolve14(homedir7(), ".0agent", "teams.yaml");
 var TeamManager = class {
   config;
   constructor() {
-    if (existsSync13(TEAMS_PATH)) {
-      this.config = YAML6.parse(readFileSync12(TEAMS_PATH, "utf8"));
+    if (existsSync15(TEAMS_PATH)) {
+      this.config = YAML6.parse(readFileSync13(TEAMS_PATH, "utf8"));
     } else {
       this.config = { memberships: [] };
     }
@@ -8986,12 +10014,12 @@ var TeamManager = class {
     }
   }
   save() {
-    mkdirSync6(resolve12(homedir7(), ".0agent"), { recursive: true });
+    mkdirSync6(resolve14(homedir7(), ".0agent"), { recursive: true });
     writeFileSync8(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
   }
 };
 
-// packages/daemon/src/TeamSync.ts
+// packages/daemon/src/services/TeamSync.ts
 var TeamSync = class {
   constructor(teamManager, adapter, entityNodeId) {
     this.teamManager = teamManager;
@@ -9069,9 +10097,9 @@ var TeamSync = class {
   }
 };
 
-// packages/daemon/src/GitHubMemorySync.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, existsSync as existsSync14, readdirSync as readdirSync4 } from "node:fs";
-import { resolve as resolve13 } from "node:path";
+// packages/daemon/src/services/GitHubMemorySync.ts
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, existsSync as existsSync16, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve15 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 var GITHUB_API = "https://api.github.com";
 async function ghFetch(path, token, opts) {
@@ -9191,10 +10219,10 @@ var GitHubMemorySync = class {
           )
         );
       }
-      const customSkillsDir = resolve13(homedir8(), ".0agent", "skills", "custom");
-      if (existsSync14(customSkillsDir)) {
+      const customSkillsDir = resolve15(homedir8(), ".0agent", "skills", "custom");
+      if (existsSync16(customSkillsDir)) {
         for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
-          const content = readFileSync13(resolve13(customSkillsDir, file), "utf8");
+          const content = readFileSync14(resolve15(customSkillsDir, file), "utf8");
           pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
         }
       }
@@ -9380,7 +10408,7 @@ var GitHubMemorySync = class {
   }
   async pullCustomSkills() {
     const { token, owner, repo } = this.config;
-    const dir = resolve13(homedir8(), ".0agent", "skills", "custom");
+    const dir = resolve15(homedir8(), ".0agent", "skills", "custom");
     try {
       const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
       if (!res.ok) return;
@@ -9390,7 +10418,7 @@ var GitHubMemorySync = class {
         if (content) {
           const { mkdirSync: mkdirSync11 } = await import("node:fs");
           mkdirSync11(dir, { recursive: true });
-          writeFileSync9(resolve13(dir, file.name), content, "utf8");
+          writeFileSync9(resolve15(dir, file.name), content, "utf8");
         }
       }
     } catch {
@@ -9466,8 +10494,8 @@ git checkout <commit> graph/         # restore graph files
   }
 };
 
-// packages/daemon/src/CodespaceManager.ts
-import { execSync as execSync6, spawn as spawn7 } from "node:child_process";
+// packages/daemon/src/services/CodespaceManager.ts
+import { execSync as execSync8, spawn as spawn8 } from "node:child_process";
 var BROWSER_PORT_REMOTE = 3e3;
 var BROWSER_PORT_LOCAL = 3001;
 var DISPLAY_NAME = "0agent-browser";
@@ -9509,7 +10537,7 @@ var CodespaceManager = class {
     console.log(`[Codespace] Creating browser codespace from ${this.memoryRepo}...`);
     console.log("[Codespace] First time: ~2-3 minutes. Subsequent starts: ~30 seconds.");
     try {
-      const result = execSync6(
+      const result = execSync8(
         `gh codespace create --repo "${this.memoryRepo}" --machine basicLinux32gb --display-name "${DISPLAY_NAME}" --json name`,
         { encoding: "utf8", timeout: 3e5 }
       );
@@ -9523,7 +10551,7 @@ var CodespaceManager = class {
   /** Find the 0agent-browser codespace by display name. */
   findExisting() {
     try {
-      const out = execSync6("gh codespace list --json name,state,displayName,repository", {
+      const out = execSync8("gh codespace list --json name,state,displayName,repository", {
         encoding: "utf8",
         timeout: 1e4
       });
@@ -9539,7 +10567,7 @@ var CodespaceManager = class {
     const info = this.findExisting();
     if (info?.state === "Shutdown") {
       console.log("[Codespace] Starting stopped codespace (~30s)...");
-      execSync6(`gh codespace start --codespace "${name}"`, { timeout: 12e4 });
+      execSync8(`gh codespace start --codespace "${name}"`, { timeout: 12e4 });
       await this.waitForState(name, "Available", 60);
       console.log("[Codespace] Codespace is running");
     } else if (info?.state === "Starting") {
@@ -9551,7 +10579,7 @@ var CodespaceManager = class {
   /** Start the browser server inside the codespace (idempotent). */
   async startBrowserServer(name) {
     try {
-      execSync6(
+      execSync8(
         `gh codespace exec --codespace "${name}" -- bash -c "pgrep -f 'node server.js' > /dev/null 2>&1 || (cd /workspaces && nohup node server.js > /tmp/browser-server.log 2>&1 &)"`,
         { timeout: 3e4 }
       );
@@ -9562,7 +10590,7 @@ var CodespaceManager = class {
   async openTunnel(name) {
     this.closeTunnel();
     console.log(`[Codespace] Opening tunnel port ${BROWSER_PORT_REMOTE} \u2192 localhost:${BROWSER_PORT_LOCAL}...`);
-    this.forwardProcess = spawn7(
+    this.forwardProcess = spawn8(
       "gh",
       ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
       { stdio: ["ignore", "ignore", "ignore"] }
@@ -9606,7 +10634,7 @@ var CodespaceManager = class {
     this.closeTunnel();
     const info = this.findExisting();
     if (info?.state === "Available") {
-      execSync6(`gh codespace stop --codespace "${info.name}"`, { timeout: 3e4 });
+      execSync8(`gh codespace stop --codespace "${info.name}"`, { timeout: 3e4 });
       console.log("[Codespace] Stopped (state preserved, restarts in 30s when needed)");
     }
   }
@@ -9615,7 +10643,7 @@ var CodespaceManager = class {
     this.closeTunnel();
     const info = this.findExisting();
     if (info) {
-      execSync6(`gh codespace delete --codespace "${info.name}" --force`, { timeout: 3e4 });
+      execSync8(`gh codespace delete --codespace "${info.name}" --force`, { timeout: 3e4 });
       console.log("[Codespace] Deleted");
     }
   }
@@ -9641,7 +10669,7 @@ var CodespaceManager = class {
   /** Check if gh CLI is installed and authenticated. */
   static isAvailable() {
     try {
-      execSync6("gh auth status", { stdio: "ignore", timeout: 5e3 });
+      execSync8("gh auth status", { stdio: "ignore", timeout: 5e3 });
       return true;
     } catch {
       return false;
@@ -9652,7 +10680,7 @@ var CodespaceManager = class {
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_RuntimeSelfHeal();
 
-// packages/daemon/src/TelegramBridge.ts
+// packages/daemon/src/services/TelegramBridge.ts
 var TelegramBridge = class {
   constructor(config, sessions, eventBus) {
     this.config = config;
@@ -9951,52 +10979,52 @@ var SurfaceRouter = class {
   }
   _handleDaemonEvent(event) {
     const sessionId = String(event.session_id ?? "");
-    const state = this.activeSessions.get(sessionId);
-    if (!state) return;
-    const adapter = this.adapters.get(state.surface);
+    const state2 = this.activeSessions.get(sessionId);
+    if (!state2) return;
+    const adapter = this.adapters.get(state2.surface);
     if (!adapter) return;
     if (event.type === "session.token") {
-      state.tokenBuffer += String(event.token ?? "");
-      if (state.streamTimer) clearTimeout(state.streamTimer);
-      state.streamTimer = setTimeout(() => {
-        if (!state.tokenBuffer) return;
+      state2.tokenBuffer += String(event.token ?? "");
+      if (state2.streamTimer) clearTimeout(state2.streamTimer);
+      state2.streamTimer = setTimeout(() => {
+        if (!state2.tokenBuffer) return;
         adapter.send({
-          surface_channel_id: state.channelId,
-          text: state.tokenBuffer,
+          surface_channel_id: state2.channelId,
+          text: state2.tokenBuffer,
           format: "markdown",
           is_progress: true,
-          thread_id: state.threadId
+          thread_id: state2.threadId
         }).catch(() => {
         });
       }, 400);
     } else if (event.type === "session.completed") {
-      if (state.streamTimer) {
-        clearTimeout(state.streamTimer);
-        state.streamTimer = null;
+      if (state2.streamTimer) {
+        clearTimeout(state2.streamTimer);
+        state2.streamTimer = null;
       }
       const result = event.result;
       const output = String(result?.output ?? "").trim();
       if (output && output !== "(no output)") {
         adapter.send({
-          surface_channel_id: state.channelId,
+          surface_channel_id: state2.channelId,
           text: output,
           format: "markdown",
           is_progress: false,
-          thread_id: state.threadId
+          thread_id: state2.threadId
         }).catch(() => {
         });
       }
       this.activeSessions.delete(sessionId);
     } else if (event.type === "session.failed") {
-      if (state.streamTimer) {
-        clearTimeout(state.streamTimer);
-        state.streamTimer = null;
+      if (state2.streamTimer) {
+        clearTimeout(state2.streamTimer);
+        state2.streamTimer = null;
       }
       adapter.send({
-        surface_channel_id: state.channelId,
+        surface_channel_id: state2.channelId,
         text: `\u26A0\uFE0F ${String(event.error ?? "Task failed")}`,
         format: "prose",
-        thread_id: state.threadId
+        thread_id: state2.threadId
       }).catch(() => {
       });
       this.activeSessions.delete(sessionId);
@@ -10011,7 +11039,7 @@ var SurfaceRouter = class {
 };
 
 // packages/daemon/src/surfaces/TelegramAdapter.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync7 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join4 } from "node:path";
 var TelegramAdapter = class {
@@ -10061,13 +11089,13 @@ var TelegramAdapter = class {
   async send(msg) {
     const chatId = Number(msg.surface_channel_id);
     if (!chatId) return;
-    const state = this.streamingState.get(chatId);
-    if (msg.is_progress && state) {
-      state.accumulatedText = msg.text;
-      await this._editMessage(chatId, state.workingMsgId, `\u23F3 ${this._truncate(msg.text, 3800)}`);
+    const state2 = this.streamingState.get(chatId);
+    if (msg.is_progress && state2) {
+      state2.accumulatedText = msg.text;
+      await this._editMessage(chatId, state2.workingMsgId, `\u23F3 ${this._truncate(msg.text, 3800)}`);
     } else {
-      if (state) {
-        await this._editMessage(chatId, state.workingMsgId, msg.text);
+      if (state2) {
+        await this._editMessage(chatId, state2.workingMsgId, msg.text);
         this.streamingState.delete(chatId);
       } else {
         await this._sendMessage(chatId, msg.text);
@@ -10218,7 +11246,7 @@ Sessions: ${h.active_sessions} active`
       const fileUrl = await this._getFileUrl(fileId);
       if (!fileUrl) return null;
       const tmpDir = join4(tmpdir3(), "0agent-voice");
-      if (!existsSync15(tmpDir)) mkdirSync7(tmpDir, { recursive: true });
+      if (!existsSync17(tmpDir)) mkdirSync7(tmpDir, { recursive: true });
       const tmpPath = join4(tmpDir, `${fileId}.ogg`);
       const wavPath = join4(tmpDir, `${fileId}.wav`);
       const res = await fetch(fileUrl);
@@ -10226,20 +11254,20 @@ Sessions: ${h.active_sessions} active`
       const buf = await res.arrayBuffer();
       const { writeFileSync: writeFileSync13 } = await import("node:fs");
       writeFileSync13(tmpPath, Buffer.from(buf));
-      const { execSync: execSync9 } = await import("node:child_process");
+      const { execSync: execSync11 } = await import("node:child_process");
       try {
-        execSync9(`ffmpeg -y -i "${tmpPath}" -ar 16000 -ac 1 "${wavPath}" 2>/dev/null`, { timeout: 3e4 });
+        execSync11(`ffmpeg -y -i "${tmpPath}" -ar 16000 -ac 1 "${wavPath}" 2>/dev/null`, { timeout: 3e4 });
       } catch {
       }
-      const inputFile = existsSync15(wavPath) ? wavPath : tmpPath;
-      const whisperOut = execSync9(
+      const inputFile = existsSync17(wavPath) ? wavPath : tmpPath;
+      const whisperOut = execSync11(
         `whisper "${inputFile}" --model ${this.whisperModel} --output_format txt --output_dir "${tmpDir}" --fp16 False 2>/dev/null`,
         { timeout: 12e4, encoding: "utf8" }
       );
       const txtPath = inputFile.replace(/\.(ogg|wav)$/, ".txt");
-      if (existsSync15(txtPath)) {
-        const { readFileSync: readFileSync17 } = await import("node:fs");
-        return readFileSync17(txtPath, "utf8").trim();
+      if (existsSync17(txtPath)) {
+        const { readFileSync: readFileSync18 } = await import("node:fs");
+        return readFileSync18(txtPath, "utf8").trim();
       }
       return whisperOut?.trim() || null;
     } catch {
@@ -10405,24 +11433,24 @@ var SlackAdapter = class {
     if (!this.app) return;
     const client = this.app["client"];
     const stateKey = `${msg.surface_channel_id}:${msg.thread_id ?? ""}`;
-    const state = this.streamingState.get(stateKey);
-    if (msg.is_progress && state) {
+    const state2 = this.streamingState.get(stateKey);
+    if (msg.is_progress && state2) {
       try {
         await client["chat.update"]({
-          channel: state.channelId,
-          ts: state.ts,
+          channel: state2.channelId,
+          ts: state2.ts,
           text: `\u23F3 ${this._truncate(msg.text, 3e3)}`
         });
       } catch {
       }
     } else {
-      if (state) {
+      if (state2) {
         try {
           await client["chat.update"]({
-            channel: state.channelId,
-            ts: state.ts,
+            channel: state2.channelId,
+            ts: state2.ts,
             text: msg.text,
-            thread_ts: state.threadTs || void 0
+            thread_ts: state2.threadTs || void 0
           });
         } catch {
           await this._postMessage(client, msg.surface_channel_id, msg.text, msg.thread_id);
@@ -10681,10 +11709,10 @@ var WhatsAppAdapter = class {
 import * as readline from "node:readline";
 
 // packages/daemon/src/surfaces/WhisperSTT.ts
-import { execSync as execSync7, spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync14 } from "node:fs";
+import { execSync as execSync9, spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, readFileSync as readFileSync15 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join5, basename } from "node:path";
+import { join as join5, basename as basename2 } from "node:path";
 var WhisperSTT = class _WhisperSTT {
   model;
   language;
@@ -10700,20 +11728,20 @@ var WhisperSTT = class _WhisperSTT {
       console.warn("[WhisperSTT] No Whisper binary found. Install: pip install openai-whisper");
       return null;
     }
-    if (!existsSync16(audioPath)) {
+    if (!existsSync18(audioPath)) {
       console.warn(`[WhisperSTT] Audio file not found: ${audioPath}`);
       return null;
     }
     const outDir = join5(tmpdir4(), "0agent-whisper");
-    if (!existsSync16(outDir)) mkdirSync8(outDir, { recursive: true });
+    if (!existsSync18(outDir)) mkdirSync8(outDir, { recursive: true });
     try {
       const langFlag = this.language ? `--language ${this.language}` : "";
       const cmd = this.binary === "faster-whisper" ? `faster-whisper "${audioPath}" --model ${this.model} ${langFlag} --output_format txt --output_dir "${outDir}"` : `whisper "${audioPath}" --model ${this.model} ${langFlag} --output_format txt --output_dir "${outDir}" --fp16 False`;
-      execSync7(cmd, { timeout: 18e4, stdio: "pipe" });
-      const baseName = basename(audioPath).replace(/\.[^.]+$/, "");
+      execSync9(cmd, { timeout: 18e4, stdio: "pipe" });
+      const baseName = basename2(audioPath).replace(/\.[^.]+$/, "");
       const txtPath = join5(outDir, `${baseName}.txt`);
-      if (existsSync16(txtPath)) {
-        return readFileSync14(txtPath, "utf8").trim();
+      if (existsSync18(txtPath)) {
+        return readFileSync15(txtPath, "utf8").trim();
       }
       return null;
     } catch (err) {
@@ -10738,14 +11766,14 @@ var WhisperSTT = class _WhisperSTT {
 };
 async function recordAudio(durationSeconds) {
   const outDir = join5(tmpdir4(), "0agent-voice");
-  if (!existsSync16(outDir)) mkdirSync8(outDir, { recursive: true });
+  if (!existsSync18(outDir)) mkdirSync8(outDir, { recursive: true });
   const outPath = join5(outDir, `recording-${Date.now()}.wav`);
   const soxResult = spawnSync5(
     "sox",
     ["-d", "-r", "16000", "-c", "1", "-b", "16", outPath, "trim", "0", String(durationSeconds)],
     { timeout: (durationSeconds + 5) * 1e3, stdio: "pipe" }
   );
-  if (soxResult.status === 0 && existsSync16(outPath)) return outPath;
+  if (soxResult.status === 0 && existsSync18(outPath)) return outPath;
   const platform3 = process.platform;
   let ffmpegDevice;
   if (platform3 === "darwin") {
@@ -10760,11 +11788,11 @@ async function recordAudio(durationSeconds) {
     ["-y", ...ffmpegDevice, "-ar", "16000", "-ac", "1", "-t", String(durationSeconds), outPath],
     { timeout: (durationSeconds + 5) * 1e3, stdio: "pipe" }
   );
-  return ffmpegResult.status === 0 && existsSync16(outPath) ? outPath : null;
+  return ffmpegResult.status === 0 && existsSync18(outPath) ? outPath : null;
 }
 
 // packages/daemon/src/surfaces/NativeTTS.ts
-import { spawnSync as spawnSync6, spawn as spawn8 } from "node:child_process";
+import { spawnSync as spawnSync6, spawn as spawn9 } from "node:child_process";
 var NativeTTS = class _NativeTTS {
   engine;
   voice;
@@ -10788,11 +11816,11 @@ var NativeTTS = class _NativeTTS {
     if (!this.resolvedEngine) return;
     const cleaned = this._clean(text);
     if (!cleaned) return;
-    return new Promise((resolve17) => {
+    return new Promise((resolve19) => {
       const args = this._buildArgs(this.resolvedEngine, cleaned);
-      const proc = spawn8(this.resolvedEngine, args, { stdio: "ignore" });
-      proc.on("close", () => resolve17());
-      proc.on("error", () => resolve17());
+      const proc = spawn9(this.resolvedEngine, args, { stdio: "ignore" });
+      proc.on("close", () => resolve19());
+      proc.on("error", () => resolve19());
     });
   }
   /** Check if any TTS engine is available */
@@ -10850,7 +11878,7 @@ var NativeTTS = class _NativeTTS {
   }
   _speakWith(engine, text) {
     const args = this._buildArgs(engine, text);
-    const proc = spawn8(engine, args, { stdio: "ignore", detached: true });
+    const proc = spawn9(engine, args, { stdio: "ignore", detached: true });
     proc.unref();
   }
   /** Remove markdown/ANSI and control chars before speaking */
@@ -10975,10 +12003,10 @@ var VoiceAdapter = class {
 };
 
 // packages/daemon/src/surfaces/MeetingAdapter.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { join as join6 } from "node:path";
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 var MeetingAdapter = class {
   name = "meeting";
   messageHandler = null;
@@ -11003,7 +12031,7 @@ var MeetingAdapter = class {
     this.triggerPhrases = config.trigger_phrases ?? ["agent,", "hey agent", "ok agent"];
     this.contextWindowSeconds = config.context_window_seconds ?? 120;
     this.tmpDir = join6(tmpdir5(), "0agent-meeting");
-    if (!existsSync17(this.tmpDir)) mkdirSync9(this.tmpDir, { recursive: true });
+    if (!existsSync19(this.tmpDir)) mkdirSync9(this.tmpDir, { recursive: true });
     this.stt = new WhisperSTT({ model: config.whisper_model ?? "base" });
   }
   onMessage(handler) {
@@ -11088,7 +12116,7 @@ ${msg.text}
   async _captureAndTranscribeChunk(channelId) {
     const chunkPath = join6(this.tmpDir, `chunk-${Date.now()}.wav`);
     const captured = await this._captureSystemAudio(chunkPath, this.chunkSeconds);
-    if (!captured || !existsSync17(chunkPath)) return;
+    if (!captured || !existsSync19(chunkPath)) return;
     const text = await this.stt.transcribe(chunkPath);
     if (!text || text.trim().length < 3) return;
     const segment = { text: text.trim(), timestamp: Date.now() };
@@ -11109,7 +12137,7 @@ ${msg.text}
     }
   }
   async _captureSystemAudio(outPath, seconds) {
-    return new Promise((resolve17) => {
+    return new Promise((resolve19) => {
       const platform3 = process.platform;
       let args;
       if (platform3 === "darwin") {
@@ -11117,18 +12145,18 @@ ${msg.text}
       } else if (platform3 === "linux") {
         args = ["-y", "-f", "pulse", "-i", "default.monitor", "-ar", "16000", "-ac", "1", "-t", String(seconds), outPath];
       } else {
-        resolve17(false);
+        resolve19(false);
         return;
       }
-      const proc = spawn9("ffmpeg", args, { stdio: "pipe" });
+      const proc = spawn10("ffmpeg", args, { stdio: "pipe" });
       this.ffmpegProcess = proc;
       proc.on("close", (code) => {
         this.ffmpegProcess = null;
-        resolve17(code === 0);
+        resolve19(code === 0);
       });
       proc.on("error", () => {
         this.ffmpegProcess = null;
-        resolve17(false);
+        resolve19(false);
       });
     });
   }
@@ -11226,12 +12254,12 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve15(homedir9(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve17(homedir9(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve15(homedir9(), ".0agent");
-    if (!existsSync19(dotDir)) {
+    const dotDir = resolve17(homedir9(), ".0agent");
+    if (!existsSync21(dotDir)) {
       mkdirSync10(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
@@ -11305,10 +12333,10 @@ var ZeroAgentDaemon = class {
       console.log(`[0agent] Teams: ${teams.map((t) => t.team_name).join(", ")}`);
     }
     const _daemonFile = fileURLToPath3(import.meta.url);
-    const _agentRoot = resolve15(dirname7(_daemonFile), "..");
+    const _agentRoot = resolve17(dirname7(_daemonFile), "..");
     let agentRoot;
     try {
-      const _pkg = JSON.parse(readFileSync16(resolve15(_agentRoot, "package.json"), "utf8"));
+      const _pkg = JSON.parse(readFileSync17(resolve17(_agentRoot, "package.json"), "utf8"));
       if (_pkg.name === "0agent") agentRoot = _agentRoot;
     } catch {
     }
@@ -11512,7 +12540,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync19(this.pidFilePath)) {
+    if (existsSync21(this.pidFilePath)) {
       try {
         unlinkSync4(this.pidFilePath);
       } catch {
@@ -11542,11 +12570,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 import { homedir as homedir10 } from "node:os";
-import { existsSync as existsSync20 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve16(homedir10(), ".0agent", "config.yaml");
-if (!existsSync20(CONFIG_PATH)) {
+import { existsSync as existsSync22 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve18(homedir10(), ".0agent", "config.yaml");
+if (!existsSync22(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.