thincoder 0.12.58 → 0.12.60

package/src/tools/checklist-sync.mjs

@@ -0,0 +1,181 @@
+/**
+ * checklist-sync.mjs — checklist 并发写同步机（R10 F4，MULTI-INSTANCE-COLLAB.md §2a.3
+ * ——2026-09-06，自 checklist.mjs 拆出：门控 + 合并 + 序列化——防 checklist.mjs 超 300
+ * 行 advisory 线；本模块为纯同步机制，不持 checklist 业务状态）。
+ *
+ * 双端 checklist 同路径 {cwd}/.thincoder/checklist.md——多实例并发写原为裸整文件覆盖
+ * （丢项）。写前 mtime 门控 + ID 键合并（评审修正 #6 基线规则：基线 = 本读-改-写链内
+ * 最近一次 stat 的 mtime；本进程自写后刷新——parse 规范化写回不误触发 merged/重分配）。
+ * .bak 不做（决策点② A：cwd 在 git 仓库内——git 兜底现场）。
+ *
+ * 冲突语义（flushWrite 内收口）：写前 stat ≠ 基线（对端并发写过）→ 重读磁盘 → 双方
+ * union by ID（本端新增 + 盘上他端新增都保留；同 ID 不同文本 → 盘上保留、本端重分配
+ * max+1 续分配；同 ID 仅状态不同 → in_progress 胜过 pending——标记不丢）；checklist
+ * 文件合并时按 done 文件归档 ID 排除（含子任务点号 ID——并发 mark-done 的"盘上有旧
+ * pending 副本"不复活已归档项——done 集合 union 的另一半）。checklist-done.md 自身
+ * 合并 = 纯 union（无归档排除）。
+ *
+ * 调用方（checklist.mjs）通过 flushWrite 的 opts 注入：reread（磁盘无写回重读）、
+ * doneFile 路径、isDone（目标文件是否为 done 文件）——避免本模块反向依赖 checklist
+ * 的 parse/树结构。
+ */
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs"
+
+const baselines = new Map() // filePath → 最近一次读的 stat mtime（null = 读时文件缺失）
+
+/** F4 测试缝（伪属主范式——T-F4a..d）：在每次写前门控处注入"对端写盘"钩子——模拟本链
+ *  parse 后、write 前对端实例的真实并发写。生产不设置（null → 零行为影响）。 */
+let writeGateHook = null
+export function _setWriteGateHookForTest(fn) { writeGateHook = fn }
+
+/** 文件缺失 → null（门控 t0 基线形态）。 */
+export function statMtime(p) {
+  try { return statSync(p).mtimeMs } catch { return null }
+}
+
+/** 调用方（parse 读链）登记基线——读后写链以它为门控比对基准。 */
+export function noteReadBaseline(filePath, mtime) {
+  baselines.set(filePath, mtime)
+}
+
+/** Done 文件归档根 ID 清单（含子任务点号 ID：T1 与 T1.2 都进——归档排除用；编号预留
+ *  nextRootId 的 /^T(\d+)$/ 过滤不受影响）。 */
+export 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+)(?:\.\d+)*): /)
+    if (m) roots.push({ id: m[1] })
+  }
+  return roots
+}
+
+/** Serialize items to markdown lines (2-space indent per depth) — tree structure preserved. */
+function renderItems(nodes, depth, out) {
+  const indent = "  ".repeat(depth)
+  for (const item of nodes) {
+    const mark = item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "
+    const label = item.id ? `${item.id}: ${item.text}` : item.text
+    out.push(`${indent}- [${mark}] ${label}`)
+    if (item.children?.length) renderItems(item.children, depth + 1, out)
+  }
+}
+
+/**
+ * 门控 + 合并 + 写（F4 收口——parse 规范化写回 / add / mark 双写都经它）。
+ * @param filePath 目标文件（checklist.md 或 checklist-done.md）
+ * @param items 本端（读-改-写链产物）的顶层 items
+ * @param opts.reread 磁盘无写回重读函数（返回盘上顶层 items——合并触发时调用）
+ * @param opts.doneFile done 文件路径（checklist 合并的归档排除源）
+ * @param opts.isDone 目标文件是否为 done 文件（true = 纯 union，无归档排除）
+ * @returns { merged, items }——merged=true 时 items 为落盘真相（本端节点原地重分配——
+ *   调用方持有的引用/消息读到的即最终 ID）；merged=false 时 items 为原输入。
+ */
+export function flushWrite(filePath, items, { reread, doneFile, isDone }) {
+  if (writeGateHook) writeGateHook(filePath) // 测试缝：模拟对端此刻写盘
+  const base = baselines.get(filePath) // undefined = 本链无读（防御——无基线无从门控）
+  const now = statMtime(filePath)
+  let finalItems = items
+  let merged = false
+  if (base !== undefined && now !== base) {
+    // 磁盘被对端并发改过（本链读后）→ 重读磁盘 + 合并（ID union）
+    const diskItems = reread()
+    finalItems = mergeItems(diskItems, items, doneFile, isDone)
+    merged = true
+  }
+  const out = []
+  renderItems(finalItems, 0, out)
+  writeFileSync(filePath, out.join("\n") + "\n")
+  baselines.set(filePath, statMtime(filePath)) // 自写后刷新基线（防自写误判并发）
+  return { merged, items: finalItems }
+}
+
+// ── F4 合并（ID 键 union）─────────────────────────────────────────────────────
+
+function flattenTree(nodes, out = []) {
+  for (const n of nodes) {
+    out.push(n)
+    if (n.children?.length) flattenTree(n.children, out)
+  }
+  return out
+}
+
+/** 层内递归合并（磁盘序在前；本端独有/重分配项追加尾部）——规则见文件头注释。 */
+function mergeLevel(diskNodes, ourNodes, env) {
+  const diskById = new Map(diskNodes.filter((n) => n.id != null).map((n) => [n.id, n]))
+  const ourById = new Map(ourNodes.filter((n) => n.id != null).map((n) => [n.id, n]))
+  const result = []
+  const pending = [] // 本端独有 + 同 ID 异文本（待重分配）——追加在磁盘序之后
+  for (const d of diskNodes) {
+    if (d.id != null && !env.isDone && env.doneIds.has(d.id)) continue // 已归档（对端 mark-done）→ 不复活
+    const o = d.id != null ? ourById.get(d.id) : null
+    if (!o) { result.push(d); continue } // 盘上独有 → 整棵保留
+    const childEnv = { ...env, prefix: `${d.id}.` } // 子层重分配域 = 父 ID 前缀（"T1" → "T1."）
+    if (o.text === d.text && o.status === d.status) {
+      // 双端同一节点（parse 规范化幂等场景）→ 去重；子树仍逐层合并（防丢任一端子新增）
+      d.children = mergeLevel(d.children ?? [], o.children ?? [], childEnv)
+      result.push(d)
+      continue
+    }
+    if (o.text === d.text) {
+      // 仅状态不同 → in_progress 胜过 pending（标记意图不丢；同文本不可能 pending×pending）
+      const carry = d.status === "in_progress" ? d : o
+      carry.children = mergeLevel(d.children ?? [], o.children ?? [], childEnv)
+      result.push(carry)
+      continue
+    }
+    // 同 ID 不同文本（并发 add 各自从同基线分到同号）→ 盘上保留；本端项排队重分配
+    result.push(d)
+    pending.push(o)
+  }
+  for (const o of ourNodes) {
+    if (o.id == null) { pending.push(o); continue } // 无 ID 行（理论极少——parse 已归一）→ 原样追加
+    if (!env.isDone && env.doneIds.has(o.id)) continue // 本端项已被归档 → 丢弃（不复活）
+    if (!diskById.has(o.id)) pending.push(o) // 本端独有 → 保留（含子树）
+    // 共享 ID 已在磁盘循环处理（去重/状态/文本冲突排队）
+  }
+  for (const o of pending) {
+    if (o.id != null && diskById.has(o.id)) reassignNode(o, env) // 文本冲突项 → 重分配 max+1 续分配
+    result.push(o)
+  }
+  return result
+}
+
+/** 重分配：层前缀（根 "T" / 子树 `${parentId}.`）下 max+1；子树 ID 前缀同步换新
+ *  （"T4.1" → "T5.1"——ID 层级与父节点保持一致）。原地改——调用方引用即最终 ID。 */
+function reassignNode(node, env) {
+  let max = 0
+  for (const id of env.allIds) {
+    if (!id?.startsWith(env.prefix)) continue
+    const suffix = id.slice(env.prefix.length)
+    if (/^\d+$/.test(suffix)) max = Math.max(max, parseInt(suffix))
+  }
+  const oldId = node.id
+  const newId = `${env.prefix}${max + 1}`
+  node.id = newId
+  env.allIds.add(newId)
+  if (oldId) renameSubtreePrefixes(node, oldId, newId)
+}
+
+function renameSubtreePrefixes(node, oldId, newId) {
+  for (const c of node.children ?? []) {
+    if (c.id?.startsWith(`${oldId}.`)) {
+      c.id = newId + c.id.slice(oldId.length)
+      renameSubtreePrefixes(c, oldId, newId)
+    }
+  }
+}
+
+/** 合并入口：isDone = checklist-done 文件（纯 union——无归档排除）；否则按 done 文件
+ *  当前归档 ID 排除（含点号子 ID——对端 mark-done 归档的项不因本端旧 parse 复活）。 */
+function mergeItems(diskItems, ourItems, doneFile, isDone) {
+  const doneRoots = isDone ? [] : readDoneRoots(doneFile)
+  const doneIds = new Set(doneRoots.map((r) => r.id))
+  const allIds = new Set() // 重分配 max 计算域：双端全树 + 归档根（根层防撞）
+  for (const n of flattenTree(diskItems).concat(flattenTree(ourItems))) {
+    if (n.id != null) allIds.add(n.id)
+  }
+  for (const id of doneIds) allIds.add(id)
+  const env = { isDone, doneIds, allIds, prefix: "T" } // 根层前缀 "T"；子层在 mergeLevel 递归时推导
+  return mergeLevel(diskItems, ourItems, env)
+}

package/src/tools/checklist.mjs

@@ -1,6 +1,9 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs"
+import { readFileSync, existsSync, mkdirSync } from "node:fs"
 import { join, dirname } from "node:path"
 import { DESC } from "./shared.mjs"
+// F4 并发写同步机（门控 + ID union 合并 + 序列化）在 checklist-sync.mjs——本文件只留
+// parse/树操作与工具执行；设计见 MULTI-INSTANCE-COLLAB.md §2a.3（D-F4a/b）。
+import { statMtime, noteReadBaseline, readDoneRoots, flushWrite } from "./checklist-sync.mjs"
 
 const CHECKLIST = "checklist.md"
 const DONE = "checklist-done.md"
@@ -15,8 +18,21 @@ function donePath(cwd) { return join(cwd, ".thincoder", DONE) }
  * "index" is the 1-based position in the flat markdown list.
  */
 function parse(filePath) {
-  if (!existsSync(filePath)) return []
-  const lines = readFileSync(filePath, "utf-8").split("\n")
+  return readItems(filePath, { writeback: true })
+}
+
+/** 读盘 → 建树 → 无 ID 行一次性分配（assignIds）；writeback=true 时（公开 parse 语义）
+ *  分配后立即经 write() 落盘（同走 F4 门控——并发写合并/放弃重分配）。基线在**读前**
+ *  stat（stat→read 序：对端在读与 stat 微窗口写入只造成假合并，绝不漏检静默覆盖）。 */
+function readItems(filePath, { writeback }) {
+  const base = statMtime(filePath) // 基线 = 本链最近 stat（评审修正 #6）
+  let text = null
+  try {
+    if (existsSync(filePath)) text = readFileSync(filePath, "utf-8")
+  } catch { text = null } // 读失败（对端删/半写）→ 按缺失降级
+  noteReadBaseline(filePath, text === null ? null : base)
+  if (text === null) return []
+  const lines = text.split("\n")
   const items = []
   let flatIdx = 0
   const stack = [{ children: items, depth: -1 }] // virtual root
@@ -29,12 +45,12 @@ function parse(filePath) {
     const depth = Math.floor(indent.length / 2) // 2 spaces = 1 level
     const raw = m[2]
     const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
-    const text = m[3].trim()
+    const text2 = m[3].trim()
 
     // 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 bareText = text2
     let idTok
     while ((idTok = bareText.match(/^(T[\d.]+):\s*/))) {
       if (id == null) id = idTok[1]
@@ -56,7 +72,7 @@ function parse(filePath) {
   function assignIds(nodes, parentId) {
     for (const n of nodes) {
       if (!n.id) {
-        n.id = parentId ? nextChildId(parentId, nodes) : nextRootId(nodes, doneRoots)
+        n.id = parentId ? nextChildId(parentId, nodes, doneIds) : nextRootId(nodes, doneRoots)
         assigned = true
       }
       if (n.children?.length) assignIds(n.children, n.id)
@@ -65,20 +81,15 @@ function parse(filePath) {
   // 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))
+  const doneIds = doneRoots.map((r) => r.id) // 含点号子 ID——子层分配同样预留
   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] })
+  if (writeback && assigned) {
+    // 规范化写回（同走门控——F4）：合并发生时返回落盘真相——调用方（add/mark/list）在
+    // 磁盘真值上继续，避免基于过期 parse 再触发一轮合并
+    const r = write(filePath, items)
+    if (r.merged) return r.items
   }
-  return roots
+  return items
 }
 
 function nextRootId(items, doneItems) {
@@ -92,7 +103,7 @@ function nextRootId(items, doneItems) {
   return `T${max + 1}`
 }
 
-function nextChildId(parentId, children) {
+function nextChildId(parentId, children, archivedIds) {
   let max = 0
   const prefix = `${parentId}.`
   for (const c of children) {
@@ -101,27 +112,24 @@ function nextChildId(parentId, children) {
       if (/^\d+$/.test(suffix)) max = Math.max(max, parseInt(suffix))
     }
   }
+  // 归档预留（F4 补正）：已归档同前缀点号 ID 不复用——重加子项撞归档 ID 会被门控合并误删
+  for (const id of archivedIds ?? []) {
+    if (typeof id !== "string" || !id.startsWith(prefix)) continue
+    const suffix = 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 })
-  const lines = []
-  const indent = "  ".repeat(_depth)
-  for (const item of items) {
-    const mark = item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "
-    const label = item.id ? `${item.id}: ${item.text}` : item.text
-    lines.push(`${indent}- [${mark}] ${label}`)
-    if (item.children?.length) {
-      lines.push(...write(filePath, item.children, _depth + 1).split("\n").filter(Boolean))
-    }
-  }
-  if (_depth === 0) {
-    writeFileSync(filePath, lines.join("\n") + "\n")
-    return ""
-  }
-  return lines.join("\n")
+/** Write items back to file, preserving tree structure — F4 收口点（门控 + 合并见
+ *  checklist-sync.mjs flushWrite）。返回 { merged, items }（同 flushWrite 契约）。 */
+function write(filePath, items) {
+  mkdirSync(dirname(filePath), { recursive: true })
+  return flushWrite(filePath, items, {
+    reread: () => readItems(filePath, { writeback: false }), // 合并用磁盘重读（无写回）
+    doneFile: join(dirname(filePath), DONE), // checklist 合并的归档排除源
+    isDone: filePath.endsWith(DONE), // done 文件自身 = 纯 union
+  })
 }
 
 /** Find a node by ID in the tree */
@@ -222,11 +230,16 @@ export const checklistTool = {
           parentId = found.item.id
         }
 
-        const id = parentId ? nextChildId(parentId, target) : nextRootId(items, parse(donePath(ctx.cwd)))
+        // 归档预留（根 + 点号子 ID——add 父/子都扫 done 文件；防撞号 + 防合并误删）
+        const doneItems = parse(donePath(ctx.cwd))
+        const id = parentId
+          ? nextChildId(parentId, target, doneItems.map((i) => i.id))
+          : nextRootId(items, doneItems)
         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})` : ""}`
+        // F4：合并可能原地重分配本端新项（并发同号）——以 node.id（落盘真相）报回
+        return `Added: [ ] ${node.id}: ${args.item}${parentId ? ` (under ${parentId})` : ""}`
       }
       case "mark": {
         if (args.id == null && args.index == null) return "Error: 'id' or 'index' is required for mark"

package/src/tools/delete.md

@@ -10,3 +10,4 @@ Notes:
 - Untracked or non-git files are deleted immediately
 - Tracked files require force=true (user must confirm separately)
 - Directories must be removed with bash (rm -rf)
+- Returns `Deleted <path>` (or `Error: ...` on failure/tracked refusal).

package/src/tools/edit-batch.mjs

@@ -1,17 +1,23 @@
 /**
  * edit-batch.mjs — edit 工具的数组形态（edits: [...]）：一次多文件原子替换。
- * （2026-08-31 工具顺手度 §9 ②；2026-09-01 缺陷修复"同文件多条串行累积"。）
- * 从 file.mjs 拆出（500 行硬限，先例 git-ext.mjs）——纯移动，零行为变化。
+ * （2026-08-31 工具顺手度 §9 ②；2026-09-01 缺陷修复"同文件多条串行累积"；
+ * 2026-09-04 EDIT.md §6——条目级判定+应用迁至 edit-diff.mjs——批量调共用。）
  *
  * 语义：同一 path 的多条编辑按序**串行累积应用**——第 n 条基于前 n-1 条已应用后的
  * 累积内容做匹配与替换；跨 path 条目互不影响（并行原子语义）；任一条失败 →
- * 全不写（原子性保留）。
+ * 全不写（原子性保留）。每条目独立按判定序（EDIT.md §4——分支 0 单行替换 / 零重叠→替换即删 /
+ * LCS / 空 new 显式报错；EDIT.md §5（约束——删行形态）：省略 new_string = 删行。顶层 path
+ * （args.path）为无自带 path 条目的默认（2026-09-05 用户裁定——条目自带 path 优先——见
+ * EDIT.md §5 修订注）。
  */
 import { readFile, writeFile } from "node:fs/promises"
 import { resolveInCwd, normalizeEOL, joinWithEol, gitDiffOne, autoSyntaxCheck } from "./shared.mjs"
 // file.mjs ↔ edit-batch.mjs 循环引用：两侧导入的都是函数声明（提升初始化），
 // 仅在调用期使用——ESM 循环下安全（无模块求值期取值）。
 import { recordWrite, appendWriteContext } from "./file.mjs"
+// EDIT.md §6：批量条目判定+应用共用 edit-diff（EDIT.md §4 分支 0 单行替换 + 行级 LCS——零重叠→替换即删）；
+// EDIT.md §5：edits 互斥错误文本随前置校验分支迁出至 edit-diff.mjs。
+import { assertEditArgsExclusive, validateEditEntry, computeEditEntry, splitLines, EMPTY_NEW_STRING_LINE, deleteTarget } from "./edit-diff.mjs"
 
 /**
  * Apply the `edits` array form: multi-file atomic replacement. Throws on any
@@ -19,11 +25,9 @@ import { recordWrite, appendWriteContext } from "./file.mjs"
  */
 export async function applyEditBatch(args, ctx) {
   if (!Array.isArray(args.edits) || args.edits.length === 0) {
-    throw new Error("edits must be a non-empty array of {path, old_string, new_string}")
-  }
-  if (args.path || args.old_string !== undefined || args.new_string !== undefined) {
-    throw new Error("edits array is mutually exclusive with path/old_string/new_string")
+    throw new Error("edits must be a non-empty array of {path, old_string | line/startLine+endLine, new_string}")
   }
+  assertEditArgsExclusive(args)
   // 原子：先全量检查（所有文件的替换都可执行）——任一失败全不写。
   // 2026-09-01 缺陷修复（TOOLS.md §9 ②"同文件多条规则"）：同一 path 的多条编辑
   // 按序**串行累积应用**——第 n 条基于前 n-1 条已应用后的累积内容做匹配与替换
@@ -31,55 +35,42 @@ export async function applyEditBatch(args, ctx) {
   // 除最后一条外全部静默丢失）；跨 path 条目互不影响（并行原子语义不变）。
   const groups = new Map() // abs → 每文件一条流水线
   for (const e of args.edits) {
-    if (!e.path) throw new Error("each edit must have a path")
-    if (!e.old_string) throw new Error(`edit for ${e.path}: old_string must not be empty`)
-    if (typeof e.new_string !== "string") {
-      throw new Error(
-        `edit for ${e.path}: new_string must be a string` +
-        `${e.new_string === undefined ? " (missing)" : ` (got ${typeof e.new_string})`}`,
-      )
-    }
-    const abs = resolveInCwd(ctx, e.path)
+    // 2026-09-05 用户裁定：顶层 path + edits 并存合法化——`e.path || args.path`（条目优先；
+    // 缺省入口仅在此兜底）；两者皆无 → 原错误文本（措辞补顶层选项）。
+    const p = e.path || args.path
+    if (!p) throw new Error("each edit must have a path — give each entry its own path or pass a top-level path")
+    // 前置校验（空 old / 非字符串 new——文本同 edit-diff 批量形态；读盘前校验）
+    validateEditEntry(e, { label: `edit for ${p}: `, rich: false })
+    const abs = resolveInCwd(ctx, p)
     let g = groups.get(abs)
     if (!g) {
       const raw = await readFile(abs, "utf8")
-      g = { abs, path: e.path, raw, content: normalizeEOL(raw), edits: [] }
+      g = { abs, path: p, raw, content: normalizeEOL(raw), edits: [] }
       groups.set(abs, g)
     }
     g.edits.push(e)
   }
-  const prepared = [] // 顺序 = args.edits 顺序（回显按条）；recordWrite 每组一条合并快照
+  const prepared = [] // 每条目一条回显；同文件内按 args 序，跨文件按首次出现分组序（应用/回显语义均正确）
   for (const g of groups.values()) {
     g.netShift = 0 // 组内行数差累积（合并快照的 shift = 全组净漂移）
     for (const e of g.edits) {
-      const content = g.content
-      const occurrences = content.split(e.old_string).length - 1
-      if (occurrences === 0) {
-        throw new Error(
-          `edit aborted (atomic — no files written): old_string not found in ${g.path}\n` +
-          `  searched: "${e.old_string.slice(0, 100).split("\n")[0]}${e.old_string.length > 100 ? "…" : ""}"`
-        )
-      }
-      if (occurrences > 1 && !e.replace_all) {
-        throw new Error(
-          `edit aborted (atomic — no files written): old_string matches ${occurrences} times in ${g.path}; ` +
-          `provide more context or set replace_all`
-        )
-      }
-      const matchIdx = content.indexOf(e.old_string)
-      const editStartLine = matchIdx >= 0 ? content.slice(0, matchIdx).split("\n").length : 1
-      const lineShift = e.new_string.split("\n").length - e.old_string.split("\n").length
-      const updated = e.replace_all
-        ? content.split(e.old_string).join(e.new_string)
-        : content.replace(e.old_string, () => e.new_string)
+      // 条目级判定+应用（edit-diff——EDIT.md §4 分支 0 单行替换 + 判定序 1/2/3 + 空 new 显式报错 +
+      // >1000 行报错（diff 形态——D1 行号条目走 applyLineEdit，不经 LCS，无此上限））
+      const out = computeEditEntry(g.content, e, {
+        path: g.path,
+        absPath: g.abs,
+        abortPrefix: "edit aborted (atomic — no files written): ",
+      })
       prepared.push({
         g,
-        editStartLine, // 基于累积内容计算——已天然计入前面条目的行偏移，不再累加
-        lineShift,
-        occurrences: e.replace_all ? occurrences : 1,
+        editStartLine: out.editStartLine, // 基于累积内容计算——已天然计入前面条目的行偏移，不再累加
+        lineShift: out.lineShift,
+        occurrences: out.occurrences,
+        note: out.note ?? null, // P15.11——空白差异自动落点标记（成功消息追加）
+        deleted: out.deleted ?? false, // 删行形态（EDIT.md §5）——结果文本用 Deleted 前缀
       })
-      g.content = updated // 串行累积：下一条基于本条应用后的内容
-      g.netShift += lineShift
+      g.content = out.updated // 串行累积：下一条基于本条应用后的内容
+      g.netShift += out.lineShift
     }
   }
   // 全部检查通过——每文件一次写盘（同文件多条：写入串行累积后的最终内容）；
@@ -97,8 +88,104 @@ export async function applyEditBatch(args, ctx) {
     // #4（2026-09-01 交付评审尾巴）：与单文件路径对齐——每条结果附 git diff +
     // autoSyntaxCheck（同文件多条会重复 diff/检查，换取格式一致、实现零分支）
     const diff = gitDiffOne(ctx.cwd, p.g.abs)
-    const base = `Edited ${p.g.path}: replaced ${p.occurrences} occurrence(s)${diff ? "\n" + diff : ""}${await autoSyntaxCheck(p.g.abs)}`
+    const base = p.deleted
+      ? `Deleted ${deleteTarget(p)} of ${p.g.path}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(p.g.abs)}`
+      : `Edited ${p.g.path}: replaced ${p.occurrences} occurrence(s)${p.note ? ` — ${p.note}` : ""}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(p.g.abs)}`
     results.push(await appendWriteContext(p.g.abs, p.editStartLine, base))
   }
   return results.join("\n")
 }
+
+// ---------------------------------------------------------------------------
+// 2026-09-08 edit 语义升级（EDIT.md §2/§3——D1 按行号改 / D2 模糊匹配，落点定死本模块；
+// 条目判定接线在 edit-diff.mjs computeEditEntry——单形态/批量/ACP 桥三通道自动继承；
+// 阶段 2 删行形态见 EDIT.md §5（约束）。以下均为纯函数（无 IO）——edit-diff.mjs 调用期导入
+// （ESM 循环引用安全：两侧仅函数声明，提升初始化——同 file.mjs ↔ edit-diff.mjs 先例）。
+
+/**
+ * D2 行级 normalize（EDIT.md §3——匹配档位；阶段 2 normalize 统一基准——双端同算法）：
+ * ① 去首尾空白 + 去行尾空格；② tab → 2 空格；③ 引号**单遍逐字符映射**——ASCII 单引号 /
+ * 弯引号 ‘ ’ “ ” / 反引号 → 直双引号 "（评审 #2 定稿目标字符 = "——与 ASCII 单引号规则
+ * 合并为单遍映射，无顺序依赖——防两端分叉）。**不做行内 \s+ 折叠**——缩进/对齐是结构信息，
+ * 折叠会误匹配文字相似但结构不同的行（统一基准 5——CLI 从未折叠，防误配回归）。仅用于匹配
+ * 比较——替换永远用文件原文窗口。
+ */
+const QUOTE_TO_DOUBLE = {
+  "'": '"', "\u2018": '"', "\u2019": '"', "\u201c": '"', "\u201d": '"', "`": '"',
+}
+export function normalizeEditLine(line) {
+  let out = ""
+  for (const ch of line) {
+    if (ch === "\t") out += "  "
+    else out += QUOTE_TO_DOUBLE[ch] ?? ch
+  }
+  return out.replace(/\s+$/g, "").trim()
+}
+
+/** D2 模糊匹配阈值：行级 normalize 后逐行相等比例 ≥0.9 即匹配（评审 #4 定稿）。 */
+export const FUZZY_MATCH_THRESHOLD = 0.9
+/** D2 成功消息追加 note（双端同句——同 WHITESPACE_VARIANT_NOTE 机制）。 */
+export const FUZZY_MATCH_NOTE = "applied via fuzzy match (≥90% of lines identical after whitespace/indent/quote normalization)"
+
+/**
+ * D2 模糊匹配（P15.11 空白自动落点的推广——逐字/trim 等价都失败后的最后一档）：
+ * 找文件中**唯一**窗口——行数与 old 相同、normalizeEditLine 后逐行相等比例 ≥90% →
+ * 返回 { actual }（actual = 文件窗口原文）；多窗口达标 → null（歧义不猜——走 not-found
+ * 报错引导）；old 含尾换行 → null（终止符语义边界——同 P15.11）。比例向上取整行数：
+ * 需要相等行数 = ceil(m × 0.9)（m=1 即 normalize 后全等——单行细微差异由此命中）。
+ */
+export function findFuzzyWindow(content, old) {
+  if (old.endsWith("\n")) return null
+  const oldLines = old.split("\n")
+  const m = oldLines.length
+  const fileLines = content.split("\n")
+  if (m === 0 || fileLines.length < m) return null
+  const norm = oldLines.map(normalizeEditLine)
+  const need = Math.ceil(m * FUZZY_MATCH_THRESHOLD)
+  let hit = null
+  for (let i = 0; i + m <= fileLines.length; i++) {
+    let eq = 0
+    for (let j = 0; j < m; j++) {
+      if (normalizeEditLine(fileLines[i + j]) === norm[j]) eq++
+    }
+    if (eq < need) continue
+    const actual = fileLines.slice(i, i + m).join("\n")
+    if (actual === old) continue // 逐字已匹配——occurrences=0 前提下不会发生
+    if (hit) return null // 多窗口达标 → 歧义 → 不猜
+    hit = { actual }
+  }
+  return hit
+}
+
+/**
+ * D1 按行号改（EDIT.md §2/§5——F1）：entry 带 line（单行）或 startLine/endLine（1-based
+ * 闭区间）→ 直接按行号替换该行/行范围为 new_string（无需 old_string——互斥校验在
+ * validateEditEntry）。阶段 2 删行形态（EDIT.md §5——裁定 A）：**省略 new_string =
+ * 删除该行/范围**（意图有界——删哪行是显式声明）；显式空串 `new_string: ""` →
+ * EMPTY_NEW_STRING_LINE 显式报错（模板生成 new_string 但落空 ≠ 删行意图——防误删）。
+ * 内容域 = normalizeEOL 后 LF（与 computeEditEntry 同域）；尾随换行随原文件保持（删到
+ * 文件为空 → ""——无剩余行即无终止符）。行号越界 → 明确报错。原子性由调用方保证
+ * （本函数纯计算）。
+ * 返回 { updated, editStartLine, lineShift, occurrences, note, deleted? }（同 computeEditEntry 形态）。
+ */
+export function applyLineEdit(content, entry, opts = {}) {
+  const prefix = opts.abortPrefix ?? ""
+  if (entry.new_string === "") throw new Error(prefix + EMPTY_NEW_STRING_LINE)
+  const lines = splitLines(content)
+  const start = entry.line ?? entry.startLine
+  const end = entry.line ?? entry.endLine
+  if (start > lines.length || end > lines.length) {
+    throw new Error(prefix + `line ${end > lines.length ? end : start} out of range — ${opts.path ?? "file"} has ${lines.length} line(s)`)
+  }
+  const removed = end - start + 1
+  if (entry.new_string === undefined) {
+    // 删行/删范围（EDIT.md §5）——省略 new_string：受影响行整体移除
+    const remaining = [...lines.slice(0, start - 1), ...lines.slice(end)]
+    const updated = remaining.join("\n") + (remaining.length > 0 && content.endsWith("\n") ? "\n" : "")
+    return { updated, editStartLine: start, lineShift: -removed, occurrences: 1, note: null, deleted: true }
+  }
+  const newLines = splitLines(entry.new_string)
+  const updated = [...lines.slice(0, start - 1), ...newLines, ...lines.slice(end)].join("\n") +
+    (content.endsWith("\n") ? "\n" : "")
+  return { updated, editStartLine: start, lineShift: newLines.length - removed, occurrences: 1, note: null }
+}