thincoder 0.12.43 → 0.12.45

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 本文件记录 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
+
+- **安全修复：subagent 变形 role 绕过工程模式门禁**——`role="Coder"/" coder"` 等非精确字符串穿透两个模式门禁（精确比较），fallthrough 到全工具/无 overlay 子代理，绕过设计评审拿到完整写权限。修复：execute 入口 ROLES 白名单，未知 role 直接 throw（fail-closed）；防回归测试锁定 7 种变形值 × 两种模式
+- IK9UZ8 思考型模型标题生成（vscode 端同修对齐）
+- 文档状态/TODO 销账（24+13 处"待评审"→"已实现"；TODO 7 条已实现条目核对关闭）
+- TUI.md 章节号重编号（## 4-10 顺延，无重复）
+
+### Added
+
+- **ESLint 引入**（规则基线对齐 vscode 端）：lint script + 21 个 error 清零（死赋值/cause 补全）
+- **跨端同构模块语义锚点比对测试**：14 个跨仓库契约（advisor 收敛协议、蒸馏语义、64K 阈值）两端必须一致——单边漂移立即红
+- **RELEASE.md**：npm 发布流程 + 4 条踩坑记录（vsce 自动 bump、Open VSX 异步激活、ovsx 无 TTY 静默失败、prepublishOnly）
+
+### Docs
+
+- 文档债收口：6 处"待合并"全部处理（真碎片合并/归档/独立保留定性）
+
 ## [0.12.43] — 2026-08-25
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.43",
+  "version": "0.12.45",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",
@@ -32,8 +32,13 @@
   },
   "scripts": {
     "test": "node --test \"test/*.mjs\"",
-    "prepublishOnly": "node --test \"test/*.mjs\""
+    "prepublishOnly": "node --test \"test/*.mjs\"",
+    "lint": "eslint src"
   },
   "author": "liwei <liwei@51marine.com> (上海新舶)",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "^9.0.0",
+    "@eslint/js": "^9.0.0"
+  }
 }

package/src/advisor/repos.mjs

@@ -49,7 +49,7 @@ export function collectRepoSnapshots(repos, cwd) {
   const targets = repos.length > 0 ? repos : [cwd]
   const parts = []
   for (const repo of targets) {
-    let status = "", diff = ""
+    let status, diff
     try {
       status = execFileSync("git", ["status", "--porcelain"], {
         cwd: repo, encoding: "utf8", timeout: GIT_TIMEOUT, stdio: ["ignore", "pipe", "pipe"],
@@ -153,7 +153,7 @@ export function isDocOnlyChange(repos, cwd) {
   const targets = repos.length > 0 ? repos : [cwd]
   let sawChanges = false
   for (const repo of targets) {
-    let status = ""
+    let status
     try {
       status = execFileSync("git", ["status", "--porcelain"], {
         cwd: repo, encoding: "utf8", timeout: GIT_TIMEOUT, stdio: ["ignore", "pipe", "pipe"],

package/src/agent/dispatch.mjs

@@ -49,7 +49,7 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
   const prepared = []
   for (const toolCall of toolCalls) {
     const tool = toolByName.get(toolCall.name)
-    let args = {}
+    let args
     try {
       args = JSON.parse(toolCall.arguments || "{}")
     } catch {

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-tools/subagent.mjs

@@ -77,6 +77,14 @@ export const subagentTool = {
     const parent = ctx.agent
     const role = args.role
 
+    // Role normalization + whitelist (2026-08-25, coder-leak fix): exact-string gates let
+    // variant roles ("Coder", " coder") bypass BOTH mode gates and fall through to
+    // full tools / no overlay — a full-write coder without design review. Schema enums are
+    // advisory; providers don't enforce them. Fail closed on unknown roles.
+    const ROLES = new Set(["explore", "plan", "coder", "eng-coder"])
+    if (!ROLES.has(role)) {
+      throw new Error(`Unknown subagent role: ${JSON.stringify(role)}. Valid roles: explore, plan, coder, eng-coder (exact spelling).`)
+    }
     // Role is mutually exclusive per mode: normal mode → "coder", engineering mode → "eng-coder"
     if (parent.config?.agent?.engineering && role === "coder") {
       throw new Error("Engineering mode: use role='eng-coder' for implementation tasks.")

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/config.mjs

@@ -235,7 +235,7 @@ export function loadConfig() {
     try {
       config = JSON.parse(readFileSync(configPath, "utf8"))
     } catch (error) {
-      throw new Error(`Config file is not valid JSON, check or delete it: ${configPath}\n  ${error.message}`)
+      throw new Error(`Config file is not valid JSON, check or delete it: ${configPath}\n  ${error.message}`, { cause: error })
     }
   }
 

package/src/git/checkpoint.mjs

@@ -29,7 +29,7 @@ function git(cwd, args, { allowFail = false } = {}) {
     return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim()
   } catch (error) {
     if (allowFail) return null
-    throw new Error(`git ${args.join(" ")} failed: ${error.stderr?.toString().trim() || error.message}`)
+    throw new Error(`git ${args.join(" ")} failed: ${error.stderr?.toString().trim() || error.message}`, { cause: error })
   }
 }
 
@@ -324,7 +324,7 @@ export async function listFileVersions(cwd, filePath) {
     } else if ((meta.tracked ?? []).includes(filePath) || (meta.untracked ?? []).includes(filePath)) {
       // Legacy snapshot (no per-file meta): fall back to stat-ing the copy
       const src = join((meta.tracked ?? []).includes(filePath) ? join(root, id, "files") : join(root, id, "untracked"), filePath)
-      let size = null, sha = null
+      let size, sha
       try {
         const buf = await readFile(src)
         size = buf.length

package/src/git/gitmem.mjs

@@ -55,14 +55,16 @@ export async function pullTeam(dir) {
       try { await git(dir, ["rebase", "--abort"]) } catch {
         abortFailed = true
       }
-      throw new Error(
+      const conflictError = new Error(
         `Team memory sync conflict: local and remote modified the same entry.\n` +
         `Please resolve manually in ${dir} with \`git pull\`, then re-run \`thincoder sync\`.\n` +
         (abortFailed
           ? `(WARNING: git rebase --abort also failed — the repo may be in a conflicted state. ` +
             `Run \`cd ${dir} && git rebase --abort\` manually to clean up.)`
           : `(The local repo has been restored to its pre-sync state — nothing was lost.)`),
+        { cause: error },
       )
+      throw conflictError
     }
     throw error
   }

package/src/memory/core.mjs

@@ -198,7 +198,7 @@ export async function putMarkdown(memory, { layer, dir, type, title, content, ta
  * vanished entries are removed from the index.
  */
 export async function syncDir(memory, { layer, dir }) {
-  let names = []
+  let names
   try {
     names = (await readdir(dir)).filter((n) => n.endsWith(".md"))
   } catch {

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
@@ -261,7 +289,7 @@ export const insertAfterTool = {
       try {
         regex = new RegExp(args.after_regex)
       } catch (e) {
-        throw new Error(`after_regex /${args.after_regex}/ is not a valid JavaScript regex: ${e.message}`)
+        throw new Error(`after_regex /${args.after_regex}/ is not a valid JavaScript regex: ${e.message}`, { cause: e })
       }
       const matches = []
       for (let i = 0; i < lines.length; i++) {
@@ -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/tools/system.mjs

@@ -339,7 +339,7 @@ export const grepTool = {
       const pat = args.literal ? escapeRegExp(String(args.pattern)) : args.pattern
       regex = new RegExp(pat, args.ignoreCase ? "i" : "")
     } catch (e) {
-      throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`)
+      throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`, { cause: e })
     }
     const fileFilter = args.glob ? globToRegex(args.glob) : null
     const before = Math.max(0, Math.floor(args.before ?? 0))
@@ -439,7 +439,7 @@ export const lsTool = {
     try {
       entries = await readdir(abs, { withFileTypes: true })
     } catch (e) {
-      if (e.code === "ENOENT" || e.code === "ENOTDIR") throw new Error(`ls: ${args.path ?? "."} — ${e.code === "ENOTDIR" ? "not a directory" : "not found"}`)
+      if (e.code === "ENOENT" || e.code === "ENOTDIR") throw new Error(`ls: ${args.path ?? "."} — ${e.code === "ENOTDIR" ? "not a directory" : "not found"}`, { cause: e })
       throw e
     }
     const rows = await Promise.all(

package/src/tools/web.mjs

@@ -187,6 +187,6 @@ export const fetchTool = {
       const ct = headerOf(response, "content-type") ?? ""
       const body = await response.text()
       return ct.includes("text/html") ? truncate(htmlToText(body)) : truncate(body)
-    } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}`) }
+    } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}`, { cause: e }) }
   },
 }

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

package/src/tui/layout.mjs

@@ -61,7 +61,7 @@ export function computeLayout(state, { cols, rows }) {
   const pickerH = overlay ? Math.min(overlay.lines.length + 1, Math.max(6, rows - 12)) : 0
 
   // Todo
-  let visibleTasks = []
+  let visibleTasks
   if (state.tasks.length <= MAX_TASK_LINES) {
     visibleTasks = state.tasks
   } else {