0agent 1.0.29 → 1.0.31

package/bin/chat.js

@@ -166,7 +166,7 @@ async function connectWS() {
       ws.send(JSON.stringify({ type: 'subscribe', topics: ['sessions', 'graph', 'insights'] }));
     });
     ws.on('message', data => handleWsEvent(JSON.parse(data.toString())));
-    ws.on('close', () => { wsReady = false; setTimeout(connectWS, 2000); });
+    ws.on('close', () => { wsReady = false; setTimeout(connectWS, 800); }); // faster reconnect
     ws.on('error', () => { wsReady = false; });
   } catch {}
 }
@@ -189,6 +189,79 @@ function handleWsEvent(event) {
       lineBuffer += event.token;
       break;
     }
+    case 'runtime.heal_proposal': {
+      // Daemon found a code bug and is proposing a fix — requires human y/n
+      const p = event.proposal ?? {};
+      process.stdout.write('\n');
+      process.stdout.write(`  ${fmt(C.yellow, '🔧 Runtime code bug detected')}\n`);
+      process.stdout.write(`  ${fmt(C.dim, p.error_summary ?? '')}\n`);
+      process.stdout.write(`  ${fmt(C.dim, 'File: ' + (p.location?.relPath ?? 'unknown'))}\n\n`);
+
+      if (p.explanation) {
+        process.stdout.write(`  ${fmt(C.bold, 'Diagnosis:')} ${p.explanation}\n\n`);
+      }
+
+      if (p.diff) {
+        process.stdout.write(`  ${fmt(C.bold, 'Proposed fix:')}\n`);
+        const diffLines = String(p.diff).split('\n');
+        for (const line of diffLines) {
+          if (line.startsWith('-')) process.stdout.write(`  ${fmt(C.red, line)}\n`);
+          else if (line.startsWith('+')) process.stdout.write(`  ${fmt(C.green, line)}\n`);
+          else process.stdout.write(`  ${fmt(C.dim, line)}\n`);
+        }
+        process.stdout.write('\n');
+      }
+
+      const confidence = p.confidence ?? 'medium';
+      const confColor = confidence === 'high' ? C.green : confidence === 'medium' ? C.yellow : C.red;
+      process.stdout.write(`  Confidence: ${fmt(confColor, confidence.toUpperCase())}\n\n`);
+
+      // Ask for approval — use readline in raw mode for single keypress
+      process.stdout.write(`  Apply this fix and restart daemon? ${fmt(C.bold, '[y/N]')} `);
+
+      const handleHealApproval = async (key) => {
+        process.stdin.removeListener('keypress', handleHealApproval);
+        const answer = key?.toLowerCase() ?? 'n';
+        process.stdout.write(answer + '\n\n');
+
+        if (answer === 'y') {
+          // Store proposal then approve
+          await fetch(`${BASE_URL}/api/runtime/proposals`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(p),
+          }).catch(() => {});
+
+          const approveRes = await fetch(`${BASE_URL}/api/runtime/proposals/${p.proposal_id}/approve`, {
+            method: 'POST',
+          }).catch(() => null);
+          const data = approveRes?.ok ? await approveRes.json().catch(() => null) : null;
+
+          if (data?.applied) {
+            process.stdout.write(`  ${fmt(C.green, '✓')} Patch applied. ${data.message}\n`);
+            process.stdout.write(`  ${fmt(C.dim, 'Daemon restarting — reconnecting in 5s...')}\n\n`);
+          } else {
+            process.stdout.write(`  ${fmt(C.red, '✗')} Could not apply: ${data?.message ?? 'unknown error'}\n\n`);
+            rl.prompt();
+          }
+        } else {
+          await fetch(`${BASE_URL}/api/runtime/proposals/${p.proposal_id}`, { method: 'DELETE' }).catch(() => {});
+          process.stdout.write(`  ${fmt(C.dim, 'Fix rejected. The bug remains.')}\n\n`);
+          rl.prompt();
+        }
+      };
+
+      // Listen for a single keypress
+      if (process.stdin.isTTY) {
+        process.stdin.once('data', (buf) => {
+          handleHealApproval(buf.toString().trim().toLowerCase());
+        });
+      } else {
+        rl.once('line', (line) => handleHealApproval(line.trim().toLowerCase()));
+      }
+      break;
+    }
+
     case 'schedule.fired': {
       // Show when a scheduled job fires — even if user is idle
       const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
@@ -276,6 +349,50 @@ async function runTask(input) {
     const s = await res.json();
     sessionId = s.session_id ?? s.id;
     spinner.start('Thinking');  // show immediately after session created
+
+    // Polling fallback — runs concurrently with WS events.
+    // Catches completion when WS is disconnected (e.g. daemon just restarted).
+    let lastPolledStep = 0;
+    const sid = sessionId;
+    const pollTimer = setInterval(async () => {
+      if (!pendingResolve || sessionId !== sid) { clearInterval(pollTimer); return; }
+      try {
+        const r = await fetch(`${BASE_URL}/api/sessions/${sid}`, { signal: AbortSignal.timeout(2000) });
+        const session = await r.json();
+
+        // Show any new steps not yet shown via WS
+        const steps = session.steps ?? [];
+        for (let j = lastPolledStep; j < steps.length; j++) {
+          spinner.stop();
+          console.log(`  \x1b[2m›\x1b[0m ${steps[j].description}`);
+          spinner.start(steps[j].description.slice(0, 50));
+        }
+        lastPolledStep = steps.length;
+
+        if (session.status === 'completed' || session.status === 'failed') {
+          clearInterval(pollTimer);
+          if (!pendingResolve) return; // WS already handled it
+          spinner.stop();
+          if (session.status === 'completed') {
+            const out = session.result?.output;
+            if (out && typeof out === 'string') {
+              console.log(`\n  ${out}`);
+            }
+            if (session.result?.files_written?.length) console.log(`  \x1b[32m✓\x1b[0m Files: ${session.result.files_written.join(', ')}`);
+            if (session.result?.tokens_used) console.log(`  \x1b[2m${session.result.tokens_used} tokens\x1b[0m`);
+            console.log(`\n  \x1b[32m✓ Done\x1b[0m\n`);
+          } else {
+            console.log(`\n  \x1b[31m✗ Failed:\x1b[0m ${session.error}\n`);
+          }
+          const resolve_ = pendingResolve;
+          pendingResolve = null;
+          sessionId = null;
+          resolve_();
+          rl.prompt();
+        }
+      } catch {}
+    }, 1500);
+
     return new Promise(resolve => { pendingResolve = resolve; });
   } catch (e) {
     console.log(`  ${fmt(C.red, '✗')} ${e.message}`);
@@ -654,9 +771,10 @@ rl.on('line', async (input) => {
     rl.prompt();
   } else {
     await runTask(line);
-    // prompt() is called from WS handler after session.completed
-    // but fall back if WS not connected
-    if (!wsReady) rl.prompt();
+    // runTask resolves when session completes (via WS or polling fallback)
+    // rl.prompt() may already have been called by the handler that resolved it,
+    // but calling it again is a safe no-op if readline is already prompting
+    if (!streaming) rl.prompt();
   }
 });
 

package/dist/daemon.mjs

@@ -1501,7 +1501,7 @@ var init_EdgeWeightUpdater = __esm({
         this.weightLog.append(event);
       }
       sleep(ms) {
-        return new Promise((resolve14) => setTimeout(resolve14, ms));
+        return new Promise((resolve15) => setTimeout(resolve15, ms));
       }
     };
   }
@@ -2717,7 +2717,7 @@ var init_AgentExecutor = __esm({
         }
       }
       shellExec(command, timeoutMs) {
-        return new Promise((resolve14) => {
+        return new Promise((resolve15) => {
           const chunks = [];
           const proc = spawn2("bash", ["-c", command], {
             cwd: this.cwd,
@@ -2728,10 +2728,10 @@ var init_AgentExecutor = __esm({
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("close", (code) => {
             const output = chunks.join("").trim();
-            resolve14(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
+            resolve15(output || (code === 0 ? "(command completed, no output)" : `exit code ${code}`));
           });
           proc.on("error", (err) => {
-            resolve14(`Error: ${err.message}`);
+            resolve15(`Error: ${err.message}`);
           });
         });
       }
@@ -2960,6 +2960,258 @@ var init_ExecutionVerifier = __esm({
   }
 });
 
+// packages/daemon/src/RuntimeSelfHeal.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve5, dirname as dirname3 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync as execSync4, spawn as spawn3 } 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));
+}
+function parseStackTrace(stack) {
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const match = line.match(/\((.+):(\d+):(\d+)\)/) ?? line.match(/at (.+):(\d+):(\d+)$/);
+    if (!match) continue;
+    let filePath = match[1];
+    if (filePath.startsWith("file://")) filePath = fileURLToPath(filePath);
+    if (!filePath.includes("packages") && !filePath.includes("dist/daemon")) continue;
+    return {
+      file: filePath,
+      line: parseInt(match[2], 10),
+      col: parseInt(match[3], 10),
+      relPath: filePath.replace(/.*\/0agent[^/]*\//, "")
+    };
+  }
+  return null;
+}
+function extractContext(filePath, errorLine, contextLines = 30) {
+  try {
+    if (!existsSync6(filePath)) return null;
+    const content = readFileSync5(filePath, "utf8");
+    const lines = content.split("\n");
+    const start = Math.max(0, errorLine - contextLines);
+    const end = Math.min(lines.length, errorLine + contextLines);
+    return lines.slice(start, end).map((l, i) => {
+      const lineNum = start + i + 1;
+      const marker = lineNum === errorLine ? ">>>" : "   ";
+      return `${marker} ${String(lineNum).padStart(4)} | ${l}`;
+    }).join("\n");
+  } catch {
+    return null;
+  }
+}
+var RUNTIME_BUG_PATTERNS, TASK_FAILURE_PATTERNS, RuntimeSelfHeal;
+var init_RuntimeSelfHeal = __esm({
+  "packages/daemon/src/RuntimeSelfHeal.ts"() {
+    "use strict";
+    RUNTIME_BUG_PATTERNS = [
+      /packages\/(daemon|core|subagent|mcp-hub)\/src\//,
+      /dist\/daemon\.mjs/,
+      /TypeError: Cannot read propert/,
+      /TypeError: .+ is not a function/,
+      /ReferenceError: .+ is not defined/,
+      /TypeError: Cannot set propert/,
+      /TypeError: .+ is undefined/
+    ];
+    TASK_FAILURE_PATTERNS = [
+      /Anthropic \d{3}:/,
+      // API error — not our bug
+      /HTTP \d{3}/,
+      // HTTP error
+      /ENOENT/,
+      // file not found
+      /EACCES/,
+      // permission denied
+      /AbortError/,
+      // timeout
+      /network/i
+      // network issue
+    ];
+    RuntimeSelfHeal = class {
+      constructor(llm, eventBus) {
+        this.llm = llm;
+        this.eventBus = eventBus;
+        let dir = dirname3(fileURLToPath(import.meta.url));
+        while (dir !== "/" && !existsSync6(resolve5(dir, "package.json"))) {
+          dir = resolve5(dir, "..");
+        }
+        this.projectRoot = dir;
+      }
+      projectRoot;
+      /**
+       * Analyze an error and propose a code fix.
+       * Returns null if the error is a task failure (not a code bug).
+       */
+      async analyze(error, task) {
+        if (!isRuntimeBug(error)) return null;
+        const location = parseStackTrace(error);
+        if (!location) return null;
+        const tsPath = this.findSourceFile(location);
+        const codePath = tsPath ?? location.file;
+        const context = extractContext(codePath, location.line);
+        if (!context) return null;
+        const proposal = await this.proposeFix(error, task, codePath, location.line, context);
+        return proposal;
+      }
+      /**
+       * Emit a WS event to notify the chat TUI that a heal proposal is ready.
+       * The human must call applyPatch() after approving.
+       */
+      emitProposal(proposal) {
+        this.eventBus.emit({
+          type: "runtime.heal_proposal",
+          proposal
+        });
+      }
+      /**
+       * Apply an approved patch to the source file, rebuild bundle, restart daemon.
+       * Called only after human approval.
+       */
+      async applyPatch(proposal) {
+        const tsPath = this.findSourceFile(proposal.location);
+        if (!tsPath || !existsSync6(tsPath)) {
+          return {
+            applied: false,
+            restarted: false,
+            message: "Source files not found. If running from source, apply the fix manually and rebuild."
+          };
+        }
+        try {
+          const original = readFileSync5(tsPath, "utf8");
+          const backup = tsPath + ".bak";
+          writeFileSync3(backup, original, "utf8");
+          if (!original.includes(proposal.original_code.trim())) {
+            return {
+              applied: false,
+              restarted: false,
+              message: "Could not locate the code section to patch. The file may have changed."
+            };
+          }
+          const patched = original.replace(proposal.original_code, proposal.proposed_code);
+          writeFileSync3(tsPath, patched, "utf8");
+          const bundleScript = resolve5(this.projectRoot, "scripts", "bundle.mjs");
+          if (existsSync6(bundleScript)) {
+            try {
+              execSync4(`node "${bundleScript}"`, {
+                cwd: this.projectRoot,
+                timeout: 6e4,
+                stdio: "ignore"
+              });
+            } catch {
+              writeFileSync3(tsPath, original, "utf8");
+              return {
+                applied: false,
+                restarted: false,
+                message: "Bundle rebuild failed. Backup restored. Fix may have introduced a syntax error."
+              };
+            }
+          }
+          setTimeout(() => this.restartDaemon(), 1500);
+          return {
+            applied: true,
+            restarted: true,
+            message: `Patched ${proposal.location.relPath}. Restarting daemon...`
+          };
+        } catch (err) {
+          return {
+            applied: false,
+            restarted: false,
+            message: `Failed to apply patch: ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+      // ─── Private helpers ───────────────────────────────────────────────────────
+      findSourceFile(location) {
+        const candidates = [
+          resolve5(this.projectRoot, location.relPath),
+          // If relPath starts with dist/, look in src/
+          resolve5(this.projectRoot, location.relPath.replace(/^dist\//, "src/").replace(/\.js$/, ".ts")),
+          resolve5(this.projectRoot, "packages", "daemon", "src", location.relPath.replace(/.*src\//, "")),
+          resolve5(this.projectRoot, "packages", "core", "src", location.relPath.replace(/.*src\//, ""))
+        ];
+        for (const p of candidates) {
+          if (existsSync6(p)) return p;
+        }
+        return null;
+      }
+      async proposeFix(error, task, filePath, errorLine, codeContext) {
+        const systemPrompt = `You are an expert TypeScript/Node.js debugger analyzing a runtime error in the 0agent codebase.
+Your job: identify the exact bug and propose a minimal, surgical fix.
+Return ONLY valid JSON \u2014 no markdown, no explanation outside the JSON.`;
+        const userPrompt = `Runtime error in the 0agent daemon:
+
+ERROR:
+${error.slice(0, 1e3)}
+
+TASK THAT TRIGGERED IT:
+${task.slice(0, 200)}
+
+CODE CONTEXT (>>> marks error line):
+${codeContext}
+
+FILE: ${filePath}
+
+Respond with this exact JSON structure:
+{
+  "explanation": "one-sentence explanation of the bug",
+  "confidence": "high|medium|low",
+  "original_code": "exact code string to replace (must match file exactly)",
+  "proposed_code": "fixed replacement code",
+  "diff": "human-readable before/after showing the change"
+}
+
+Rules:
+- original_code must be an EXACT substring of the file (copy-paste from context above)
+- proposed_code must be syntactically valid TypeScript
+- Make the minimal change that fixes the bug
+- If you cannot determine a safe fix, set confidence to "low" and explain why`;
+        try {
+          const response = await this.llm.complete(
+            [{ role: "user", content: userPrompt }],
+            systemPrompt
+          );
+          const json = JSON.parse(response.content.trim().replace(/^```json\n?/, "").replace(/\n?```$/, ""));
+          return {
+            proposal_id: crypto.randomUUID().slice(0, 8),
+            error_summary: error.split("\n")[0].slice(0, 120),
+            location: { file: filePath, line: errorLine, col: 0, relPath: filePath.replace(this.projectRoot + "/", "") },
+            original_code: json.original_code ?? "",
+            proposed_code: json.proposed_code ?? "",
+            diff: json.diff ?? "",
+            explanation: json.explanation ?? "",
+            confidence: json.confidence ?? "medium"
+          };
+        } catch {
+          return {
+            proposal_id: crypto.randomUUID().slice(0, 8),
+            error_summary: error.split("\n")[0].slice(0, 120),
+            location: { file: filePath, line: errorLine, col: 0, relPath: filePath.replace(this.projectRoot + "/", "") },
+            original_code: "",
+            proposed_code: "",
+            diff: "",
+            explanation: "Could not generate a fix proposal.",
+            confidence: "low"
+          };
+        }
+      }
+      restartDaemon() {
+        const bundlePath = resolve5(this.projectRoot, "dist", "daemon.mjs");
+        if (existsSync6(bundlePath)) {
+          const child = spawn3(process.execPath, [bundlePath], {
+            detached: true,
+            stdio: "ignore",
+            env: process.env
+          });
+          child.unref();
+        }
+        setTimeout(() => process.exit(0), 200);
+      }
+    };
+  }
+});
+
 // packages/daemon/src/SelfHealLoop.ts
 var SelfHealLoop_exports = {};
 __export(SelfHealLoop_exports, {
@@ -2971,13 +3223,15 @@ var init_SelfHealLoop = __esm({
     "use strict";
     init_AgentExecutor();
     init_ExecutionVerifier();
+    init_RuntimeSelfHeal();
     SelfHealLoop = class {
-      constructor(llm, config, onStep, onToken, maxAttempts = 3) {
+      constructor(llm, config, onStep, onToken, maxAttempts = 3, runtimeHealer) {
         this.llm = llm;
         this.config = config;
         this.onStep = onStep;
         this.onToken = onToken;
         this.maxAttempts = maxAttempts;
+        this.runtimeHealer = runtimeHealer;
         this.verifier = new ExecutionVerifier(config.cwd);
       }
       verifier;
@@ -3005,6 +3259,17 @@ var init_SelfHealLoop = __esm({
         if (!lastVerification.success) {
           this.onStep(`\u26A0 Verification: ${lastVerification.details}`);
         }
+        const lastError = finalResult?.output ?? "";
+        if (this.runtimeHealer && isRuntimeBug(lastError)) {
+          this.onStep("\u{1F527} This looks like a runtime code bug \u2014 analyzing for self-fix...");
+          this.runtimeHealer.analyze(lastError, "session task").then((proposal) => {
+            if (proposal) {
+              this.onStep(`\u{1F527} Fix proposed for ${proposal.location.relPath}:${proposal.location.line} \u2014 awaiting your approval in terminal`);
+              this.runtimeHealer.emitProposal(proposal);
+            }
+          }).catch(() => {
+          });
+        }
         return { ...finalResult, heal_attempts: attempts, healed: false };
       }
       buildHealContext(attempt, verification, result, originalContext) {
@@ -3036,9 +3301,9 @@ var ProactiveSurface_exports = {};
 __export(ProactiveSurface_exports, {
   ProactiveSurface: () => ProactiveSurface
 });
-import { execSync as execSync5 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync12, statSync, readdirSync as readdirSync5 } from "node:fs";
-import { resolve as resolve11, join as join3 } from "node:path";
+import { execSync as execSync6 } from "node:child_process";
+import { existsSync as existsSync13, readFileSync as readFileSync13, statSync, readdirSync as readdirSync5 } from "node:fs";
+import { resolve as resolve12, join as join3 } from "node:path";
 function readdirSafe(dir) {
   try {
     return readdirSync5(dir);
@@ -3087,7 +3352,7 @@ var init_ProactiveSurface = __esm({
         return [...this.insights];
       }
       async poll() {
-        if (!existsSync12(resolve11(this.cwd, ".git"))) return;
+        if (!existsSync13(resolve12(this.cwd, ".git"))) return;
         const newInsights = [];
         const gitInsight = this.checkGitActivity();
         if (gitInsight) newInsights.push(gitInsight);
@@ -3105,7 +3370,7 @@ var init_ProactiveSurface = __esm({
         try {
           const currentHead = this.getGitHead();
           if (!currentHead || currentHead === this.lastKnownHead) return null;
-          const log = execSync5(
+          const log = execSync6(
             `git log ${this.lastKnownHead}..${currentHead} --oneline --stat`,
             { cwd: this.cwd, timeout: 3e3, encoding: "utf8" }
           ).trim();
@@ -3131,13 +3396,13 @@ var init_ProactiveSurface = __esm({
         ];
         for (const dir of outputPaths) {
           try {
-            if (!existsSync12(dir)) continue;
+            if (!existsSync13(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 = readFileSync12(path, "utf8");
+              const content = readFileSync13(path, "utf8");
               const failures = [...content.matchAll(/<failure[^>]*message="([^"]+)"/g)].length;
               if (failures > 0) {
                 return this.makeInsight(
@@ -3181,7 +3446,7 @@ var init_ProactiveSurface = __esm({
       }
       getGitHead() {
         try {
-          return execSync5("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
+          return execSync6("git rev-parse HEAD", { cwd: this.cwd, timeout: 1e3, encoding: "utf8" }).trim();
         } catch {
           return "";
         }
@@ -3192,8 +3457,8 @@ var init_ProactiveSurface = __esm({
 
 // packages/daemon/src/ZeroAgentDaemon.ts
 init_src();
-import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "node:fs";
-import { resolve as resolve12 } from "node:path";
+import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync2, existsSync as existsSync14, mkdirSync as mkdirSync6 } from "node:fs";
+import { resolve as resolve13 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 
 // packages/daemon/src/config/DaemonConfig.ts
@@ -3946,19 +4211,19 @@ var ProjectScanner = class {
   async getRunningPorts() {
     const open = [];
     await Promise.all(PORTS_TO_CHECK.map(
-      (port) => new Promise((resolve14) => {
+      (port) => new Promise((resolve15) => {
         const s = createServer();
         s.listen(port, "127.0.0.1", () => {
           s.close();
-          resolve14();
+          resolve15();
         });
         s.on("error", () => {
           open.push(port);
-          resolve14();
+          resolve15();
         });
         setTimeout(() => {
           s.close();
-          resolve14();
+          resolve15();
         }, 200);
       })
     ));
@@ -4034,8 +4299,8 @@ var ConversationStore = class {
 };
 
 // packages/daemon/src/SessionManager.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import YAML2 from "yaml";
 var SessionManager = class {
@@ -4357,7 +4622,7 @@ Current task:`;
           model: agentResult.model
         });
       } else {
-        const cfgPath = resolve5(homedir2(), ".0agent", "config.yaml");
+        const cfgPath = resolve6(homedir2(), ".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 });
@@ -4398,9 +4663,9 @@ Current task:`;
    */
   getFreshLLM() {
     try {
-      const configPath = resolve5(homedir2(), ".0agent", "config.yaml");
-      if (!existsSync6(configPath)) return this.llm;
-      const raw = readFileSync5(configPath, "utf8");
+      const configPath = resolve6(homedir2(), ".0agent", "config.yaml");
+      if (!existsSync7(configPath)) return this.llm;
+      const raw = readFileSync6(configPath, "utf8");
       const cfg = YAML2.parse(raw);
       const providers = cfg.llm_providers;
       if (!providers?.length) return this.llm;
@@ -4660,7 +4925,7 @@ var BackgroundWorkers = class {
 };
 
 // packages/daemon/src/SkillRegistry.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync3, existsSync as existsSync7, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFileSync as readFileSync7, readdirSync as readdirSync3, existsSync as existsSync8, writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join2 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 import YAML3 from "yaml";
@@ -4683,11 +4948,11 @@ var SkillRegistry = class {
     this.loadFromDir(this.customDir, false);
   }
   loadFromDir(dir, isBuiltin) {
-    if (!existsSync7(dir)) return;
+    if (!existsSync8(dir)) return;
     const files = readdirSync3(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
     for (const file of files) {
       try {
-        const raw = readFileSync6(join2(dir, file), "utf8");
+        const raw = readFileSync7(join2(dir, file), "utf8");
         const skill = YAML3.parse(raw);
         if (skill.name) {
           this.skills.set(skill.name, skill);
@@ -4724,7 +4989,7 @@ var SkillRegistry = class {
     }
     mkdirSync3(this.customDir, { recursive: true });
     const filePath = join2(this.customDir, `${name}.yaml`);
-    writeFileSync3(filePath, yamlContent, "utf8");
+    writeFileSync4(filePath, yamlContent, "utf8");
     const skill = YAML3.parse(yamlContent);
     this.skills.set(name, skill);
     return skill;
@@ -4737,7 +5002,7 @@ var SkillRegistry = class {
       throw new Error(`Cannot delete built-in skill: ${name}`);
     }
     const filePath = join2(this.customDir, `${name}.yaml`);
-    if (existsSync7(filePath)) {
+    if (existsSync8(filePath)) {
       unlinkSync(filePath);
     }
     this.skills.delete(name);
@@ -4748,11 +5013,11 @@ var SkillRegistry = class {
 };
 
 // packages/daemon/src/HTTPServer.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
 import { serve } from "@hono/node-server";
-import { readFileSync as readFileSync8 } from "node:fs";
-import { resolve as resolve7, dirname as dirname3 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { readFileSync as readFileSync9 } from "node:fs";
+import { resolve as resolve8, dirname as dirname4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/daemon/src/routes/health.ts
 import { Hono } from "hono";
@@ -5042,8 +5307,8 @@ function memoryRoutes(deps) {
 
 // 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 { readFileSync as readFileSync8, existsSync as existsSync9 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import YAML4 from "yaml";
 function llmRoutes() {
@@ -5051,11 +5316,11 @@ function llmRoutes() {
   app.post("/ping", async (c) => {
     const start = Date.now();
     try {
-      const configPath = resolve6(homedir4(), ".0agent", "config.yaml");
-      if (!existsSync8(configPath)) {
+      const configPath = resolve7(homedir4(), ".0agent", "config.yaml");
+      if (!existsSync9(configPath)) {
         return c.json({ ok: false, error: "Config not found. Run: 0agent init" });
       }
-      const cfg = YAML4.parse(readFileSync7(configPath, "utf8"));
+      const cfg = YAML4.parse(readFileSync8(configPath, "utf8"));
       const providers = cfg.llm_providers;
       const def = providers?.find((p) => p.is_default) ?? providers?.[0];
       if (!def) {
@@ -5529,18 +5794,56 @@ function scheduleRoutes(deps) {
   return app;
 }
 
+// packages/daemon/src/routes/runtime.ts
+import { Hono as Hono13 } from "hono";
+var pendingProposals = /* @__PURE__ */ new Map();
+function runtimeRoutes(deps) {
+  const app = new Hono13();
+  app.post("/proposals", async (c) => {
+    const proposal = await c.req.json();
+    pendingProposals.set(proposal.proposal_id, {
+      proposal,
+      expires: Date.now() + 10 * 6e4
+    });
+    return c.json({ ok: true, proposal_id: proposal.proposal_id });
+  });
+  app.post("/proposals/:id/approve", async (c) => {
+    if (!deps.healer) return c.json({ ok: false, error: "Self-heal not available" }, 503);
+    const id = c.req.param("id");
+    const entry = pendingProposals.get(id);
+    if (!entry) return c.json({ ok: false, error: "Proposal not found or expired" }, 404);
+    if (Date.now() > entry.expires) {
+      pendingProposals.delete(id);
+      return c.json({ ok: false, error: "Proposal expired" }, 410);
+    }
+    pendingProposals.delete(id);
+    const result = await deps.healer.applyPatch(entry.proposal);
+    return c.json(result);
+  });
+  app.delete("/proposals/:id", (c) => {
+    pendingProposals.delete(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  app.get("/proposals", (c) => {
+    const now = Date.now();
+    const active = [...pendingProposals.entries()].filter(([, v]) => v.expires > now).map(([, v]) => v.proposal);
+    return c.json(active);
+  });
+  return app;
+}
+
 // packages/daemon/src/HTTPServer.ts
 function findGraphHtml() {
   const candidates = [
-    resolve7(dirname3(fileURLToPath(import.meta.url)), "graph.html"),
+    resolve8(dirname4(fileURLToPath2(import.meta.url)), "graph.html"),
     // dev (src/)
-    resolve7(dirname3(fileURLToPath(import.meta.url)), "..", "graph.html"),
+    resolve8(dirname4(fileURLToPath2(import.meta.url)), "..", "graph.html"),
     // bundled (dist/../)
-    resolve7(dirname3(fileURLToPath(import.meta.url)), "..", "dist", "graph.html")
+    resolve8(dirname4(fileURLToPath2(import.meta.url)), "..", "dist", "graph.html")
   ];
   for (const p of candidates) {
     try {
-      readFileSync8(p);
+      readFileSync9(p);
       return p;
     } catch {
     }
@@ -5554,7 +5857,7 @@ var HTTPServer = class {
   deps;
   constructor(deps) {
     this.deps = deps;
-    this.app = new Hono13();
+    this.app = new Hono14();
     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 }));
@@ -5566,13 +5869,14 @@ var HTTPServer = class {
     this.app.route("/api/memory", memoryRoutes({ getSync: deps.getMemorySync ?? (() => null) }));
     this.app.route("/api/llm", llmRoutes());
     this.app.route("/api/schedule", scheduleRoutes({ scheduler: deps.scheduler ?? null }));
+    this.app.route("/api/runtime", runtimeRoutes({ healer: deps.healer ?? null }));
     this.app.route("/api/codespace", codespaceRoutes({
       getManager: deps.getCodespaceManager ?? (() => null),
       setup: deps.setupCodespace ?? (async () => ({ started: false, error: "Not configured" }))
     }));
     const serveGraph = (c) => {
       try {
-        const html = readFileSync8(GRAPH_HTML_PATH, "utf8");
+        const html = readFileSync9(GRAPH_HTML_PATH, "utf8");
         return c.html(html);
       } catch {
         return c.html("<p>Graph UI not found. Run: pnpm build</p>");
@@ -5582,7 +5886,7 @@ var HTTPServer = class {
     this.app.get("/graph", serveGraph);
   }
   start() {
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       this.server = serve(
         {
           fetch: this.app.fetch,
@@ -5590,20 +5894,20 @@ var HTTPServer = class {
           hostname: this.deps.host
         },
         () => {
-          resolve14();
+          resolve15();
         }
       );
     });
   }
   stop() {
-    return new Promise((resolve14, reject) => {
+    return new Promise((resolve15, reject) => {
       if (!this.server) {
-        resolve14();
+        resolve15();
         return;
       }
       this.server.close((err) => {
         if (err) reject(err);
-        else resolve14();
+        else resolve15();
       });
     });
   }
@@ -5614,11 +5918,11 @@ var HTTPServer = class {
 
 // packages/daemon/src/IdentityManager.ts
 init_src();
-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 { readFileSync as readFileSync10, writeFileSync as writeFileSync5, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
+import { resolve as resolve9, dirname as dirname5 } from "node:path";
 import { homedir as homedir5, hostname } from "node:os";
 import YAML5 from "yaml";
-var IDENTITY_PATH = resolve8(homedir5(), ".0agent", "identity.yaml");
+var IDENTITY_PATH = resolve9(homedir5(), ".0agent", "identity.yaml");
 var DEFAULT_IDENTITY = {
   name: "User",
   device_id: `unknown-device`,
@@ -5634,8 +5938,8 @@ var IdentityManager = class {
    * Load or create identity. Call once at daemon startup.
    */
   async init() {
-    if (existsSync9(IDENTITY_PATH)) {
-      const raw = readFileSync9(IDENTITY_PATH, "utf8");
+    if (existsSync10(IDENTITY_PATH)) {
+      const raw = readFileSync10(IDENTITY_PATH, "utf8");
       this.identity = YAML5.parse(raw);
     } else {
       this.identity = {
@@ -5686,25 +5990,25 @@ var IdentityManager = class {
     return lines.join(" ");
   }
   save() {
-    const dir = dirname4(IDENTITY_PATH);
-    if (!existsSync9(dir)) {
+    const dir = dirname5(IDENTITY_PATH);
+    if (!existsSync10(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
-    writeFileSync4(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
+    writeFileSync5(IDENTITY_PATH, YAML5.stringify(this.identity), "utf8");
   }
 };
 
 // packages/daemon/src/TeamManager.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync5 } from "node:fs";
+import { resolve as resolve10 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 import YAML6 from "yaml";
-var TEAMS_PATH = resolve9(homedir6(), ".0agent", "teams.yaml");
+var TEAMS_PATH = resolve10(homedir6(), ".0agent", "teams.yaml");
 var TeamManager = class {
   config;
   constructor() {
-    if (existsSync10(TEAMS_PATH)) {
-      this.config = YAML6.parse(readFileSync10(TEAMS_PATH, "utf8"));
+    if (existsSync11(TEAMS_PATH)) {
+      this.config = YAML6.parse(readFileSync11(TEAMS_PATH, "utf8"));
     } else {
       this.config = { memberships: [] };
     }
@@ -5759,8 +6063,8 @@ var TeamManager = class {
     }
   }
   save() {
-    mkdirSync5(resolve9(homedir6(), ".0agent"), { recursive: true });
-    writeFileSync5(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
+    mkdirSync5(resolve10(homedir6(), ".0agent"), { recursive: true });
+    writeFileSync6(TEAMS_PATH, YAML6.stringify(this.config), "utf8");
   }
 };
 
@@ -5843,8 +6147,8 @@ var TeamSync = class {
 };
 
 // packages/daemon/src/GitHubMemorySync.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync11, readdirSync as readdirSync4 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, existsSync as existsSync12, readdirSync as readdirSync4 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 var GITHUB_API = "https://api.github.com";
 async function ghFetch(path, token, opts) {
@@ -5964,10 +6268,10 @@ var GitHubMemorySync = class {
           )
         );
       }
-      const customSkillsDir = resolve10(homedir7(), ".0agent", "skills", "custom");
-      if (existsSync11(customSkillsDir)) {
+      const customSkillsDir = resolve11(homedir7(), ".0agent", "skills", "custom");
+      if (existsSync12(customSkillsDir)) {
         for (const file of readdirSync4(customSkillsDir).filter((f) => f.endsWith(".yaml"))) {
-          const content = readFileSync11(resolve10(customSkillsDir, file), "utf8");
+          const content = readFileSync12(resolve11(customSkillsDir, file), "utf8");
           pushes.push(putFile(token, owner, repo, `skills/custom/${file}`, content, commitMsg));
         }
       }
@@ -6153,7 +6457,7 @@ var GitHubMemorySync = class {
   }
   async pullCustomSkills() {
     const { token, owner, repo } = this.config;
-    const dir = resolve10(homedir7(), ".0agent", "skills", "custom");
+    const dir = resolve11(homedir7(), ".0agent", "skills", "custom");
     try {
       const res = await ghFetch(`/repos/${owner}/${repo}/contents/skills/custom`, token);
       if (!res.ok) return;
@@ -6163,7 +6467,7 @@ var GitHubMemorySync = class {
         if (content) {
           const { mkdirSync: mkdirSync7 } = await import("node:fs");
           mkdirSync7(dir, { recursive: true });
-          writeFileSync6(resolve10(dir, file.name), content, "utf8");
+          writeFileSync7(resolve11(dir, file.name), content, "utf8");
         }
       }
     } catch {
@@ -6240,7 +6544,7 @@ git checkout <commit> graph/         # restore graph files
 };
 
 // packages/daemon/src/CodespaceManager.ts
-import { execSync as execSync4, spawn as spawn3 } from "node:child_process";
+import { execSync as execSync5, spawn as spawn4 } from "node:child_process";
 var BROWSER_PORT_REMOTE = 3e3;
 var BROWSER_PORT_LOCAL = 3001;
 var DISPLAY_NAME = "0agent-browser";
@@ -6282,7 +6586,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 = execSync4(
+      const result = execSync5(
         `gh codespace create --repo "${this.memoryRepo}" --machine basicLinux32gb --display-name "${DISPLAY_NAME}" --json name`,
         { encoding: "utf8", timeout: 3e5 }
       );
@@ -6296,7 +6600,7 @@ var CodespaceManager = class {
   /** Find the 0agent-browser codespace by display name. */
   findExisting() {
     try {
-      const out = execSync4("gh codespace list --json name,state,displayName,repository", {
+      const out = execSync5("gh codespace list --json name,state,displayName,repository", {
         encoding: "utf8",
         timeout: 1e4
       });
@@ -6312,7 +6616,7 @@ var CodespaceManager = class {
     const info = this.findExisting();
     if (info?.state === "Shutdown") {
       console.log("[Codespace] Starting stopped codespace (~30s)...");
-      execSync4(`gh codespace start --codespace "${name}"`, { timeout: 12e4 });
+      execSync5(`gh codespace start --codespace "${name}"`, { timeout: 12e4 });
       await this.waitForState(name, "Available", 60);
       console.log("[Codespace] Codespace is running");
     } else if (info?.state === "Starting") {
@@ -6324,7 +6628,7 @@ var CodespaceManager = class {
   /** Start the browser server inside the codespace (idempotent). */
   async startBrowserServer(name) {
     try {
-      execSync4(
+      execSync5(
         `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 }
       );
@@ -6335,7 +6639,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 = spawn3(
+    this.forwardProcess = spawn4(
       "gh",
       ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
       { stdio: ["ignore", "ignore", "ignore"] }
@@ -6379,7 +6683,7 @@ var CodespaceManager = class {
     this.closeTunnel();
     const info = this.findExisting();
     if (info?.state === "Available") {
-      execSync4(`gh codespace stop --codespace "${info.name}"`, { timeout: 3e4 });
+      execSync5(`gh codespace stop --codespace "${info.name}"`, { timeout: 3e4 });
       console.log("[Codespace] Stopped (state preserved, restarts in 30s when needed)");
     }
   }
@@ -6388,7 +6692,7 @@ var CodespaceManager = class {
     this.closeTunnel();
     const info = this.findExisting();
     if (info) {
-      execSync4(`gh codespace delete --codespace "${info.name}" --force`, { timeout: 3e4 });
+      execSync5(`gh codespace delete --codespace "${info.name}" --force`, { timeout: 3e4 });
       console.log("[Codespace] Deleted");
     }
   }
@@ -6414,7 +6718,7 @@ var CodespaceManager = class {
   /** Check if gh CLI is installed and authenticated. */
   static isAvailable() {
     try {
-      execSync4("gh auth status", { stdio: "ignore", timeout: 5e3 });
+      execSync5("gh auth status", { stdio: "ignore", timeout: 5e3 });
       return true;
     } catch {
       return false;
@@ -6423,6 +6727,7 @@ var CodespaceManager = class {
 };
 
 // packages/daemon/src/ZeroAgentDaemon.ts
+init_RuntimeSelfHeal();
 var ZeroAgentDaemon = class {
   config = null;
   adapter = null;
@@ -6439,15 +6744,16 @@ var ZeroAgentDaemon = class {
   proactiveSurfaceInstance = null;
   codespaceManager = null;
   schedulerManager = null;
+  runtimeHealer = null;
   startedAt = 0;
   pidFilePath;
   constructor() {
-    this.pidFilePath = resolve12(homedir8(), ".0agent", "daemon.pid");
+    this.pidFilePath = resolve13(homedir8(), ".0agent", "daemon.pid");
   }
   async start(opts) {
     this.config = await loadConfig(opts?.config_path);
-    const dotDir = resolve12(homedir8(), ".0agent");
-    if (!existsSync13(dotDir)) {
+    const dotDir = resolve13(homedir8(), ".0agent");
+    if (!existsSync14(dotDir)) {
       mkdirSync6(dotDir, { recursive: true });
     }
     this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
@@ -6538,6 +6844,25 @@ var ZeroAgentDaemon = class {
       proactiveSurface = new ProactiveSurface2(this.graph, this.eventBus, cwd);
     } catch {
     }
+    if (llmExecutor?.isConfigured) {
+      this.runtimeHealer = new RuntimeSelfHeal(llmExecutor, this.eventBus);
+      process.on("uncaughtException", (err) => {
+        const stack = err.stack ?? err.message;
+        console.error("[0agent] Uncaught exception:", stack);
+        this.runtimeHealer?.analyze(stack, "daemon runtime").then((proposal) => {
+          if (proposal && this.eventBus) {
+            this.runtimeHealer?.emitProposal(proposal);
+            fetch(`http://127.0.0.1:${this.config.server.port}/api/runtime/proposals`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(proposal)
+            }).catch(() => {
+            });
+          }
+        }).catch(() => {
+        });
+      });
+    }
     this.schedulerManager = new SchedulerManager(this.adapter, this.sessionManager, this.eventBus);
     this.schedulerManager.start();
     this.backgroundWorkers = new BackgroundWorkers({
@@ -6565,6 +6890,7 @@ var ZeroAgentDaemon = class {
       proactiveSurface,
       getCodespaceManager: () => this.codespaceManager,
       scheduler: this.schedulerManager,
+      healer: this.runtimeHealer,
       setupCodespace: async () => {
         if (!this.codespaceManager) return { started: false, error: "GitHub memory not configured. Run: 0agent memory connect github" };
         try {
@@ -6576,7 +6902,7 @@ var ZeroAgentDaemon = class {
       }
     });
     await this.httpServer.start();
-    writeFileSync7(this.pidFilePath, String(process.pid), "utf8");
+    writeFileSync8(this.pidFilePath, String(process.pid), "utf8");
     console.log(
       `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
     );
@@ -6623,7 +6949,7 @@ var ZeroAgentDaemon = class {
       this.graph = null;
     }
     this.adapter = null;
-    if (existsSync13(this.pidFilePath)) {
+    if (existsSync14(this.pidFilePath)) {
       try {
         unlinkSync2(this.pidFilePath);
       } catch {
@@ -6653,11 +6979,11 @@ var ZeroAgentDaemon = class {
 };
 
 // packages/daemon/src/start.ts
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } 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)) {
+import { existsSync as existsSync15 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve14(homedir9(), ".0agent", "config.yaml");
+if (!existsSync15(CONFIG_PATH)) {
   console.error(`
   0agent is not initialised.
 

package/package.json

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