thincoder 0.12.44 → 0.12.46

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 本文件记录 ThinCoder CLI 的发布历史。格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/)，版本遵循[语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [0.12.46] — 2026-08-27
+
+### Fixed
+
+- **checklist 工具坐标系断裂**：`add` 返回任务 ID、`mark` 却只收列表位置 index，agent 拿 ID 定位不到条目、只能猜 index——误标无关条目（线上事故）。修复：`mark` 加 `id` 参数（优先于 index）；auto-ID 按「最大根号+1」分配（含 `checklist-done.md` 双文件扫描，归档 ID 恒占位不复用）；历史重复 `T[\d.]+:` 前缀读入即归一；标记父任务 done 时子任务非全 done 则拒绝（防静默丢弃子树），全 done 则递归归档整棵子树
+- **子 agent/advisor 模型显示补录**（TUI.md 文档欠账，功能此前已实现）
+
+## [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.46",
   "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/checklist.md

@@ -4,7 +4,10 @@ Items support tree hierarchy via indentation (2 spaces per level) and auto-assig
 
 Parameters:
 - action: "add" | "mark" | "list"
+- id: task ID to mark, e.g. "T3" (with "mark"; preferred — use the ID returned by `add`, or from `list`)
 - item: text for new item (with "add")
-- index: 1-based index (with "mark")  
+- index: 1-based index (with "mark"; fallback — use only when you have no ID)
 - status: "pending" | "in_progress" | "done" (with "mark")
 - parent: parent task ID for hierarchical tasks, e.g. "T1" (with "add")
+
+Note: marking a parent "done" requires all its child tasks already done — otherwise it is rejected (complete the children before marking the parent done).

package/src/tools/checklist.mjs

@@ -31,42 +31,79 @@ function parse(filePath) {
     const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
     const text = m[3].trim()
 
-    // Extract explicit ID if present (e.g. "T1:", "T1.1:") — strip it from the text
-    // so write() doesn't re-prepend it (round-trip would otherwise accumulate "T1: T1: ...")
-    const idMatch = text.match(/^(T[\d.]+):\s*/)
-    const node = {
-      id: idMatch ? idMatch[1] : null,
-      index: flatIdx,
-      depth,
-      status,
-      text: idMatch ? text.slice(idMatch[0].length) : text,
-      children: [],
+    // Strip ALL leading "T[\d.]+:" tokens (historical dirty data can accumulate
+    // "T15: T15: T15:"); keep the first token as the ID and the rest as text.
+    let id = null
+    let bareText = text
+    let idTok
+    while ((idTok = bareText.match(/^(T[\d.]+):\s*/))) {
+      if (id == null) id = idTok[1]
+      bareText = bareText.slice(idTok[0].length)
     }
+    const node = { id, index: flatIdx, depth, status, text: bareText, children: [] }
 
     // Find parent by popping stack until we find a node at depth-1
     while (stack.length > 1 && stack.at(-1).depth >= depth) stack.pop()
     const parent = stack.at(-1)
     parent.children.push(node)
-    // Auto-assign ID if not explicit
-    if (!node.id) {
-      const siblingCount = parent.children.length
-      const base = parent.id ? `${parent.id}` : "T"
-      if (parent.id) {
-        node.id = `${base}.${siblingCount}`
-      } else {
-        // Root level: T1, T2, T3...
-        let rootIdx = 0
-        for (const c of items) {
-          if (c.id?.match(/^T\d+$/)) rootIdx = Math.max(rootIdx, parseInt(c.id.slice(1)))
-        }
-        node.id = `T${rootIdx + 1}`
+    stack.push({ children: node.children, depth, id: node.id })
+  }
+
+  // Assign stable IDs to lines that lacked an explicit one, exactly once.
+  // IDs are "max existing number + 1" (not position-based) so gaps left by
+  // archived items never collide, and persisted IDs never drift on re-read.
+  let assigned = false
+  function assignIds(nodes, parentId) {
+    for (const n of nodes) {
+      if (!n.id) {
+        n.id = parentId ? nextChildId(parentId, nodes) : nextRootId(nodes, doneRoots)
+        assigned = true
       }
+      if (n.children?.length) assignIds(n.children, n.id)
     }
-    stack.push({ children: node.children, depth, id: node.id })
   }
+  // Root IDs archived to the done file also reserve numbers (mirrors the `add`
+  // path's double-file scan), so auto-assigned IDs never collide with them.
+  const doneRoots = readDoneRoots(join(dirname(filePath), DONE))
+  assignIds(items, null)
+  if (assigned) write(filePath, items)
+
   return items
 }
 
+function readDoneRoots(doneFile) {
+  if (!existsSync(doneFile)) return []
+  const roots = []
+  for (const line of readFileSync(doneFile, "utf-8").split("\n")) {
+    const m = line.match(/^- \[.\] (T\d+): /)
+    if (m) roots.push({ id: m[1] })
+  }
+  return roots
+}
+
+function nextRootId(items, doneItems) {
+  let max = 0
+  for (const list of [items, doneItems]) {
+    for (const c of list ?? []) {
+      const m = c.id?.match(/^T(\d+)$/)
+      if (m) max = Math.max(max, parseInt(m[1]))
+    }
+  }
+  return `T${max + 1}`
+}
+
+function nextChildId(parentId, children) {
+  let max = 0
+  const prefix = `${parentId}.`
+  for (const c of children) {
+    if (c.id?.startsWith(prefix)) {
+      const suffix = c.id.slice(prefix.length)
+      if (/^\d+$/.test(suffix)) max = Math.max(max, parseInt(suffix))
+    }
+  }
+  return `${prefix}${max + 1}`
+}
+
 /** Write items back to file, preserving tree structure */
 function write(filePath, items, _depth = 0) {
   if (_depth === 0) mkdirSync(dirname(filePath), { recursive: true })
@@ -108,6 +145,26 @@ function flatten(items, out = []) {
   return out
 }
 
+/** True if every descendant (children, grandchildren, …) is done. */
+function allChildrenDone(node) {
+  for (const c of node.children ?? []) {
+    if (c.status !== "done" || !allChildrenDone(c)) return false
+  }
+  return true
+}
+
+/** Recursively clone a subtree for archiving, forcing every status to done. */
+function archiveSubtree(node) {
+  return {
+    id: node.id,
+    index: 0,
+    depth: 0,
+    status: "done",
+    text: node.text,
+    children: (node.children ?? []).map(archiveSubtree),
+  }
+}
+
 /** Parse pending items only (for context injection) */
 export function pendingItems(cwd) {
   const flat = flatten(parse(checklistPath(cwd)))
@@ -125,13 +182,17 @@ export const checklistTool = {
         enum: ["add", "mark", "list"],
         description: "add a new item / mark item status / list all items"
       },
+      id: {
+        type: "string",
+        description: "Task ID to mark (preferred — use the ID returned by add, e.g. 'T3')"
+      },
       item: {
         type: "string",
         description: "Item text (required for add)"
       },
       index: {
         type: "number",
-        description: "1-based item index (required for mark)"
+        description: "1-based item index (fallback for mark, only when id is absent)"
       },
       status: {
         type: "string",
@@ -161,48 +222,46 @@ export const checklistTool = {
           parentId = found.item.id
         }
 
-        // Auto-assign ID
-        let id
-        if (parentId) {
-          id = `${parentId}.${target.length + 1}`
-        } else {
-          let maxIdx = 0
-          for (const c of items) {
-            const m = c.id?.match(/^T(\d+)$/)
-            if (m) maxIdx = Math.max(maxIdx, parseInt(m[1]))
-          }
-          id = `T${maxIdx + 1}`
-        }
-
+        const id = parentId ? nextChildId(parentId, target) : nextRootId(items, parse(donePath(ctx.cwd)))
         const node = { id, index: 0, depth: parentId ? 1 : 0, status: "pending", text: args.item, children: [] }
         target.push(node)
         write(checklistPath(ctx.cwd), items)
         return `Added: [ ] ${id}: ${args.item}${parentId ? ` (under ${parentId})` : ""}`
       }
       case "mark": {
-        if (args.index == null) return "Error: 'index' is required for mark"
+        if (args.id == null && args.index == null) return "Error: 'id' or 'index' is required for mark"
         const status = args.status
         if (!status || !["pending", "in_progress", "done"].includes(status)) return "Error: 'status' is required (pending|in_progress|done)"
         const cp = checklistPath(ctx.cwd)
         const items = parse(cp)
-        const flat = flatten(items)
-        if (args.index < 1 || args.index > flat.length) return `Error: index ${args.index} out of range (1-${flat.length})`
-        const item = flat[args.index - 1]
+        let item
+        if (args.id != null) {
+          const found = findById(items, args.id)
+          if (!found) return `Error: id '${args.id}' not found. Use 'list' to see all task IDs.`
+          item = found.item
+        } else {
+          const flat = flatten(items)
+          if (args.index < 1 || args.index > flat.length) return `Error: index ${args.index} out of range (1-${flat.length})`
+          item = flat[args.index - 1]
+        }
         const old = item.status
         if (old === status) return `Already ${status}: ${item.text}`
+        if (status === "done" && item.children?.length && !allChildrenDone(item)) {
+          return "Error: 父任务仍有未完成的子任务，先处理子任务再标父 done"
+        }
         item.status = status
         if (status === "done") {
-          // Move to done file
+          // Move the whole subtree to the done file (hierarchy preserved).
           const dp = donePath(ctx.cwd)
           const doneItems = parse(dp)
-          doneItems.push({ id: item.id, index: 0, depth: 0, status: "done", text: item.text, children: [] })
+          doneItems.push(archiveSubtree(item))
           write(dp, doneItems)
-          // Remove from tree
+          // Remove the subtree from the tree.
           const found = findById(items, item.id)
           if (found) found.parent.splice(found.idx, 1)
         }
         write(cp, items)
-        return `Marked #${args.index} ${old} → ${status}: ${item.id}: ${item.text}`
+        return `Marked ${item.id} ${old} → ${status}`
       }
       case "list": {
         const items = parse(checklistPath(ctx.cwd))

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