0agent 1.0.14 → 1.0.16

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.14",
+  "version": "1.0.16",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",