thincoder 0.12.44 → 0.12.45

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 本文件记录 ThinCoder CLI 的发布历史。格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/)，版本遵循[语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [0.12.45] — 2026-08-26
+
+### Fixed
+
+- **编辑工具 CRLF 行尾写回丢失**：`edit` / `apply_patch` / `hashline_edit` / `insert_after` 在 Windows CRLF 文件上写回全部被转成 LF（normalize 后直接落盘）——现按"首个换行符类型"检测原文件行尾并原样恢复，diff 不再整文件重写；`new_string`/`new_content` 含 CRLF 时先归一化再转换，杜绝 `\r\r\n`
+- **`old_string not found` 黑盒报错**：失败时返回相似度最高的 top 3 候选行（行号+预览+LCS 相似度，阈值 0.5，多行 old_string 只对首行并标注 `old_string line 1:`）——从盲猜变导航
+
+### Added
+
+- **`write` 行尾语义**：覆盖既有文件按原行尾恢复；新建文件默认 LF，同目录多数派为 CRLF 时跟随（≤20 文件嗅探）
+- **`hashline_edit` 编码损坏探测**：文件含 U+FFFD（替换符）时结果追加警告（编码可能已损坏、哈希寻址可能不可靠），不阻断
+
+### Changed
+
+- 候选相似度 LCS 计算复用模块级 DP 缓冲（大文件失败路径不再有每行分配的 GC 压力）
+
 ## [0.12.44] — 2026-08-25
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.44",
+  "version": "0.12.45",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/agent-tools/advisor.mjs

@@ -7,40 +7,40 @@ import { randomUUID, createHmac } from "node:crypto"
 import { runAdvisorReview } from "../advisor/run.mjs"
 import { isDocFile } from "../advisor/repos.mjs"
 
-const TOKEN_EXPIRY_MS = 3600000 // 1 hour
+const TOKEN_TTL_DEFAULT_MS = 7 * 24 * 3600 * 1000 // 7-day ceiling (v2 2026-08-25): multi-batch delivery must not re-review an unchanged design within a week; agent.engTokenTtlMs overrides
 const TOKEN_SECRET = process.env.THINCODER_TOKEN_SECRET || "thincoder-default-secret"
 
+/** Effective token TTL: config override with runtime validation (advisor timeoutMs precedent —
+ *  invalid values fall back to the default, never silently disable the ceiling). */
+function effectiveTokenTtlMs(agent) {
+  const cfg = agent?.config?.agent?.engTokenTtlMs
+  return (Number.isFinite(cfg) && cfg > 0) ? cfg : TOKEN_TTL_DEFAULT_MS
+}
+
 /** Generate a signed design token with expiration */
-function generateDesignToken() {
+function generateDesignToken(agent) {
   const uuid = randomUUID()
-  const expiresAt = Date.now() + TOKEN_EXPIRY_MS
+  const expiresAt = Date.now() + effectiveTokenTtlMs(agent)
   const payload = `${uuid}:${expiresAt}`
   const signature = createHmac("sha256", TOKEN_SECRET).update(payload).digest("hex").slice(0, 16)
   return `${payload}:${signature}`
 }
 
-/** Validate design token: check format, expiration, and signature
- *  For backward compatibility, tokens that don't match the new format are accepted as-is
- */
+/** Validate design token: format, expiration, signature — ALL fail-closed (v2 2026-08-25).
+ *  The two legacy fail-open branches (parts!=3 → true, NaN expiry → true) were pass-through
+ *  backdoors: any malformed string bypassed validation. Only exact signed tokens pass now.
+ *  Format must be exactly uuid:expiresAt:hmacSig. */
 export function validateDesignToken(token) {
   if (!token || typeof token !== "string") return false
-  
+
   // New format: uuid:expiresAt:signature (3 parts separated by ':')
   const parts = token.split(":")
-  if (parts.length !== 3) {
-    // Old format or simple token - accept for backward compatibility
-    return true
-  }
-  
+  if (parts.length !== 3) return false // fail-closed (was: return true)
+
   const [uuid, expiresAt, signature] = parts
   const expTime = parseInt(expiresAt, 10)
-  
-  // If it looks like a new format token, validate it properly
-  if (isNaN(expTime)) {
-    // Not a valid new format, treat as old format
-    return true
-  }
-  
+  if (isNaN(expTime)) return false // fail-closed (was: return true)
+
   // Check expiration
   if (Date.now() > expTime) return false
   
@@ -130,7 +130,7 @@ export const advisorTool = {
     // Generate the design token BEFORE the review and inject it into the advisor's prompt.
     // The advisor (LLM) decides pass/fail itself and echoes the token only on approval —
     // the gate is a mechanical string match, not fragile semantics parsing.
-    const designToken = reviewType === "design" ? generateDesignToken() : null
+    const designToken = reviewType === "design" ? generateDesignToken(agent) : null
     const result = await runAdvisorReview(agent, reviewType, {
       onOutput: ctx.onOutput,
       signal: ctx.signal,
@@ -159,9 +159,13 @@ export const advisorTool = {
         return `${cleanResult}\n\nApproved. Pass this exact token to eng-coder (designToken parameter): ${designToken}`
       }
       // Review failed (or advisor chose not to pass) → invalidate any previously-issued token.
-      // Guard: result === null means the review was skipped (advisor disabled / not engineering
-      // mode) — a skipped review must not revoke an already-issued token.
-      if (result !== null) agent._engDesignToken = null
+      // Guards (v2 2026-08-25): result === null means the review was SKIPPED (advisor disabled /
+      // not engineering mode) — must not revoke. An error reply (own "Advisor:" prefix — the
+      // error-return convention of runAdvisorReview) is a provider crash/timeout artifact, not
+      // a completed verdict — a network glitch must not revoke unrelated standing tokens.
+      // Only a COMPLETED review that did not pass revokes.
+      const isCompletedReview = result !== null && !result.startsWith("Advisor:")
+      if (isCompletedReview) agent._engDesignToken = null
       // Strip every dead token occurrence from the raw output so the main agent can't grab an invalid one
       if (result) {
         const stripped = result.replace(makeDesignTokenRegex(designToken, "g"), "").trim()

package/src/agent-tools/eng.mjs

@@ -3,7 +3,7 @@
  * In engineering mode the agent follows design-before-code methodology.
  * Toggled here at session level; persisted by /eng.
  */
-import { ENG_ON_REMINDER } from "../agent.mjs"
+import { ENG_ON_REMINDER, ENG_OFF_REMINDER } from "../agent.mjs"
 
 export const engTool = {
   name: "eng",
@@ -27,8 +27,7 @@ export const engTool = {
       ctx.agent._touchedFiles = []         // clear mutation tracking
       ctx.agent._lastEngState = false
       ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-      ctx.agent._pendingReminders.push(
-        "[System reminder: engineering mode is now OFF — standard discipline applies. Changes go through the normal workflow.]")
+      ctx.agent._pendingReminders.push(ENG_OFF_REMINDER)
       // 持久化工程模式状态到会话
       if (ctx.persistState) {
         await ctx.persistState({
@@ -42,8 +41,14 @@ export const engTool = {
       return "Engineering mode exited. Standard discipline now applies. You may edit files directly."
     }
     if (args.action === "enter") {
+      // Idempotent enter (v2 2026-08-25): already in engineering mode → no-op. The old
+      // unconditional token clear killed standing design tokens on a redundant defensive
+      // eng(enter) — only a real off→on transition requires a fresh design review.
+      if (ctx.agent.config.agent.engineering) {
+        return "Engineering mode already active. Existing design tokens stay valid."
+      }
       ctx.agent.config.agent.engineering = true
-      ctx.agent._engDesignToken = null   // re-entering requires a fresh design review
+      ctx.agent._engDesignToken = null   // off→on transition requires a fresh design review
       ctx.agent._lastEngState = true
       ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
       ctx.agent._pendingReminders.push(ENG_ON_REMINDER)

package/src/agent.mjs

@@ -61,14 +61,19 @@ export const ENG_ON_REMINDER =
 // Re-exported for API compatibility (single source of truth: advisor/repos.mjs)
 export { hasCodeMutations } from "./advisor/repos.mjs"
 
-/** Engineering-mode status injection — one reminder when engineering mode is ON. */
+/** Engineering mode OFF reminder — shared with the eng tool and the injector. */
+export const ENG_OFF_REMINDER =
+  "[System reminder: engineering mode is now OFF — standard discipline applies. " +
+  "Changes go through the normal workflow: you may edit files directly, advisor/verify " +
+  "guards apply per config.]"
+
+/** Engineering-mode status injection — one reminder on EVERY transition (2026-08-25:
+ *  OFF is announced too — the model must know the gates lifted; silence after /eng-off
+ *  left it guessing. Covers TUI /eng, resume, and any path bypassing the eng tool.) */
 function injectEngineeringReminder(agent) {
   const eng = agent.config?.agent?.engineering ?? false
-  // Only notify on transitions into ON — OFF is silence (the system prompt
-  // already carries the standard discipline; no need to remind the model
-  // that it's in the default mode).
-  if (eng && !agent._lastEngState) {
-    agent.history.push({ role: "user", content: ENG_ON_REMINDER, transient: true })
+  if (eng !== agent._lastEngState) {
+    agent.history.push({ role: "user", content: eng ? ENG_ON_REMINDER : ENG_OFF_REMINDER, transient: true })
   }
   agent._lastEngState = eng
 }

package/src/tools/file.mjs

@@ -7,6 +7,11 @@ import {
   resolveInCwd,
   resolveExternal,
   normalizeEOL,
+  detectFileEol,
+  joinWithEol,
+  majorityEol,
+  findCandidates,
+  FFFD_WARNING,
 } from "./shared.mjs";
 import { specForModel } from "../config.mjs";
 import { createHash } from "node:crypto";
@@ -160,7 +165,12 @@ export const writeTool = {
     await mkdir(dirname(abs), { recursive: true })
     const st = await stat(abs).catch(() => null)
     if (st?.isDirectory()) throw new Error(`Path is a directory: ${args.path}`)
-    await writeFile(abs, args.content, "utf8")
+    // EOL semantics: overwriting an existing file restores ITS original EOL style (F1);
+    // a new file follows the directory's majority style, defaulting to LF (F2).
+    const prev = st ? await readFile(abs, "utf8").catch(() => null) : null
+    const eol = prev != null ? detectFileEol(prev) : majorityEol(dirname(abs))
+    const content = eol === "\r\n" ? normalizeEOL(args.content).replace(/\n/g, "\r\n") : args.content
+    await writeFile(abs, content, "utf8")
     markDirty(abs)
     const diff = gitDiffOne(ctx.cwd, abs)
     return `Wrote ${args.content.length} chars to ${args.path}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
@@ -189,15 +199,28 @@ export const editTool = {
     if (!args.old_string) {
       throw new Error("old_string must not be empty (empty string matches everywhere and would corrupt the file)")
     }
-    const content = normalizeEOL(await readFile(abs, "utf8"))
+    const raw = await readFile(abs, "utf8")
+    const content = normalizeEOL(raw)
     const occurrences = content.split(args.old_string).length - 1
     if (occurrences === 0) {
       // Give clues to help the model locate: first-line preview + common causes
       const preview = args.old_string.slice(0, 100).split("\n")[0]
+      // Similarity candidates (LCS, line-level, top 3, score ≥ 0.5) — turns the
+      // "not found" black box into a pointer at the most likely intended line.
+      // Multi-line old_string: only its first line is scored (marked accordingly).
+      const cands = findCandidates(content.split("\n"), args.old_string)
+      let candText = ""
+      if (cands.length > 0) {
+        const header = args.old_string.includes("\n")
+          ? `  similar lines (old_string line 1: "${args.old_string.split("\n")[0].slice(0, 80)}"):`
+          : "  similar lines:"
+        candText = "\n" + header + "\n" + cands.map((c) => `    L${c.line}: ${c.preview} (${Math.round(c.score * 100)}%)`).join("\n")
+      }
       throw new Error(
         `old_string not found in ${args.path}\n` +
         `  searched: "${preview}${args.old_string.length > 100 ? "…" : ""}"\n` +
-        `  hints: whitespace mismatch? file already changed? try reading the file first`
+        `  hints: whitespace mismatch? file already changed? try reading the file first` +
+        candText
       )
     }
     if (occurrences > 1 && !args.replace_all) {
@@ -207,7 +230,11 @@ export const editTool = {
       ? content.split(args.old_string).join(args.new_string)
       // Functional replacement: avoid $-substitution patterns in new_string (match string / backreference) being expanded
       : content.replace(args.old_string, () => args.new_string)
-    await writeFile(abs, updated, "utf8")
+    // Write back in the file's ORIGINAL EOL style (first-newline rule) — a CRLF
+    // file must not come back as LF (that rewrites every line in the diff).
+    // normalizeEOL first: new_string may carry \r\n (e.g. pasted from a raw CRLF
+    // read); without normalizing, split leaves stray \r and CRLF join makes \r\r\n.
+    await writeFile(abs, joinWithEol(normalizeEOL(updated).split("\n"), raw), "utf8")
     markDirty(abs)
     const diff = gitDiffOne(ctx.cwd, abs)
     return `Edited ${args.path}: replaced ${args.replace_all ? occurrences : 1} occurrence(s)${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
@@ -244,7 +271,8 @@ export const insertAfterTool = {
         `Read the file again (read tool) to refresh line numbers, then retry insert_after.`
       )
     }
-    const text = normalizeEOL(await readFile(abs, "utf8"))
+    const raw = await readFile(abs, "utf8") // original bytes — EOL detection needs the file's real line endings
+    const text = normalizeEOL(raw)
     const lines = text.split("\n")
 
     let targetLine
@@ -274,8 +302,10 @@ export const insertAfterTool = {
       throw new Error("Either after_line or after_regex is required")
     }
 
-    lines.splice(targetLine, 0, args.content)
-    const updated = lines.join("\n")
+    lines.splice(targetLine, 0, normalizeEOL(args.content))
+    // Write back in the file's ORIGINAL EOL style (review R9#2: same bug class as
+    // edit — a CRLF file must not silently become LF here either).
+    const updated = joinWithEol(lines, raw)
     await writeFile(abs, updated, "utf8")
     markDirty(abs)
     const diff = gitDiffOne(ctx.cwd, abs)
@@ -310,7 +340,11 @@ export const hashlineEditTool = {
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path)
     if (!args.old_hashes?.length) throw new Error("old_hashes must not be empty — read the file with hashes=true to get line hashes")
-    const content = normalizeEOL(await readFile(abs, "utf8"))
+    const raw = await readFile(abs, "utf8")
+    const content = normalizeEOL(raw)
+    // Encoding-corruption probe: U+FFFD means the file is not clean UTF-8 — hash
+    // addressing may be unreliable. Warn (never block).
+    const corrupted = content.includes("\uFFFD")
     const lines = content.split("\n")
     const fileHashes = lines.map((l) => hashLine(l))
     const target = args.old_hashes
@@ -334,7 +368,8 @@ export const hashlineEditTool = {
       const preview = target.join(" ")
       throw new Error(
         `Hash sequence not found in ${args.path}: ${preview}\n` +
-        `The file may have been modified since you last read it. Current hashes (first ${maxShow} lines):\n${hashDump}`
+        `The file may have been modified since you last read it. Current hashes (first ${maxShow} lines):\n${hashDump}` +
+        (corrupted ? `\n${FFFD_WARNING}` : "")
       )
     }
 
@@ -359,13 +394,14 @@ export const hashlineEditTool = {
 
     const pos = matches[0]
     // Replace: remove old lines, insert new lines at the same position
-    const newLines = args.new_content.split("\n")
+    const newLines = normalizeEOL(args.new_content).split("\n") // normalize: CRLF in new_content would join into \r\r\n
     lines.splice(pos, target.length, ...newLines)
-    const updated = lines.join("\n")
+    // Write back in the file's original EOL style (same rule as edit / apply_patch).
+    const updated = joinWithEol(lines, raw)
     await writeFile(abs, updated, "utf8")
     markDirty(abs)
     const diff = gitDiffOne(ctx.cwd, abs)
-    return `Edited ${args.path}: replaced ${target.length} line(s) at L${pos + 1} with ${newLines.length} line(s)${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
+    return `Edited ${args.path}: replaced ${target.length} line(s) at L${pos + 1} with ${newLines.length} line(s)${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}${corrupted ? `\n${FFFD_WARNING}` : ""}`
   },
 }
 

package/src/tools/patch.mjs

@@ -1,17 +1,16 @@
 import {
   DESC,
   autoSyntaxCheck,
-  resolveInCwd
+  resolveInCwd,
+  normalizeEOL,
+  detectFileEol,
+  majorityEol
 } from "./shared.mjs";
 import { markDirty } from "./file.mjs";
 import { execFileSync } from "node:child_process";
-import { mkdir } from "node:fs/promises";
-import { readFile } from "node:fs/promises";
-import { stat, lstat } from "node:fs/promises";
-import { writeFile } from "node:fs/promises";
-import { unlink } from "node:fs/promises";
+import { mkdir, readFile, lstat, writeFile, unlink } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { join, relative, dirname } from "node:path";
+import { relative, dirname } from "node:path";
 
 /**
  * Parse a unified diff: returns [{ path, isNew, hunks: [{ ops: [{type:" "|"-"|"+", text}] }] }]
@@ -121,18 +120,22 @@ export const applyPatchTool = {
       const abs = resolveInCwd(ctx, f.path)
       if (f.isNew) {
         if (existsSync(abs)) throw new Error(`Cannot create ${f.path}: file already exists`)
-        const content = f.hunks.flatMap((h) => h.ops.filter((o) => o.type === "+").map((o) => o.text)).join("\n") + "\n"
+        // New file: follow the directory's majority EOL style (default LF).
+        const eol = majorityEol(dirname(abs))
+        const content = f.hunks.flatMap((h) => h.ops.filter((o) => o.type === "+").map((o) => o.text)).join(eol) + eol
         planned.push({ abs, path: f.path, content, isNew: true })
       } else {
         const original = await readFile(abs, "utf8").catch(() => { throw new Error(`File not found: ${f.path}`) })
-        const eol = original.includes("\r\n") ? "\r\n" : "\n"
-        const lines = original.split("\n")
-        applyHunks(lines, f.hunks, eol, f.path)
-        planned.push({ abs, path: f.path, content: lines.join("\n"), isNew: false })
+        const eol = detectFileEol(original)
+        // Apply hunks in the normalized LF domain, then write back joined with the
+        // file's ORIGINAL EOL style — join("\n") here used to rewrite CRLF files as LF.
+        const lines = normalizeEOL(original).split("\n")
+        applyHunks(lines, f.hunks, "\n", f.path)
+        planned.push({ abs, path: f.path, content: lines.join(eol), isNew: false })
       }
     }
     // Multi-file write: write all to .tmp first, rename only after all succeed — failure cleans up written .tmp without affecting committed files
-    const { rename, unlink } = await import("node:fs/promises")
+    const { rename } = await import("node:fs/promises") // unlink already statically imported
     const written = []
     try {
       for (const p of planned) {

package/src/tools/shared.mjs

@@ -4,7 +4,7 @@
  */
 
 import { spawn, execFileSync, execFile } from "node:child_process"
-import { readFileSync, existsSync, realpathSync } from "node:fs"
+import { readFileSync, existsSync, realpathSync, readdirSync, statSync, openSync, readSync, closeSync } from "node:fs"
 import { dirname, join, resolve, relative, isAbsolute, sep } from "node:path"
 import { fileURLToPath } from "node:url"
 
@@ -55,6 +55,106 @@ export function normalizeEOL(text) {
   return text.replace(/\r\n/g, "\n")
 }
 
+/** Detect a file's EOL style by the type of its FIRST newline: "\r\n" first →
+ *  the whole file is written back as CRLF; a bare "\n" or no newline → LF.
+ *  Never counts occurrences (mixed files follow the first line's style). */
+export function detectFileEol(text) {
+  const i = text.indexOf("\n")
+  return i > 0 && text[i - 1] === "\r" ? "\r\n" : "\n"
+}
+
+/** Join lines with the EOL style detected from the original text (write-back restore). */
+export function joinWithEol(lines, originalText) {
+  return lines.join(detectFileEol(originalText))
+}
+
+const MAJORITY_EOL_MAX_FILES = 20
+const EOL_SNIFF_BYTES = 4096
+
+/** Majority EOL style of a directory's existing files (≤20 files, first 4KB each).
+ *  New files follow the directory's majority style; empty dir / tie / LF majority → "\n". */
+export function majorityEol(dirPath) {
+  let names
+  try { names = readdirSync(dirPath) } catch { return "\n" }
+  let crlf = 0, lf = 0
+  for (const name of names) {
+    if (crlf + lf >= MAJORITY_EOL_MAX_FILES) break
+    try {
+      const p = join(dirPath, name)
+      if (!statSync(p).isFile()) continue
+      const fd = openSync(p, "r")
+      let head = ""
+      try {
+        const buf = Buffer.alloc(EOL_SNIFF_BYTES)
+        const n = readSync(fd, buf, 0, EOL_SNIFF_BYTES, 0)
+        head = buf.subarray(0, n).toString("utf8")
+      } finally {
+        closeSync(fd)
+      }
+      if (detectFileEol(head) === "\r\n") crlf++
+      else lf++
+    } catch { /* unreadable entry — skip */ }
+  }
+  return crlf > lf ? "\r\n" : "\n"
+}
+
+const CANDIDATE_MAX_LEN = 500
+const CANDIDATE_PREVIEW_LEN = 80
+
+/** Longest-common-substring length (rolling-row DP). Inputs are pre-truncated by the caller. */
+function lcsLength(a, b) {
+  // Reused DP buffers (review R9#6): per-line allocation caused GC pressure on
+  // large files — hoist two module-level rows, grow to fit, swap by index.
+  const need = b.length + 1
+  if (_lcsBuf0.length < need) {
+    const size = Math.max(need, _lcsBuf0.length * 2)
+    _lcsBuf0 = new Uint16Array(size)
+    _lcsBuf1 = new Uint16Array(size)
+  }
+  let prev = _lcsBuf0, cur = _lcsBuf1
+  prev.fill(0, 0, need)
+  let best = 0
+  for (let i = 1; i <= a.length; i++) {
+    cur[0] = 0
+    const ca = a.charCodeAt(i - 1)
+    for (let j = 1; j < need; j++) {
+      if (ca === b.charCodeAt(j - 1)) {
+        const v = prev[j - 1] + 1
+        cur[j] = v
+        if (v > best) best = v
+      } else cur[j] = 0 // must reset — buffer is reused
+    }
+    const t = prev; prev = cur; cur = t
+  }
+  return best
+}
+let _lcsBuf0 = new Uint16Array(0), _lcsBuf1 = new Uint16Array(0)
+/** Line-level similarity candidates for a failed edit: score = LCS(oldString, line) / max(len).
+ *  Multi-line old_string matches on its FIRST line only (failures usually diverge there).
+ *  Both sides are truncated to 500 chars before scoring so minified files can't blow the budget.
+ *  Returns up to topN [{ line (1-based), preview, score }] with score >= threshold, best first. */
+export function findCandidates(lines, oldString, topN = 3, threshold = 0.5) {
+  const needle = oldString.split("\n")[0].slice(0, CANDIDATE_MAX_LEN)
+  if (!needle) return []
+  const scored = []
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i]
+    if (!raw) continue
+    const line = raw.length > CANDIDATE_MAX_LEN ? raw.slice(0, CANDIDATE_MAX_LEN) : raw
+    const longer = Math.max(needle.length, line.length)
+    const shorter = Math.min(needle.length, line.length)
+    // LCS ≤ shorter side — a length ratio below the threshold can never reach it; skip the DP.
+    if (shorter / longer < threshold) continue
+    const score = lcsLength(needle, line) / longer
+    if (score >= threshold) scored.push({ line: i + 1, preview: raw.slice(0, CANDIDATE_PREVIEW_LEN), score })
+  }
+  scored.sort((a, b) => b.score - a.score || a.line - b.line)
+  return scored.slice(0, topN)
+}
+
+/** Appended to hashline_edit results when the file contains U+FFFD (encoding-corruption probe). */
+export const FFFD_WARNING = "⚠ file contains U+FFFD (replacement char) — encoding may be corrupted; hash-based addressing may be unreliable. Consider fixing the file encoding first."
+
 /** Convert to OpenAI tools parameter format */
 export function toOpenAISchema(tool) {
   return {

package/src/tui/cmd-eng.mjs

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url"
 import { ansi, C } from "./ansi.mjs"
 
 const templateDir = join(fileURLToPath(import.meta.url), "..", "..", "prompts")
+import { ENG_OFF_REMINDER } from "../agent.mjs"
 
 export async function handleEngCommand(ctx) {
   const { agent, pushLine, pushLabel, persistRaw, showPicker } = ctx
@@ -31,7 +32,14 @@ export async function handleEngCommand(ctx) {
   }
 
   agent.config.agent.engineering = !agent.config.agent.engineering
-  if (!agent.config.agent.engineering) agent._engDesignToken = null // invalidate stale token
+  if (!agent.config.agent.engineering) {
+    agent._engDesignToken = null // invalidate stale token
+    // OFF must reach the model too (2026-08-25): /auto pushes a reminder on toggle — the
+    // mode flip is invisible to the agent otherwise. (ON needs none here: the injector
+    // in agent.mjs already announces ON transitions on the next turn.)
+    agent._pendingReminders = agent._pendingReminders ?? []
+    agent._pendingReminders.push(ENG_OFF_REMINDER)
+  }
   await persistRaw((raw) => {
     raw.agent ??= {}
     raw.agent.engineering = agent.config.agent.engineering