open-agents-ai 0.138.72 → 0.138.74

package/README.md

@@ -1,15 +1,3 @@
-<p align="center">
-<pre align="center">
-  ██████╗  █████╗
- ██╔═══██╗██╔══██╗    ░▒▓█▓▒░   ░▒▓▓▒░  ░▒▓▓▒░
- ██║   ██║███████║     ░▒▓█▓▒░▒▓▓▒░▒▓▓▒░▒▓▓▒░
- ██║   ██║██╔══██║      ░▒▓█▓▒░▒▓▓▒░░▒▓▓▒░
- ╚██████╔╝██║  ██║       ░▒▓▓▒░▒▓▓▒░▒▓▓▒░
-  ╚═════╝ ╚═╝  ╚═╝        ░▒▓▓▒░░▒▓▓▒░
-  /help  /voice  /cohere  /model
-</pre>
-</p>
-
 <h1 align="center">Open Agents</h1>
 
 <p align="center">

package/dist/index.js

@@ -12915,7 +12915,48 @@ ${issues.map((i) => `  - ${i}`).join("\n")}` : "  No issues found."),
         const top = items.slice(0, k);
         if (top.length === 0)
           return "";
-        return top.map((m) => `- [${m.type}] ${m.content.slice(0, 200)} (confidence: ${m.scores.confidence.toFixed(2)}, utility: ${m.scores.utility.toFixed(2)})`).join("\n");
+        return top.map((m) => `- [${m.type}][${m.id}] ${m.content.slice(0, 200)} (confidence: ${m.scores.confidence.toFixed(2)}, utility: ${m.scores.utility.toFixed(2)})`).join("\n");
+      }
+      // ── Outcome-weighted feedback (WO-FL5) ───────────────────────────────
+      // Per ExpeL (arXiv:2308.10144): contrastive learning from success/failure.
+      // Per MemRL (arXiv:2601.03192): environmental feedback > text similarity.
+      /** Update memory scores based on task outcome. Called after task completion.
+       *  Memories used in successful tasks get boosted. Memories present during failures get decayed. */
+      updateFromOutcomeSync(surfacedMemoryText, succeeded) {
+        const { readFileSync: readFileSync33, writeFileSync: writeFileSync20, existsSync: existsSync45, mkdirSync: mkdirSync21 } = __require("node:fs");
+        const metaDir = join21(this.cwd, ".oa", "memory", "metabolism");
+        const storeFile = join21(metaDir, "store.json");
+        if (!existsSync45(storeFile))
+          return;
+        let store = [];
+        try {
+          store = JSON.parse(readFileSync33(storeFile, "utf8"));
+        } catch {
+          return;
+        }
+        const idMatches = surfacedMemoryText.match(/\[(mem-[a-zA-Z0-9-]+)\]/g);
+        if (!idMatches || idMatches.length === 0)
+          return;
+        const surfacedIds = new Set(idMatches.map((m) => m.slice(1, -1)));
+        let updated = false;
+        for (const item of store) {
+          if (!surfacedIds.has(item.id))
+            continue;
+          item.accessCount++;
+          item.lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (succeeded) {
+            item.scores.utility = Math.min(1, item.scores.utility + 0.1);
+            item.scores.confidence = Math.min(1, item.scores.confidence + 0.05);
+          } else {
+            item.scores.utility = Math.max(0, item.scores.utility - 0.05);
+            item.scores.confidence = Math.max(0, item.scores.confidence - 0.02);
+          }
+          updated = true;
+        }
+        if (updated) {
+          mkdirSync21(metaDir, { recursive: true });
+          writeFileSync20(storeFile, JSON.stringify(store, null, 2));
+        }
       }
       // ── Storage ──────────────────────────────────────────────────────────
       async loadStore(dir) {
@@ -13332,6 +13373,58 @@ Recommendation: Strategy ${scored[0].index + 1} scores highest.`;
           return [];
         }
       }
+      // ── Sync retrieval for context injection (WO-FL4) ─────────────────────
+      // Per EvoSkill (arXiv:2603.02766): retrieve relevant strategies from archive.
+      /** Retrieve top-K strategies for context injection. Returns "" if none. */
+      getRelevantStrategiesSync(k = 3, taskType) {
+        const { readFileSync: readFileSync33, existsSync: existsSync45 } = __require("node:fs");
+        const archiveFile = join23(this.cwd, ".oa", "arche", "variants.json");
+        if (!existsSync45(archiveFile))
+          return "";
+        let variants = [];
+        try {
+          variants = JSON.parse(readFileSync33(archiveFile, "utf8"));
+        } catch {
+          return "";
+        }
+        if (variants.length === 0)
+          return "";
+        let filtered = variants;
+        if (taskType) {
+          const typeMatch = filtered.filter((v) => v.tags.some((t) => t.toLowerCase().includes(taskType.toLowerCase())));
+          if (typeMatch.length > 0)
+            filtered = typeMatch;
+        }
+        filtered.sort((a, b) => b.confidence * (1 + b.reuse_count * 0.1) - a.confidence * (1 + a.reuse_count * 0.1));
+        const top = filtered.slice(0, k);
+        return top.map((v) => `- [${v.outcome.includes("success") || v.outcome.includes("pass") ? "SUCCESS" : "FAILURE"}] ${v.strategy.slice(0, 200)} (confidence: ${v.confidence.toFixed(2)})`).join("\n");
+      }
+      /** Archive a strategy variant synchronously (for task completion path) */
+      archiveVariantSync(strategy, outcome, tags = []) {
+        const { readFileSync: readFileSync33, writeFileSync: writeFileSync20, existsSync: existsSync45, mkdirSync: mkdirSync21 } = __require("node:fs");
+        const dir = join23(this.cwd, ".oa", "arche");
+        const archiveFile = join23(dir, "variants.json");
+        let variants = [];
+        try {
+          if (existsSync45(archiveFile))
+            variants = JSON.parse(readFileSync33(archiveFile, "utf8"));
+        } catch {
+        }
+        variants.push({
+          id: `var-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+          strategy: strategy.slice(0, 500),
+          context: "",
+          outcome: outcome.slice(0, 200),
+          confidence: /success|pass|complete|fixed/i.test(outcome) ? 0.75 : 0.3,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          reuse_count: 0,
+          tags: tags.length > 0 ? tags : this.extractTags(strategy)
+        });
+        if (variants.length > 50)
+          variants = variants.slice(-50);
+        mkdirSync21(dir, { recursive: true });
+        writeFileSync20(archiveFile, JSON.stringify(variants, null, 2));
+      }
       async saveArchive(variants) {
         const dir = join23(this.cwd, ".oa", "arche");
         await mkdir8(dir, { recursive: true });
@@ -54143,6 +54236,32 @@ ${metabolismMemories}
     }
   } catch {
   }
+  try {
+    const archeFile = join59(repoRoot, ".oa", "arche", "variants.json");
+    if (existsSync43(archeFile)) {
+      const variants = JSON.parse(readFileSync32(archeFile, "utf8"));
+      if (variants.length > 0) {
+        let filtered = variants;
+        if (taskType) {
+          const typeMatch = filtered.filter((v) => v.tags?.some((t) => t.toLowerCase().includes(taskType.toLowerCase())));
+          if (typeMatch.length > 0)
+            filtered = typeMatch;
+        }
+        filtered.sort((a, b) => (b.confidence || 0) - (a.confidence || 0));
+        const top = filtered.slice(0, 3);
+        if (top.length > 0) {
+          const lines = top.map((v) => `- [${v.outcome?.includes("success") ? "OK" : "FAIL"}] ${(v.strategy || "").slice(0, 150)}`);
+          dynamicContext += `
+
+<strategy-archive>
+Past strategies (COHERE Exploration Archive):
+${lines.join("\n")}
+</strategy-archive>`;
+        }
+      }
+    }
+  } catch {
+  }
   if (taskType && modelTier !== "small") {
     dynamicContext += "\n\n" + buildTaskContext(taskType);
   }
@@ -54922,7 +55041,6 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
               version_history: [{ version: 1, change: "Initial identity creation", timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
             };
           }
-          console.error("[IK-DEBUG] Creating/updating identity at", ikFile, "exists:", existsSync43(ikFile));
           const event = `Task completed: ${result.summary.slice(0, 200)}`;
           if (/success|pass|complete|done|fixed/i.test(event)) {
             ikState.homeostasis.uncertainty = Math.max(0, ikState.homeostasis.uncertainty - 0.1);
@@ -57845,7 +57963,7 @@ async function runWithTUI(task, config, repoPath) {
   renderUserMessage(task);
   try {
     const handle = startTask(task, config, repoRoot);
-    const result = await handle.promise;
+    await handle.promise;
     try {
       const ikDir = join59(repoRoot, ".oa", "identity");
       const ikFile = join59(ikDir, "self-state.json");
@@ -57871,24 +57989,62 @@ async function runWithTUI(task, config, repoPath) {
           version_history: [{ version: 1, change: "Initial identity creation", timestamp: (/* @__PURE__ */ new Date()).toISOString() }]
         };
       }
-      const completed = result && result.completed;
-      if (completed) {
-        ikState.homeostasis.uncertainty = Math.max(0, ikState.homeostasis.uncertainty - 0.1);
-        ikState.homeostasis.coherence = Math.min(1, ikState.homeostasis.coherence + 0.05);
-      } else {
-        ikState.homeostasis.uncertainty = Math.min(1, ikState.homeostasis.uncertainty + 0.1);
-        ikState.homeostasis.coherence = Math.max(0, ikState.homeostasis.coherence - 0.05);
-      }
+      ikState.homeostasis.uncertainty = Math.max(0, ikState.homeostasis.uncertainty - 0.1);
+      ikState.homeostasis.coherence = Math.min(1, ikState.homeostasis.coherence + 0.05);
       ikState.session_count = (ikState.session_count || 0) + 1;
       ikState.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-      process.stderr.write(`[identity] WRITING to ${ikFile}
-`);
       writeFileSync18(ikFile, JSON.stringify(ikState, null, 2));
-      process.stderr.write(`[identity] WRITTEN successfully
-`);
     } catch (ikErr) {
-      process.stderr.write(`[identity] ERROR: ${ikErr}
-`);
+    }
+    try {
+      const { ExplorationCultureTool: ExplorationCultureTool2 } = __require("@open-agents/execution");
+      const ec = new ExplorationCultureTool2(repoRoot);
+      ec.archiveVariantSync(`Task: ${task.slice(0, 200)}`, "success \u2014 completed", ["general"]);
+    } catch {
+      try {
+        const archeDir = join59(repoRoot, ".oa", "arche");
+        const archeFile = join59(archeDir, "variants.json");
+        let variants = [];
+        try {
+          if (existsSync43(archeFile))
+            variants = JSON.parse(readFileSync32(archeFile, "utf8"));
+        } catch {
+        }
+        variants.push({
+          id: `var-${Date.now().toString(36)}`,
+          strategy: `Task: ${task.slice(0, 300)}`,
+          context: "",
+          outcome: "success \u2014 completed",
+          confidence: 0.75,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          reuse_count: 0,
+          tags: ["general"]
+        });
+        if (variants.length > 50)
+          variants = variants.slice(-50);
+        mkdirSync19(archeDir, { recursive: true });
+        writeFileSync18(archeFile, JSON.stringify(variants, null, 2));
+      } catch {
+      }
+    }
+    try {
+      const metaFile = join59(repoRoot, ".oa", "memory", "metabolism", "store.json");
+      if (existsSync43(metaFile)) {
+        const store = JSON.parse(readFileSync32(metaFile, "utf8"));
+        const surfaced = store.filter((m) => m.type !== "quarantine" && m.scores?.confidence > 0.15).sort((a, b) => b.scores.utility * b.scores.confidence - a.scores.utility * a.scores.confidence).slice(0, 5);
+        let updated = false;
+        for (const item of surfaced) {
+          item.accessCount = (item.accessCount || 0) + 1;
+          item.lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
+          item.scores.utility = Math.min(1, (item.scores.utility || 0.5) + 0.1);
+          item.scores.confidence = Math.min(1, (item.scores.confidence || 0.5) + 0.05);
+          updated = true;
+        }
+        if (updated) {
+          writeFileSync18(metaFile, JSON.stringify(store, null, 2));
+        }
+      }
+    } catch {
     }
   } catch (err) {
     renderError(err instanceof Error ? err.message : String(err));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.138.72",
+  "version": "0.138.74",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",