0agent 1.0.15 → 1.0.17

package/bin/0agent.js

@@ -94,6 +94,10 @@ switch (cmd) {
     await runServe(args.slice(1));
     break;
 
+  case 'watch':
+    await runWatch();
+    break;
+
   default:
     showHelp();
     break;
@@ -447,12 +451,12 @@ async function streamSession(sessionId) {
             break;
           case 'session.completed': {
             if (streaming) { process.stdout.write('\n'); streaming = false; }
-            // Show files written + commands run
             const r = event.result ?? {};
             if (r.files_written?.length) console.log(`\n  \x1b[32m✓\x1b[0m Files: ${r.files_written.join(', ')}`);
             if (r.commands_run?.length) console.log(`  \x1b[32m✓\x1b[0m Commands run: ${r.commands_run.length}`);
             if (r.tokens_used) console.log(`  \x1b[2m${r.tokens_used} tokens · ${r.model}\x1b[0m`);
             console.log('\n  \x1b[32m✓ Done\x1b[0m\n');
+            await showResultPreview(r);   // confirm server/file actually exists
             ws.close();
             resolve();
             break;
@@ -496,6 +500,7 @@ async function pollSession(sessionId) {
       console.log('\n  ✓ Done\n');
       const out = s.result?.output ?? s.result;
       if (out && typeof out === 'string') console.log(`  ${out}\n`);
+      await showResultPreview(s.result ?? {});
       return;
     }
     if (s.status === 'failed') {
@@ -804,6 +809,177 @@ async function waitForTunnelUrl(proc, pattern, timeout) {
   });
 }
 
+// ─── Result preview — confirms the agent's work actually ran ────────────────
+
+async function showResultPreview(result) {
+  if (!result) return;
+  const files = result.files_written ?? [];
+  const cmds  = result.commands_run  ?? [];
+  const out   = result.output        ?? '';
+
+  // 1. Server check — if a port was mentioned, verify HTTP response
+  const allText = [...cmds, out].join(' ');
+  const portMatch = allText.match(/(?:localhost:|port\s*[=:]?\s*)(\d{4,5})/i);
+  if (portMatch) {
+    const port = parseInt(portMatch[1], 10);
+    await sleep(1200); // give server a moment to bind
+    try {
+      const res = await fetch(`http://localhost:${port}/`, { signal: AbortSignal.timeout(2500) });
+      const body = await res.text();
+      const preview = body.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 120);
+      console.log(`  \x1b[32m⬡ Confirmed live:\x1b[0m http://localhost:${port} (HTTP ${res.status})`);
+      if (preview) console.log(`  \x1b[2m${preview}\x1b[0m`);
+    } catch {
+      // Server not up yet — non-fatal, ExecutionVerifier already handled this
+    }
+  }
+
+  // 2. File preview — show first few lines of the most significant created file
+  if (files.length > 0) {
+    const mainFile = files.find(f => /\.(html|jsx?|tsx?|py|rs|go|md|css|json)$/.test(f)) ?? files[0];
+    try {
+      const { readFileSync } = await import('node:fs');
+      const { resolve: res } = await import('node:path');
+      const fullPath = res(process.env['ZEROAGENT_CWD'] ?? process.cwd(), mainFile);
+      const content  = readFileSync(fullPath, 'utf8');
+      const lines    = content.split('\n').slice(0, 6).join('\n');
+      console.log(`\n  \x1b[2m── ${mainFile} ─────────────────────────────────\x1b[0m`);
+      console.log(`  \x1b[2m${lines}\x1b[0m`);
+      if (content.split('\n').length > 6) console.log(`  \x1b[2m...\x1b[0m`);
+    } catch {}
+  }
+
+  console.log();
+}
+
+// ─── Watch mode — ambient intelligence ──────────────────────────────────────
+
+async function runWatch() {
+  // Ensure daemon is running (auto-starts if needed)
+  await requireDaemon();
+
+  const { basename } = await import('node:path');
+  const cwdName = basename(process.cwd());
+
+  // Header
+  console.log(`\n  \x1b[1m0agent\x1b[0m watching \x1b[36m${cwdName}\x1b[0m`);
+  console.log(`  ${'─'.repeat(42)}`);
+
+  // Show current graph state
+  try {
+    const h = await fetch(`${BASE_URL}/api/health`).then(r => r.json()).catch(() => null);
+    if (h) {
+      console.log(`  Graph:  ${h.graph_nodes ?? 0} nodes · ${h.graph_edges ?? 0} edges`);
+      console.log(`  Uptime: ${Math.round((h.uptime_ms ?? 0) / 60000)}m · Sandbox: ${h.sandbox_backend ?? '—'}`);
+    }
+  } catch {}
+
+  // Show any unseen insights immediately
+  try {
+    const insights = await fetch(`${BASE_URL}/api/insights?seen=false`).then(r => r.json()).catch(() => []);
+    if (Array.isArray(insights) && insights.length > 0) {
+      console.log(`\n  \x1b[33m${insights.length} unseen insight${insights.length > 1 ? 's' : ''}:\x1b[0m`);
+      for (const ins of insights.slice(0, 3)) {
+        const icon = ins.type === 'test_failure' ? '\x1b[31m●\x1b[0m' : ins.type === 'git_anomaly' ? '\x1b[33m⚡\x1b[0m' : '\x1b[36m◆\x1b[0m';
+        console.log(`  ${icon} ${ins.summary}`);
+        if (ins.suggested_action) console.log(`    \x1b[2m→ ${ins.suggested_action}\x1b[0m`);
+      }
+    } else {
+      console.log(`\n  Watching for insights...`);
+    }
+  } catch {}
+
+  console.log(`\n  \x1b[2mPress Enter to run suggested action · q to quit\x1b[0m\n`);
+
+  // Connect WebSocket for live events
+  const WS = await importWS();
+  let lastSuggestion = null;
+  let ws;
+
+  const connect = () => {
+    ws = new WS(`ws://localhost:4200/ws`);
+
+    ws.on('open', () => {
+      ws.send(JSON.stringify({ type: 'subscribe', topics: ['sessions', 'graph', 'insights', 'stats'] }));
+    });
+
+    ws.on('message', (data) => {
+      try {
+        const event = JSON.parse(data.toString());
+        const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+
+        switch (event.type) {
+          case 'agent.insight': {
+            const ins = event.insight ?? {};
+            const icon = ins.type === 'test_failure' ? '\x1b[31m● test\x1b[0m'
+              : ins.type === 'git_anomaly'   ? '\x1b[33m⚡ git\x1b[0m'
+              : '\x1b[36m◆ insight\x1b[0m';
+            console.log(`  [${ts}] ${icon}  ${ins.summary}`);
+            if (ins.suggested_action) {
+              console.log(`          \x1b[36m→ ${ins.suggested_action}\x1b[0m`);
+              lastSuggestion = ins.suggested_action;
+            }
+            break;
+          }
+          case 'session.completed':
+            console.log(`  [${ts}] \x1b[32m✓\x1b[0m  Session completed`);
+            break;
+          case 'session.failed':
+            console.log(`  [${ts}] \x1b[31m✗\x1b[0m  Session failed: ${event.error}`);
+            break;
+          case 'graph.weight_updated':
+            // Subtle learning indicator — one dot per weight change
+            process.stdout.write('\x1b[2m·\x1b[0m');
+            break;
+          case 'team.synced':
+            console.log(`  [${ts}] \x1b[35m⬡\x1b[0m  Team synced (↑${event.deltas_pushed ?? 0} ↓${event.deltas_pulled ?? 0})`);
+            break;
+        }
+      } catch {}
+    });
+
+    ws.on('error', () => {});
+    ws.on('close', () => {
+      setTimeout(connect, 3000); // reconnect on daemon restart
+    });
+  };
+
+  connect();
+
+  // Keyboard handling — Enter = act, q = quit
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', async (key) => {
+      if (key === '\u0003' || key === 'q') { // Ctrl+C or q
+        process.stdout.write('\n');
+        ws?.close();
+        process.stdin.setRawMode(false);
+        process.exit(0);
+      }
+      if (key === '\r' && lastSuggestion) {
+        // Extract executable part from suggestion
+        const cmd = lastSuggestion.match(/(?:0agent\s+)?(\/?[\w-]+(?:\s+"[^"]*")?)/);
+        if (cmd) {
+          process.stdout.write('\n');
+          const parts = cmd[1].trim().split(/\s+/);
+          if (parts[0].startsWith('/')) {
+            await runSkill(parts[0].slice(1), parts.slice(1));
+          } else if (parts[0] === 'run' || !['start','stop','init','chat'].includes(parts[0])) {
+            await runTask(parts[0] === 'run' ? parts.slice(1) : parts);
+          }
+          lastSuggestion = null;
+        }
+      }
+    });
+  } else {
+    // Non-interactive: just watch, no keyboard
+    process.on('SIGINT', () => { ws?.close(); process.exit(0); });
+    await new Promise(() => {}); // run forever
+  }
+}
+
 function showHelp() {
   console.log(`
   0agent — An agent that learns.
@@ -838,6 +1014,10 @@ function showHelp() {
     0agent /build --task next
     0agent /qa --url https://staging.myapp.com
     0agent serve --tunnel          # then share the URL + 0agent team join <CODE>
+    0agent watch                   # ambient mode — live insights, press Enter to act
+
+  Auto-start:
+    The daemon auto-starts on first 0agent run. No need for 0agent start.
 `);
 }
 
@@ -853,10 +1033,46 @@ async function isDaemonRunning() {
 }
 
 async function requireDaemon() {
-  if (!(await isDaemonRunning())) {
-    console.log('\n  Daemon is not running. Start it with: 0agent start\n');
+  if (await isDaemonRunning()) return;
+
+  // Auto-start if config exists — no manual `0agent start` needed
+  if (!existsSync(CONFIG_PATH)) {
+    console.log('\n  Not initialised. Run: 0agent init\n');
     process.exit(1);
   }
+
+  process.stdout.write('  Starting daemon');
+  await _startDaemonBackground();
+
+  for (let i = 0; i < 24; i++) {
+    await sleep(500);
+    process.stdout.write('.');
+    if (await isDaemonRunning()) {
+      process.stdout.write(' ✓\n\n');
+      return;
+    }
+  }
+  process.stdout.write(' ✗\n');
+  console.log('  Daemon failed to start. Check: 0agent logs\n');
+  process.exit(1);
+}
+
+// Internal: spawn daemon process without printing the full startup banner
+async function _startDaemonBackground() {
+  const { resolve: res, dirname: dn, existsSync: ex } = await import('node:path').then(m => m);
+  const pkgRoot   = res(dn(new URL(import.meta.url).pathname), '..');
+  const bundled   = res(pkgRoot, 'dist', 'daemon.mjs');
+  const devPath   = res(pkgRoot, 'packages', 'daemon', 'dist', 'start.js');
+  const script    = ex(bundled) ? bundled : devPath;
+  if (!ex(script)) return;
+
+  mkdirSync(resolve(AGENT_DIR, 'logs'), { recursive: true });
+  const child = spawn(process.execPath, [script], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, ZEROAGENT_CONFIG: CONFIG_PATH },
+  });
+  child.unref();
 }
 
 async function importWS() {

package/dist/daemon.mjs

@@ -989,9 +989,24 @@ var init_TraceStore = __esm({
 });
 
 // packages/core/src/storage/WeightEventLog.ts
+var WeightEventLog;
 var init_WeightEventLog = __esm({
   "packages/core/src/storage/WeightEventLog.ts"() {
     "use strict";
+    WeightEventLog = class {
+      constructor(adapter) {
+        this.adapter = adapter;
+      }
+      append(event) {
+        this.adapter.insertWeightEvent(event);
+      }
+      getByEdge(edgeId) {
+        return this.adapter.getWeightEvents(edgeId);
+      }
+      getByTrace(traceId) {
+        return this.adapter.getWeightEventsByTrace(traceId);
+      }
+    };
   }
 });
 
@@ -1426,9 +1441,58 @@ var init_ArchivalMemory = __esm({
 });
 
 // packages/core/src/concurrency/EdgeWeightUpdater.ts
+var EdgeWeightUpdater;
 var init_EdgeWeightUpdater = __esm({
   "packages/core/src/concurrency/EdgeWeightUpdater.ts"() {
     "use strict";
+    EdgeWeightUpdater = class {
+      constructor(adapter, weightLog) {
+        this.adapter = adapter;
+        this.weightLog = weightLog;
+      }
+      /**
+       * Update edge weight with optimistic concurrency control.
+       * Retries up to 3 times with exponential backoff (1ms, 2ms, 4ms).
+       * On 3rd failure: LWW (last-write-wins) fallback.
+       */
+      async update(edgeId, expectedWeight, newWeight, reason, traceId) {
+        const delays = [1, 2, 4];
+        let currentExpected = expectedWeight;
+        for (let attempt = 0; attempt <= 2; attempt++) {
+          const success = this.adapter.updateEdgeWeight(edgeId, newWeight, currentExpected);
+          if (success) {
+            this.logEvent(edgeId, currentExpected, newWeight, reason, traceId);
+            return true;
+          }
+          const edge = this.adapter.getEdge(edgeId);
+          if (!edge) return false;
+          currentExpected = edge.weight;
+          if (attempt < 2) {
+            await this.sleep(delays[attempt]);
+          }
+        }
+        console.warn(`OCC conflict on edge ${edgeId} after 3 retries \u2014 LWW fallback`);
+        this.adapter.forceUpdateEdgeWeight(edgeId, newWeight);
+        this.logEvent(edgeId, currentExpected, newWeight, `${reason}:lww_fallback`, traceId);
+        return true;
+      }
+      logEvent(edgeId, oldWeight, newWeight, reason, traceId) {
+        const event = {
+          id: crypto.randomUUID(),
+          edge_id: edgeId,
+          old_weight: oldWeight,
+          new_weight: newWeight,
+          delta: newWeight - oldWeight,
+          reason,
+          trace_id: traceId ?? null,
+          created_at: Date.now()
+        };
+        this.weightLog.append(event);
+      }
+      sleep(ms) {
+        return new Promise((resolve11) => setTimeout(resolve11, ms));
+      }
+    };
   }
 });
 
@@ -3166,6 +3230,9 @@ ${issues}`);
   return result.data;
 }
 
+// packages/daemon/src/SessionManager.ts
+init_src();
+
 // packages/daemon/src/EntityScopedContext.ts
 init_src();
 var EntityScopedContextLoader = class {
@@ -3501,6 +3568,61 @@ var ProjectScanner = class {
   }
 };
 
+// packages/daemon/src/ConversationStore.ts
+var CREATE_TABLE = `
+  CREATE TABLE IF NOT EXISTS conversations (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    user_entity_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_conv_user ON conversations(user_entity_id, created_at);
+`;
+var ConversationStore = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  initialised = false;
+  init() {
+    if (this.initialised) return;
+    this.adapter.db.exec(CREATE_TABLE);
+    this.initialised = true;
+  }
+  append(msg) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare(
+      `INSERT INTO conversations (id, session_id, user_entity_id, role, content, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(msg.id, msg.session_id, msg.user_entity_id, msg.role, msg.content, msg.created_at);
+  }
+  getHistory(userEntityId, limit = 20) {
+    this.init();
+    const db = this.adapter.db;
+    const rows = db.prepare(
+      `SELECT * FROM conversations WHERE user_entity_id = ?
+       ORDER BY created_at DESC LIMIT ?`
+    ).all(userEntityId, limit);
+    return rows.reverse();
+  }
+  /**
+   * Build conversation history as LLM messages for context injection.
+   */
+  buildContextMessages(userEntityId, limit = 10) {
+    return this.getHistory(userEntityId, limit).map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+  }
+  clearHistory(userEntityId) {
+    this.init();
+    const db = this.adapter.db;
+    db.prepare(`DELETE FROM conversations WHERE user_entity_id = ?`).run(userEntityId);
+  }
+};
+
 // packages/daemon/src/SessionManager.ts
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
@@ -3511,6 +3633,8 @@ var SessionManager = class {
   cwd;
   identity;
   projectContext;
+  conversationStore;
+  weightUpdater;
   anthropicFetcher = new AnthropicSkillFetcher();
   constructor(deps = {}) {
     this.inferenceEngine = deps.inferenceEngine;
@@ -3520,6 +3644,12 @@ var SessionManager = class {
     this.cwd = deps.cwd ?? process.cwd();
     this.identity = deps.identity;
     this.projectContext = deps.projectContext;
+    if (deps.adapter) {
+      this.conversationStore = new ConversationStore(deps.adapter);
+      this.conversationStore.init();
+      const wLog = new WeightEventLog(deps.adapter);
+      this.weightUpdater = new EdgeWeightUpdater(deps.adapter, wLog);
+    }
   }
   /**
    * Create a new session with status 'pending'.
@@ -3707,9 +3837,22 @@ var SessionManager = class {
         );
         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;
+        const userEntityId = enrichedReq.entity_id ?? this.identity?.entity_node_id;
+        let conversationHistory;
+        if (this.conversationStore && userEntityId) {
+          const history = this.conversationStore.buildContextMessages(userEntityId, 8);
+          if (history.length > 0) {
+            const historyStr = history.map((m) => `${m.role === "user" ? "User" : "Agent"}: ${m.content.slice(0, 400)}`).join("\n");
+            conversationHistory = `CONVERSATION HISTORY (use this for context on follow-up requests):
+${historyStr}
+
+Current task:`;
+          }
+        }
         const systemContext = [
           identityContext,
           projectCtx,
+          conversationHistory,
           anthropicContext,
           enrichedReq.context?.system_context ? String(enrichedReq.context.system_context) : void 0
         ].filter(Boolean).join("\n\n") || void 0;
@@ -3726,6 +3869,49 @@ var SessionManager = class {
         } 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(),
+            session_id: sessionId,
+            user_entity_id: userEntityId,
+            role: "user",
+            content: enrichedReq.task,
+            created_at: now
+          });
+          this.conversationStore.append({
+            id: crypto.randomUUID(),
+            session_id: sessionId,
+            user_entity_id: userEntityId,
+            role: "assistant",
+            content: agentResult.output.slice(0, 1e3),
+            // cap stored output length
+            created_at: now + 1
+          });
+        }
+        const selectedEdgeId = session.plan?.selected_edge?.edge_id;
+        if (selectedEdgeId && this.weightUpdater && this.graph) {
+          const outcomeSignal = this.computeOutcomeSignal(agentResult);
+          if (outcomeSignal !== 0) {
+            const edge = this.graph.getEdge(selectedEdgeId);
+            if (edge && !edge.locked) {
+              const newWeight = Math.max(0, Math.min(
+                1,
+                edge.weight + outcomeSignal * 0.1
+                // learning rate 0.1
+              ));
+              await this.weightUpdater.update(
+                edge.id,
+                edge.weight,
+                newWeight,
+                outcomeSignal > 0 ? "task_outcome_positive" : "task_outcome_negative",
+                session.id
+              );
+              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(", ")}`);
         }
@@ -3774,6 +3960,23 @@ var SessionManager = class {
       this.eventBus.emit(event);
     }
   }
+  /**
+   * Convert a task result into a weight signal for the knowledge graph.
+   *
+   * Signal scale: -0.3 (failed after retries) to +0.3 (verified success first try).
+   * Neutral (0) when no verification was possible — don't penalise unverifiable tasks.
+   */
+  computeOutcomeSignal(result) {
+    const healAttempts = result["heal_attempts"];
+    if (!healAttempts || healAttempts.length === 0) return 0;
+    const last = healAttempts[healAttempts.length - 1];
+    const verification = last?.["verification"];
+    if (!verification || verification["method"] === "none") return 0;
+    const success = verification["success"] === true;
+    const healed = result["healed"] === true;
+    if (success) return healed ? 0.1 : 0.3;
+    return -0.2;
+  }
 };
 
 // packages/daemon/src/WebSocketEvents.ts
@@ -5013,7 +5216,9 @@ var ZeroAgentDaemon = class {
       llm: llmExecutor,
       cwd,
       identity: identity ?? void 0,
-      projectContext: projectContext ?? void 0
+      projectContext: projectContext ?? void 0,
+      adapter: this.adapter
+      // enables ConversationStore + weight feedback
     });
     const teamSync = identity && teams.length > 0 ? new TeamSync(teamManager, this.adapter, identity.entity_node_id) : null;
     let proactiveSurface = null;

package/package.json

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