thincoder 0.12.59 → 0.12.61

package/src/tools/edit-batch.mjs

@@ -1,22 +1,23 @@
 /**
  * edit-batch.mjs — edit 工具的数组形态（edits: [...]）：一次多文件原子替换。
  * （2026-08-31 工具顺手度 §9 ②；2026-09-01 缺陷修复"同文件多条串行累积"；
- * 2026-09-04 TOOLS.md §15 D15.1——条目级判定+应用迁至 edit-diff.mjs——批量调共用。）
+ * 2026-09-04 EDIT.md §6——条目级判定+应用迁至 edit-diff.mjs——批量调共用。）
  *
  * 语义：同一 path 的多条编辑按序**串行累积应用**——第 n 条基于前 n-1 条已应用后的
  * 累积内容做匹配与替换；跨 path 条目互不影响（并行原子语义）；任一条失败 →
- * 全不写（原子性保留）。每条目独立按判定序（§15.2 分支 0 单行替换 / 零重叠→插入 / LCS /
- * 空 new 显式报错）。顶层 path（args.path）为无自带 path 条目的默认（2026-09-05 用户裁定
- * ——条目自带 path 优先——见 TOOLS.md D15.3#9 修订注）。
+ * 全不写（原子性保留）。每条目独立按判定序（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"
-// TOOLS.md §15 D15.1：批量条目判定+应用共用 edit-diff（§15.2 分支 0 单行替换 + 行级 LCS——零重叠→插入）；
-// D15.3#9：edits 互斥错误文本随前置校验分支迁出至 edit-diff.mjs。
-import { assertEditArgsExclusive, validateEditEntry, computeEditEntry } from "./edit-diff.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
@@ -24,7 +25,7 @@ import { assertEditArgsExclusive, validateEditEntry, computeEditEntry } from "./
  */
 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}")
+    throw new Error("edits must be a non-empty array of {path, old_string | line/startLine+endLine, new_string}")
   }
   assertEditArgsExclusive(args)
   // 原子：先全量检查（所有文件的替换都可执行）——任一失败全不写。
@@ -53,7 +54,8 @@ export async function applyEditBatch(args, ctx) {
   for (const g of groups.values()) {
     g.netShift = 0 // 组内行数差累积（合并快照的 shift = 全组净漂移）
     for (const e of g.edits) {
-      // 条目级判定+应用（edit-diff——§15.2 分支 0 单行替换 + 判定序 1/2/3 + 空 new 显式报错 + >1000 行报错）
+      // 条目级判定+应用（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,
@@ -65,6 +67,7 @@ export async function applyEditBatch(args, ctx) {
         lineShift: out.lineShift,
         occurrences: out.occurrences,
         note: out.note ?? null, // P15.11——空白差异自动落点标记（成功消息追加）
+        deleted: out.deleted ?? false, // 删行形态（EDIT.md §5）——结果文本用 Deleted 前缀
       })
       g.content = out.updated // 串行累积：下一条基于本条应用后的内容
       g.netShift += out.lineShift
@@ -85,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)${p.note ? ` — ${p.note}` : ""}${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 }
+}

package/src/tools/edit-diff.mjs

@@ -1,22 +1,31 @@
 /**
- * edit-diff.mjs — edit 工具的行级 diff 内核（TOOLS.md §15 D15.1，2026-09-04）。
+ * edit-diff.mjs — edit 工具的行级 diff 内核（权威语义 = EDIT.md——2026-09-04 拆出）。
  *
- * edit 新语义（用户裁定——breaking——不承诺旧行为兼容）：old_string = 变化区**当前内容**
- * （必须精确存在、单次匹配——不变）；new_string = 该区的**期望结果**。判定序：
- *   0. 分支 0（TOOLS.md §15.2——单行精确替换）：old 单行 && new 单行 && old 全文唯一 &&
+ * edit 语义（权威 = EDIT.md §2-§5——2026-09-08 语义升级 D1/D2/D3 已并入）：两种定位形态（互斥）——
+ * ① 按行号改（D1/F1）：line（单行）/ startLine+endLine（1-based 闭区间）→ 直接替换该
+ *    行/行范围为 new_string（无需 old_string——实现落点 edit-batch.mjs applyLineEdit）；
+ *    阶段 2 删行形态（EDIT.md §5——约束）：省略 new_string = 删除该行/范围（有界意图）；
+ * ② 内容定位：old_string = 变化区**当前内容**（单次匹配——匹配档位：逐字 → P15.11 唯一
+ *    空白差异窗口 → D2/F2 模糊匹配（行级 normalize 后 ≥90% 行相等——edit-batch.mjs
+ *    findFuzzyWindow））；new_string = 该区的**期望结果**。判定序：
+ *   0. 分支 0（EDIT.md §4——单行精确替换）：old 单行 && new 单行 && old 全文唯一 &&
  *      new 非空 → **就地替换该行**（行数不变——EOL 由调用方 joinWithEol 恢复）；
- *   1. 零重叠（old 每一行都不出现在 new 行集中）→ 按**插入**——new 整体插入在 old
- *      最后一行之后（旧内容保留——数据零丢失）；
+ *   1. 零重叠（old 每一行都不出现在 new 行集中）→ **替换即删**（D3/F3，2026-09-08——
+ *      breaking：old 行整体删除、new 取而代之——旧行不再保留；新增行用 insert_after）；
  *   2. 有公共行（≥1）→ 行级 LCS——公共行保留、差异行增删；
  *   3. new 与 old 行级完全一致 → 原样替换（no-op 语义——仍报成功）。
- * 空 new_string（纯删除意图）→ 显式报错（不静默——先于分支 0——单行替换永不成删除）；
- * 分支 0 只在 computeEditEntry 条目判定层（壳/桥/批量自动继承）——applyPatchLines
- * （纯 diff 层）语义不动。old/new 行数各上限 1000（超限报错）。
+ * 内容形态空 new_string（纯删除意图）→ 显式报错（不静默——先于分支 0——单行替换永不
+ * 成删除）；行号形态显式空串 → 同样显式错（防误删——模板落空 ≠ 删行意图；EDIT.md
+ * §5 空串 vs 省略矩阵）；**省略 new_string = 删行/范围**（阶段 2 命名删行形态）；
+ * 分支 0 只在 computeEditEntry 条目判定层（壳/桥/批量自动继承）——
+ * applyPatchLines（纯 diff 层）语义不动。old/new 行数各上限 1000（超限报错）。
  *
  * 行尾权威 = EDIT-TOOL-EOL-DESIGN.md：判定/应用在 normalizeEOL 后的 LF 域计算，
  * 写回由调用方 joinWithEol(原文) 恢复原行尾。
  * 模块拆分（file.mjs ≤500 硬限）：file.mjs 只留工具壳与转发——单形态执行体与前置校验
  * 分支整段迁出至本模块（模块拆分写优先纪律：先迁后删、逻辑体不变、wiring 导入）。
+ * edit-diff.mjs ↔ edit-batch.mjs 循环引用（2026-09-08——D1/D2 实现落点 edit-batch）：
+ * 两侧仅函数声明（提升初始化）、仅调用期使用——ESM 循环下安全（同 file.mjs 先例）。
  */
 import { readFile, writeFile } from "node:fs/promises"
 import {
@@ -25,14 +34,31 @@ import {
 // file.mjs ↔ edit-diff.mjs 循环引用：两侧导入的都是函数声明（提升初始化），
 // 仅在调用期使用——ESM 循环下安全（无模块求值期取值）。
 import { recordWrite, appendWriteContext, lastWriteOf, isDirty } from "./file.mjs"
+// D1/D2 落点（EDIT.md §6——edit-batch.mjs）：按行号改 + 模糊匹配纯函数。
+import { applyLineEdit, findFuzzyWindow, FUZZY_MATCH_NOTE } from "./edit-batch.mjs"
 
 export const MAX_DIFF_LINES = 1000
 export const REGION_TOO_LARGE = "edit region too large — narrow the change"
 export const EMPTY_NEW_STRING = "empty new_string — for deletion, keep the context lines you want to preserve in both old_string and new_string"
-export const EDIT_ARGS_MUTEX = "edits array is mutually exclusive with top-level old_string/new_string — a top-level path is allowed (default for entries without their own path); provide each change's old_string/new_string inside its edits entry"
+export const EMPTY_NEW_STRING_LINE = "empty new_string with line-based targeting is an explicit error — OMIT new_string to delete the line/range (deleting by number is explicit intent; an empty replacement is a mistake, not a delete)"
+export const EDIT_ARGS_MUTEX = "edits array is mutually exclusive with top-level old_string/new_string/line/startLine/endLine — a top-level path is allowed (default for entries without their own path); provide each change's targeting (old_string or line range) and new_string inside its edits entry"
 
-/** 行切分（尾随换行终止最后一行——非额外空行）："a\nb\n" → ["a","b"]。 */
-function splitLines(text) {
+/** D1（2026-09-08）：条目带按行号改参数（line / startLine / endLine 任一）。 */
+export function hasLineParams(entry) {
+  return entry.line !== undefined || entry.startLine !== undefined || entry.endLine !== undefined
+}
+
+/** 删行结果文本（EDIT.md——删行返回文本；out.deleted 才调用）：单行 "line N" / 范围 "lines N-M"。
+ *  删行 lineShift = -(范围行数)——end = start - 1 - lineShift。 */
+export function deleteTarget(out) {
+  const start = out.editStartLine
+  const end = start - 1 - out.lineShift
+  return start === end ? `line ${start}` : `lines ${start}-${end}`
+}
+
+/** 行切分（尾随换行终止最后一行——非额外空行）："a\nb\n" → ["a","b"]。
+ *  2026-09-08 导出（D1 落点 edit-batch.mjs applyLineEdit 复用同语义）。 */
+export function splitLines(text) {
   const lines = text.split("\n")
   if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop()
   return lines
@@ -40,7 +66,9 @@ function splitLines(text) {
 
 /**
  * 行级 LCS（整行相等判定）合并：公共行保留（LCS 序）、old 独有行删除、new 独有行按其在
- * new 中相对公共行的位置插入。结果在 LF 域；区域尾随换行随 oldText（区域边界保持）。
+ * new 中相对公共行的位置插入；**零重叠 → 替换即删**（D3，2026-09-08 语义升级——
+ * breaking：old 行整体删除、new 取而代之，旧行不再保留——原"零重叠→插入保留旧行"
+ * 语义废止；新增行用 insert_after）。结果在 LF 域；区域尾随换行随 oldText（区域边界保持）。
  * 返回 { ok: true, resultText } 或 { ok: false, reason }。
  */
 export function applyPatchLines(oldText, newText) {
@@ -50,11 +78,11 @@ export function applyPatchLines(oldText, newText) {
   if (oldLines.length > MAX_DIFF_LINES || newLines.length > MAX_DIFF_LINES) {
     return { ok: false, reason: REGION_TOO_LARGE }
   }
-  // 判定 1（F15.2）：零重叠 → 插入——new 整体插在 old 最后一行之后（旧内容保留）
+  // 判定 1（D3——替换即删）：零重叠 → old 行删、new 整体取代（旧行不再保留）
   const newSet = new Set(newLines)
   const merged = oldLines.some((l) => newSet.has(l))
     ? lcsMerge(oldLines, newLines) // 判定 2/3——公共行保留、差异行增删
-    : [...oldLines, ...newLines]
+    : [...newLines]
   return { ok: true, resultText: merged.join("\n") + (oldText.endsWith("\n") ? "\n" : "") }
 }
 
@@ -91,27 +119,69 @@ function lcsMerge(a, b) {
 }
 
 /**
- * D15.3#9 修订（2026-09-05 用户裁定——顶层 path + edits 并存合法化：顶层 path = 无自带
+ * （2026-09-05 用户裁定——EDIT.md §5——顶层 path + edits 并存合法化：顶层 path = 无自带
  * path 条目的默认——模型直觉形态「顶层 path + 数组条目」不再拒绝；条目自带 path 优先）。
- * 互斥收窄为只对顶层 old_string/new_string——edits 下它们无批语义可解释——顶层 path 不再触发。
+ * 互斥收窄为只对顶层 old_string/new_string（+ 2026-09-08 D1 的 line/startLine/endLine）——
+ * edits 下它们无批语义可解释——顶层 path 不再触发。
  */
 export function assertEditArgsExclusive(args) {
-  if (args.old_string !== undefined || args.new_string !== undefined) {
+  if (args.old_string !== undefined || args.new_string !== undefined || hasLineParams(args)) {
     throw new Error(EDIT_ARGS_MUTEX)
   }
 }
 
 /**
- * 前置校验（空 old / 非字符串 new）——error 文本按调用形态（单形态 rich / 批量 label）。
+ * 前置校验——内容形态：空 old / 非字符串 new；按行号改形态（D1，2026-09-08；阶段 2
+ * 删行——EDIT.md §5）：与 old_string 互斥 / line 与 startLine|endLine 互斥 /
+ * startLine+endLine 须成对 / 正整数 / endLine ≥ startLine / replace_all 不适用 /
+ * new_string：省略（undefined）= 删行 / 显式空串 = 显式错（防误删）/ 其他类型报错。
+ * error 文本按调用形态（单形态 rich / 批量 label）。
  * opts: { label = ""（批量前缀 "edit for <path>: "）, rich = true（单形态完整文本） }
  */
 export function validateEditEntry(entry, opts = {}) {
   const label = opts.label ?? ""
+  if (hasLineParams(entry)) {
+    if (entry.old_string !== undefined) {
+      throw new Error(label + "line/startLine/endLine are mutually exclusive with old_string — target by line number OR by content, not both")
+    }
+    if (entry.line !== undefined && (entry.startLine !== undefined || entry.endLine !== undefined)) {
+      throw new Error(label + "line is mutually exclusive with startLine/endLine — single line or a range, not both")
+    }
+    if ((entry.startLine === undefined) !== (entry.endLine === undefined)) {
+      throw new Error(label + "startLine and endLine must be given together (1-based, inclusive)")
+    }
+    for (const k of ["line", "startLine", "endLine"]) {
+      if (entry[k] !== undefined && (!Number.isInteger(entry[k]) || entry[k] < 1)) {
+        throw new Error(label + `${k} must be a positive integer (1-based), got ${JSON.stringify(entry[k])}`)
+      }
+    }
+    if (entry.startLine !== undefined && entry.endLine < entry.startLine) {
+      throw new Error(label + `endLine (${entry.endLine}) is before startLine (${entry.startLine})`)
+    }
+    if (entry.replace_all) {
+      throw new Error(label + "replace_all does not apply to line-based edits (a line range is already a single explicit target)")
+    }
+    if (entry.new_string === "") {
+      throw new Error(label + EMPTY_NEW_STRING_LINE + (opts.rich === false ? "" : " — nothing written"))
+    }
+    if (entry.new_string !== undefined && typeof entry.new_string !== "string") {
+      throw new Error(
+        label + `new_string must be a string (got ${typeof entry.new_string})` +
+        (opts.rich === false ? "" : " — nothing written")
+      )
+    }
+    return
+  }
   if (!entry.old_string) {
     throw new Error(
       label + "old_string must not be empty" + (opts.rich === false ? "" : " (empty string matches everywhere and would corrupt the file)")
     )
   }
+  if (entry.new_string === "") {
+    // 空串 vs 省略矩阵（EDIT.md §5/§8.1）：内容形态空串 = 显式错（无界意图防静默）——
+    // 先于 replace_all 分支（否则 replace_all + 空串会静默删除全部 occurrences——绕过保护）
+    throw new Error(label + EMPTY_NEW_STRING + (opts.rich === false ? "" : " — nothing written"))
+  }
   if (typeof entry.new_string !== "string") {
     throw new Error(
       label + `new_string must be a string${entry.new_string === undefined ? " (missing)" : ` (got ${typeof entry.new_string})`}` +
@@ -121,7 +191,7 @@ export function validateEditEntry(entry, opts = {}) {
 }
 
 /**
- * 分支 0 形态判定（TOOLS.md §15.2 D15.9.1）：old/new 各为单行——无内部换行（splitLines
+ * 分支 0 形态判定（EDIT.md §4）：old/new 各为单行——无内部换行（splitLines
  * 语义：尾随单个换行符是行终止而非新行——old/new 行内容均不含 \n）——且 new 非空
  * （"" 经 splitLines 切分为 []——由下方 !== "" 守卫先拦截——空 new 不落本分支——落
  * applyPatchLines 的空 new 显式错误——单行替换永不成删除）。多匹配与 replace_all 不落
@@ -136,11 +206,11 @@ function isSingleLineReplace(entry) {
 }
 
 /**
- * 条目级判定+应用（单形态与批量共用——D15.1"批量条目判定+应用调用 edit-diff"）：
- * 匹配校验（精确存在——非 replace_all 单次）→ 按判定序应用（分支 0 单行替换 / 零重叠插入 /
+ * 条目级判定+应用（单形态与批量共用——EDIT.md §6"批量条目判定+应用调用 edit-diff"）：
+ * 匹配校验（精确存在——非 replace_all 单次）→ 按判定序应用（分支 0 单行替换 / 零重叠替换即删 /
  * LCS 替换 / replace_all 字面）→
  * 元数据（受影响区首行/行数差/次数——recordWrite 与结果回显用）。
- * 返回 { updated, editStartLine, lineShift, occurrences }；失败抛错（含路径/引导）。
+ * 返回 { updated, editStartLine, lineShift, occurrences, note?, deleted? }；失败抛错（含路径/引导）。
  * opts: { path, abortPrefix（批量 "edit aborted (atomic — no files written): "） }
  */
 /**
@@ -180,6 +250,10 @@ export const WHITESPACE_VARIANT_NOTE = "applied to the unique whitespace-only ma
 
 export function computeEditEntry(content, entry, opts = {}) {
   validateEditEntry(entry, { ...opts, rich: !opts.abortPrefix })
+  // D1 按行号改（EDIT.md §2/§5）：行号定位条目直接按行替换（applyLineEdit——落点
+  // edit-batch.mjs），不走 old_string 匹配/判定序；省略 new_string = 删行（EDIT.md §5）；
+  // 互斥/越界/显式空串均在 validateEditEntry/applyLineEdit 显式报错。
+  if (hasLineParams(entry)) return applyLineEdit(content, entry, opts)
   // P15.11：not-found 时先查唯一空白差异窗口——命中则以其原文为实际 old 继续（内容零差异
   // ——自动落点 + note 明示）；实质差异/歧义仍走下方 not-found 报错（不猜内容）。
   let old = entry.old_string
@@ -189,6 +263,13 @@ export function computeEditEntry(content, entry, opts = {}) {
     const variant = findWhitespaceVariant(content, old)
     if (variant) { old = variant.actual; occurrences = 1; note = WHITESPACE_VARIANT_NOTE }
   }
+  // D2 模糊匹配（2026-09-08——P15.11 的推广）：逐字/trim 等价都失败后，找唯一
+  // normalize 后 ≥90% 行相等的窗口——细微差异（缩进/引号/行尾空格/少量行差异）自动
+  // 落点 + note 明示；多窗口歧义/不足阈值仍走 not-found 报错（不猜内容）。
+  if (occurrences === 0) {
+    const fuzzy = findFuzzyWindow(content, old)
+    if (fuzzy) { old = fuzzy.actual; occurrences = 1; note = FUZZY_MATCH_NOTE }
+  }
   if (occurrences === 0) {
     const preview = entry.old_string.slice(0, 100).split("\n")[0]
     const cands = findCandidates(content.split("\n"), entry.old_string)
@@ -220,11 +301,11 @@ export function computeEditEntry(content, entry, opts = {}) {
   let updated
   let resultForShift
   if (entry.replace_all) {
-    // 字面替换——不做插入规则（old 多处时"插到哪处"无定义）——不落分支 0（§15.2 D15.9.2）
+    // 字面替换——不做插入规则（old 多处时"插到哪处"无定义）——不落分支 0（EDIT.md §4）
     updated = content.split(old).join(entry.new_string)
     resultForShift = entry.new_string
   } else if (isSingleLineReplace(entry)) {
-    // 分支 0（§15.2 D15.9.1——单行精确替换）：old 单行 && new 单行 && old 唯一匹配
+    // 分支 0（EDIT.md §4——单行精确替换）：old 单行 && new 单行 && old 唯一匹配
     // （occ==1 既有校验保证）&& new 非空（空 new 显式错误先于本分支——防删除）→ **就地
     // 替换该行**——不再零重叠插入（P15.8——行尾段编辑反复踩的插入坑）。只替换行内容段：
     // old/new 的尾随换行符属文件结构而非行内容——留在原位——行数不变——EOL 由调用方
@@ -242,7 +323,7 @@ export function computeEditEntry(content, entry, opts = {}) {
     updated = content.slice(0, matchIdx) + r.resultText + content.slice(matchIdx + old.length)
     resultForShift = r.resultText
   }
-  // 行数差 = 应用后区域行数 − 旧区域行数（分支 0 单行替换：0；插入：new 行数；LCS：new−old）
+  // 行数差 = 应用后区域行数 − 旧区域行数（分支 0 单行替换：0；零重叠替换即删：new−old；LCS：new−old）
   const lineShift = splitLines(resultForShift).length - splitLines(old).length
   return { updated, editStartLine, lineShift, occurrences: entry.replace_all ? occurrences : 1, note }
 }
@@ -260,6 +341,8 @@ export async function runSingleEdit(args, ctx) {
   await writeFile(abs, joinWithEol(normalizeEOL(out.updated).split("\n"), raw), "utf8")
   recordWrite(abs, { type: "edit", startLine: out.editStartLine, shift: out.lineShift })
   const diff = gitDiffOne(ctx.cwd, abs)
-  const baseResult = `Edited ${args.path}: replaced ${out.occurrences} occurrence(s)${out.note ? ` — ${out.note}` : ""}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
+  const baseResult = out.deleted
+    ? `Deleted ${deleteTarget(out)} of ${args.path}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
+    : `Edited ${args.path}: replaced ${out.occurrences} occurrence(s)${out.note ? ` — ${out.note}` : ""}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
   return await appendWriteContext(abs, out.editStartLine, baseResult)
 }

package/src/tools/edit.md

@@ -1,25 +1,30 @@
-Edit a file as a patch. old_string is the current content of the region to change (must match exactly once); new_string is the desired result of that region. Lines shared by both are kept; lines only in new_string take their position relative to the shared lines (LCS order) — when no line overlaps, new_string is inserted after old_string (old content stays) — except a unique single-line old_string paired with a single-line new_string: that exact line is replaced in place (line count unchanged); for a multi-line replacement, include a shared context line — for adding a new line use insert_after: a unique single-line old/new pair replaces the line in place; multi-line zero-overlap pairs still insert per the diff rules above. replace_all keeps literal replacement of every occurrence — the insert rule does not apply.
+Edit a file as a patch — targeted by content or by line number. Two targeting forms (mutually exclusive — use one): ① line-based: `line: N` replaces that single line, `startLine: N, endLine: M` replaces the inclusive 1-based line range — no old_string needed when you know the line number; give new_string to replace, or OMIT new_string to delete the line/range; ② content-based: old_string is the current content of the region to change (must match exactly once); new_string is the desired result of that region. old_string matching is tolerant: exact match first, then a unique whitespace-only variant, then fuzzy match (unique window with ≥90% of lines identical after trimming, tab→space indent and quote normalization — ASCII single, curly single/double and backtick quotes all unify to straight double quotes). Lines shared by old/new are kept; lines only in new_string take their position relative to the shared lines (LCS order); lines only in old_string are deleted — a replacement never leaves old lines behind (zero overlap → old lines are replaced by new_string, not kept). A unique single-line old_string paired with a single-line new_string replaces that exact line in place (line count unchanged). To add a new line without removing anything use insert_after. replace_all keeps literal replacement of every occurrence — the diff rules do not apply.
 
 **Routing — pick the right edit tool:**
-- Precise line-targeted change → `hashline_edit` (hash-based, immune to whitespace/encoding drift — preferred)
-- Add a line/entry after a known line → insert_after — includes checklist items and doc lines.
-- Same change across multiple files or many spots → `apply_patch`
-- Rewrite an entire file → `write`
+- Delete a line/range by number → omit new_string: edit with `line: N` / `startLine: N, endLine: M`
+- Line numbers fresh (just read) → `line`/`startLine`/`endLine` targeting — precise, no content copy needed
+- Line numbers may have drifted / content has whitespace-encoding noise → `hashline_edit` (content-hash addressing — position-independent)
+- Add a line/entry after a known line → insert_after
+- Same change across multiple files → apply_patch
+- Rewrite an entire file → write
 - Rename a symbol project-wide → `lsp` or `grep` first to map every caller
 
 **Batch multiple edits into ONE call via the `edits` array** (preferred over N single edit calls): multiple changes to the SAME file go into one `edits` array (entries are applied serially, each based on the previous one's result); independent changes across MULTIPLE files also go into the same `edits` array — one call, atomic (any failure writes nothing). A batched call is one permission ask, one undo unit, and one turn instead of N. A top-level path may accompany the array — entries without their own path inherit it (entry paths override).
 
 Parameters:
 - path: File path (single form: required; with the edits array: optional — the default for entries without their own path)
-- old_string (required): Current content of the region to change (must match exactly once)
-- new_string (required): Desired result of the region — diffed against old_string (shared lines kept; zero overlap → new_string inserted after old_string — a unique single-line old/new pair replaces the line in place)
-- replace_all: Replace all occurrences instead of just one (default false)
-- edits: Array of {path?, old_string, new_string, replace_all?} entries — batch form; mutually exclusive with top-level old_string/new_string — a top-level path is allowed and applies to entries without their own path
+- old_string: Current content of the region to change (must match exactly once — tolerant matching: exact → whitespace-only variant → fuzzy ≥90% line-equal). Mutually exclusive with line/startLine/endLine — required unless line targeting is used
+- new_string: Desired result of the region — diffed against old_string (shared lines kept; old-only lines deleted — a replacement never leaves old lines behind). Content-based edits: required — an explicit empty string is an error (protects against forgetting it). Line-based edits (line/startLine/endLine): give it to replace the line/range, or OMIT it to delete — an explicit empty string is NOT deletion (error — omit instead)
+- line: 1-based line number — replace that single line with new_string, or OMIT new_string to DELETE it (mutually exclusive with old_string and startLine/endLine)
+- startLine / endLine: 1-based inclusive line range to replace with new_string (given together; mutually exclusive with old_string) — OMIT new_string to DELETE the range
+- replace_all: Replace all occurrences instead of just one (default false; content-based targeting only)
+- edits: Array of {path?, old_string?, new_string?, line?, startLine?, endLine?, replace_all?} entries — batch form; mutually exclusive with top-level old_string/new_string/line/startLine/endLine — a top-level path is allowed and applies to entries without their own path
 
 Notes:
 - Prefer this over write for targeted edits — it's safer and keeps changes targeted
-- If old_string matches zero times: error. If it matches multiple times without replace_all: error — add more surrounding context to make it unique
-- new_string empty (deletion) is an explicit error — keep the context lines you want to preserve in both old_string and new_string
-- Returns `Edited <path>: replaced N occurrence(s)` + git diff + syntax-check note + context block (L..-L..).
+- If old_string matches zero times (even fuzzy): error. If it matches multiple times without replace_all: error — add more surrounding context to make it unique
+- Content-based edits: new_string empty is an explicit error (protects against forgetting it).
+- Line-based edits: OMIT new_string to delete the line/range — deleting by number is an explicit, bounded intent.
+- Returns `Edited <path>: replaced N occurrence(s)` (delete-mode: `Deleted line N of <path>` / `Deleted lines N-M of <path>`) + git diff + syntax-check note + context block (L..-L..).
 - Never fabricate the old_string — copy it verbatim from the actual file using read first
 - use the most recent read of the file as the source of old_string / line numbers / hashes — re-read after the file changed

package/src/tools/execute.mjs

@@ -24,7 +24,7 @@
  *   filter     — return only output lines matching this regex (case-insensitive)
  *   timeoutMs  — timeout (default 30s, max 600000ms)
  */
-import { spawn } from "node:child_process"
+import { spawn, execFileSync } from "node:child_process"
 import { resolve } from "node:path"
 import { DESC } from "./shared.mjs"
 
@@ -58,6 +58,19 @@ function applyFilter(output, filter) {
   }
 }
 
+/** Platform-aware process tree kill — mirror of system.mjs/verify.mjs killProcessTree.
+ *  Timeout/abort must reach grandchildren: a script that spawned children keeps the
+ *  pipes open otherwise — "close" never fires and the tool stalls until the 3s kick
+ *  while the orphan keeps running (2026-09-05 advisor 🟡#4). */
+function killProcessTree(child) {
+  if (process.platform === "win32") {
+    try { execFileSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" }) } catch {}
+  } else {
+    try { process.kill(-child.pid, "SIGKILL") } catch {}
+    try { child.kill("SIGKILL") } catch {}
+  }
+}
+
 /** Spawn node with the given args, capture stdout/stderr, enforce timeout/abort.
  *  Resolves { text, ok } — ok=false on non-zero exit / timeout / abort. */
 function runNode(childArgs, baseDir, timeoutMs, signal) {
@@ -66,6 +79,13 @@ function runNode(childArgs, baseDir, timeoutMs, signal) {
       cwd: baseDir,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
+      // POSIX detached → 子进程为组首——killProcessTree 的 -pid 组杀可达孙进程（win 用
+      // taskkill /T 不需 detached）——2026-09-05 advisor 🟡#4
+      detached: process.platform !== "win32",
+      // 双保险（2026-09-05——裸 spawn 无 signal 教训——system.mjs 同款）：abort 时
+      // Node 自动杀直接子进程（第一道）——onAbort 手动 kill 兜底（SIGKILL 防信号陷阱
+      // 脚本——见 kill 注释）——AbortError 在 error 分支让路（close 必随——走 mode 收尾）
+      ...(signal ? { signal } : {}),
     })
 
     let outBuf = "", errBuf = "", truncated = false, settled = false, mode = null
@@ -79,8 +99,9 @@ function runNode(childArgs, baseDir, timeoutMs, signal) {
       if (signal) signal.removeEventListener("abort", onAbort)
       resolvePromise({ text, ok })
     }
-    // SIGKILL (not SIGTERM) so a signal-trapping script can't dodge the watchdog.
-    const kill = () => { try { child.kill("SIGKILL") } catch { /* already gone */ } }
+    // Tree kill（SIGKILL/taskkill /T——signal-trapping 脚本躲不开 watchdog；孙进程持管道
+    // 时直接 kill 不达——close 不触发拖到 kick——2026-09-05 advisor 🟡#4 对齐 bash/verify）
+    const kill = () => { killProcessTree(child) }
     // After kill, wait for "close" (child fully reaped) before settling — settling
     // early races the caller deleting the cwd dir while the child still holds it.
     const armKick = () => { kickTimer = setTimeout(() => settle(mode === "abort" ? "(stopped)" : timeoutErrorText(timeoutMs), false), 3000) }
@@ -100,7 +121,13 @@ function runNode(childArgs, baseDir, timeoutMs, signal) {
     }
     child.stdout.on("data", (d) => { outBuf = cap(outBuf, d.toString()) })
     child.stderr.on("data", (d) => { errBuf = cap(errBuf, d.toString()) })
-    child.on("error", (e) => settle(`Error: failed to start node: ${e.message}`, false))
+    child.on("error", (e) => {
+      // signal 双保险（2026-09-05）：abort 时 Node signal option 杀子进程 → 本事件以
+      // AbortError 先触发——让路（close 必随——close 分支 mode==="abort" →
+      // settle("(stopped)")）——不把中止误报为启动失败
+      if (e.name === "AbortError") return
+      settle(`Error: failed to start node: ${e.message}`, false)
+    })
     child.on("close", (code) => {
       if (mode === "abort") return settle("(stopped)", false)
       if (mode === "timeout") return settle(timeoutErrorText(timeoutMs), false)