0agent 1.0.78 → 1.0.82

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,10 +1969,10 @@ 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) {
@@ -2022,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":
@@ -2039,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) => {
@@ -2153,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") {
@@ -2327,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";
@@ -2474,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() {
@@ -2495,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";
@@ -2610,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 {
@@ -2706,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";
@@ -2823,12 +2826,12 @@ var init_ShellCapability = __esm({
   }
 });
 
-// packages/daemon/src/capabilities/FileCapability.ts
-import { readFileSync as readFileSync2, writeFileSync, readdirSync, mkdirSync, existsSync as existsSync2 } from "node:fs";
+// packages/daemon/src/tools/FileCapability.ts
+import { readFileSync as readFileSync2, writeFileSync, readdirSync, mkdirSync, existsSync as existsSync2, statSync } 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";
@@ -2859,6 +2862,11 @@ var init_FileCapability = __esm({
         try {
           if (op === "read") {
             if (!existsSync2(safe)) return { success: false, output: `Not found: ${rel}`, duration_ms: Date.now() - start };
+            if (statSync(safe).isDirectory()) {
+              const entries = readdirSync(safe, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => `${e.isDirectory() ? "d" : "f"}  ${e.name}`).join("\n");
+              return { success: true, output: `(directory listing for ${rel}):
+${entries || "(empty)"}`, duration_ms: Date.now() - start };
+            }
             const content = readFileSync2(safe, "utf8");
             return {
               success: true,
@@ -2913,10 +2921,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 {
@@ -3014,14 +3022,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";
@@ -4012,14 +4020,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
@@ -4152,7 +4160,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"
@@ -4163,7 +4171,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve17(ok);
+            resolve19(ok);
           };
           const onAbort = () => {
             try {
@@ -4185,7 +4193,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"]
@@ -4198,7 +4206,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 {
@@ -4227,13 +4235,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 { existsSync as existsSync3, mkdirSync as mkdirSync2, copyFileSync, statSync as statSync2 } 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";
@@ -4265,7 +4273,7 @@ var init_SurgeCapability = __esm({
           return { success: false, output: `Path does not exist: ${target}`, duration_ms: 0 };
         }
         let publishDir = target;
-        if (statSync(target).isFile()) {
+        if (statSync2(target).isFile()) {
           publishDir = join("/tmp", `surge-${Date.now()}`);
           mkdirSync2(publishDir, { recursive: true });
           copyFileSync(target, join(publishDir, "index.html"));
@@ -4307,10 +4315,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";
@@ -4584,11 +4592,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";
@@ -4747,11 +4755,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();
@@ -4862,10 +4870,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 {
@@ -5050,10 +5058,10 @@ ${lines.join("\n")}`,
   }
 });
 
-// packages/daemon/src/capabilities/SessionSearchCapability.ts
+// packages/daemon/src/tools/SessionSearchCapability.ts
 var SessionSearchCapability;
 var init_SessionSearchCapability = __esm({
-  "packages/daemon/src/capabilities/SessionSearchCapability.ts"() {
+  "packages/daemon/src/tools/SessionSearchCapability.ts"() {
     "use strict";
     SessionSearchCapability = class {
       name = "session_search";
@@ -5132,14 +5140,343 @@ ${results.join("\n\n")}`,
   }
 });
 
-// packages/daemon/src/capabilities/CodespaceBrowserCapability.ts
+// 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 {
@@ -5206,10 +5543,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();
@@ -5225,6 +5562,8 @@ var init_CapabilityRegistry = __esm({
     init_CredentialVaultCapability();
     init_MonitorWatchCapability();
     init_SessionSearchCapability();
+    init_WorktreeCapability();
+    init_LSPCapability();
     CapabilityRegistry = class {
       capabilities = /* @__PURE__ */ new Map();
       /**
@@ -5262,6 +5601,8 @@ var init_CapabilityRegistry = __esm({
         if (dbPath) {
           this.register(new SessionSearchCapability(() => dbPath));
         }
+        this.register(new WorktreeCapability());
+        this.register(new LSPCapability());
         if (graph) {
           this.register(new MemoryCapability(graph, onMemoryWrite));
         }
@@ -5302,6 +5643,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");
@@ -5332,9 +5677,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();
@@ -5349,13 +5694,15 @@ var init_capabilities = __esm({
     init_CredentialVaultCapability();
     init_MonitorWatchCapability();
     init_SessionSearchCapability();
+    init_WorktreeCapability();
+    init_LSPCapability();
   }
 });
 
-// packages/daemon/src/IterationBudget.ts
+// packages/daemon/src/utils/IterationBudget.ts
 var IterationBudget;
 var init_IterationBudget = __esm({
-  "packages/daemon/src/IterationBudget.ts"() {
+  "packages/daemon/src/utils/IterationBudget.ts"() {
     "use strict";
     IterationBudget = class _IterationBudget {
       constructor(maxIterations, parent, childAllocation) {
@@ -5432,7 +5779,7 @@ var init_IterationBudget = __esm({
   }
 });
 
-// packages/daemon/src/PromptInjectionScanner.ts
+// packages/daemon/src/utils/PromptInjectionScanner.ts
 function scanForInjection(content, source) {
   const warnings = [];
   let sanitized = content;
@@ -5469,7 +5816,7 @@ function sanitizeContextFile(content, filePath, log) {
 }
 var INJECTION_PATTERNS, INVISIBLE_CHARS;
 var init_PromptInjectionScanner = __esm({
-  "packages/daemon/src/PromptInjectionScanner.ts"() {
+  "packages/daemon/src/utils/PromptInjectionScanner.ts"() {
     "use strict";
     INJECTION_PATTERNS = [
       // Direct instruction override
@@ -5495,19 +5842,160 @@ var init_PromptInjectionScanner = __esm({
   }
 });
 
+// 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) {
@@ -5519,7 +6007,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);
         }
@@ -5572,12 +6060,26 @@ var init_AgentExecutor = __esm({
           }
           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) {
@@ -5591,7 +6093,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) {
@@ -5627,6 +6131,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();
           }
@@ -5644,8 +6154,13 @@ var init_AgentExecutor = __esm({
           const { parallel, serial } = this._partitionToolCalls(toolCalls);
           if (parallel.length > 0) {
             const results = await Promise.all(parallel.map(async (tc) => {
-              this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)}) [parallel]`);
-              return { tc, result: await this._executeSingleTool(tc, signal, filesWritten, commandsRun) };
+              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" : ""}`);
@@ -5653,8 +6168,11 @@ var init_AgentExecutor = __esm({
             }
           }
           for (const tc of serial) {
-            this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})`);
-            const result = await this._executeSingleTool(tc, signal, filesWritten, commandsRun);
+            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 });
           }
@@ -5700,9 +6218,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
@@ -5711,10 +6229,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}`);
           });
         });
       }
@@ -5729,8 +6247,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;
       }
@@ -5821,7 +6339,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)";
@@ -5831,7 +6349,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) {
@@ -5962,15 +6480,15 @@ 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) {
                 const sanitized = sanitizeContextFile(content, f);
                 lines.push(``, `Project instructions:`, sanitized);
@@ -6084,6 +6602,9 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
       async _executeSingleTool(tc, signal, filesWritten, commandsRun) {
         let result;
         try {
+          if (!tc.input || Object.keys(tc.input).length === 0) {
+            return `Error: empty tool input for ${tc.name}. Provide required parameters.`;
+          }
           const capResult = await this.registry.execute(tc.name, tc.input, this.cwd, signal);
           result = capResult.output;
           const MAX_TOOL_OUTPUT = 4e3;
@@ -6152,8 +6673,8 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
 });
 
 // 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"() {
@@ -6190,8 +6711,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",
@@ -6230,10 +6751,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));
@@ -6257,8 +6778,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);
@@ -6303,8 +6824,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;
       }
@@ -6340,7 +6861,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,
@@ -6348,7 +6869,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())) {
@@ -6360,10 +6881,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"
@@ -6394,14 +6915,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;
       }
@@ -6466,9 +6987,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
@@ -6566,14 +7087,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 statSync3, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve16, join as join7 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -6583,7 +7104,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 {
@@ -6622,7 +7143,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);
@@ -6640,7 +7161,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();
@@ -6666,13 +7187,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);
+              const stat = statSync3(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(
@@ -6716,7 +7237,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 "";
         }
@@ -6727,8 +7248,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
@@ -6926,7 +7447,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) {
@@ -7003,7 +7524,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 = [
@@ -7122,9 +7643,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];
@@ -7173,13 +7694,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");
@@ -7188,24 +7709,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"
@@ -7217,7 +7738,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"
@@ -7230,19 +7751,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);
       })
     ));
@@ -7251,9 +7772,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 {
         }
       }
@@ -7262,7 +7783,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,
@@ -7317,7 +7838,7 @@ var ConversationStore = class {
   }
 };
 
-// packages/daemon/src/SmartModelRouter.ts
+// 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,
@@ -7387,9 +7908,130 @@ function getFastModelId(provider, _currentModel) {
   }
 }
 
+// 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 {
@@ -7782,6 +8424,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,
@@ -7790,7 +8441,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 });
@@ -7833,9 +8484,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;
@@ -7861,9 +8512,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") {
@@ -8101,7 +8752,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
@@ -8225,8 +8876,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";
@@ -8249,11 +8900,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);
@@ -8303,7 +8954,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);
@@ -8316,8 +8967,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
@@ -8609,8 +9260,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() {
@@ -8618,11 +9269,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) {
@@ -8707,7 +9358,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,
@@ -9137,15 +9788,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 {
     }
@@ -9181,7 +9832,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>");
@@ -9191,7 +9842,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,
@@ -9199,20 +9850,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();
       });
     });
   }
@@ -9224,13 +9875,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`,
@@ -9246,8 +9897,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 = {
@@ -9299,24 +9950,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: [] };
     }
@@ -9371,12 +10022,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;
@@ -9454,9 +10105,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) {
@@ -9576,10 +10227,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));
         }
       }
@@ -9765,7 +10416,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;
@@ -9775,7 +10426,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 {
@@ -9851,8 +10502,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";
@@ -9894,7 +10545,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 }
       );
@@ -9908,7 +10559,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
       });
@@ -9924,7 +10575,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") {
@@ -9936,7 +10587,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 }
       );
@@ -9947,7 +10598,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"] }
@@ -9991,7 +10642,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)");
     }
   }
@@ -10000,7 +10651,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");
     }
   }
@@ -10026,7 +10677,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;
@@ -10037,7 +10688,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;
@@ -10336,52 +10987,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);
@@ -10396,7 +11047,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 {
@@ -10446,13 +11097,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);
@@ -10603,7 +11254,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);
@@ -10611,20 +11262,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 {
@@ -10790,24 +11441,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);
@@ -11066,10 +11717,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;
@@ -11085,20 +11736,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) {
@@ -11123,14 +11774,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") {
@@ -11145,11 +11796,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;
@@ -11173,11 +11824,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 */
@@ -11235,7 +11886,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 */
@@ -11360,10 +12011,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;
@@ -11388,7 +12039,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) {
@@ -11473,7 +12124,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() };
@@ -11494,7 +12145,7 @@ ${msg.text}
     }
   }
   async _captureSystemAudio(outPath, seconds) {
-    return new Promise((resolve17) => {
+    return new Promise((resolve19) => {
       const platform3 = process.platform;
       let args;
       if (platform3 === "darwin") {
@@ -11502,18 +12153,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);
       });
     });
   }
@@ -11611,12 +12262,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 });
@@ -11690,10 +12341,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 {
     }
@@ -11897,7 +12548,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync19(this.pidFilePath)) {
+    if (existsSync21(this.pidFilePath)) {
       try {
         unlinkSync4(this.pidFilePath);
       } catch {
@@ -11927,11 +12578,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.