open-agents-ai 0.187.476 → 0.187.477

package/dist/index.js

@@ -282094,14 +282094,14 @@ ${lanes.join("\n")}
         return { value: value2, isSyntacticallyString, resolvedOtherFiles, hasExternalReferences };
       }
       function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression }) {
-        function evaluate2(expr, location) {
+        function evaluate3(expr, location) {
           let isSyntacticallyString = false;
           let resolvedOtherFiles = false;
           let hasExternalReferences = false;
           expr = skipParentheses(expr);
           switch (expr.kind) {
             case 225:
-              const result = evaluate2(expr.operand, location);
+              const result = evaluate3(expr.operand, location);
               resolvedOtherFiles = result.resolvedOtherFiles;
               hasExternalReferences = result.hasExternalReferences;
               if (typeof result.value === "number") {
@@ -282116,8 +282116,8 @@ ${lanes.join("\n")}
               }
               break;
             case 227: {
-              const left = evaluate2(expr.left, location);
-              const right = evaluate2(expr.right, location);
+              const left = evaluate3(expr.left, location);
+              const right = evaluate3(expr.right, location);
               isSyntacticallyString = (left.isSyntacticallyString || right.isSyntacticallyString) && expr.operatorToken.kind === 40;
               resolvedOtherFiles = left.resolvedOtherFiles || right.resolvedOtherFiles;
               hasExternalReferences = left.hasExternalReferences || right.hasExternalReferences;
@@ -282192,7 +282192,7 @@ ${lanes.join("\n")}
           let resolvedOtherFiles = false;
           let hasExternalReferences = false;
           for (const span of expr.templateSpans) {
-            const spanResult = evaluate2(span.expression, location);
+            const spanResult = evaluate3(span.expression, location);
             if (spanResult.value === void 0) {
               return evaluatorResult(
                 /*value*/
@@ -282214,7 +282214,7 @@ ${lanes.join("\n")}
             hasExternalReferences
           );
         }
-        return evaluate2;
+        return evaluate3;
       }
       function isConstAssertion(location) {
         return isAssertionExpression(location) && isConstTypeReference(location.type) || isJSDocTypeTag(location) && isConstTypeReference(location.typeExpression);
@@ -312752,7 +312752,7 @@ ${lanes.join("\n")}
         var emitResolver = createResolver();
         var nodeBuilder = createNodeBuilder();
         var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions, nodeBuilder.syntacticBuilderResolver);
-        var evaluate2 = createEvaluator({
+        var evaluate3 = createEvaluator({
           evaluateElementAccessExpression,
           evaluateEntityNameExpression
         });
@@ -348722,7 +348722,7 @@ ${lanes.join("\n")}
                     case 72:
                     case 50:
                     case 73:
-                      const rhsEval = evaluate2(right);
+                      const rhsEval = evaluate3(right);
                       if (typeof rhsEval.value === "number" && Math.abs(rhsEval.value) >= 32) {
                         errorOrSuggestion(
                           isEnumMember(walkUpParenthesizedExpressions(right.parent.parent)),
@@ -349225,7 +349225,7 @@ ${lanes.join("\n")}
             texts.push(span.literal.text);
             types2.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
           }
-          const evaluated = node.parent.kind !== 216 && evaluate2(node).value;
+          const evaluated = node.parent.kind !== 216 && evaluate3(node).value;
           if (evaluated) {
             return getFreshTypeOfLiteralType(getStringLiteralType(evaluated));
           }
@@ -354706,7 +354706,7 @@ ${lanes.join("\n")}
         function computeConstantEnumMemberValue(member) {
           const isConstEnum = isEnumConst(member.parent);
           const initializer = member.initializer;
-          const result = evaluate2(initializer, member);
+          const result = evaluate3(initializer, member);
           if (result.value !== void 0) {
             if (isConstEnum && typeof result.value === "number" && !isFinite(result.value)) {
               error2(
@@ -354761,7 +354761,7 @@ ${lanes.join("\n")}
           if (isConstantVariable(symbol3)) {
             const declaration = symbol3.valueDeclaration;
             if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
-              const result = evaluate2(declaration.initializer, declaration);
+              const result = evaluate3(declaration.initializer, declaration);
               if (location && getSourceFileOfNode(location) !== getSourceFileOfNode(declaration)) {
                 return evaluatorResult(
                   result.value,
@@ -512128,6 +512128,106 @@ var init_personality = __esm({
   }
 });
 
+// packages/orchestrator/dist/critic.js
+function buildForceProgressBlockMessage(call, hits) {
+  const argPreview = JSON.stringify(call.args ?? {}).slice(0, 200);
+  return `[FORCED PROGRESS BLOCK — you have called ${call.tool}(${argPreview}) ${hits} times with identical arguments and received the cached result each time. The data is not changing. You are stuck in a read-only loop instead of advancing the plan.
+
+REQUIRED before this tool will run again with these arguments:
+  • file_write or file_edit, OR
+  • todo_write that advances the plan, OR
+  • task_complete (if all phases are done).
+
+If you genuinely need this same data again, call a DIFFERENT tool first (one of the three above). Until then, refer to your conversation history — the result of this exact call is already there.]`;
+}
+function evaluate(inputs) {
+  const { proposedCall, fingerprint, isReadLike, recentToolResults, dedupHitCount, observerRedundantBlock } = inputs;
+  if (observerRedundantBlock) {
+    const cached = recentToolResults.get(fingerprint);
+    return {
+      decision: "observer_block",
+      reason: "Littleman observer flagged this fingerprint as redundant",
+      cachedResult: cached ? cached.result : null
+    };
+  }
+  if (isReadLike) {
+    const cached = recentToolResults.get(fingerprint);
+    if (cached !== void 0) {
+      const hits = (dedupHitCount.get(fingerprint) ?? 0) + 1;
+      const threshold = proposedCall.tool === "shell" ? SHELL_THRESHOLD : FS_THRESHOLD;
+      if (hits >= threshold) {
+        return {
+          decision: "force_progress_block",
+          reason: `${proposedCall.tool} fingerprint hit count ${hits} >= ${threshold}`,
+          hitNumber: hits,
+          blockMessage: buildForceProgressBlockMessage(proposedCall, hits)
+        };
+      }
+      return {
+        decision: "serve_cached",
+        reason: cached.compacted ? "post-compaction cache re-serve" : `duplicate call #${hits} (still under ${threshold}-hit gate)`,
+        cachedResult: cached.result,
+        compacted: cached.compacted,
+        hitNumber: hits
+      };
+    }
+  }
+  return { decision: "pass" };
+}
+function buildStagnationDiagnostic(signals) {
+  const variantList = signals.variantList.slice(0, 8).map((v) => `  • ${v}`).join("\n");
+  return [
+    `[STAGNATION DETECTED — DIAGNOSTIC MODE REQUIRED]`,
+    ``,
+    `Over the last ${signals.windowSamples} turns you have:`,
+    `  • Completed 0 new todos`,
+    `  • Written/edited only ${signals.filesDelta} unique file(s) (need ≥3 for healthy progress)`,
+    `  • Accumulated ${signals.failureSum} failures`,
+    `  • Tried ${signals.variantCount} different shell-command variants:`,
+    variantList,
+    ``,
+    `You are not making progress — you are trying surface-level variants of the same approach without diagnosing root cause. This is the failure mode that prevents real completion.`,
+    ``,
+    `MANDATORY NEXT ACTIONS (do NOT call task_complete; do NOT try another variant):`,
+    ``,
+    `1. READ THE FULL ERROR — re-read your most recent failure output ENTIRELY. If it's in a log packet, call log_explore({op:"errors"}) then log_explore({op:"lines", start:..., end:...}) for context. Do not skim.`,
+    ``,
+    `2. STATE A HYPOTHESIS in writing — what specifically is wrong? "I think X is failing because Y." Be concrete. Do NOT propose a fix yet.`,
+    ``,
+    `3. VERIFY ONE ASSUMPTION — pick the ONE thing you most BELIEVE to be true and test it with the smallest possible command:`,
+    `     • If you think a package is installed: ls node_modules/<name>/package.json`,
+    `     • If you think an env var is set: printenv <NAME>`,
+    `     • If you think a file imports correctly: head -5 <file>`,
+    `     • If you don't know what an error means: web_search("<exact error string>")`,
+    ``,
+    `4. CHECK SILENT FAILURES — npm install reporting "added N packages" does NOT mean ALL declared deps installed; npm sometimes drops packages with peer-dep conflicts without erroring. Verify each expected dep individually.`,
+    ``,
+    `DO NOT in your next response:`,
+    `  • Try another version, flag, or variant of any command in the list above`,
+    `  • Wipe node_modules / re-install — that hides the original error`,
+    `  • Call task_complete — being stuck on a debug problem is NEVER grounds for task_complete`,
+    ``,
+    `task_complete is ONLY for actual completion or unrecoverable hardware/permission errors. You are stuck on a fixable problem; diagnose it.`
+  ].join("\n");
+}
+function isStagnant(signals, opts) {
+  const failureThreshold = opts?.failureThreshold ?? 5;
+  const variantThreshold = opts?.variantThreshold ?? 4;
+  const filesDeltaMin = opts?.filesDeltaMin ?? 3;
+  const minSamples = opts?.minSamples ?? 30;
+  if (signals.windowSamples < minSamples)
+    return false;
+  return signals.completedDelta === 0 && signals.filesDelta < filesDeltaMin && signals.failureSum >= failureThreshold && signals.variantCount >= variantThreshold;
+}
+var SHELL_THRESHOLD, FS_THRESHOLD;
+var init_critic = __esm({
+  "packages/orchestrator/dist/critic.js"() {
+    "use strict";
+    SHELL_THRESHOLD = 2;
+    FS_THRESHOLD = 3;
+  }
+});
+
 // packages/orchestrator/dist/pressure-gate.js
 function detectPressure(message2) {
   const hasProfanity = PRESSURE_SIGNALS.test(message2);
@@ -514455,7 +514555,7 @@ function h10(t2) {
 function h11(t2) {
   return t2 * t2 * (t2 - 1);
 }
-function evaluate(controls, r2) {
+function evaluate2(controls, r2) {
   const { K: K2, N, P: P2, E: Eb, Pd, Ed, expansion, epsSigma, deltaMax } = controls;
   const eps2 = epsSigma * epsSigma;
   const u = new Float64Array(K2);
@@ -514731,7 +514831,7 @@ function deserialize(obj) {
 function rmse(controls, samples) {
   let sumSq = 0;
   for (const s2 of samples) {
-    const pred = evaluate(controls, s2.input);
+    const pred = evaluate2(controls, s2.input);
     for (let n2 = 0; n2 < controls.N; n2++) {
       const diff = pred[n2] - s2.output[n2];
       sumSq += diff * diff;
@@ -514906,7 +515006,7 @@ var init_embeddingAligner = __esm({
           const range = max - min;
           normalized[k] = range > 1e-10 ? Math.max(0, Math.min(1, (projected[k] - min) / range)) : 0.5;
         }
-        const aligned64 = evaluate(this.state.controls, normalized);
+        const aligned64 = evaluate2(this.state.controls, normalized);
         const result = new Float32Array(this.state.dstDim);
         for (let n2 = 0; n2 < this.state.dstDim; n2++)
           result[n2] = aligned64[n2];
@@ -514993,7 +515093,7 @@ var init_embeddingAligner = __esm({
         let avgCosine = 0;
         if (testSamples.length > 0) {
           for (const s2 of testSamples) {
-            const pred = evaluate(controls, s2.input);
+            const pred = evaluate2(controls, s2.input);
             avgCosine += cosine(pred, s2.output);
           }
           avgCosine /= testSamples.length;
@@ -516500,7 +516600,7 @@ __export(dist_exports2, {
   retrieveByPPR: () => retrieveByPPR,
   splanifoldCosine: () => cosine,
   splanifoldDeserialize: () => deserialize,
-  splanifoldEvaluate: () => evaluate,
+  splanifoldEvaluate: () => evaluate2,
   splanifoldFit: () => fit,
   splanifoldRmse: () => rmse,
   splanifoldSerialize: () => serialize
@@ -518372,6 +518472,7 @@ var init_agenticRunner = __esm({
     init_dist();
     init_personality();
     init_promptLoader();
+    init_critic();
     init_pressure_gate();
     init_dist5();
     init_dist7();
@@ -520658,53 +520759,30 @@ TASK: ${task}` : task;
               for (const s2 of stagnationWindow)
                 for (const p2 of s2.filesTouchedThisTurn)
                   fileSet.add(p2);
-              const filesDelta = fileSet.size;
-              const failureSum = stagnationWindow.reduce((a2, s2) => a2 + s2.failuresThisTurn, 0);
               const variantSet = /* @__PURE__ */ new Set();
               for (const s2 of stagnationWindow)
                 for (const p2 of s2.shellPrefixesThisTurn)
                   variantSet.add(p2);
-              const variantCount = variantSet.size;
-              if (completedDelta === 0 && filesDelta < STAG_FILES_DELTA_MIN && failureSum >= STAG_FAILURE_THRESHOLD && variantCount >= STAG_VARIANT_THRESHOLD) {
-                const variantList = [...variantSet].slice(0, 8).map((v) => `  • ${v}`).join("\n");
-                const stagMsg = [
-                  `[STAGNATION DETECTED — DIAGNOSTIC MODE REQUIRED]`,
-                  ``,
-                  `Over the last ${stagnationWindow.length} turns you have:`,
-                  `  • Completed 0 new todos`,
-                  `  • Written/edited only ${filesDelta} unique file(s) (need ≥${STAG_FILES_DELTA_MIN} for healthy progress)`,
-                  `  • Accumulated ${failureSum} failures`,
-                  `  • Tried ${variantCount} different shell-command variants:`,
-                  variantList,
-                  ``,
-                  `You are not making progress — you are trying surface-level variants of the same approach without diagnosing root cause. This is the failure mode that prevents real completion.`,
-                  ``,
-                  `MANDATORY NEXT ACTIONS (do NOT call task_complete; do NOT try another variant):`,
-                  ``,
-                  `1. READ THE FULL ERROR — re-read your most recent failure output ENTIRELY. If it's in a log packet, call log_explore({op:"errors"}) then log_explore({op:"lines", start:..., end:...}) for context. Do not skim.`,
-                  ``,
-                  `2. STATE A HYPOTHESIS in writing — what specifically is wrong? "I think X is failing because Y." Be concrete. Do NOT propose a fix yet.`,
-                  ``,
-                  `3. VERIFY ONE ASSUMPTION — pick the ONE thing you most BELIEVE to be true and test it with the smallest possible command:`,
-                  `     • If you think a package is installed: ls node_modules/<name>/package.json`,
-                  `     • If you think an env var is set: printenv <NAME>`,
-                  `     • If you think a file imports correctly: head -5 <file>`,
-                  `     • If you don't know what an error means: web_search("<exact error string>")`,
-                  ``,
-                  `4. CHECK SILENT FAILURES — npm install reporting "added N packages" does NOT mean ALL declared deps installed; npm sometimes drops packages with peer-dep conflicts without erroring. Verify each expected dep individually.`,
-                  ``,
-                  `DO NOT in your next response:`,
-                  `  • Try another version, flag, or variant of any command in the list above`,
-                  `  • Wipe node_modules / re-install — that hides the original error`,
-                  `  • Call task_complete — being stuck on a debug problem is NEVER grounds for task_complete`,
-                  ``,
-                  `task_complete is ONLY for actual completion or unrecoverable hardware/permission errors. You are stuck on a fixable problem; diagnose it.`
-                ].join("\n");
-                messages2.push({ role: "system", content: stagMsg });
+              const failureSum = stagnationWindow.reduce((a2, s2) => a2 + s2.failuresThisTurn, 0);
+              const signals = {
+                completedDelta,
+                filesDelta: fileSet.size,
+                failureSum,
+                variantCount: variantSet.size,
+                windowSamples: stagnationWindow.length,
+                variantList: [...variantSet]
+              };
+              if (isStagnant(signals, {
+                failureThreshold: STAG_FAILURE_THRESHOLD,
+                variantThreshold: STAG_VARIANT_THRESHOLD,
+                filesDeltaMin: STAG_FILES_DELTA_MIN,
+                minSamples: STAG_MIN_SAMPLES
+              })) {
+                messages2.push({ role: "system", content: buildStagnationDiagnostic(signals) });
                 stagnationCooldownUntilTurn = turn + 5;
                 this.emit({
                   type: "status",
-                  content: `STAGNATION DETECTED — injected diagnostic mode at turn ${turn} (${variantCount} variants, ${failureSum} failures, ${filesDelta} files in window)`,
+                  content: `STAGNATION DETECTED — injected diagnostic mode at turn ${turn} (${signals.variantCount} variants, ${signals.failureSum} failures, ${signals.filesDelta} files in window)`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
               }
@@ -521509,16 +521587,6 @@ ${memoryLines.join("\n")}`
                 toolCallBudget.set(tc.name, budgetRemaining - 1);
               }
               const toolFingerprint = `${tc.name}:${argsKey}`;
-              if (this._littlemanRedundantBlocks.has(toolFingerprint)) {
-                this._littlemanRedundantBlocks.delete(toolFingerprint);
-                const cachedEntry2 = recentToolResults.get(toolFingerprint);
-                this.emit({ type: "tool_call", toolName: tc.name, toolArgs: tc.arguments, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-                const blockMsg = cachedEntry2 ? `[BLOCKED — this tool+args already succeeded. Re-served from cache:]
-
-${cachedEntry2.result.slice(0, 500)}` : `[BLOCKED — the observer confirmed this tool already succeeded with these arguments on a prior turn. Do NOT re-run. Use your prior findings to proceed.]`;
-                this.emit({ type: "tool_result", toolName: tc.name, success: true, content: blockMsg.slice(0, 100), turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-                return { tc, output: blockMsg };
-              }
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -521535,22 +521603,53 @@ ${cachedEntry2.result.slice(0, 500)}` : `[BLOCKED — the observer confirmed thi
                 "sub_agent",
                 "priority_delegate",
                 "ask_user",
-                // WO-TASK-02 — todo_write is a state-write tool. Calling it twice
-                // with the same args is idempotent (it just re-stores the same
-                // list) but the dedup detector was flagging it as a wasted call
-                // and blocking the planning workflow. The agent uses todo_write
-                // as its primary checkpoint mechanism so it MUST always execute.
                 "todo_write",
-                // nexus is also a state tool — connect is idempotent but the
-                // dedup warning was causing confused agents to bail out to
-                // shell workarounds (npm install, find /bin, etc.) when they
-                // saw "DUPLICATE CALL" after their first connect. Let the
-                // tool see every call and return the cached state itself.
                 "nexus"
               ].includes(tc.name);
               const isReadLike = baseIsReadLike || tc.name === "shell" && this._isShellCommandReadOnly(tc.arguments?.["command"] ?? tc.arguments?.["cmd"] ?? "");
-              const cachedEntry = recentToolResults.get(toolFingerprint);
-              if (isReadLike && cachedEntry !== void 0) {
+              const observerRedundantBlock = this._littlemanRedundantBlocks.has(toolFingerprint);
+              if (observerRedundantBlock) {
+                this._littlemanRedundantBlocks.delete(toolFingerprint);
+              }
+              const criticDecision = evaluate({
+                proposedCall: { tool: tc.name, args: tc.arguments ?? {} },
+                fingerprint: toolFingerprint,
+                isReadLike,
+                recentToolResults,
+                dedupHitCount,
+                recentFailures: this._recentFailures.map((f2) => ({
+                  fingerprint: f2.fingerprint,
+                  toolName: f2.tool,
+                  errorPreview: (f2.error || f2.output || "").slice(0, 200)
+                })),
+                stagnationSignals: null,
+                // stagnation gate handled at top-of-turn
+                stagnationGateActive: false,
+                observerRedundantBlock
+              });
+              if (criticDecision.decision === "observer_block") {
+                this.emit({ type: "tool_call", toolName: tc.name, toolArgs: tc.arguments, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                const blockMsg = criticDecision.cachedResult ? `[BLOCKED — this tool+args already succeeded. Re-served from cache:]
+
+${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confirmed this tool already succeeded with these arguments on a prior turn. Do NOT re-run. Use your prior findings to proceed.]`;
+                this.emit({ type: "tool_result", toolName: tc.name, success: true, content: blockMsg.slice(0, 100), turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                return { tc, output: blockMsg };
+              }
+              if (criticDecision.decision === "force_progress_block") {
+                dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
+                this.emit({ type: "tool_call", toolName: tc.name, toolArgs: tc.arguments, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: criticDecision.blockMessage.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                return { tc, output: criticDecision.blockMessage };
+              }
+              if (criticDecision.decision === "serve_cached") {
+                dedupHitCount.set(toolFingerprint, criticDecision.hitNumber);
                 this.emit({
                   type: "tool_call",
                   toolName: tc.name,
@@ -521558,36 +521657,13 @@ ${cachedEntry2.result.slice(0, 500)}` : `[BLOCKED — the observer confirmed thi
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
-                const hits = (dedupHitCount.get(toolFingerprint) ?? 0) + 1;
-                dedupHitCount.set(toolFingerprint, hits);
-                const threshold = tc.name === "shell" ? 2 : DEDUP_ESCALATION_THRESHOLD;
-                if (hits >= threshold) {
-                  const argPreview = JSON.stringify(tc.arguments ?? {}).slice(0, 200);
-                  const blockMsg = `[FORCED PROGRESS BLOCK — you have called ${tc.name}(${argPreview}) ${hits} times with identical arguments and received the cached result each time. The data is not changing. You are stuck in a read-only loop instead of advancing the plan.
-
-REQUIRED before this tool will run again with these arguments:
-  • file_write or file_edit, OR
-  • todo_write that advances the plan, OR
-  • task_complete (if all phases are done).
-
-If you genuinely need this same data again, call a DIFFERENT tool first (one of the three above). Until then, refer to your conversation history — the result of this exact call is already there.]`;
-                  this.emit({
-                    type: "tool_result",
-                    toolName: tc.name,
-                    success: false,
-                    content: blockMsg.slice(0, 120),
-                    turn,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                  });
-                  return { tc, output: blockMsg };
-                }
-                const header = cachedEntry.compacted ? `[RE-SERVED FROM CACHE — the original result was compacted from context. Here is the data again. No need to call this tool again.]
+                const header = criticDecision.compacted ? `[RE-SERVED FROM CACHE — the original result was compacted from context. Here is the data again. No need to call this tool again.]
 
-` : `[DUPLICATE CALL #${hits} — you already called ${tc.name} with these exact arguments. The result is identical. Do NOT call this again. Use the data you already have to make progress. One more identical call will trigger a hard progress block.]
+` : `[DUPLICATE CALL #${criticDecision.hitNumber} — you already called ${tc.name} with these exact arguments. The result is identical. Do NOT call this again. Use the data you already have to make progress. One more identical call will trigger a hard progress block.]
 
 `;
-                const truncatedCache = cachedEntry.result.length > 500 ? cachedEntry.result.slice(0, 500) + `
-... [${cachedEntry.result.length - 500} chars omitted — same as before]` : cachedEntry.result;
+                const truncatedCache = criticDecision.cachedResult.length > 500 ? criticDecision.cachedResult.slice(0, 500) + `
+... [${criticDecision.cachedResult.length - 500} chars omitted — same as before]` : criticDecision.cachedResult;
                 const dedupOutput = header + truncatedCache;
                 this.emit({
                   type: "tool_result",

package/npm-shrinkwrap.json

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

package/package.json

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