open-agents-ai 0.187.276 → 0.187.277

package/dist/index.js

@@ -269758,6 +269758,10 @@ var init_agenticRunner = __esm({
       // WO-KG-15
       _retrievalContextCache = null;
       // WO-KG-15: cache per-run
+      // Observer world-model and cohort stats
+      _observerMode = "both";
+      _worldFacts = { files: /* @__PURE__ */ new Map(), lastTest: {}, lastLists: /* @__PURE__ */ new Map() };
+      _argCohorts = /* @__PURE__ */ new Map();
       // ── WO-NC-07: Error pattern learning → pre-action guidance injection ──
       // Records error patterns (tool + error signature → learned guidance).
       // When the same tool+context is about to be called again, injects the
@@ -269839,8 +269843,10 @@ var init_agenticRunner = __esm({
           contextWindowSize: options2?.contextWindowSize ?? 0,
           personality: options2?.personality ?? PERSONALITY_PRESETS.balanced,
           personalityName: options2?.personalityName ?? "",
-          finalVarResolver: options2?.finalVarResolver ?? void 0
+          finalVarResolver: options2?.finalVarResolver ?? void 0,
+          observerMode: options2?.observerMode ?? "both"
         };
+        this._observerMode = this.options.observerMode;
       }
       /** Update context window size (e.g. after querying Ollama /api/show) */
       setContextWindowSize(size) {
@@ -270206,6 +270212,27 @@ ${body}`;
           }
         }
       }
+      /** Build a light fingerprint for arg cohort learning */
+      buildArgCohortKey(tool, args) {
+        const keys = Object.keys(args || {}).sort();
+        const parts = [tool];
+        for (const k of keys) {
+          const v = args[k];
+          if (typeof v === "string")
+            parts.push(`${k}:${v.slice(0, 64)}`);
+          else if (typeof v === "number" || typeof v === "boolean")
+            parts.push(`${k}:${String(v)}`);
+          else
+            parts.push(`${k}:${JSON.stringify(v).slice(0, 64)}`);
+        }
+        let h = 2166136261;
+        const s2 = parts.join("|");
+        for (let i2 = 0; i2 < s2.length; i2++) {
+          h ^= s2.charCodeAt(i2);
+          h = Math.imul(h, 16777619);
+        }
+        return `${tool}#${(h >>> 0).toString(16)}`;
+      }
       /** Register a tool for the agent to use */
       registerTool(tool) {
         this.tools.set(tool.name, tool);
@@ -270540,6 +270567,9 @@ TASK: ${task}` : task;
         this._hookDenyHintCount = 0;
         this._selfConsistencyVotes = 0;
         this._retrievalContextCache = null;
+        this._observerMode = this.options.observerMode ?? "both";
+        this._worldFacts = { files: /* @__PURE__ */ new Map(), lastTest: {}, lastLists: /* @__PURE__ */ new Map() };
+        this._argCohorts.clear();
         this._lastTodoWriteTurn = -1;
         this._lastTodoReminderTurn = -1;
         let pendingConstraintWarnings = [];
@@ -271114,6 +271144,14 @@ ${memoryLines.join("\n")}`
             const executeSingle = async (tc) => {
               if (this.aborted)
                 return null;
+              const cohortKey = this.buildArgCohortKey(tc.name, tc.arguments);
+              const cohort = this._argCohorts.get(cohortKey);
+              if (cohort && cohort.failure >= 3 && cohort.success === 0) {
+                this.emit({ type: "observer_reaction", timestamp: (/* @__PURE__ */ new Date()).toISOString(), observer: { class: "arg_cohort_risk", shortText: `${tc.name} with similar args has failed ${cohort.failure}× recently`, confidence: 0.85 } });
+                if (this._observerMode === "skillcoach" || this._observerMode === "both") {
+                  this.pendingUserMessages.push(`[LITTLEMAN] ${tc.name} with similar arguments has failed ${cohort.failure}× recently. Try a different approach first: read relevant files, adjust arguments, or verify prerequisites.`);
+                }
+              }
               if (this._errorPatterns.size > 0) {
                 for (const [sig, pattern] of this._errorPatterns) {
                   if (pattern.tool === tc.name && pattern.count >= 2 && !this._errorGuidanceInjected.has(sig)) {
@@ -271298,6 +271336,35 @@ ${memoryLines.join("\n")}`
                   }
                 }
               }
+              const updated = this._argCohorts.get(cohortKey) || { success: 0, failure: 0, lastOutcomeTurn: turn };
+              if (result.success)
+                updated.success++;
+              else
+                updated.failure++;
+              updated.lastOutcomeTurn = turn;
+              this._argCohorts.set(cohortKey, updated);
+              try {
+                if (tc.name === "file_read") {
+                  const p2 = String(tc.arguments?.["path"] ?? tc.arguments?.["file"] ?? "");
+                  if (p2)
+                    this._worldFacts.files.set(p2, { exists: result.success, size: (result.output || "").length, hashSample: (result.output || "").slice(0, 32), lastSeenTurn: turn });
+                } else if (tc.name === "list_directory") {
+                  const dir = String(tc.arguments?.["path"] ?? ".");
+                  this._worldFacts.lastLists.set(dir, { entriesCount: (result.output.match(/\n/g) || []).length + 1, lastSeenTurn: turn });
+                } else if (tc.name === "shell") {
+                  const cmd = String(tc.arguments?.["command"] ?? "");
+                  if (/\b(npm|pnpm|yarn)\s+test\b|\bjest\b|\bvitest\b/i.test(cmd)) {
+                    const passed = /PASS|✓\s*all/i.test(result.output) && !/FAIL|✗/i.test(result.output);
+                    this._worldFacts.lastTest = { passed, summary: result.output.slice(0, 200), turn };
+                  }
+                  if (/^cd\s+/.test(cmd)) {
+                    const m2 = cmd.match(/^cd\s+([^&;\n]+)/);
+                    if (m2)
+                      this._worldFacts.lastCwd = m2[1];
+                  }
+                }
+              } catch {
+              }
               if (this._episodeStore) {
                 try {
                   const episodeContent = result.success ? `${tc.name}: ${(result.output ?? "").slice(0, 500)}` : `${tc.name} ERROR: ${(result.error ?? result.output ?? "").slice(0, 500)}`;
@@ -273086,6 +273153,9 @@ ${trimmedNew}`;
         }
         while (this._littlemanToolOutcomes.length > 20)
           this._littlemanToolOutcomes.shift();
+        const emitReaction = (cls, shortText, confidence, details2) => {
+          this.emit({ type: "observer_reaction", timestamp: (/* @__PURE__ */ new Date()).toISOString(), observer: { class: cls, shortText, confidence, details: details2 } });
+        };
         const lastAssistant = [...recent].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
         if (lastAssistant && typeof lastAssistant.content === "string") {
           const text = lastAssistant.content.toLowerCase();
@@ -273095,9 +273165,10 @@ ${trimmedNew}`;
             const successes = recentOutcomes.filter((o2) => o2.succeeded);
             if (successes.length >= 1) {
               const successList = successes.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
-              this.pendingUserMessages.push(`[LITTLEMAN] Correction: your recent tools DID succeed. Do not retry them.
-Successful results: ${successList}
-Build on these results instead of retrying. What is your NEXT step toward the goal?`);
+              emitReaction("false_failure", `Claimed failure, but recent tools succeeded (${successes.length})`, 0.9, successList);
+              if (this._observerMode === "skillcoach" || this._observerMode === "both") {
+                this.pendingUserMessages.push(`[LITTLEMAN] Correction: recent tools DID succeed. Do not retry them. Successful results: ${successList}. Use them to advance the task.`);
+              }
               this.emit({
                 type: "status",
                 content: `Littleman: corrected false failure claim (${successes.length} tools succeeded)`,
@@ -273106,6 +273177,22 @@ Build on these results instead of retrying. What is your NEXT step toward the go
             }
           }
         }
+        if (lastAssistant && typeof lastAssistant.content === "string") {
+          const text = lastAssistant.content.toLowerCase();
+          const claimsSuccess = /(done|fixed|success|passed|complete)/i.test(text);
+          if (claimsSuccess) {
+            const recentOutcomes = this._littlemanToolOutcomes.slice(-4);
+            const failures = recentOutcomes.filter((o2) => !o2.succeeded);
+            const successes = recentOutcomes.filter((o2) => o2.succeeded);
+            if (failures.length > 0 && successes.length === 0) {
+              const failList = failures.map((o2) => `${o2.tool}: ${o2.preview.slice(0, 60)}`).join("; ");
+              emitReaction("false_success", `Claimed success, but recent tools failed (${failures.length})`, 0.9, failList);
+              if (this._observerMode === "skillcoach" || this._observerMode === "both") {
+                this.pendingUserMessages.push(`[LITTLEMAN] Your recent tools show errors (${failures.length}). Verify the last tool output and correct the issue before claiming success.`);
+              }
+            }
+          }
+        }
         const lastToolCalls = recent.filter((m2) => m2.role === "assistant" && m2.tool_calls?.length).flatMap((m2) => m2.tool_calls ?? []);
         for (const tc of lastToolCalls) {
           const name10 = tc.function.name;
@@ -273117,8 +273204,10 @@ Build on these results instead of retrying. What is your NEXT step toward the go
           const argsKey = name10 === "shell" ? String(args.command ?? "").slice(0, 60) : name10 === "web_fetch" ? String(args.url ?? "").slice(0, 80) : String(args.path ?? args.url ?? args.query ?? "").slice(0, 60);
           const prior = this._littlemanToolOutcomes.find((o2) => o2.succeeded && o2.tool === name10 && o2.preview.includes(argsKey.slice(0, 30)) && o2.turn < turn);
           if (prior) {
-            this.pendingUserMessages.push(`[LITTLEMAN] You already ran ${name10} successfully on turn ${prior.turn} with similar arguments. Result was: ${prior.preview.slice(0, 100)}
-Do NOT re-run it. Use the result you already have and proceed to the next step.`);
+            emitReaction("redundant_action", `Already ran ${name10} successfully on turn ${prior.turn}`, 0.8, prior.preview);
+            if (this._observerMode === "skillcoach" || this._observerMode === "both") {
+              this.pendingUserMessages.push(`[LITTLEMAN] You already ran ${name10} successfully on turn ${prior.turn} with similar arguments. Do NOT re-run it. Use the existing result and proceed.`);
+            }
             this.emit({
               type: "status",
               content: `Littleman: prevented redundant ${name10} call (succeeded on turn ${prior.turn})`,
@@ -273140,7 +273229,10 @@ Do NOT re-run it. Use the result you already have and proceed to the next step.`
               }
             }
             if (consecutiveShortResults >= 3) {
-              this.pendingUserMessages.push(`[LITTLEMAN] You have sent ${consecutiveShortResults} consecutive outputs without reading any input. In an interactive session, you MUST alternate: receive input, then respond, then receive again. STOP sending and call your input/listening tool NOW to hear what the other side said.`);
+              emitReaction("idle_think", `Consecutive output without input: ${consecutiveShortResults}`, 0.7);
+              if (this._observerMode === "skillcoach" || this._observerMode === "both") {
+                this.pendingUserMessages.push(`[LITTLEMAN] You have sent ${consecutiveShortResults} consecutive outputs without reading any input. Alternate: receive input, then respond. Call your input tool now.`);
+              }
               this.emit({
                 type: "status",
                 content: `Littleman: blocked runaway output (${consecutiveShortResults} consecutive sends without receive)`,

package/package.json

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