bingocode 1.1.153 → 1.1.155

package/.claude/skills/leanchy/SKILL.md

@@ -19,4 +19,4 @@ description: Activate the Leanchy protocol: execution discipline, diagnostic rig
 
 ## Architecture
 - Two duplications → abstract. Search the full codebase before modifying; reuse over reinvention.
-- Module boundaries require explicit contracts. Semantic naming is the documentation.
+- Module boundaries require explicit contracts. Semantic naming is the documentation.

package/.claude/skills/leanchypro/skill.md

@@ -1,31 +1,70 @@
 ---
 name: leanchypro
-description: 激活 Leanchy Pro 协议：在基础版上强化“工具所有权”、“多工具协同”与“探针驱动”的高阶执行架构。
+description: Activate the Leanchy Pro protocol: context-density-first execution, delegation discipline, tool ownership, probe-driven delivery, and zero-hallucination engineering.
 ---
 
-# Leanchy Pro 协议指令 (Professional Execution)
+# Leanchy Pro Protocol
 
-当执行复杂工程任务、系统重构或高价值交付时，激活 Pro 级指令集。此协议在 Leanchy 基础版之上，核心强化对工具能力的极致挖掘。
+Activated for complex tasks, large-scale refactors, and high-value deliveries. Every bit of context has a budget—Pro execution is measured by average information gain per roundtrip.
 
-## 0. 工具所有权 (Tool Ownership) - 拒绝吝啬
-- **主动探测**：严禁在未经过充分工具验证前说“我认为”、“可能”。工具调用是获取真相的唯一手段。
-- **验证冗余**：对于关键逻辑，必须通过不同维度的工具（如 `Grep` 结合 `Read`, `Bash` 结合 `Agent`）进行交叉验证。
-- **结果闭环**：工具返回的每一条异常信息都必须有响应和解释，禁止忽略明显的错误信号。
+---
+
+## 0. Information Density Budget — top priority
+
+The context window is the scarcest shared resource in the execution system.
+
+### Output density rules
+Every non-tool output must:
+- Lead with conclusion: first line = result or most important statement of this round
+- Sustain ratio ≥ 0.7: information gain / total output ≥ 70%. No filler transitions, no restating what a tool just returned
+- Short beats long, absence beats padding: three short phrases beat one paragraph; delete every non-essential word
+
+### Delegation threshold
+Actions meeting any of these criteria MUST be delegated to Agent/background Bash—do NOT flow raw data into mainline context:
+- Search returning >20 lines
+- Bulk file scan or aggregate stats (Grep results >10 entries)
+- Cross-file pattern verification
+
+Agent/Bash returns summary only. Mainline receives anchor → finding → recommendation, never raw dump.
+
+### Three low-density anti-patterns
+
+Prohibited: "Let me explain what this code does" → state purpose and key logic point instead
+Prohibited: pasting every Grep result → cherry-pick 2-3 representative samples
+Prohibited: multi-paragraph reasoning → direct conclusion + optional one-line why
+
+---
+
+## 1. Tool Ownership — truth via instrumentation
 
-## 1. 多工具协同 (Multi-Tool Coordination) - 并行效率
-- **原子任务并行**：凡是逻辑独立的操作（如查多个目录、跑不相关的测试），必须在单次响应中通过并行工具调用完成。
-- **工具链化**：设计具备前导与后续依赖的工具链。前一个工具寻找锚点，后一个工具执行修改，严禁分多次对话进行。
-- **上下文保鲜**：利用 `TaskCreate` 和 `TaskUpdate` 维持长程执行状态。每完成一个物理文件的修改，立即更新任务状态。
+- Banned: "I think", "might be", "should be"
+- Cross-validate: critical logic points confirmed from different tool dimensions (Grep + Read, Bash + Agent). Never speak about a file you haven't read
+- Signal closure: every anomaly from a tool return must be explained. No skipping
 
-## 2. 探针驱动 (Probe-Driven Execution) - 防御性交付
-- **逻辑探针**：在应用大规模重构前，先编写临时脚本（Python/Bash）或插入打印语句进行逻辑路径覆盖测试。
-- **副作用探测**：修改完成后，不仅要跑受影响点的测试，必须通过 `Grep` 全局扫描是否存在非显式依赖导致的破坏。
-- **预案回滚**：所有高风险工具操作（如 `sed`, `rm`, `git reset`）执行前，必须确保当前工作区已处于 Git 追踪下或有备份。
+---
+
+## 2. Delegation — offload low-density work
+
+- Large searches → Agent. Mainline only receives source → finding → recommendation
+- Data stats / batch aggregation → Bash one-liner. Never scroll raw data in mainline
+- Long-running tasks → `run_in_background`. Never block mainline for polling loops
+
+---
+
+## 3. Probe-Driven Delivery
 
-## 3. 纪律约束 (Discipline Layer)
-- **拒绝平庸**：禁止生成模板化的、泛泛而谈的代码。每一行产出都必须符合当前 Repo 的既有范式。
-- **零过渡态**：禁止向用户展示未完成的、不可编译的代码片段（除非是为了讨论特定逻辑点）。交付即终态。
-- **协议回流**：在执行中发现的高价值模式，必须在任务结束前通过 `Write` 某种 `MEMO` 或 `CLAUDE.md` 的形式留存。
+- Pre-probe: minimal test script to verify logic-path coverage before refactoring
+- Post-probe ghost scan: Grep/Agent to find hidden dependencies or broken chains after changes
+- Rollback prep: ensure Git-clean state before risky operations
 
 ---
-*Pro 协议不仅是更快的执行，更是更深度的实证主义。*
+
+## 4. Delivery Discipline
+
+- Paradigm-locked: every line matches existing repo conventions. Zero generic patterns
+- Zero transient state: never show non-compilable/non-runnable code. What's shown is final
+- Knowledge return: patterns and new dependencies discovered must be archived to MEMO/CLAUDE.md/ADR on completion
+
+---
+
+*Pro boils down to: triangulate with tools, offload low-density work, maximize information density in mainline context.*

package/package.json

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

package/src/skills/bundled/goal.ts

@@ -59,10 +59,17 @@ export function registerGoalSkill(): void {
 
 Goal condition: "${trimmed}"
 
-This goal is now registered for this session. An independent evaluator model will check after each turn whether the goal is satisfied. Maximum ${maxIter} iterations.
+This goal is now registered for this session. After each turn, an independent evaluator (Haiku 4.5, a weak model) will check whether the goal is satisfied. Maximum ${maxIter} iterations.
 
-Tell the user: Goal set — you will work autonomously until "${trimmed}" is achieved (max ${maxIter} turns). Send \`/goal clear\` to cancel.
+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 ✗
 
+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.
+
+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/FileEditTool.ts

@@ -72,8 +72,10 @@ import {
 import {
   areFileEditsInputsEquivalent,
   findActualString,
+  findClosestLines,
   getPatchForEdit,
   preserveQuoteStyle,
+  visibleWhitespace,
 } from './utils.js'
 
 // V8/Bun string length limit is ~2^30 characters (~1 billion). For typical
@@ -315,10 +317,15 @@ export const FileEditTool = buildTool({
     // Use findActualString to handle quote normalization
     const actualOldString = findActualString(file, old_string)
     if (!actualOldString) {
+      const BASE = 'String to replace not found.'
+      const matches = findClosestLines(file, old_string)
+      const msg = matches.length
+      ? `${BASE}\n→ = tab · = space\nProvided:\n${visibleWhitespace(old_string)}\nClosest matches:\n${matches.map(m => `  line ${m.lineNumber} (${m.diffType})\n    ${visibleWhitespace(m.snippet)}`).join('\n')}\n↑ check visible whitespace markers above.`
+        : `${BASE}.\n→ = tab · = space\nProvided:\n${visibleWhitespace(old_string)}\n↑ check visible whitespace markers above.`
       return {
         result: false,
         behavior: 'ask',
-        message: `String to replace not found in file.\nString: ${old_string}`,
+        message: msg,
         meta: {
           isFilePathAbsolute: String(isAbsolute(file_path)),
         },

package/src/tools/FileEditTool/utils.ts

@@ -70,6 +70,13 @@ export function stripTrailingWhitespace(str: string): string {
  * @param searchString The string to search for
  * @returns The actual string found in the file, or null if not found
  */
+
+/** Normalizes Unicode dashes (em-dash, en-dash, horizontal bar) to standard ASCII dashes.
+ * Handles model-output ASCII dashes when file content contains Unicode dash variants.
+ * Fixes Edit tool matching failures from encoding discrepancies. */
+export function normalizeDashes(str: string): string {
+  return str.replaceAll('—', '-').replaceAll('–', '-').replaceAll('―', '-')
+}
 export function findActualString(
   fileContent: string,
   searchString: string,
@@ -89,6 +96,14 @@ export function findActualString(
     return fileContent.substring(searchIndex, searchIndex + searchString.length)
   }
 
+  // Try with normalized dashes (em-dash, en-dash -> ASCII dash)
+  const dashedSearch = normalizeDashes(searchString)
+  const dashedFile = normalizeDashes(fileContent)
+  const dashIndex = dashedFile.indexOf(dashedSearch)
+  if (dashIndex !== -1) {
+    return fileContent.substring(dashIndex, dashIndex + searchString.length)
+  }
+
   return null
 }
 
@@ -198,6 +213,75 @@ function applyCurlySingleQuotes(str: string): string {
   return result.join('')
 }
 
+/**
+ * Error class for when an edit's old_string can't be found in the file.
+ * Carries diagnostics for better error reporting.
+ */
+export class EditNotFoundError extends Error {
+  diagnostics: {
+    searchString: string
+    visibleSearch: string
+    closestMatches: {
+      snippet: string
+      lineNumber: number
+      diffType: string
+    }[]
+  }
+  constructor(
+    message: string,
+    diagnostics: EditNotFoundError['diagnostics'],
+  ) {
+    super(message)
+    this.name = 'EditNotFoundError'
+    this.diagnostics = diagnostics
+  }
+}
+
+/**
+ * Renders whitespace characters as visible Unicode equivalents:
+ * tab → '→', space → '·'
+ */
+export function visibleWhitespace(str: string): string {
+  return str.replace(/\t/g, '→').replace(/ /g, '·')
+}
+
+/**
+ * Finds up to 3 lines in fileContent whose content (non-whitespace portion)
+ * matches the content of the first line of searchString.
+ * Used for diagnostic purposes when findActualString returns null.
+ *
+ * Returns matches sorted with whitespace-diff first, then content matches.
+ */
+export function findClosestLines(
+  fileContent: string,
+  searchString: string,
+): { snippet: string; lineNumber: number; diffType: string }[] {
+  const firstContent = searchString.split('\n')[0]!.replace(/^\s+/, '')
+  if (!firstContent) return []
+
+  const matches: { snippet: string; lineNumber: number; diffType: string }[] = []
+  const fileLines = fileContent.split('\n')
+
+  for (let i = 0; i < fileLines.length; i++) {
+    const line = fileLines[i]!
+    if (line.replace(/^\s+/, '') !== firstContent) continue
+
+    const snippet = line.replace(/\s+$/, '')
+
+    // Avoid duplicates
+    if (!matches.some(m => m.snippet === snippet)) {
+      matches.push({
+        snippet,
+        lineNumber: i + 1,
+        diffType: 'content match',
+      })
+      if (matches.length >= 3) break
+    }
+  }
+
+  return matches
+}
+
 /**
  * Transform edits to ensure replace_all always has a boolean value
  * @param edits Array of edits with optional replace_all
@@ -323,7 +407,18 @@ export function getPatchForEdits({
 
     // If this edit didn't change anything, throw an error
     if (updatedFile === previousContent) {
-      throw new Error('String not found in file. Failed to apply edit.')
+      const closest = findClosestLines(fileContents, edit.old_string)
+      throw new EditNotFoundError(
+        closest.length
+          ? `Edit failed — closest match:
+${closest.map(m => `  line ${m.lineNumber}: ${visibleWhitespace(m.snippet)} (${m.diffType})`).join('\n')}`
+          : 'Edit failed — string not found in file.',
+        {
+          searchString: edit.old_string,
+          visibleSearch: visibleWhitespace(edit.old_string),
+          closestMatches: closest,
+        },
+      )
     }
 
     // Track the new string that was applied

package/src/utils/goalEvaluator.ts

@@ -42,26 +42,55 @@ export async function evaluateGoal(
 
   const prompt = `You are a goal completion evaluator. Determine if the goal has been fully achieved.
 
+IMPORTANT: The agent may produce EVAL blocks intended for you. Parse them first.
+
 Goal: "${goalCondition}"
 
 Recent assistant output:
 ${recentAssistantTexts || '(none yet)'}
 
-Respond in JSON only:
+Evaluate:
+1. Did the agent produce a final EVAL block? If so, use those values directly.
+2. If no EVAL blocks found, infer based on any explicit declarations (e.g. "✓", "100%", "fixed", "complete").
+3. Output ONLY valid JSON — no explanation or markdown.
+
+Respond in:
 {"satisfied": true|false, "reason": "<one sentence>", "gap": "<missing item or null>"}`
 
-  const response = await client.messages.create({
-    model: GOAL_EVALUATOR_MODEL,
-    max_tokens: 256,
-    messages: [{ role: 'user', content: prompt }],
-  })
+  let text = ''
+  try {
+    const response = await client.messages.create({
+      model: GOAL_EVALUATOR_MODEL,
+      max_tokens: 256,
+      messages: [{ role: 'user', content: prompt }],
+    })
+    text = response.content.find((b: any) => b.type === 'text')?.text || ''
+  } catch (e) {
+    return {
+      satisfied: false,
+      reason: 'Evaluator API error',
+      gap: e instanceof Error ? e.message : String(e),
+    }
+  }
 
-  const text =
-    response.content.find((b: any) => b.type === 'text')?.text || ''
   try {
-    const cleaned = text.replace(/^```(?:json)?\n?|\n?```$/g, '').trim()
+    // Strip markdown code fences and find JSON object bounds
+    let cleaned = text
+      .replace(/```(?:json)?\s*/gi, '')
+      .replace(/```/g, '')
+      .trim()
+    const start = cleaned.indexOf('{')
+    const end = cleaned.lastIndexOf('}')
+    if (start === -1 || end === -1 || end <= start) {
+      throw new Error('No JSON object found')
+    }
+    cleaned = cleaned.slice(start, end + 1)
     return JSON.parse(cleaned) as GoalEvalResult
-  } catch {
-    return { satisfied: false, reason: 'Evaluator parse error', gap: text }
+  } catch (e) {
+    return {
+      satisfied: false,
+      reason: 'Evaluator parse error',
+      gap: `${e instanceof Error && e.message !== 'No JSON object found' ? e.message : 'raw output'}: ${text.slice(0, 200)}`,
+    }
   }
-}
+}