edit_file: whitespace-tolerant fallback so small-model edits land (root fix)

The whole V3/Lens/ASA stack runs only AFTER a successful edit
(improveContentWithV3 fires post-edit), but small models can't reproduce
old_str byte-for-byte — indentation width, tabs vs spaces, trailing
spaces drift every time — so edit_file fails, the model loops on
re-reads/re-runs, and the smart machinery is never reached (observed:
10 reads / 9 run_commands / 1 failed edit / 0 successful edits in one
session). GH #39 names this 'literal-match brittleness on whitespace
mismatches'.

findFuzzyLineMatch runs ONLY when exact + quote-normalized + entity-
decoded matching all miss: it compares old_str to the file line-by-line
with each line whitespace-stripped and accepts ONLY a unique match,
returning the file's exact span (original indentation preserved) so the
existing uniqueness/replace logic is unchanged. Ambiguous or content-
different old_str still fails (verified) — it can't edit a guessed
location. Exact-matching models never reach this path, so it can't
regress them. This makes edits land → the downstream stack becomes
reachable. Kept the first-miss ast_edit steer as the backstop for the
residual cases fuzzy can't safely rescue.

Author: itigges22

proxy/agent.go

@@ -895,14 +895,20 @@ func runAgentLoop(ctx *AgentContext, userMessage string) error {
 				mp := extractFailurePath(parsed.Name, parsed.Args)
 				editMissByPath[mp]++
 				ext := strings.ToLower(filepath.Ext(mp))
-				if editMissByPath[mp] >= 2 && (ext == ".py" || ext == ".html" || ext == ".htm") {
-					pendingRepeatCorrective = "edit_file has failed to match old_str " +
-						"on " + mp + " twice — stop re-reading and stop retrying " +
-						"edit_file. Use ast_edit instead: {\"path\":\"" + mp + "\"," +
-						"\"selector\":\"function:NAME\" (or class:NAME, or <tag> for " +
-						"HTML), \"content\":\"<the full replacement node>\"}. ast_edit " +
-						"needs no old_str, so it can't miss on whitespace."
-					log.Printf("[agent] edit_file double-miss on %q — forcing ast_edit steer", mp)
+				// Force the ast_edit steer on the FIRST miss for structured
+				// files — small models bail to run_command after a single
+				// edit_file miss rather than retrying, so waiting for a
+				// second miss never fires (observed: 1 edit_file all session,
+				// then 9 run_command re-runs).
+				if editMissByPath[mp] >= 1 && (ext == ".py" || ext == ".html" || ext == ".htm") {
+					pendingRepeatCorrective = "edit_file's old_str did not match " +
+						mp + " (small drift in whitespace/quotes is enough to miss). " +
+						"Do NOT re-read or run the file — switch to ast_edit, which " +
+						"needs no old_str: {\"type\":\"tool_call\",\"name\":\"ast_edit\"," +
+						"\"args\":{\"path\":\"" + mp + "\",\"selector\":\"function:NAME\" " +
+						"(or class:NAME, or <tag> for HTML),\"content\":\"<the full " +
+						"replacement function/class/element>\"}}."
+					log.Printf("[agent] edit_file miss on %q — forcing ast_edit steer", mp)
 				}
 			}
 

proxy/tools.go

@@ -963,6 +963,23 @@ func editFileTool() *ToolDef {
 					}
 				}
 			}
+			if actualOldStr == "" {
+				// Last resort before failing: whitespace-tolerant line match.
+				// Small models can't reproduce a code block byte-for-byte —
+				// indentation width, tabs-vs-spaces, and trailing spaces drift
+				// constantly — so exact old_str matching is the #1 reason
+				// edit_file fails for them, which strands the whole V3/lens
+				// stack (it only engages after a successful edit). This
+				// matches old_str against the file ignoring per-line leading/
+				// trailing whitespace, and ONLY accepts a UNIQUE match — an
+				// ambiguous or content-different old_str still fails, so it
+				// can never silently edit the wrong place. Exact-matching
+				// (frontier) models never reach this path. See GH #39.
+				if fuzzy, ok := findFuzzyLineMatch(content, input.OldStr); ok {
+					log.Printf("[edit_file] exact old_str missed on %s; unique whitespace-tolerant match found — proceeding (small-model indentation drift)", input.Path)
+					actualOldStr = fuzzy
+				}
+			}
 			if actualOldStr == "" {
 				// Mismatch persists — return targeted error.
 				hasEntities := strings.Contains(input.OldStr, "<") ||
@@ -1455,6 +1472,72 @@ func improveContentWithV3(path, content string, ctx *AgentContext) (string, V3Ed
 
 // findActualString searches for oldStr in content, handling quote normalization.
 // Returns the actual string found in content (may differ in quote style).
+// findFuzzyLineMatch rescues an old_str whose only error is per-line
+// whitespace drift (indentation width, tabs vs spaces, trailing spaces) —
+// the dominant edit_file failure mode for small models. It compares old_str
+// against the file line-by-line with each line whitespace-stripped, and
+// returns the EXACT span from the file (original indentation preserved) so
+// the caller's existing uniqueness-count + replace logic works unchanged.
+//
+// Safety: it requires exactly ONE matching window. Zero or multiple matches
+// return ("", false) so the caller fails cleanly rather than editing a
+// guessed location. It also refuses to match when old_str has no
+// non-whitespace content (would match any blank run). Content differences
+// beyond whitespace (renamed tokens, changed quotes) do NOT match — those
+// are semantic and must fail.
+func findFuzzyLineMatch(content, oldStr string) (string, bool) {
+	fileLines := strings.Split(content, "\n")
+	oldLines := strings.Split(oldStr, "\n")
+	// Drop a single trailing empty line from a trailing newline in old_str.
+	if len(oldLines) > 1 && strings.TrimSpace(oldLines[len(oldLines)-1]) == "" {
+		oldLines = oldLines[:len(oldLines)-1]
+	}
+	if len(oldLines) == 0 {
+		return "", false
+	}
+	strip := func(ls []string) []string {
+		out := make([]string, len(ls))
+		nonEmpty := false
+		for i, l := range ls {
+			out[i] = strings.TrimSpace(l)
+			if out[i] != "" {
+				nonEmpty = true
+			}
+		}
+		if !nonEmpty {
+			return nil // all-whitespace target: refuse
+		}
+		return out
+	}
+	want := strip(oldLines)
+	if want == nil {
+		return "", false
+	}
+	n := len(want)
+	matchStart := -1
+	matches := 0
+	for i := 0; i+n <= len(fileLines); i++ {
+		ok := true
+		for j := 0; j < n; j++ {
+			if strings.TrimSpace(fileLines[i+j]) != want[j] {
+				ok = false
+				break
+			}
+		}
+		if ok {
+			matches++
+			matchStart = i
+			if matches > 1 {
+				return "", false // ambiguous — fail safe
+			}
+		}
+	}
+	if matches != 1 {
+		return "", false
+	}
+	return strings.Join(fileLines[matchStart:matchStart+n], "\n"), true
+}
+
 func findActualString(content, oldStr string) string {
 	// Direct match first
 	if strings.Contains(content, oldStr) {