bingocode 1.1.160 → 1.1.162

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.160",
+  "version": "1.1.162",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/bootstrap/state.ts

@@ -139,6 +139,11 @@ type State = {
   goalCondition: string | null
   goalIterationCount: number
   goalMaxIterations: number
+  // Goal evaluator history for detecting repeated gaps
+  goalEvalHistory: {
+    lastGap: string | null
+    consecutiveSameGapCount: number
+  }
   // Session-only cron tasks created via CronCreate with durable: false.
   // Fire on schedule like file-backed tasks but are never written to
   // .claude/scheduled_tasks.json — they die with the process. Typed via
@@ -365,6 +370,10 @@ function getInitialState(): State {
     goalCondition: null,
     goalIterationCount: 0,
     goalMaxIterations: 20,
+    goalEvalHistory: {
+      lastGap: null,
+      consecutiveSameGapCount: 0,
+    },
     sessionCronTasks: [],
     sessionCreatedTeams: new Set(),
     // Session-only trust flag (not persisted to disk)
@@ -1805,3 +1814,17 @@ export function getGoalMaxIterations(): number {
   return STATE.goalMaxIterations
 }
 
+// Goal evaluator history accessors
+export function getGoalEvalHistory() {
+  return STATE.goalEvalHistory
+}
+
+export function updateGoalEvalHistory(lastGap: string | null): void {
+  if (lastGap === STATE.goalEvalHistory.lastGap) {
+    STATE.goalEvalHistory.consecutiveSameGapCount++
+  } else {
+    STATE.goalEvalHistory.lastGap = lastGap
+    STATE.goalEvalHistory.consecutiveSameGapCount = 1
+  }
+}
+

package/src/hooks/useGoalEvaluator.ts

@@ -7,6 +7,8 @@ import {
   getGoalMaxIterations,
   incrementGoalIterationCount,
   setGoalCondition,
+  getGoalEvalHistory,
+  updateGoalEvalHistory,
 } from '../bootstrap/state.js'
 import { enqueue } from '../utils/messageQueueManager.js'
 import { evaluateGoal } from '../utils/goalEvaluator.js'
@@ -71,6 +73,11 @@ export function useGoalEvaluator({
         if (getGoalCondition() !== condition) return
 
         incrementGoalIterationCount()
+        updateGoalEvalHistory(result.gap)
+
+        // Check for repeated gaps - implement circuit breaker
+        const evalHistory = getGoalEvalHistory()
+        const isRepeatedGap = evalHistory.consecutiveSameGapCount >= 3 && result.gap !== null
 
         if (result.satisfied) {
           setGoalCondition(null)
@@ -79,6 +86,14 @@ export function useGoalEvaluator({
             mode: 'task-notification',
             priority: 'now',
           })
+        } else if (isRepeatedGap) {
+          // Circuit breaker: stop after 3 repeated gaps
+          setGoalCondition(null)
+          enqueue({
+            value: `⚠️ Goal evaluator stopped after detecting the same gap "${result.gap}" 3 times in a row. Please adjust your approach or output EVAL blocks in the correct format.`,
+            mode: 'task-notification',
+            priority: 'now',
+          })
         } else {
           const continueMsg = result.gap
             ? `Goal not yet met (${iterCount + 1}/${maxIter}). Gap: ${result.gap}. Continue toward: "${condition}"`

package/src/skills/bundled/goal.ts

@@ -63,11 +63,12 @@ This goal is now registered for this session. After each turn, an independent ev
 
 CRITICAL: The evaluator reads ONLY your text output. It cannot see code changes, tool results, or file contents — only the plain text you write.
 
-At each turn toward the goal, output a short evaluation block like:
-> EVAL: [metric1]: [value] / [target]  →  ✓ or ✗
+	At each turn toward the goal, output a short evaluation block like:
+	EVAL: [metric1]: [value] / [target] → ✓ or ✗
 
-This block is the ONLY signal the evaluator can reliably process. Make it short,
-unambiguous, and quantitative. Do NOT expect the evaluator to infer success from narrative discussion.
+	This block is the ONLY signal the evaluator can reliably process. Make it short,
+	unambiguous, and quantitative. Do NOT expect the evaluator to infer success from narrative discussion.
+	Note: The EVAL block can appear anywhere in your text response (not just in quote blocks).
 
 Tell the user: Goal set — you will work autonomously until "${trimmed}" is achieved (max ${maxIter} turns). Send \`/goal clear\` to cancel.
 Now begin: assess current state and take the first concrete action toward the goal.`,

package/src/tools/FileEditTool/utils.test.ts

@@ -7,16 +7,16 @@ describe("findActualString", () => {
     expect(findActualString(file, "  bar")).toBe("  bar");
   });
 
-  it("tab in file, spaces in search -> matches via indent normalization", () => {
+  it("tab in file, spaces in search => matches via indent normalization", () => {
     const file = "\t\tfoo\n\t\tbar";
-    const result = findActualString(file, "    bar"); // 4 spaces
+    const result = findActualString(file, "    bar"); // model sent spaced ver
     expect(result).toBe("\t\tbar");
   });
 
-  it("spaces in file, tabs in search -> matches via indent normalization", () => {
-    const file = "    bar"; // 4 spaces
-    const result = findActualString(file, "\tbar"); // tab
-    expect(result).toBe("    bar");
+  it("spaces in file, tabs in search => matches via indent normalization", () => {
+    const file = "    bar"; // 4-space indented file
+    const result = findActualString(file, "\tbar"); // model sent tab version
+    expect(result).toBe("    bar"); // should return actual content from file
   });
 
   it("normalizeIndentation trims leading whitespace", () => {

package/src/tools/FileEditTool/utils.ts

@@ -107,10 +107,25 @@ export function findActualString(
 
   // Try with normalized leading whitespace (tab <-> space)
   const indentNormalizedSearch = normalizeIndentation(searchString)
-  const indentNormalizedFile = normalizeIndentation(fileContent)
-  const indentIndex = indentNormalizedFile.indexOf(indentNormalizedSearch)
-  if (indentIndex !== -1) {
-    return fileContent.substring(indentIndex, indentIndex + searchString.length)
+  const indentTrimmedFile = normalizeIndentation(fileContent)
+  const matchPoint = indentTrimmedFile.indexOf(indentNormalizedSearch)
+  if (matchPoint !== -1) {
+    // Leading whitespace normalization is NOT length-preserving,
+    // so compute bounds by matching each trimmed line back to its original.
+    const origLines = fileContent.split('\n')
+    const trimmedLines = indentTrimmedFile.split('\n')
+    const searchLines = indentNormalizedSearch.split('\n')
+    for (let i = 0; i <= trimmedLines.length - searchLines.length; i++) {
+      let k = 0
+      while (k < searchLines.length && trimmedLines[i + k] === searchLines[k]) k++
+      if (k !== searchLines.length) continue
+      let start = 0
+      for (let j = 0; j < i; j++) start += origLines[j].length + 1
+      let end = start
+      for (let j = i; j < i + k; j++) end += origLines[j].length + 1
+      return fileContent.substring(start, Math.max(start, end - 1))
+    }
+    return null
   }
 
   return null

package/src/utils/goalEvaluator.ts

@@ -34,11 +34,12 @@ function parseEvalBlocks(text: string): EvalBlock[] {
   // Arrow variants: → (U+2192), -> (ASCII), => (ASCII)
   // Pass variants: ✓ (U+2713), ✔ (U+2714), PASS (case-insensitive), Y, true, yes, 1
   // Fail variants: ✗ (U+2717), ✘ (U+2718), FAIL (case-insensitive), N, false, no, 0
+  // NOTE: Removed the requirement for ">" prefix to allow EVAL blocks anywhere in text
   const arrow = /(?:→|->|=>)/g.source
   const pass = /(?:✓|✔|PASS|pass|Y\b|true|yes|1)/g.source
   const fail = /(?:✗|✘|FAIL|fail|N\b|false|no|0)/g.source
   const full = new RegExp(
-    `>\\s*EVAL:\\s*(.+?):\\s*(.+?)\\s*(?:${arrow}|)\\s*(${pass}|${fail})`,
+    `EVAL:\\s*(.+?):\\s*(.+?)\\s*(?:${arrow}|)\\s*(${pass}|${fail})`,
     'g',
   )
 
@@ -108,6 +109,15 @@ export async function evaluateGoal(
     }
   }
 
+  // If no EVAL blocks found at all, provide helpful guidance to the user
+  if (evalBlocks.length === 0) {
+    return {
+      satisfied: false,
+      reason: 'No EVAL blocks found in assistant output',
+      gap: 'Please output EVAL blocks in format: "EVAL: metric: value / target → ✓" (without > prefix)',
+    }
+  }
+
   // Phase 2: Fallback to Haiku evaluator with pre-parsed summary
   const evalInput = [
     evalSummary(evalBlocks),