open-agents-ai 0.187.508 → 0.187.509

package/dist/index.js

@@ -523505,13 +523505,7 @@ function checkMutateMtimeDelta(intent, cwd4, ctx3, _result) {
       bestNewest = auxNewest;
   }
   if (bestNewest <= 0) {
-    return {
-      trustworthy: false,
-      syntheticError: `Command (${intent.verb}) reported success but ${cwd4} contains no files. The action either didn't run or had no effect.`,
-      intentBucket: bucket,
-      outcomeClass: "broken",
-      detail: "no files under cwd after mutate intent"
-    };
+    return { trustworthy: true, intentBucket: bucket, outcomeClass: "unknown", detail: "empty cwd — verifier abstaining" };
   }
   if (bestNewest < ctx3.startedAt - MTIME_GRACE_MS) {
     const ageSec = Math.round(((ctx3.now ? ctx3.now() : Date.now()) - bestNewest) / 1e3);
@@ -523918,6 +523912,248 @@ var init_postActionVerifier = __esm({
   }
 });
 
+// packages/orchestrator/dist/errorClusterTracker.js
+var errorClusterTracker_exports = {};
+__export(errorClusterTracker_exports, {
+  ErrorClusterTracker: () => ErrorClusterTracker,
+  parseErrors: () => parseErrors
+});
+function parseErrors(output) {
+  if (!output || typeof output !== "string")
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const { re, build } of ERROR_PATTERNS) {
+    re.lastIndex = 0;
+    let m2;
+    while ((m2 = re.exec(output)) !== null) {
+      const err = build(m2);
+      if (!err)
+        continue;
+      const key = `${err.file}|${err.line ?? ""}|${err.col ?? ""}|${err.code}|${err.message.slice(0, 32)}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      out.push(err);
+    }
+  }
+  return out;
+}
+function clusterKey(scope, file, code8) {
+  return `${scope}\0${file}\0${code8}`;
+}
+function parseClusterKey(key) {
+  const parts = key.split("\0");
+  return { file: parts[1] ?? "", code: parts[2] ?? "" };
+}
+function shortFile(p2) {
+  const parts = p2.split("/");
+  return parts.length <= 2 ? p2 : `…/${parts.slice(-2).join("/")}`;
+}
+function formatStagnantLine(c9, critical) {
+  const codeLabel = c9.key.code ? `× ${c9.key.code}` : "× errors";
+  const tag = critical ? "STAGNANT-CRIT" : "STAGNANT";
+  return `${tag}: ${shortFile(c9.key.file)} ${c9.count}${codeLabel} unchanged across ${c9.attemptsSinceCountChange} attempts — per-line edits aren't converging; consider reverting the affected region or rewriting it as a unit`;
+}
+var ERROR_PATTERNS, DEFAULTS, ErrorClusterTracker;
+var init_errorClusterTracker = __esm({
+  "packages/orchestrator/dist/errorClusterTracker.js"() {
+    "use strict";
+    ERROR_PATTERNS = [
+      // Style A: file:line:col: severity[: code]: message
+      // Matches gcc, clang, eslint, golangci-lint, ruby, generic POSIX tools.
+      {
+        re: /^([^\s:()]+):(\d+):(\d+):\s*(error|warning|note)(?::\s*([A-Za-z][\w/-]*))?\s*:?\s*(.*)$/gm,
+        build: (m2) => {
+          const file = m2[1];
+          if (/^https?:\/\//.test(file))
+            return null;
+          return {
+            file,
+            line: parseInt(m2[2], 10),
+            col: parseInt(m2[3], 10),
+            severity: m2[4],
+            code: (m2[5] ?? "").trim(),
+            message: (m2[6] ?? "").trim().slice(0, 240)
+          };
+        }
+      },
+      // Style B: file(line,col): severity CODE: message  (TypeScript)
+      {
+        re: /^([^\s(]+):?\s*\((\d+),(\d+)\)\s*:?\s*(error|warning|note)\s+([A-Z]+\d+)\s*:\s*(.*)$/gm,
+        build: (m2) => ({
+          file: m2[1],
+          line: parseInt(m2[2], 10),
+          col: parseInt(m2[3], 10),
+          severity: m2[4],
+          code: m2[5],
+          message: (m2[6] ?? "").trim().slice(0, 240)
+        })
+      },
+      // Style C: error[CODE]: message ... --> file:line:col   (Rust-style)
+      {
+        re: /^error(?:\[([A-Z]\d+)\])?:\s*(.+?)\n\s*-->\s*([^\s:]+):(\d+):(\d+)/gms,
+        build: (m2) => ({
+          file: m2[3],
+          line: parseInt(m2[4], 10),
+          col: parseInt(m2[5], 10),
+          severity: "error",
+          code: (m2[1] ?? "").trim(),
+          message: (m2[2] ?? "").trim().slice(0, 240)
+        })
+      },
+      // Style D: FAILED file::test_id [- message]   (pytest, similar)
+      {
+        re: /^FAILED\s+([^\s:]+)::([\w\-.[\]/]+)(?:\s+-\s+(.*))?$/gm,
+        build: (m2) => ({
+          file: m2[1],
+          severity: "error",
+          // Treat the test id as the cluster code so a flapping test stays in
+          // its own bucket, while many distinct tests in the same file each
+          // form their own cluster (more accurate than collapsing all
+          // pytest failures in a file into one).
+          code: m2[2],
+          message: (m2[3] ?? "").trim().slice(0, 240)
+        })
+      }
+    ];
+    DEFAULTS = {
+      warnAttempts: 3,
+      criticalAttempts: 5,
+      cooldownAttempts: 2,
+      maxClusters: 200
+    };
+    ErrorClusterTracker = class {
+      opts;
+      now;
+      clusters = /* @__PURE__ */ new Map();
+      lastEmittedAt = /* @__PURE__ */ new Map();
+      // key → observations counter at last emit
+      observationCounter = 0;
+      constructor(options2 = {}) {
+        this.opts = { ...DEFAULTS, ...options2 };
+        this.now = options2.now ?? Date.now;
+      }
+      /**
+       * Feed a new tool output into the tracker. Returns the changes for this
+       * observation plus a one-line summary suitable for context injection.
+       *
+       * @param output  raw stdout/stderr from the tool
+       * @param toolKey optional caller-supplied scope (e.g. "tsc:/path/to/cwd").
+       *                If two distinct tools emit similar errors in the same
+       *                file but in different scopes, pass distinct keys to
+       *                keep their clusters separate. Default: "" (shared).
+       */
+      observe(output, toolKey = "") {
+        this.observationCounter++;
+        const errors = parseErrors(output);
+        const observedClusters = /* @__PURE__ */ new Map();
+        for (const e2 of errors) {
+          const key = clusterKey(toolKey, e2.file, e2.code);
+          const cur = observedClusters.get(key);
+          if (cur)
+            cur.count += 1;
+          else
+            observedClusters.set(key, { count: 1, sample: e2.message });
+        }
+        const changes = [];
+        const lines = [];
+        let hasCritical = false;
+        const nowMs = this.now();
+        for (const [key, { count, sample }] of observedClusters) {
+          const prior = this.clusters.get(key);
+          if (!prior) {
+            const ck = parseClusterKey(key);
+            const entry = {
+              key: ck,
+              count,
+              sample,
+              observations: 1,
+              attemptsSinceCountChange: 1,
+              lastUpdated: nowMs,
+              previousCount: 0
+            };
+            this.clusters.set(key, entry);
+            changes.push({ kind: "new", cluster: entry });
+            continue;
+          }
+          prior.observations++;
+          prior.lastUpdated = nowMs;
+          prior.sample = sample;
+          if (count === prior.count) {
+            prior.attemptsSinceCountChange++;
+          } else {
+            prior.previousCount = prior.count;
+            prior.count = count;
+            prior.attemptsSinceCountChange = 1;
+          }
+          if (count > prior.previousCount && prior.attemptsSinceCountChange === 1) {
+            changes.push({ kind: "grown", cluster: prior, from: prior.previousCount, to: count });
+            lines.push(`${shortFile(prior.key.file)}: ${prior.previousCount}→${count}× ${prior.key.code || "errors"} (regressed)`);
+          } else if (count < prior.previousCount && prior.attemptsSinceCountChange === 1) {
+            changes.push({ kind: "shrunk", cluster: prior, from: prior.previousCount, to: count });
+            lines.push(`${shortFile(prior.key.file)}: ${prior.previousCount}→${count}× ${prior.key.code || "errors"} (improving)`);
+          } else if (prior.attemptsSinceCountChange >= this.opts.warnAttempts) {
+            if (this.lastEmittedAt.has(key)) {
+              const last2 = this.lastEmittedAt.get(key);
+              const sinceEmit = this.observationCounter - last2;
+              if (sinceEmit < this.opts.cooldownAttempts)
+                continue;
+            }
+            const isCritical = prior.attemptsSinceCountChange >= this.opts.criticalAttempts;
+            if (isCritical)
+              hasCritical = true;
+            changes.push({
+              kind: "stagnant",
+              cluster: prior,
+              attempts: prior.attemptsSinceCountChange,
+              severity: isCritical ? "critical" : "warn"
+            });
+            lines.push(formatStagnantLine(prior, isCritical));
+            this.lastEmittedAt.set(key, this.observationCounter);
+          }
+        }
+        for (const [key, prior] of [...this.clusters]) {
+          if (observedClusters.has(key))
+            continue;
+          if (prior.count > 0 && nowMs - prior.lastUpdated < 6e4) {
+            changes.push({ kind: "resolved", key: prior.key });
+            lines.push(`${shortFile(prior.key.file)}: ${prior.count}× ${prior.key.code || "errors"} → 0 (resolved)`);
+            this.clusters.delete(key);
+            this.lastEmittedAt.delete(key);
+          }
+        }
+        this.evictIfNeeded();
+        return {
+          changes,
+          summaryLine: lines.length === 0 ? "" : `[ERROR CLUSTERS] ${lines.join(" | ").slice(0, 360)}`,
+          hasCritical
+        };
+      }
+      /** Read-only snapshot of currently tracked clusters (defensive copy). */
+      snapshot() {
+        return [...this.clusters.values()].map((c9) => ({ ...c9, key: { ...c9.key } }));
+      }
+      /** Remove all state — useful at session boundaries. */
+      reset() {
+        this.clusters.clear();
+        this.lastEmittedAt.clear();
+        this.observationCounter = 0;
+      }
+      evictIfNeeded() {
+        if (this.clusters.size <= this.opts.maxClusters)
+          return;
+        const sorted = [...this.clusters.entries()].sort((a2, b) => a2[1].lastUpdated - b[1].lastUpdated);
+        const toEvict = sorted.slice(0, this.clusters.size - this.opts.maxClusters);
+        for (const [key] of toEvict) {
+          this.clusters.delete(key);
+          this.lastEmittedAt.delete(key);
+        }
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/agenticRunner.js
 import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync } from "node:fs";
 import { join as _pathJoin } from "node:path";
@@ -528604,6 +528840,25 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                           toolCallLog[_toolLogTailIdx].intentBucket = _verifierResult.intentBucket;
                           toolCallLog[_toolLogTailIdx].outcomeClass = _verifierResult.outcomeClass;
                         }
+                        if (tc.name === "shell" && (result.output || result.error)) {
+                          try {
+                            const ecMod = await Promise.resolve().then(() => (init_errorClusterTracker(), errorClusterTracker_exports));
+                            if (!this._errorClusterTracker) {
+                              this._errorClusterTracker = new ecMod.ErrorClusterTracker();
+                            }
+                            const tracker = this._errorClusterTracker;
+                            const scope = _verifierResult?.intentBucket ?? "shell";
+                            const obs = tracker.observe(((result.output ?? "") + "\n" + (result.error ?? "")).slice(0, 1e5), scope);
+                            if (obs.summaryLine) {
+                              if (obs.hasCritical) {
+                                messages2.push({ role: "system", content: obs.summaryLine });
+                              } else {
+                                pushSoftInjection("system", obs.summaryLine);
+                              }
+                            }
+                          } catch {
+                          }
+                        }
                         this._hookManager.runPostToolUse(tc.name, finalArgs, (result.output ?? "").slice(0, 2e3), this._sessionId);
                       } catch (err) {
                         result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.508",
+  "version": "0.187.509",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.508",
+      "version": "0.187.509",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

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