0agent 1.0.25 → 1.0.27

package/bin/0agent.js

@@ -1318,8 +1318,26 @@ async function isDaemonRunning() {
   }
 }
 
+async function isDaemonFresh() {
+  // Check if the running daemon has the /api/llm/ping route (1.0.26+)
+  try {
+    const res = await fetch(`${BASE_URL}/api/llm/ping`, { method: 'POST', signal: AbortSignal.timeout(2000) });
+    return res.status !== 404;
+  } catch { return false; }
+}
+
 async function requireDaemon() {
-  if (await isDaemonRunning()) return;
+  if (await isDaemonRunning()) {
+    // Kill and restart if it's an old version without key routes
+    if (!(await isDaemonFresh())) {
+      process.stdout.write('  Updating daemon...');
+      try { execSync('pkill -f "daemon.mjs" 2>/dev/null; true', { stdio: 'ignore' }); } catch {}
+      await sleep(800);
+      // fall through to start fresh daemon below
+    } else {
+      return; // up to date, no action needed
+    }
+  }
 
   // Auto-start if config exists — no manual `0agent start` needed
   if (!existsSync(CONFIG_PATH)) {

package/bin/chat.js

@@ -457,54 +457,108 @@ printInsights();
 // Connect WebSocket for live events
 connectWS();
 
-// ── Startup: check daemon + LLM connection ──────────────────────────────────
+// ── Startup: ensure fresh daemon + verify LLM ────────────────────────────────
+async function _spawnDaemon() {
+  const pkgRoot = resolve(new URL(import.meta.url).pathname, '..', '..');
+  const bundled  = resolve(pkgRoot, 'dist', 'daemon.mjs');
+  if (!existsSync(bundled) || !existsSync(CONFIG_PATH)) return false;
+  const { spawn } = await import('node:child_process');
+  const child = spawn(process.execPath, [bundled], {
+    detached: true, stdio: 'ignore',
+    env: { ...process.env, ZEROAGENT_CONFIG: CONFIG_PATH },
+  });
+  child.unref();
+  // Wait up to 10s for daemon to be ready
+  for (let i = 0; i < 20; i++) {
+    await new Promise(r => setTimeout(r, 500));
+    try {
+      await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(500) });
+      return true;
+    } catch {}
+  }
+  return false;
+}
+
+async function _safeJsonFetch(url, opts) {
+  const res = await fetch(url, opts);
+  const text = await res.text();
+  try { return { status: res.status, data: JSON.parse(text) }; }
+  catch { return { status: res.status, data: null, raw: text }; }
+}
+
 (async () => {
   const startSpin = new Spinner('Starting daemon');
 
-  // Step 1: ensure daemon is running
+  // Step 1: Check if daemon is running AND up-to-date (has /api/llm/ping)
   let daemonOk = false;
+  let needsRestart = false;
+
   try {
     await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(1500) });
-    daemonOk = true;
-  } catch {
-    // Auto-start
-    startSpin.start();
-    const pkgRoot = resolve(new URL(import.meta.url).pathname, '..', '..');
-    const bundled  = resolve(pkgRoot, 'dist', 'daemon.mjs');
-    if (existsSync(bundled) && existsSync(CONFIG_PATH)) {
-      const { spawn } = await import('node:child_process');
-      const child = spawn(process.execPath, [bundled], { detached: true, stdio: 'ignore', env: { ...process.env, ZEROAGENT_CONFIG: CONFIG_PATH } });
-      child.unref();
-      for (let i = 0; i < 20; i++) {
-        await new Promise(r => setTimeout(r, 500));
-        try { await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(500) }); daemonOk = true; break; } catch {}
-      }
+    // Daemon running — check if it has the new /api/llm/ping route
+    const probe = await _safeJsonFetch(`${BASE_URL}/api/llm/ping`, {
+      method: 'POST', signal: AbortSignal.timeout(3000),
+    });
+    if (probe.status === 404 || probe.data === null) {
+      // Old daemon without this route — needs restart
+      needsRestart = true;
+    } else {
+      daemonOk = true;
     }
-    startSpin.stop();
-    if (daemonOk) process.stdout.write(`  ${fmt(C.green, '✓')} Daemon ready\n`);
-    else { console.log(`  ${fmt(C.red, '✗')} Daemon failed. Run: 0agent start`); rl.prompt(); return; }
+  } catch {
+    // Daemon not running at all
   }
 
-  // Step 2: lightweight direct API ping (1 token — fast, no daemon involved)
-  const provider = getCurrentProvider(cfg);
-  if (!provider?.api_key?.trim() && provider?.provider !== 'ollama') {
-    console.log(`  ${fmt(C.yellow, '⚠')} No API key. Use: ${fmt(C.cyan, '/key ' + (provider?.provider ?? 'anthropic') + ' <key>')}\n`);
-  } else {
-    const llmSpin = new Spinner(`Checking ${provider.provider}/${provider.model}`);
-    llmSpin.start();
+  if (needsRestart) {
+    startSpin.start('Restarting daemon (new version)');
+    // Kill old daemon
     try {
-      const result = await pingLLM(provider);
-      llmSpin.stop();
-      if (result.ok) {
-        console.log(`  ${fmt(C.green, '✓')} ${fmt(C.cyan, result.model ?? provider.model)} is ready\n`);
-      } else {
-        console.log(`  ${fmt(C.red, '✗')} LLM error: ${result.error}`);
-        console.log(`  ${fmt(C.dim, 'Fix with: /key ' + provider.provider + ' <new-key>')}\n`);
-      }
-    } catch (e) {
-      llmSpin.stop();
-      console.log(`  ${fmt(C.yellow, '⚠')} Could not reach ${provider.provider}: ${e.message}\n`);
+      const { execSync } = await import('node:child_process');
+      execSync('pkill -f "daemon.mjs" 2>/dev/null; true', { stdio: 'ignore' });
+    } catch {}
+    await new Promise(r => setTimeout(r, 800));
+    daemonOk = await _spawnDaemon();
+  } else if (!daemonOk) {
+    startSpin.start('Starting daemon');
+    daemonOk = await _spawnDaemon();
+  }
+
+  startSpin.stop();
+  if (!daemonOk) {
+    console.log(`  ${fmt(C.red, '✗')} Daemon failed to start. Run: 0agent start`);
+    rl.prompt();
+    return;
+  }
+  if (needsRestart) {
+    process.stdout.write(`  ${fmt(C.green, '✓')} Daemon updated\n`);
+  } else if (!daemonOk) {
+    process.stdout.write(`  ${fmt(C.green, '✓')} Daemon ready\n`);
+  } else {
+    // Was already running and up to date — show nothing (already running)
+    process.stdout.write(`  ${fmt(C.green, '✓')} Daemon ready\n`);
+  }
+
+  // Step 2: LLM check via daemon (not direct — this proves daemon↔API works)
+  const provider = getCurrentProvider(cfg);
+  const llmSpin = new Spinner(`Checking ${provider?.provider ?? 'LLM'}/${provider?.model ?? '...'}`);
+  llmSpin.start();
+  try {
+    const { data } = await _safeJsonFetch(`${BASE_URL}/api/llm/ping`, {
+      method: 'POST',
+      signal: AbortSignal.timeout(15_000),
+    });
+    llmSpin.stop();
+    if (data?.ok) {
+      console.log(`  ${fmt(C.green, '✓')} ${fmt(C.cyan, (data.provider ?? '') + '/' + (data.model ?? ''))} — ${data.latency_ms}ms\n`);
+    } else if (data) {
+      console.log(`  ${fmt(C.red, '✗')} LLM error: ${data.error}`);
+      console.log(`  ${fmt(C.dim, 'Fix: /key ' + (provider?.provider ?? 'anthropic') + ' <api-key>')}\n`);
+    } else {
+      console.log(`  ${fmt(C.yellow, '⚠')} LLM ping returned unexpected response\n`);
     }
+  } catch (e) {
+    llmSpin.stop();
+    console.log(`  ${fmt(C.yellow, '⚠')} LLM check failed: ${e.message}\n`);
   }
 
   rl.prompt();
@@ -532,6 +586,24 @@ rl.on('close', () => {
 });
 
 process.on('SIGINT', () => {
-  console.log(`\n  ${fmt(C.dim, 'Ctrl+C — type /help for commands or Ctrl+C again to exit')}\n`);
-  rl.prompt();
+  if (pendingResolve) {
+    // Session in progress — cancel it, don't exit
+    process.stdout.write(`\n  ${fmt(C.yellow, '↩')} Cancelled\n`);
+    spinner.stop();
+    if (sessionId) {
+      fetch(`${BASE_URL}/api/sessions/${sessionId}`, { method: 'DELETE' }).catch(() => {});
+    }
+    const resolve_ = pendingResolve;
+    pendingResolve = null;
+    sessionId = null;
+    resolve_();
+    rl.prompt();
+  } else {
+    // Not busy — show hint on first press
+    process.stdout.write(`\n  ${fmt(C.dim, 'Press Ctrl+C again to exit')}\n`);
+    rl.prompt();
+    // Second Ctrl+C within 1.5s exits
+    const timeout = setTimeout(() => {}, 1500);
+    process.once('SIGINT', () => { clearTimeout(timeout); process.exit(0); });
+  }
 });

package/dist/daemon.mjs

@@ -1490,7 +1490,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve13) => setTimeout(resolve13, ms));
+        return new Promise((resolve14) => setTimeout(resolve14, ms));
       }
     };
   }
@@ -2613,7 +2613,7 @@ var init_AgentExecutor = __esm({
         }
       }
       shellExec(command, timeoutMs) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           const chunks = [];
           const proc = spawn2("bash", ["-c", command], {
             cwd: this.cwd,
@@ -2624,10 +2624,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve13(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve14(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve13(`Error: ${err.message}`);
+            resolve14(`Error: ${err.message}`);
           });
         });
       }
@@ -2933,8 +2933,8 @@ __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
 import { execSync as execSync4 } from "node:child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync11, statSync, readdirSync as readdirSync5 } from "node:fs";
-import { resolve as resolve10, join as join3 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, statSync, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve11, join as join3 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -2983,7 +2983,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync11(resolve10(this.cwd, ".git"))) return;
+        if (!existsSync12(resolve11(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -3027,13 +3027,13 @@ var init_ProactiveSurface = __esm({
         ];
         for (const dir of outputPaths) {
           try {
-            if (!existsSync11(dir)) continue;
+            if (!existsSync12(dir)) continue;
             const xmlFiles = readdirSafe(dir).filter((f) => f.endsWith(".xml"));
             for (const xml of xmlFiles) {
               const path = join3(dir, xml);
               const stat = statSync(path);
               if (stat.mtimeMs < this.lastPollAt) continue;
-              const content = readFileSync11(path, "utf8");
+              const content = readFileSync12(path, "utf8");
               const failures = [...content.matchAll(/<failure[^>]*message="([^"]+)"/g)].length;
               if (failures > 0) {
                 return this.makeInsight(
@@ -3088,9 +3088,9 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, existsSync as existsSync12, mkdirSync as mkdirSync6 } from "node:fs";
-import { resolve as resolve11 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
 import { readFileSync, existsSync } from "node:fs";
@@ -3391,7 +3391,9 @@ var LLMExecutor = class {
         "x-api-key": this.config.api_key,
         "anthropic-version": "2023-06-01"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(6e4)
+      // 60s timeout
     });
     if (!res.ok) {
       const err = await res.text();
@@ -3514,7 +3516,8 @@ var LLMExecutor = class {
         "Content-Type": "application/json",
         "Authorization": `Bearer ${this.config.api_key}`
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(6e4)
     });
     if (!res.ok) {
       const err = await res.text();
@@ -3839,19 +3842,19 @@ var ProjectScanner = class {
   async getRunningPorts() {
     const open = [];
     await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve13) => {
+      (port) => new Promise((resolve14) => {
         const s = createServer();
         s.listen(port, "127.0.0.1", () => {
           s.close();
-          resolve13();
+          resolve14();
         });
         s.on("error", () => {
           open.push(port);
-          resolve13();
+          resolve14();
         });
         setTimeout(() => {
           s.close();
-          resolve13();
+          resolve14();
         }, 200);
       })
     ));
@@ -3984,7 +3987,7 @@ var SessionManager = class {
     session.started_at = Date.now();
     this.emit({
       type: "session.started",
-      session_id: session.id,
+      session_id: id,
       task: session.task
     });
     if (this.inferenceEngine) {
@@ -4013,7 +4016,7 @@ var SessionManager = class {
     session.steps.push(step);
     this.emit({
       type: "session.step",
-      session_id: session.id,
+      session_id: id,
       step: description,
       result: result ?? null
     });
@@ -4029,7 +4032,7 @@ var SessionManager = class {
     session.result = result;
     this.emit({
       type: "session.completed",
-      session_id: session.id,
+      session_id: id,
       result: result ?? null
     });
     return session;
@@ -4044,7 +4047,7 @@ var SessionManager = class {
     session.error = error;
     this.emit({
       type: "session.failed",
-      session_id: session.id,
+      session_id: id,
       error
     });
     return session;
@@ -4059,7 +4062,7 @@ var SessionManager = class {
     session.error = "cancelled";
     this.emit({
       type: "session.failed",
-      session_id: session.id,
+      session_id: id,
       error: "cancelled"
     });
     return session;
@@ -4082,6 +4085,14 @@ var SessionManager = class {
    * End-to-end session run: create -> start -> resolve -> step -> complete.
    * Wraps everything in try/catch to fail gracefully.
    */
+  /**
+   * Called by the route AFTER it already created the session.
+   * Uses the existing session ID — no duplicate creation.
+   */
+  async runExistingSession(sessionId, req) {
+    return this._executeSession(sessionId, req);
+  }
+  /** @deprecated Use runExistingSession from routes — this creates a duplicate session. */
   async runSession(req) {
     let enrichedReq = req;
     if (req.entity_id && this.graph) {
@@ -4103,34 +4114,42 @@ var SessionManager = class {
       }
     }
     const session = this.createSession(enrichedReq);
+    return this._executeSession(session.id, enrichedReq);
+  }
+  /**
+   * Core execution — takes an EXISTING session ID and runs it.
+   * All callers must have created the session first.
+   */
+  async _executeSession(sessionId, enrichedReq) {
     try {
-      await this.startSession(session.id);
-      this.addStep(session.id, `Extracting entities from: "${req.task.slice(0, 60)}${req.task.length > 60 ? "\u2026" : ""}"`);
-      this.addStep(session.id, "Querying knowledge graph (structural + semantic)\u2026");
-      if (session.plan) {
-        const edge = session.plan.selected_edge;
+      await this.startSession(sessionId);
+      this.addStep(sessionId, `Extracting entities from: "${enrichedReq.task.slice(0, 60)}${enrichedReq.task.length > 60 ? "\u2026" : ""}"`);
+      this.addStep(sessionId, "Querying knowledge graph (structural + semantic)\u2026");
+      const plan = this.getSession(sessionId)?.plan;
+      if (plan) {
+        const edge = plan.selected_edge;
         if (edge) {
           this.addStep(
-            session.id,
+            sessionId,
             `Selected plan: ${edge.from_label} \u2192 ${edge.to_label} (weight: ${edge.weight.toFixed(2)}, mode: ${edge.mode})`,
-            session.plan
+            plan
           );
         } else {
-          this.addStep(session.id, `No prior plan found \u2014 bootstrapping from scratch`, session.plan);
+          this.addStep(sessionId, `No prior plan found \u2014 bootstrapping from scratch`, plan);
         }
-        if (session.plan.skill) {
-          this.addStep(session.id, `Matched skill: /${session.plan.skill}`);
+        if (plan.skill) {
+          this.addStep(sessionId, `Matched skill: /${plan.skill}`);
         }
       } else {
-        this.addStep(session.id, "No inference engine connected \u2014 executing task directly");
+        this.addStep(sessionId, "No inference engine connected \u2014 executing task directly");
       }
       let anthropicContext;
       if (enrichedReq.skill && this.anthropicFetcher.isAnthropicSkill(enrichedReq.skill)) {
-        this.addStep(session.id, `Fetching skill instructions: ${enrichedReq.skill}`);
+        this.addStep(sessionId, `Fetching skill instructions: ${enrichedReq.skill}`);
         const fetched = await this.anthropicFetcher.fetch(enrichedReq.skill);
         if (fetched) {
           anthropicContext = this.anthropicFetcher.buildSystemPrompt(fetched);
-          this.addStep(session.id, `Loaded skill: ${fetched.name} (${fetched.cached ? "cached" : "fresh"})`);
+          this.addStep(sessionId, `Loaded skill: ${fetched.name} (${fetched.cached ? "cached" : "fresh"})`);
         }
       }
       const activeLLM = this.getFreshLLM();
@@ -4139,9 +4158,9 @@ var SessionManager = class {
           activeLLM,
           { cwd: this.cwd },
           // step callback → emit session.step events
-          (step) => this.addStep(session.id, step),
+          (step) => this.addStep(sessionId, step),
           // token callback → emit session.token events
-          (token) => this.emit({ type: "session.token", session_id: session.id, token })
+          (token) => this.emit({ type: "session.token", session_id: sessionId, token })
         );
         const identityContext = this.identity ? `You are talking to ${this.identity.name} (device: ${this.identity.device_id}, timezone: ${this.identity.timezone}).` : void 0;
         const projectCtx = this.projectContext ? ProjectScanner.buildContextPrompt(this.projectContext) : void 0;
@@ -4170,15 +4189,14 @@ Current task:`;
           const healLoop = new SelfHealLoop2(
             activeLLM,
             { cwd: this.cwd },
-            (step) => this.addStep(session.id, step),
-            (token) => this.emit({ type: "session.token", session_id: session.id, token })
+            (step) => this.addStep(sessionId, step),
+            (token) => this.emit({ type: "session.token", session_id: sessionId, token })
           );
           agentResult = await healLoop.executeWithHealing(enrichedReq.task, systemContext);
         } catch {
           agentResult = await executor.execute(enrichedReq.task, systemContext);
         }
         if (this.conversationStore && userEntityId) {
-          const sessionId = session.id;
           const now = Date.now();
           this.conversationStore.append({
             id: crypto.randomUUID(),
@@ -4198,7 +4216,7 @@ Current task:`;
             created_at: now + 1
           });
         }
-        const selectedEdgeId = session.plan?.selected_edge?.edge_id;
+        const selectedEdgeId = this.getSession(sessionId)?.plan?.selected_edge?.edge_id;
         if (selectedEdgeId && this.weightUpdater && this.graph) {
           const outcomeSignal = this.computeOutcomeSignal(agentResult);
           if (outcomeSignal !== 0) {
@@ -4214,20 +4232,20 @@ Current task:`;
                 edge.weight,
                 newWeight,
                 outcomeSignal > 0 ? "task_outcome_positive" : "task_outcome_negative",
-                session.id
+                sessionId
               );
               this.emit({ type: "graph.weight_updated", edge_id: edge.id, old_weight: edge.weight, new_weight: newWeight });
             }
           }
         }
         if (agentResult.files_written.length > 0) {
-          this.addStep(session.id, `Files written: ${agentResult.files_written.join(", ")}`);
+          this.addStep(sessionId, `Files written: ${agentResult.files_written.join(", ")}`);
         }
         if (agentResult.commands_run.length > 0) {
-          this.addStep(session.id, `Commands run: ${agentResult.commands_run.length}`);
+          this.addStep(sessionId, `Commands run: ${agentResult.commands_run.length}`);
         }
-        this.addStep(session.id, `Done (${agentResult.tokens_used} tokens, ${agentResult.iterations} LLM turns)`);
-        this.completeSession(session.id, {
+        this.addStep(sessionId, `Done (${agentResult.tokens_used} tokens, ${agentResult.iterations} LLM turns)`);
+        this.completeSession(sessionId, {
           output: agentResult.output,
           files_written: agentResult.files_written,
           commands_run: agentResult.commands_run,
@@ -4237,14 +4255,14 @@ Current task:`;
       } else {
         const cfgPath = resolve5(homedir2(), ".0agent", "config.yaml");
         const output = `No LLM API key found. Add one to ${cfgPath} or run: 0agent init`;
-        this.addStep(session.id, "\u26A0 No LLM API key configured \u2014 run: 0agent init");
-        this.completeSession(session.id, { output });
+        this.addStep(sessionId, "\u26A0 No LLM API key configured \u2014 run: 0agent init");
+        this.completeSession(sessionId, { output });
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      this.failSession(session.id, message);
+      this.failSession(sessionId, message);
     }
-    return this.sessions.get(session.id);
+    return this.sessions.get(sessionId);
   }
   /**
    * Return the number of active (running) sessions.
@@ -4626,10 +4644,10 @@ var SkillRegistry = class {
 };
 
 // packages/daemon/src/HTTPServer.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve6, dirname as dirname3 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { resolve as resolve7, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/daemon/src/routes/health.ts
@@ -4653,28 +4671,23 @@ function sessionRoutes(deps) {
       return c.json({ error: "task is required and must be a string" }, 400);
     }
     const session = deps.sessions.createSession(body);
-    deps.sessions.runSession(body).catch(() => {
+    deps.sessions.runExistingSession(session.id, body).catch(() => {
     });
     return c.json({ session_id: session.id, status: "pending" }, 201);
   });
   app.get("/", (c) => {
-    const sessions = deps.sessions.listSessions();
-    return c.json(sessions);
+    return c.json(deps.sessions.listSessions());
   });
   app.get("/:id", (c) => {
     const id = c.req.param("id");
     const session = deps.sessions.getSession(id);
-    if (!session) {
-      return c.json({ error: "Session not found" }, 404);
-    }
+    if (!session) return c.json({ error: "Session not found" }, 404);
     return c.json(session);
   });
   app.delete("/:id", (c) => {
     const id = c.req.param("id");
     const session = deps.sessions.getSession(id);
-    if (!session) {
-      return c.json({ error: "Session not found" }, 404);
-    }
+    if (!session) return c.json({ error: "Session not found" }, 404);
     deps.sessions.cancelSession(id);
     return c.json({ ok: true });
   });
@@ -4923,18 +4936,71 @@ function memoryRoutes(deps) {
   return app;
 }
 
+// packages/daemon/src/routes/llm.ts
+import { Hono as Hono10 } from "hono";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+import { homedir as homedir4 } 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 = resolve6(homedir4(), ".0agent", "config.yaml");
+      if (!existsSync8(configPath)) {
+        return c.json({ ok: false, error: "Config not found. Run: 0agent init" });
+      }
+      const cfg = YAML4.parse(readFileSync7(configPath, "utf8"));
+      const providers = cfg.llm_providers;
+      const def = providers?.find((p) => p.is_default) ?? providers?.[0];
+      if (!def) {
+        return c.json({ ok: false, error: "No LLM provider in config" });
+      }
+      const apiKey = String(def.api_key ?? "").trim();
+      if (!apiKey && def.provider !== "ollama") {
+        return c.json({ ok: false, error: `No API key for ${def.provider}. Run: 0agent init` });
+      }
+      const executor = new LLMExecutor({
+        provider: String(def.provider),
+        model: String(def.model),
+        api_key: apiKey,
+        base_url: def.base_url ? String(def.base_url) : void 0
+      });
+      const result = await executor.complete(
+        [{ role: "user", content: "Reply with the word: ready" }],
+        "You are a helpful assistant. Reply with exactly one word."
+      );
+      return c.json({
+        ok: true,
+        model: String(def.model),
+        provider: String(def.provider),
+        latency_ms: Date.now() - start,
+        response: result.content.trim().slice(0, 20)
+      });
+    } catch (err) {
+      return c.json({
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+        latency_ms: Date.now() - start
+      });
+    }
+  });
+  return app;
+}
+
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
-    resolve6(dirname3(fileURLToPath(import.meta.url)), "graph.html"),
+    resolve7(dirname3(fileURLToPath(import.meta.url)), "graph.html"),
     // dev (src/)
-    resolve6(dirname3(fileURLToPath(import.meta.url)), "..", "graph.html"),
+    resolve7(dirname3(fileURLToPath(import.meta.url)), "..", "graph.html"),
     // bundled (dist/../)
-    resolve6(dirname3(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
+    resolve7(dirname3(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
   ];
   for (const p of candidates) {
     try {
-      readFileSync7(p);
+      readFileSync8(p);
       return p;
     } catch {
     }
@@ -4948,7 +5014,7 @@ var HTTPServer = class {
   deps;
   constructor(deps) {
     this.deps = deps;
-    this.app = new Hono10();
+    this.app = new Hono11();
     this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
     this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
     this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
@@ -4958,9 +5024,10 @@ var HTTPServer = class {
     this.app.route("/api/skills", skillRoutes({ skillRegistry: deps.skillRegistry }));
     this.app.route("/api/insights", insightsRoutes({ proactiveSurface: deps.proactiveSurface ?? null }));
     this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
+    this.app.route("/api/llm", llmRoutes());
     const serveGraph = (c) => {
       try {
-        const html = readFileSync7(GRAPH_HTML_PATH, "utf8");
+        const html = readFileSync8(GRAPH_HTML_PATH, "utf8");
         return c.html(html);
       } catch {
         return c.html("<p>Graph UI not found. Run: pnpm build</p>");
@@ -4970,7 +5037,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve13) => {
+    return new Promise((resolve14) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -4978,20 +5045,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve13();
+          resolve14();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve13, reject) => {
+    return new Promise((resolve14, reject) => {
       if (!this.server) {
-        resolve13();
+        resolve14();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve13();
+        else resolve14();
       });
     });
   }
@@ -5002,11 +5069,11 @@ var HTTPServer = class {
 
 // packages/daemon/src/IdentityManager.ts
 init_src();
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "node:fs";
-import { resolve as resolve7, dirname as dirname4 } from "node:path";
-import { homedir as homedir4, hostname } from "node:os";
-import YAML4 from "yaml";
-var IDENTITY_PATH = resolve7(homedir4(), ".0agent", "identity.yaml");
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve as resolve8, dirname as dirname4 } from "node:path";
+import { homedir as homedir5, hostname } from "node:os";
+import YAML5 from "yaml";
+var IDENTITY_PATH = resolve8(homedir5(), ".0agent", "identity.yaml");
 var DEFAULT_IDENTITY = {
   name: "User",
   device_id: `unknown-device`,
@@ -5022,9 +5089,9 @@ var IdentityManager = class {
    * Load or create identity. Call once at daemon startup.
    */
   async init() {
-    if (existsSync8(IDENTITY_PATH)) {
-      const raw = readFileSync8(IDENTITY_PATH, "utf8");
-      this.identity = YAML4.parse(raw);
+    if (existsSync9(IDENTITY_PATH)) {
+      const raw = readFileSync9(IDENTITY_PATH, "utf8");
+      this.identity = YAML5.parse(raw);
     } else {
       this.identity = {
         ...DEFAULT_IDENTITY,
@@ -5075,24 +5142,24 @@ var IdentityManager = class {
   }
   save() {
     const dir = dirname4(IDENTITY_PATH);
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync4(IDENTITY_PATH, YAML4.stringify(this.identity), "utf8");
+    writeFileSync4(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
   }
 };
 
 // packages/daemon/src/TeamManager.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
-import { homedir as homedir5 } from "node:os";
-import YAML5 from "yaml";
-var TEAMS_PATH = resolve8(homedir5(), ".0agent", "teams.yaml");
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+import YAML6 from "yaml";
+var TEAMS_PATH = resolve9(homedir6(), ".0agent", "teams.yaml");
 var TeamManager = class {
   config;
   constructor() {
-    if (existsSync9(TEAMS_PATH)) {
-      this.config = YAML5.parse(readFileSync9(TEAMS_PATH, "utf8"));
+    if (existsSync10(TEAMS_PATH)) {
+      this.config = YAML6.parse(readFileSync10(TEAMS_PATH, "utf8"));
     } else {
       this.config = { memberships: [] };
     }
@@ -5147,8 +5214,8 @@ var TeamManager = class {
     }
   }
   save() {
-    mkdirSync5(resolve8(homedir5(), ".0agent"), { recursive: true });
-    writeFileSync5(TEAMS_PATH, YAML5.stringify(this.config), "utf8");
+    mkdirSync5(resolve9(homedir6(), ".0agent"), { recursive: true });
+    writeFileSync5(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
   }
 };
 
@@ -5231,9 +5298,9 @@ var TeamSync = class {
 };
 
 // packages/daemon/src/GitHubMemorySync.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve10 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 var GITHUB_API = "https://api.github.com";
 async function ghFetch(path, token, opts) {
   return fetch(`${GITHUB_API}${path}`, {
@@ -5352,10 +5419,10 @@ var GitHubMemorySync = class {
           )
         );
       }
-      const customSkillsDir = resolve9(homedir6(), ".0agent", "skills", "custom");
-      if (existsSync10(customSkillsDir)) {
+      const customSkillsDir = resolve10(homedir7(), ".0agent", "skills", "custom");
+      if (existsSync11(customSkillsDir)) {
         for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
-          const content = readFileSync10(resolve9(customSkillsDir, file), "utf8");
+          const content = readFileSync11(resolve10(customSkillsDir, file), "utf8");
           pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
         }
       }
@@ -5540,7 +5607,7 @@ var GitHubMemorySync = class {
   }
   async pullCustomSkills() {
     const { token, owner, repo } = this.config;
-    const dir = resolve9(homedir6(), ".0agent", "skills", "custom");
+    const dir = resolve10(homedir7(), ".0agent", "skills", "custom");
     try {
       const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
       if (!res.ok) return;
@@ -5550,7 +5617,7 @@ var GitHubMemorySync = class {
         if (content) {
           const { mkdirSync: mkdirSync7 } = await import("node:fs");
           mkdirSync7(dir, { recursive: true });
-          writeFileSync6(resolve9(dir, file.name), content, "utf8");
+          writeFileSync6(resolve10(dir, file.name), content, "utf8");
         }
       }
     } catch {
@@ -5614,12 +5681,12 @@ var ZeroAgentDaemon = class {
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve11(homedir7(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve12(homedir8(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve11(homedir7(), ".0agent");
-    if (!existsSync12(dotDir)) {
+    const dotDir = resolve12(homedir8(), ".0agent");
+    if (!existsSync13(dotDir)) {
       mkdirSync6(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
@@ -5771,7 +5838,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync12(this.pidFilePath)) {
+    if (existsSync13(this.pidFilePath)) {
       try {
         unlinkSync2(this.pidFilePath);
       } catch {
@@ -5801,11 +5868,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve12 } from "node:path";
-import { homedir as homedir8 } from "node:os";
-import { existsSync as existsSync13 } from "node:fs";
-var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve12(homedir8(), ".0agent", "config.yaml");
-if (!existsSync13(CONFIG_PATH)) {
+import { resolve as resolve13 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { existsSync as existsSync14 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve13(homedir9(), ".0agent", "config.yaml");
+if (!existsSync14(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.
 

package/package.json

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