0agent 1.0.91 → 1.0.93

package/bin/0agent.js

@@ -21,7 +21,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, openSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
-import { homedir, platform } from 'node:os';
+import { homedir, platform, arch } from 'node:os';
 import { spawn, execSync } from 'node:child_process';
 import { createInterface } from 'node:readline';
 

package/dist/daemon.mjs

@@ -1507,7 +1507,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve19) => setTimeout(resolve19, ms));
+        return new Promise((resolve20) => setTimeout(resolve20, ms));
       }
     };
   }
@@ -4170,7 +4170,7 @@ Run manually: pip3 install open-interpreter`,
       }
       /** Async pip install — never blocks the event loop (unlike spawnSync). */
       _pipInstall(pkg, signal) {
-        return new Promise((resolve19) => {
+        return new Promise((resolve20) => {
           const proc = spawn4("pip3", ["install", pkg, "-q"], {
             env: process.env,
             stdio: "ignore"
@@ -4181,7 +4181,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve19(ok);
+            resolve20(ok);
           };
           const onAbort = () => {
             try {
@@ -4203,7 +4203,7 @@ Run manually: pip3 install open-interpreter`,
         });
       }
       _runScript(scriptPath, stdinData, signal) {
-        return new Promise((resolve19) => {
+        return new Promise((resolve20) => {
           const proc = spawn4("python3", [scriptPath], {
             env: process.env,
             stdio: ["pipe", "pipe", "pipe"]
@@ -4216,7 +4216,7 @@ Run manually: pip3 install open-interpreter`,
             settled = true;
             signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
-            resolve19({ stdout: out.join(""), stderr: err.join(""), code });
+            resolve20({ stdout: out.join(""), stderr: err.join(""), code });
           };
           const onAbort = () => {
             try {
@@ -6203,7 +6203,7 @@ var init_AgentExecutor = __esm({
       }
       // ─── Legacy tool execution (used by built-in tools, not capabilities) ──────
       shellExec(command, timeoutMs) {
-        return new Promise((resolve19) => {
+        return new Promise((resolve20) => {
           const chunks = [];
           const proc = spawn5("bash", ["-c", command], {
             cwd: this.cwd,
@@ -6214,10 +6214,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve19(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve20(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve19(`Error: ${err.message}`);
+            resolve20(`Error: ${err.message}`);
           });
         });
       }
@@ -6733,8 +6733,8 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
 });
 
 // packages/daemon/src/ExecutionVerifier.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
 var ExecutionVerifier;
 var init_ExecutionVerifier = __esm({
   "packages/daemon/src/ExecutionVerifier.ts"() {
@@ -6771,8 +6771,8 @@ var init_ExecutionVerifier = __esm({
           };
         }
         if (files.length > 0) {
-          const lastFile = resolve8(this.cwd, files[files.length - 1]);
-          const exists = existsSync9(lastFile);
+          const lastFile = resolve9(this.cwd, files[files.length - 1]);
+          const exists = existsSync10(lastFile);
           return {
             success: exists,
             method: "file_exists",
@@ -6811,8 +6811,8 @@ var init_ExecutionVerifier = __esm({
 });
 
 // packages/daemon/src/RuntimeSelfHeal.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync10 } from "node:fs";
-import { resolve as resolve9, dirname as dirname3 } from "node:path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync11 } from "node:fs";
+import { resolve as resolve10, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execSync as execSync7, spawn as spawn6 } from "node:child_process";
 function isRuntimeBug(error) {
@@ -6838,8 +6838,8 @@ function parseStackTrace(stack) {
 }
 function extractContext(filePath, errorLine, contextLines = 30) {
   try {
-    if (!existsSync10(filePath)) return null;
-    const content = readFileSync7(filePath, "utf8");
+    if (!existsSync11(filePath)) return null;
+    const content = readFileSync8(filePath, "utf8");
     const lines = content.split("\n");
     const start = Math.max(0, errorLine - contextLines);
     const end = Math.min(lines.length, errorLine + contextLines);
@@ -6884,8 +6884,8 @@ var init_RuntimeSelfHeal = __esm({
         this.llm = llm;
         this.eventBus = eventBus;
         let dir = dirname3(fileURLToPath(import.meta.url));
-        while (dir !== "/" && !existsSync10(resolve9(dir, "package.json"))) {
-          dir = resolve9(dir, "..");
+        while (dir !== "/" && !existsSync11(resolve10(dir, "package.json"))) {
+          dir = resolve10(dir, "..");
         }
         this.projectRoot = dir;
       }
@@ -6921,7 +6921,7 @@ var init_RuntimeSelfHeal = __esm({
        */
       async applyPatch(proposal) {
         const tsPath = this.findSourceFile(proposal.location);
-        if (!tsPath || !existsSync10(tsPath)) {
+        if (!tsPath || !existsSync11(tsPath)) {
           return {
             applied: false,
             restarted: false,
@@ -6929,9 +6929,9 @@ var init_RuntimeSelfHeal = __esm({
           };
         }
         try {
-          const original = readFileSync7(tsPath, "utf8");
+          const original = readFileSync8(tsPath, "utf8");
           const backup = tsPath + ".bak";
-          writeFileSync5(backup, original, "utf8");
+          writeFileSync6(backup, original, "utf8");
           if (!original.includes(proposal.original_code.trim())) {
             return {
               applied: false,
@@ -6940,9 +6940,9 @@ var init_RuntimeSelfHeal = __esm({
             };
           }
           const patched = original.replace(proposal.original_code, proposal.proposed_code);
-          writeFileSync5(tsPath, patched, "utf8");
-          const bundleScript = resolve9(this.projectRoot, "scripts", "bundle.mjs");
-          if (existsSync10(bundleScript)) {
+          writeFileSync6(tsPath, patched, "utf8");
+          const bundleScript = resolve10(this.projectRoot, "scripts", "bundle.mjs");
+          if (existsSync11(bundleScript)) {
             try {
               execSync7(`node "${bundleScript}"`, {
                 cwd: this.projectRoot,
@@ -6950,7 +6950,7 @@ var init_RuntimeSelfHeal = __esm({
                 stdio: "ignore"
               });
             } catch {
-              writeFileSync5(tsPath, original, "utf8");
+              writeFileSync6(tsPath, original, "utf8");
               return {
                 applied: false,
                 restarted: false,
@@ -6975,14 +6975,14 @@ var init_RuntimeSelfHeal = __esm({
       // ─── Private helpers ───────────────────────────────────────────────────────
       findSourceFile(location) {
         const candidates = [
-          resolve9(this.projectRoot, location.relPath),
+          resolve10(this.projectRoot, location.relPath),
           // If relPath starts with dist/, look in 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\//, ""))
+          resolve10(this.projectRoot, location.relPath.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")),
+          resolve10(this.projectRoot, "packages", "daemon", "src", location.relPath.replace(/.*src\//, "")),
+          resolve10(this.projectRoot, "packages", "core", "src", location.relPath.replace(/.*src\//, ""))
         ];
         for (const p of candidates) {
-          if (existsSync10(p)) return p;
+          if (existsSync11(p)) return p;
         }
         return null;
       }
@@ -7047,8 +7047,8 @@ Rules:
         }
       }
       restartDaemon() {
-        const bundlePath = resolve9(this.projectRoot, "dist", "daemon.mjs");
-        if (existsSync10(bundlePath)) {
+        const bundlePath = resolve10(this.projectRoot, "dist", "daemon.mjs");
+        if (existsSync11(bundlePath)) {
           const child = spawn6(process.execPath, [bundlePath], {
             detached: true,
             stdio: "ignore",
@@ -7153,8 +7153,8 @@ __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
 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";
+import { existsSync as existsSync21, readFileSync as readFileSync17, statSync as statSync3, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve17, join as join7 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -7203,7 +7203,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync20(resolve16(this.cwd, ".git"))) return;
+        if (!existsSync21(resolve17(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -7247,13 +7247,13 @@ var init_ProactiveSurface = __esm({
         ];
         for (const dir of outputPaths) {
           try {
-            if (!existsSync20(dir)) continue;
+            if (!existsSync21(dir)) continue;
             const xmlFiles = readdirSafe(dir).filter((f) => f.endsWith(".xml"));
             for (const xml of xmlFiles) {
               const path = join7(dir, xml);
               const stat = statSync3(path);
               if (stat.mtimeMs < this.lastPollAt) continue;
-              const content = readFileSync16(path, "utf8");
+              const content = readFileSync17(path, "utf8");
               const failures = [...content.matchAll(/<failure[^>]*message="([^"]+)"/g)].length;
               if (failures > 0) {
                 return this.makeInsight(
@@ -7308,9 +7308,9 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-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";
+import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync18 } from "node:fs";
+import { resolve as resolve18 } from "node:path";
+import { homedir as homedir10 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
 import { readFileSync, existsSync } from "node:fs";
@@ -7811,19 +7811,19 @@ var ProjectScanner = class {
   async getRunningPorts() {
     const open = [];
     await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve19) => {
+      (port) => new Promise((resolve20) => {
         const s = createServer();
         s.listen(port, "127.0.0.1", () => {
           s.close();
-          resolve19();
+          resolve20();
         });
         s.on("error", () => {
           open.push(port);
-          resolve19();
+          resolve20();
         });
         setTimeout(() => {
           s.close();
-          resolve19();
+          resolve20();
         }, 200);
       })
     ));
@@ -8088,10 +8088,119 @@ var AutoMemoryExtractor = class {
   }
 };
 
-// packages/daemon/src/SessionManager.ts
-import { readFileSync as readFileSync8, existsSync as existsSync11 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+// packages/daemon/src/services/MemoryHeartbeat.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5, appendFileSync, mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve as resolve8 } from "node:path";
 import { homedir as homedir3 } from "node:os";
+var AGENT_DIR = resolve8(homedir3(), ".0agent");
+var MEMORY_PATH = resolve8(AGENT_DIR, "MEMORY.md");
+var IDENTITY_PATH = resolve8(AGENT_DIR, "identity.md");
+var SOUL_PATH = resolve8(AGENT_DIR, "soul.md");
+var MemoryHeartbeat = class {
+  constructor(llm) {
+    this.llm = llm;
+    mkdirSync4(AGENT_DIR, { recursive: true });
+  }
+  hourlyTimer = null;
+  sessionCount = 0;
+  /** Start the hourly consolidation timer. */
+  start() {
+    if (this.hourlyTimer) return;
+    this.hourlyTimer = setInterval(() => this._hourlyConsolidate().catch(() => {
+    }), 60 * 60 * 1e3);
+  }
+  stop() {
+    if (this.hourlyTimer) {
+      clearInterval(this.hourlyTimer);
+      this.hourlyTimer = null;
+    }
+  }
+  /**
+   * Called after every completed session. Appends a one-liner to MEMORY.md.
+   * Fast, synchronous, never blocks.
+   */
+  afterSession(task, output, model) {
+    this.sessionCount++;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const taskSummary = task.slice(0, 100).replace(/\n/g, " ");
+    const outputSummary = output.slice(0, 100).replace(/\n/g, " ");
+    if (!existsSync9(MEMORY_PATH)) {
+      writeFileSync5(MEMORY_PATH, "# Memory\n\nSession log \u2014 auto-updated after every interaction.\n\n", "utf8");
+    }
+    const line = `- [${timestamp}] **${taskSummary}** \u2192 ${outputSummary}${output.length > 100 ? "\u2026" : ""}
+`;
+    try {
+      appendFileSync(MEMORY_PATH, line, "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Hourly consolidation: reviews MEMORY.md and updates identity.md and soul.md
+   * with anything learned. Uses LLM to synthesize.
+   */
+  async _hourlyConsolidate() {
+    if (!this.llm?.isConfigured) return;
+    if (this.sessionCount === 0) return;
+    const memoryContent = this._readFile(MEMORY_PATH);
+    const identityContent = this._readFile(IDENTITY_PATH);
+    const soulContent = this._readFile(SOUL_PATH);
+    if (!memoryContent) return;
+    const prompt = [
+      "You manage three files for a persistent AI agent. Review the recent memory log",
+      "and determine if identity.md or soul.md need updates.",
+      "",
+      "## Current MEMORY.md (session log):",
+      memoryContent.slice(-3e3),
+      "",
+      "## Current identity.md:",
+      identityContent?.slice(0, 1500) || "(empty)",
+      "",
+      "## Current soul.md:",
+      soulContent?.slice(0, 1500) || "(empty)",
+      "",
+      "## Instructions:",
+      "Return a JSON object with two optional fields:",
+      `- "identity_append": text to APPEND to identity.md (new facts about the owner, new capabilities, new projects). Only include if there's something new.`,
+      `- "soul_append": text to APPEND to soul.md (learned preferences, communication style insights, new boundaries). Only include if there's something new.`,
+      "",
+      "Return {} if nothing needs updating.",
+      "Keep additions concise \u2014 1-3 lines max per field."
+    ].join("\n");
+    try {
+      const resp = await this.llm.complete(
+        [{ role: "user", content: prompt }],
+        "You are a memory manager. Return ONLY valid JSON. No explanation."
+      );
+      const jsonMatch = resp.content.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+      const updates = JSON.parse(jsonMatch[0]);
+      if (updates.identity_append?.trim()) {
+        appendFileSync(IDENTITY_PATH, `
+${updates.identity_append.trim()}
+`, "utf8");
+      }
+      if (updates.soul_append?.trim()) {
+        appendFileSync(SOUL_PATH, `
+${updates.soul_append.trim()}
+`, "utf8");
+      }
+      this.sessionCount = 0;
+    } catch {
+    }
+  }
+  _readFile(path) {
+    try {
+      return existsSync9(path) ? readFileSync7(path, "utf8") : null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// packages/daemon/src/SessionManager.ts
+import { readFileSync as readFileSync9, existsSync as existsSync12 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 import YAML2 from "yaml";
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
@@ -8108,6 +8217,7 @@ var SessionManager = class {
   anthropicFetcher = new AnthropicSkillFetcher();
   agentRoot;
   onMemoryWritten;
+  heartbeat = new MemoryHeartbeat();
   constructor(deps = {}) {
     this.inferenceEngine = deps.inferenceEngine;
     this.eventBus = deps.eventBus;
@@ -8118,6 +8228,8 @@ var SessionManager = class {
     this.projectContext = deps.projectContext;
     this.agentRoot = deps.agentRoot;
     this.onMemoryWritten = deps.onMemoryWritten;
+    this.heartbeat = new MemoryHeartbeat(deps.llm);
+    this.heartbeat.start();
     if (deps.adapter) {
       this.conversationStore = new ConversationStore(deps.adapter);
       this.conversationStore.init();
@@ -8487,8 +8599,9 @@ Current task:`;
           tokens_used: agentResult.tokens_used,
           model: agentResult.model
         });
+        this.heartbeat.afterSession(enrichedReq.task, agentResult.output, agentResult.model);
       } else {
-        const cfgPath = resolve10(homedir3(), ".0agent", "config.yaml");
+        const cfgPath = resolve11(homedir4(), ".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 });
@@ -8531,9 +8644,9 @@ Current task:`;
    */
   getFreshLLM() {
     try {
-      const configPath = resolve10(homedir3(), ".0agent", "config.yaml");
-      if (!existsSync11(configPath)) return this.llm;
-      const raw = readFileSync8(configPath, "utf8");
+      const configPath = resolve11(homedir4(), ".0agent", "config.yaml");
+      if (!existsSync12(configPath)) return this.llm;
+      const raw = readFileSync9(configPath, "utf8");
       const cfg = YAML2.parse(raw);
       const providers = cfg.llm_providers;
       if (!providers?.length) return this.llm;
@@ -8559,9 +8672,9 @@ Current task:`;
     if (!this.graph) return;
     let extractLLM;
     try {
-      const cfgPath = resolve10(homedir3(), ".0agent", "config.yaml");
-      if (existsSync11(cfgPath)) {
-        const raw = readFileSync8(cfgPath, "utf8");
+      const cfgPath = resolve11(homedir4(), ".0agent", "config.yaml");
+      if (existsSync12(cfgPath)) {
+        const raw = readFileSync9(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") {
@@ -8924,9 +9037,9 @@ var BackgroundWorkers = class {
 };
 
 // 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 { readFileSync as readFileSync10, readdirSync as readdirSync3, existsSync as existsSync13, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, mkdirSync as mkdirSync5 } from "node:fs";
 import { join as join3 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import YAML3 from "yaml";
 var SkillRegistry = class {
   skills = /* @__PURE__ */ new Map();
@@ -8934,8 +9047,8 @@ var SkillRegistry = class {
   builtinDir;
   customDir;
   constructor(opts) {
-    this.builtinDir = opts?.builtinDir ?? join3(homedir4(), ".0agent", "skills", "builtin");
-    this.customDir = opts?.customDir ?? join3(homedir4(), ".0agent", "skills", "custom");
+    this.builtinDir = opts?.builtinDir ?? join3(homedir5(), ".0agent", "skills", "builtin");
+    this.customDir = opts?.customDir ?? join3(homedir5(), ".0agent", "skills", "custom");
   }
   /**
    * Load all skills from builtin + custom directories.
@@ -8947,11 +9060,11 @@ var SkillRegistry = class {
     this.loadFromDir(this.customDir, false);
   }
   loadFromDir(dir, isBuiltin) {
-    if (!existsSync12(dir)) return;
+    if (!existsSync13(dir)) return;
     const files = readdirSync3(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     for (const file of files) {
       try {
-        const raw = readFileSync9(join3(dir, file), "utf8");
+        const raw = readFileSync10(join3(dir, file), "utf8");
         const skill = YAML3.parse(raw);
         if (skill.name) {
           this.skills.set(skill.name, skill);
@@ -8986,9 +9099,9 @@ var SkillRegistry = class {
     if (this.builtinNames.has(name)) {
       throw new Error(`Cannot override built-in skill: ${name}`);
     }
-    mkdirSync4(this.customDir, { recursive: true });
+    mkdirSync5(this.customDir, { recursive: true });
     const filePath = join3(this.customDir, `${name}.yaml`);
-    writeFileSync6(filePath, yamlContent, "utf8");
+    writeFileSync7(filePath, yamlContent, "utf8");
     const skill = YAML3.parse(yamlContent);
     this.skills.set(name, skill);
     return skill;
@@ -9001,7 +9114,7 @@ var SkillRegistry = class {
       throw new Error(`Cannot delete built-in skill: ${name}`);
     }
     const filePath = join3(this.customDir, `${name}.yaml`);
-    if (existsSync12(filePath)) {
+    if (existsSync13(filePath)) {
       unlinkSync3(filePath);
     }
     this.skills.delete(name);
@@ -9014,8 +9127,8 @@ var SkillRegistry = class {
 // packages/daemon/src/HTTPServer.ts
 import { Hono as Hono14 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync11 } from "node:fs";
-import { resolve as resolve12, dirname as dirname4 } from "node:path";
+import { readFileSync as readFileSync12 } from "node:fs";
+import { resolve as resolve13, dirname as dirname4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/daemon/src/routes/health.ts
@@ -9307,20 +9420,20 @@ function memoryRoutes(deps) {
 // packages/daemon/src/routes/llm.ts
 init_LLMExecutor();
 import { Hono as Hono10 } from "hono";
-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 { readFileSync as readFileSync11, existsSync as existsSync14 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import YAML4 from "yaml";
 function llmRoutes() {
   const app = new Hono10();
   app.post("/ping", async (c) => {
     const start = Date.now();
     try {
-      const configPath = resolve11(homedir5(), ".0agent", "config.yaml");
-      if (!existsSync13(configPath)) {
+      const configPath = resolve12(homedir6(), ".0agent", "config.yaml");
+      if (!existsSync14(configPath)) {
         return c.json({ ok: false, error: "Config not found. Run: 0agent init" });
       }
-      const cfg = YAML4.parse(readFileSync10(configPath, "utf8"));
+      const cfg = YAML4.parse(readFileSync11(configPath, "utf8"));
       const providers = cfg.llm_providers;
       const def = providers?.find((p) => p.is_default) ?? providers?.[0];
       if (!def) {
@@ -9835,15 +9948,15 @@ function runtimeRoutes(deps) {
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
-    resolve12(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
+    resolve13(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
     // dev (src/)
-    resolve12(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
+    resolve13(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
     // bundled (dist/../)
-    resolve12(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
+    resolve13(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
   ];
   for (const p of candidates) {
     try {
-      readFileSync11(p);
+      readFileSync12(p);
       return p;
     } catch {
     }
@@ -9879,7 +9992,7 @@ var HTTPServer = class {
     }
     const serveGraph = (c) => {
       try {
-        const html = readFileSync11(GRAPH_HTML_PATH, "utf8");
+        const html = readFileSync12(GRAPH_HTML_PATH, "utf8");
         return c.html(html);
       } catch {
         return c.html("<p>Graph UI not found. Run: pnpm build</p>");
@@ -9889,7 +10002,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -9897,20 +10010,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve19();
+          resolve20();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve19, reject) => {
+    return new Promise((resolve20, reject) => {
       if (!this.server) {
-        resolve19();
+        resolve20();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve19();
+        else resolve20();
       });
     });
   }
@@ -9924,11 +10037,11 @@ init_LLMExecutor();
 
 // packages/daemon/src/utils/IdentityManager.ts
 init_src();
-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 { readFileSync as readFileSync13, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve14, dirname as dirname5 } from "node:path";
+import { homedir as homedir7, hostname } from "node:os";
 import YAML5 from "yaml";
-var IDENTITY_PATH = resolve13(homedir6(), ".0agent", "identity.yaml");
+var IDENTITY_PATH2 = resolve14(homedir7(), ".0agent", "identity.yaml");
 var DEFAULT_IDENTITY = {
   name: "User",
   device_id: `unknown-device`,
@@ -9944,8 +10057,8 @@ var IdentityManager = class {
    * Load or create identity. Call once at daemon startup.
    */
   async init() {
-    if (existsSync14(IDENTITY_PATH)) {
-      const raw = readFileSync12(IDENTITY_PATH, "utf8");
+    if (existsSync15(IDENTITY_PATH2)) {
+      const raw = readFileSync13(IDENTITY_PATH2, "utf8");
       this.identity = YAML5.parse(raw);
     } else {
       this.identity = {
@@ -9996,25 +10109,25 @@ var IdentityManager = class {
     return lines.join(" ");
   }
   save() {
-    const dir = dirname5(IDENTITY_PATH);
-    if (!existsSync14(dir)) {
-      mkdirSync5(dir, { recursive: true });
+    const dir = dirname5(IDENTITY_PATH2);
+    if (!existsSync15(dir)) {
+      mkdirSync6(dir, { recursive: true });
     }
-    writeFileSync7(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
+    writeFileSync8(IDENTITY_PATH2, YAML5.stringify(this.identity), "utf8");
   }
 };
 
 // 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 { readFileSync as readFileSync14, writeFileSync as writeFileSync9, existsSync as existsSync16, mkdirSync as mkdirSync7 } from "node:fs";
+import { resolve as resolve15 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 import YAML6 from "yaml";
-var TEAMS_PATH = resolve14(homedir7(), ".0agent", "teams.yaml");
+var TEAMS_PATH = resolve15(homedir8(), ".0agent", "teams.yaml");
 var TeamManager = class {
   config;
   constructor() {
-    if (existsSync15(TEAMS_PATH)) {
-      this.config = YAML6.parse(readFileSync13(TEAMS_PATH, "utf8"));
+    if (existsSync16(TEAMS_PATH)) {
+      this.config = YAML6.parse(readFileSync14(TEAMS_PATH, "utf8"));
     } else {
       this.config = { memberships: [] };
     }
@@ -10069,8 +10182,8 @@ var TeamManager = class {
     }
   }
   save() {
-    mkdirSync6(resolve14(homedir7(), ".0agent"), { recursive: true });
-    writeFileSync8(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
+    mkdirSync7(resolve15(homedir8(), ".0agent"), { recursive: true });
+    writeFileSync9(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
   }
 };
 
@@ -10153,9 +10266,9 @@ var TeamSync = class {
 };
 
 // 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";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync10, existsSync as existsSync17, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve16 } from "node:path";
+import { homedir as homedir9 } from "node:os";
 var GITHUB_API = "https://api.github.com";
 async function ghFetch(path, token, opts) {
   return fetch(`${GITHUB_API}${path}`, {
@@ -10274,10 +10387,10 @@ var GitHubMemorySync = class {
           )
         );
       }
-      const customSkillsDir = resolve15(homedir8(), ".0agent", "skills", "custom");
-      if (existsSync16(customSkillsDir)) {
+      const customSkillsDir = resolve16(homedir9(), ".0agent", "skills", "custom");
+      if (existsSync17(customSkillsDir)) {
         for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
-          const content = readFileSync14(resolve15(customSkillsDir, file), "utf8");
+          const content = readFileSync15(resolve16(customSkillsDir, file), "utf8");
           pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
         }
       }
@@ -10463,7 +10576,7 @@ var GitHubMemorySync = class {
   }
   async pullCustomSkills() {
     const { token, owner, repo } = this.config;
-    const dir = resolve15(homedir8(), ".0agent", "skills", "custom");
+    const dir = resolve16(homedir9(), ".0agent", "skills", "custom");
     try {
       const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
       if (!res.ok) return;
@@ -10471,9 +10584,9 @@ var GitHubMemorySync = class {
       for (const file of files.filter((f) => f.name.endsWith(".yaml"))) {
         const content = await getFile(token, owner, repo, `skills/custom/${file.name}`);
         if (content) {
-          const { mkdirSync: mkdirSync11 } = await import("node:fs");
-          mkdirSync11(dir, { recursive: true });
-          writeFileSync9(resolve15(dir, file.name), content, "utf8");
+          const { mkdirSync: mkdirSync12 } = await import("node:fs");
+          mkdirSync12(dir, { recursive: true });
+          writeFileSync10(resolve16(dir, file.name), content, "utf8");
         }
       }
     } catch {
@@ -11094,7 +11207,7 @@ var SurfaceRouter = class {
 };
 
 // packages/daemon/src/surfaces/TelegramAdapter.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync7 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join4 } from "node:path";
 var TelegramAdapter = class {
@@ -11308,28 +11421,28 @@ Sessions: ${h.active_sessions} active`
       const fileUrl = await this._getFileUrl(fileId);
       if (!fileUrl) return null;
       const tmpDir = join4(tmpdir3(), "0agent-voice");
-      if (!existsSync17(tmpDir)) mkdirSync7(tmpDir, { recursive: true });
+      if (!existsSync18(tmpDir)) mkdirSync8(tmpDir, { recursive: true });
       const tmpPath = join4(tmpDir, `${fileId}.ogg`);
       const wavPath = join4(tmpDir, `${fileId}.wav`);
       const res = await fetch(fileUrl);
       if (!res.ok) return null;
       const buf = await res.arrayBuffer();
-      const { writeFileSync: writeFileSync13 } = await import("node:fs");
-      writeFileSync13(tmpPath, Buffer.from(buf));
+      const { writeFileSync: writeFileSync14 } = await import("node:fs");
+      writeFileSync14(tmpPath, Buffer.from(buf));
       const { execSync: execSync11 } = await import("node:child_process");
       try {
         execSync11(`ffmpeg -y -i "${tmpPath}" -ar 16000 -ac 1 "${wavPath}" 2>/dev/null`, { timeout: 3e4 });
       } catch {
       }
-      const inputFile = existsSync17(wavPath) ? wavPath : tmpPath;
+      const inputFile = existsSync18(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 (existsSync17(txtPath)) {
-        const { readFileSync: readFileSync18 } = await import("node:fs");
-        return readFileSync18(txtPath, "utf8").trim();
+      if (existsSync18(txtPath)) {
+        const { readFileSync: readFileSync19 } = await import("node:fs");
+        return readFileSync19(txtPath, "utf8").trim();
       }
       return whisperOut?.trim() || null;
     } catch {
@@ -11772,7 +11885,7 @@ import * as readline from "node:readline";
 
 // packages/daemon/src/surfaces/WhisperSTT.ts
 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 { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync16 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join5, basename as basename2 } from "node:path";
 var WhisperSTT = class _WhisperSTT {
@@ -11790,20 +11903,20 @@ var WhisperSTT = class _WhisperSTT {
       console.warn("[WhisperSTT] No Whisper binary found. Install: pip install openai-whisper");
       return null;
     }
-    if (!existsSync18(audioPath)) {
+    if (!existsSync19(audioPath)) {
       console.warn(`[WhisperSTT] Audio file not found: ${audioPath}`);
       return null;
     }
     const outDir = join5(tmpdir4(), "0agent-whisper");
-    if (!existsSync18(outDir)) mkdirSync8(outDir, { recursive: true });
+    if (!existsSync19(outDir)) mkdirSync9(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`;
       execSync9(cmd, { timeout: 18e4, stdio: "pipe" });
       const baseName = basename2(audioPath).replace(/\.[^.]+$/, "");
       const txtPath = join5(outDir, `${baseName}.txt`);
-      if (existsSync18(txtPath)) {
-        return readFileSync15(txtPath, "utf8").trim();
+      if (existsSync19(txtPath)) {
+        return readFileSync16(txtPath, "utf8").trim();
       }
       return null;
     } catch (err) {
@@ -11828,14 +11941,14 @@ var WhisperSTT = class _WhisperSTT {
 };
 async function recordAudio(durationSeconds) {
   const outDir = join5(tmpdir4(), "0agent-voice");
-  if (!existsSync18(outDir)) mkdirSync8(outDir, { recursive: true });
+  if (!existsSync19(outDir)) mkdirSync9(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 && existsSync18(outPath)) return outPath;
+  if (soxResult.status === 0 && existsSync19(outPath)) return outPath;
   const platform3 = process.platform;
   let ffmpegDevice;
   if (platform3 === "darwin") {
@@ -11850,7 +11963,7 @@ async function recordAudio(durationSeconds) {
     ["-y", ...ffmpegDevice, "-ar", "16000", "-ac", "1", "-t", String(durationSeconds), outPath],
     { timeout: (durationSeconds + 5) * 1e3, stdio: "pipe" }
   );
-  return ffmpegResult.status === 0 && existsSync18(outPath) ? outPath : null;
+  return ffmpegResult.status === 0 && existsSync19(outPath) ? outPath : null;
 }
 
 // packages/daemon/src/surfaces/NativeTTS.ts
@@ -11878,11 +11991,11 @@ var NativeTTS = class _NativeTTS {
     if (!this.resolvedEngine) return;
     const cleaned = this._clean(text);
     if (!cleaned) return;
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       const args = this._buildArgs(this.resolvedEngine, cleaned);
       const proc = spawn8(this.resolvedEngine, args, { stdio: "ignore" });
-      proc.on("close", () => resolve19());
-      proc.on("error", () => resolve19());
+      proc.on("close", () => resolve20());
+      proc.on("error", () => resolve20());
     });
   }
   /** Check if any TTS engine is available */
@@ -12065,7 +12178,7 @@ var VoiceAdapter = class {
 };
 
 // packages/daemon/src/surfaces/MeetingAdapter.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync10, writeFileSync as writeFileSync12 } 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";
@@ -12093,7 +12206,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 (!existsSync19(this.tmpDir)) mkdirSync9(this.tmpDir, { recursive: true });
+    if (!existsSync20(this.tmpDir)) mkdirSync10(this.tmpDir, { recursive: true });
     this.stt = new WhisperSTT({ model: config.whisper_model ?? "base" });
   }
   onMessage(handler) {
@@ -12178,7 +12291,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 || !existsSync19(chunkPath)) return;
+    if (!captured || !existsSync20(chunkPath)) return;
     const text = await this.stt.transcribe(chunkPath);
     if (!text || text.trim().length < 3) return;
     const segment = { text: text.trim(), timestamp: Date.now() };
@@ -12199,7 +12312,7 @@ ${msg.text}
     }
   }
   async _captureSystemAudio(outPath, seconds) {
-    return new Promise((resolve19) => {
+    return new Promise((resolve20) => {
       const platform3 = process.platform;
       let args;
       if (platform3 === "darwin") {
@@ -12207,18 +12320,18 @@ ${msg.text}
       } else if (platform3 === "linux") {
         args = ["-y", "-f", "pulse", "-i", "default.monitor", "-ar", "16000", "-ac", "1", "-t", String(seconds), outPath];
       } else {
-        resolve19(false);
+        resolve20(false);
         return;
       }
       const proc = spawn9("ffmpeg", args, { stdio: "pipe" });
       this.ffmpegProcess = proc;
       proc.on("close", (code) => {
         this.ffmpegProcess = null;
-        resolve19(code === 0);
+        resolve20(code === 0);
       });
       proc.on("error", () => {
         this.ffmpegProcess = null;
-        resolve19(false);
+        resolve20(false);
       });
     });
   }
@@ -12277,7 +12390,7 @@ ${fullTranscript}`,
     const content = `Meeting Transcript
 ${"=".repeat(40)}
 ${this.getTranscript()}`;
-    writeFileSync11(outPath, content, "utf8");
+    writeFileSync12(outPath, content, "utf8");
     return outPath;
   }
   static isAvailable() {
@@ -12316,13 +12429,13 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve17(homedir9(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve18(homedir10(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve17(homedir9(), ".0agent");
-    if (!existsSync21(dotDir)) {
-      mkdirSync10(dotDir, { recursive: true });
+    const dotDir = resolve18(homedir10(), ".0agent");
+    if (!existsSync22(dotDir)) {
+      mkdirSync11(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
     this.graph = new KnowledgeGraph(this.adapter);
@@ -12395,10 +12508,10 @@ var ZeroAgentDaemon = class {
       console.log(`[0agent] Teams: ${teams.map((t) => t.team_name).join(", ")}`);
     }
     const _daemonFile = fileURLToPath3(import.meta.url);
-    const _agentRoot = resolve17(dirname7(_daemonFile), "..");
+    const _agentRoot = resolve18(dirname7(_daemonFile), "..");
     let agentRoot;
     try {
-      const _pkg = JSON.parse(readFileSync17(resolve17(_agentRoot, "package.json"), "utf8"));
+      const _pkg = JSON.parse(readFileSync18(resolve18(_agentRoot, "package.json"), "utf8"));
       if (_pkg.name === "0agent") agentRoot = _agentRoot;
     } catch {
     }
@@ -12550,7 +12663,7 @@ var ZeroAgentDaemon = class {
       }
     });
     await this.httpServer.start();
-    writeFileSync12(this.pidFilePath, String(process.pid), "utf8");
+    writeFileSync13(this.pidFilePath, String(process.pid), "utf8");
     console.log(
       `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
     );
@@ -12602,7 +12715,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync21(this.pidFilePath)) {
+    if (existsSync22(this.pidFilePath)) {
       try {
         unlinkSync4(this.pidFilePath);
       } catch {
@@ -12632,11 +12745,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve18 } from "node:path";
-import { homedir as homedir10 } from "node:os";
-import { existsSync as existsSync22 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve18(homedir10(), ".0agent", "config.yaml");
-if (!existsSync22(CONFIG_PATH)) {
+import { resolve as resolve19 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { existsSync as existsSync23 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve19(homedir11(), ".0agent", "config.yaml");
+if (!existsSync23(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0agent",
-  "version": "1.0.91",
+  "version": "1.0.93",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",