aura-basetools 0.13.2 → 0.14.0

package/lib/transaction-store.mjs

@@ -1,17 +1,16 @@
 /**
- * transaction-store.mjs —— 写事务日志、回滚与 undo。
+ * transaction-store.mjs —— 写事务日志与**失败回滚**（内部实现，不再暴露 undo/transactions 工具）。
  *
  * 一次写事务在 `~/.aura/transactions/<workspace-key>/<id>/` 下留下：
  *   · `meta.json` —— 事务状态与每个文件的原始 mode/版本/备份名；
  *   · `originals/<n>.bin` —— 写前原始字节（逐字节，含 BOM/行尾）。
  *
  * 事务的生命周期：
- *   pending → committed（写成功，可 undo）
+ *   pending → committed（写成功；日志仅用于内部回滚，不再提供 undo）
  *           → rolled_back（写失败，已恢复原字节）
  *           → recovery_required（写失败且恢复也失败；meta 里留着可手工恢复的路径）
- *   committed → undone（undo 成功）
  *
- * 回滚/undo 前会比一次 `afterVersion`：文件在事务之后又被别人改过就拒绝覆盖（`--force` 才强制）。
+ * 回滚前会比一次 `afterVersion`：文件在事务之后又被别人改过就拒绝覆盖。
  * 这不是安全边界；它只保证遵守本协议的进程不会静默覆盖并发写。
  */
 import fs from 'node:fs'
@@ -262,21 +261,6 @@ function readAllMeta(root) {
   return out.sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
 }
 
-/** 取最近一条可 undo 的 committed 事务。 */
-export function latestCommitted(root) {
-  return readAllMeta(root).find((meta) => meta.status === 'committed') ?? null
-}
-
-export function listTransactions(root) {
-  return readAllMeta(root).map((meta) => ({
-    id: meta.id,
-    tool: meta.tool,
-    createdAt: meta.createdAt,
-    status: meta.status,
-    files: Array.isArray(meta.files) ? meta.files.length : 0,
-    dir: meta.dir,
-  }))
-}
 
 function prune(root, keep = KEEP) {
   const metas = readAllMeta(root).filter((meta) => meta.status !== 'pending')
@@ -285,66 +269,3 @@ function prune(root, keep = KEEP) {
   }
 }
 
-/**
- * 撤销一条 committed 事务。
- *
- * 任何文件在当前时间点的版本与事务提交后的版本不一致 ⇒ 默认拒绝，避免覆盖后续编辑；
- * `force: true` 才强制恢复旧字节。
- */
-export async function undoTransaction(root, provider, options = {}) {
-  const metas = readAllMeta(root)
-  const meta = options.id ? metas.find((m) => m.id === options.id) : metas.find((m) => m.status === 'committed')
-  if (meta === undefined) {
-    throw Object.assign(new Error(options.id ? `transaction not found: ${options.id}` : 'no committed transaction to undo'), {
-      code: 'TRANSACTION_NOT_FOUND',
-    })
-  }
-  if (meta.status !== 'committed') {
-    throw Object.assign(new Error(`transaction ${meta.id} is ${meta.status}, not committed`), {
-      code: 'TRANSACTION_NOT_UNDOABLE',
-      status: meta.status,
-    })
-  }
-  const force = options.force === true
-  /**
-   * 先做一次**只读预检**：任何文件在事务后又被改过 ⇒ 整个 undo 拒绝。
-   * 旧顺序会先把还能恢复的文件写回去，再发现某个文件冲突——那就是一次部分 undo；
-   * 对一个以“不会静默改错”为卖点的工具，部分恢复比拒绝更坏。
-   */
-  const plans = []
-  const conflicts = []
-  for (const entry of meta.files) {
-    if (!entry.written) continue
-    let current
-    try { current = provider.stat(entry.path) } catch { current = undefined }
-    if (!force && entry.afterVersion !== null && current?.version !== entry.afterVersion) {
-      conflicts.push({ path: entry.path, reason: 'changed since this transaction', expected: entry.afterVersion, actual: current?.version ?? null })
-    }
-    plans.push(entry)
-  }
-  if (conflicts.length > 0) {
-    throw Object.assign(new Error(`transaction ${meta.id} cannot be undone: ${conflicts.length} file(s) changed after it`), {
-      code: 'TRANSACTION_STALE',
-      transaction: meta.id,
-      conflicts,
-    })
-  }
-  let restored = 0
-  for (const entry of plans) {
-    try {
-      if (entry.existed) {
-        writeBytesAtomic(entry.realPath, fs.readFileSync(path.join(meta.dir, entry.backup)), entry.mode ?? 0o600)
-      } else {
-        fs.rmSync(entry.realPath, { force: true })
-      }
-      restored += 1
-    } catch (error) {
-      conflicts.push({ path: entry.path, reason: String(error?.message ?? error) })
-    }
-  }
-  meta.status = conflicts.length === 0 ? 'undone' : 'recovery_required'
-  meta.undoneAt = new Date().toISOString()
-  meta.undoConflicts = conflicts
-  saveMeta(meta)
-  return { transaction: meta.id, status: meta.status, restored, conflicts, dir: meta.dir }
-}

package/locator-lab/args.mjs

@@ -126,12 +126,12 @@ export function normalizeReadRequest(args, totalLines = undefined) {
  * 导出它是为了不再出现第二份：守卫要拿它算“合法键集合”，而如果有两份名单，
  * 新增一种地址写法时必有一处漏改——那正是本项目反复出现的形状。
  */
-export const FLAT_ADDRESS_KEYS = ['target', 'intent', 'lines', 'start_line', 'end_line', 'line_cue', 'anchor', 'handle', 'old']
+export const FLAT_ADDRESS_KEYS = ['target', 'lines', 'start_line', 'end_line', 'line_cue', 'anchor', 'handle', 'old']
 
 /**
  * `targets` 元素（单目标参数）的合法键。
  *
- * 与顶层工具键**分开**：`targets` 本身、批量级的 `include_transaction` 都不是元素参数；
+ * 与顶层工具键**分开**：`targets` 本身不是元素参数；
  * 放进元素里只会被静默丢掉。三面（CLI / MCP / DSH）共用这一份，未知键一律
  * `ARGS_UNKNOWN_KEY`，不再只校验顶层。
  */
@@ -140,7 +140,7 @@ export const MT_READ_ELEMENT_KEYS = [
 ]
 export const MT_EDIT_ELEMENT_KEYS = [
   'file_path', 'hunks', 'create', 'dry_run', 'require_observation',
-  'target', 'intent', 'lines', 'start_line', 'end_line', 'line_cue', 'anchor', 'old', 'context',
+  'target', 'lines', 'start_line', 'end_line', 'line_cue', 'anchor', 'old', 'context',
   'replace', 'replace_all', 'eol', 'expect', 'near', 'handle', 'line', 'position',
 ]
 

package/locator-lab/locator-api.mjs

@@ -23,28 +23,24 @@ import { indexFile, locateWith, normSpace } from './anchor-core.mjs'
 /**
  * 定位一份源码里的改动点。
  *
- * 五层寻址，按"模型要提供什么"从强到弱排列。每层覆盖上一层够不到的场景，
+ * 四层寻址，按"模型要提供什么"从强到弱排列。每层覆盖上一层够不到的场景，
  * 但**都不要求模型复现字节**——这是它们与 `edit` 的根本差别：
  *
- *   1. `intent`  —— 一段模糊意图（符号名片段 / 短语 / 近似原文）。引擎按固定次序收敛：
- *                    精确符号 → 符号子串 → 文本锚点；收敛不了就报歧义并给候选，绝不猜。
- *   2. `target`  —— 符号名。不读文本，对内容记错免疫。适合改整个函数/类/类型。
- *   3. `lines`   —— 行号区间。模型刚用 `read` 看过文件，输出就是 `<行号>: <文本>`，
+ *   1. `target`  —— 符号名。不读文本，对内容记错免疫。适合改整个函数/类/类型。
+ *   2. `lines`   —— 行号区间。模型刚用 `read` 看过文件，输出就是 `<行号>: <文本>`，
  *                    `grep` 也给行号——**位置是它本来就知道的信息**，我却一直只让它给内容。
  *                    把行号纳入地址空间后，符号体内的任意一行都变得可精确寻址。
- *   4. `lineCue` —— 一个词。当模型记不住行号时，说"就在有 resolvePolicy 的那一行"。
+ *   3. `lineCue` —— 一个词。当模型记不住行号时，说"就在有 resolvePolicy 的那一行"。
  *                    只接受**全文件唯一**的线索；不唯一则报歧义并给出候选行号，绝不猜。
- *   5. `anchor`  —— 记得的原文。五级降级匹配，容错性最好但要求模型复现内容。
+ *   4. `anchor`  —— 记得的原文。五级降级匹配，容错性最好但要求模型复现内容。
  *
- * `intent` 与其余四层**互斥**（由 `planHunks` 判）：同时给两个地址时谁说了算没有正确答案。
- * 前两层偏**精确**（要么命中要么报错），后三层偏**容错**。
- * 调用方可以传 `assert` 做内容校验，五层都适用——那才是防止"指到错的行"的那道闸。
+ * 前两层偏**精确**（要么命中要么报错），后两层偏**容错**。
+ * 调用方可以传 `assert` 做内容校验，四层都适用——那才是防止"指到错的行"的那道闸。
  * 判据是**包含且唯一**：这段文字必须在整个文件里只出现一处，且该处落在受寻址区间内
  * （短引文例外，仍要求与区间整段相等；推导见 {@link ASSERT_RELAX_MIN_CHARS}）。
  *
  * @param {string} source - 源码全文
  * @param {object} request - 定位请求
- * @param {string} [request.intent] - 模糊意图地址（符号名片段 / 短语 / 近似原文）
  * @param {string} [request.target] - 符号名（`name` / `kind:name` / `Outer/Inner` / `name#n`）
  * @param {{start:number,end:number}} [request.lines] - 1-based 闭区间行号
  * @param {string} [request.lineCue] - 一个词的线索，必须全文件唯一
@@ -644,53 +640,14 @@ function assertVerdict(lines, startLine, endLine, tier, actual, assertText) {
   }
 }
 
-/**
- * 意图地址（T16）的符号子串匹配：这个候选符号离 `near` 有多远。
- *
- * 判据只有一条：**`near` 落在符号的跨度里就是 0**，否则取到两端中较近的那一端。
- * 与 `resolveTarget` 的 `|startLine - near|` 刻意不同：`intent` 匹配的是"大概想改哪个符号"，
- * 调用方给的 `near` 常常是**符号体内**的一行（它刚从 read 回执里抄来），拿起点算距离会把
- * 一个明显在说的符号判成第二近。跨度包含 `near` ⇒ 距离 0，是这里唯一能自洽的口径。
- *
- * @param - 符号投影（含 startLine / endLine）
- * @param near - 1-based 行号提示
- * @returns 非负整数距离
- */
-function symbolDistanceFrom(symbol, near) {
-  if (near >= symbol.startLine && near <= symbol.endLine) return 0
-  return Math.min(Math.abs(near - symbol.startLine), Math.abs(near - symbol.endLine))
-}
 
 /**
- * 多个子串命中里，`near` 能否**严格**收敛到一个（唯一最小值）。
+ * 定位一个区间。四层降级：符号身份 → 行号 → 唯一词 → 文本锚点。
  *
- * 不唯一（并列最小）⇒ null：那正是"该报歧义"的形状，猜测在这里比拒绝贵得多。
- * @returns 命中的符号，或 null（near 没给 / 并列）
- */
-function nearestSymbolBySpan(symbols, near) {
-  let best = null
-  let bestDistance = Infinity
-  let ties = 0
-  for (const symbol of symbols) {
-    const distance = symbolDistanceFrom(symbol, near)
-    if (distance < bestDistance) {
-      bestDistance = distance
-      best = symbol
-      ties = 1
-    } else if (distance === bestDistance) ties += 1
-  }
-  return ties === 1 ? best : null
-}
-
-/**
- * 定位一个区间。五层降级：意图 → 符号身份 → 行号 → 唯一词 → 文本锚点。
- *
- * `intent`（T16）是**最弱但最自然**的一层：调用方给一个符号名片段、短语或近似原文，
- * 引擎先当符号名解析（精确/限定写法），再按符号名子串匹配，最后才落到文本匹配。
  * 每一档都**确定性地**收敛到一个区间；收敛不了就报歧义并给候选，不猜。
  *
  * @param source - 文件全文
- * @param request - `intent` / `target` / `lines` / `lineCue` / `anchor` 五选一，外加 `near` 与 `assert`
+ * @param request - `target` / `lines` / `lineCue` / `anchor` 四选一，外加 `near` 与 `assert`
  * @returns 命中时 `{ok: true, startLine, endLine, tier, actual}`；未命中时 `{ok: false, code, message, ...}`。
  *   `actual` 是该区间的原文，供调用方核对或展示。
  */
@@ -761,125 +718,6 @@ export function locate(source, request = {}) {
     return { ok: false, code: 'LOCATOR_LINE_SHARED', message, shared }
   }
 
-  // ── 第 0 层：意图地址（T16）。调用方给一段模糊的意图串，引擎确定性地落成精确区间。
-  //
-  // 解析次序（每一档都不猜，落不下来就报歧义并给候选）：
-  //   ① 已知语言时，先当符号名解析（`resolveTarget` 的精确 / 限定写法）——命中就算 symbol 档；
-  //   ② 符号名没对上（或对上多个）⇒ 按符号名**子串**匹配（先区分大小写，再忽略大小写）；
-  //   ③ 一个符号都没命中（或语言未知）⇒ 落到文本匹配（`locateWith`，与 `anchor` 同一份引擎）。
-  //
-  // 顺序上刻意在 `target` 之前：`intent` 与其余地址字段**互斥**（`PATCH_INTENT_CONFLICT`，
-  // 由 `planHunks` 判），所以两者同时到达这里是不可能的；放在最前只是把"intent 自成一层"写明。
-  if (typeof request.intent === 'string' && request.intent.trim().length > 0) {
-    const intent = request.intent.trim()
-    const near = request.near ?? null
-    const label = clipReceiptLabel(filePath === null ? 'this file' : filePath, RECEIPT_LABEL_CHARS)
-    /** 跨度覆盖不了符号体时的拒绝——与 `target=` 那一支**同一句话、同一个码**（不是第二套说法）。 */
-    const spanIncomplete = (hit) => ({
-      ok: false,
-      code: 'LOCATOR_SPAN_INCOMPLETE',
-      message: `cannot address "${hit.name}" by intent in ${label}: the span does not cover the body — ${hit.spanNote}; address it with lines= or line_cue= instead`,
-      hint: directoryHint(source, lang),
-    })
-    if (lang !== null) {
-      const index = indexStructure(source, lang)
-      /**
-       * 精确/限定符号：先**不带 near** 解析，拿到唯一命中或完整候选。
-       * 带 near 交给 `resolveTarget` 会用“起点距离”，与 intent 档的“跨度包含 near 记 0”冲突，
-       * 实测会把 near 落在第一个长函数体内的情况选到第二个同名函数上。歧义时这里用
-       * `nearestSymbolBySpan` 按跨度收敛；解析不了再落到子串匹配。
-       */
-      let exact = null
-      try {
-        exact = resolveTarget(index, intent, null)
-      } catch (error) {
-        if (error.code === 'STRUCT_AMBIGUOUS') {
-          const candidates = Array.isArray(error.candidates) ? error.candidates : []
-          if (near !== null && near !== undefined) {
-            const chosen = nearestSymbolBySpan(candidates, near)
-            if (chosen !== null) {
-              if (chosen.spanComplete === false) return spanIncomplete(chosen)
-              return done(chosen.startLine, chosen.endLine, 'intent~symbol', true)
-            }
-          }
-          return failure('LOCATOR_INTENT_AMBIGUOUS', `intent ${JSON.stringify(intent)}: ${error.message}`, candidates)
-        }
-        // STRUCT_NOT_FOUND / 其它：符号名没猜中不是终点，落到子串匹配（下面）。
-      }
-      if (exact !== null) {
-        if (exact.spanComplete === false) return spanIncomplete(exact)
-        const shared = sharedLineContent(source, index, exact, lang)
-        if (shared !== null) return sharedLineRefusal(exact, shared, 'intent')
-        return done(exact.startLine, exact.endLine, 'intent~symbol')
-      }
-      // 用原始符号表而不是 `listSymbols` 投影：整行区间是否越界要看 token，投影里没有。
-      const symbols = index.symbols
-      let matches = symbols.filter((s) => s.name.includes(intent))
-      if (matches.length === 0) {
-        const lower = intent.toLowerCase()
-        matches = symbols.filter((s) => s.name.toLowerCase().includes(lower))
-      }
-      if (matches.length === 1) {
-        const only = matches[0]
-        if (only.spanComplete === false) return spanIncomplete(only)
-        const shared = sharedLineContent(source, index, only, lang)
-        if (shared !== null) return sharedLineRefusal(only, shared, 'intent')
-        return done(only.startLine, only.endLine, 'intent~symbol')
-      }
-      if (matches.length > 1) {
-        if (near !== null && near !== undefined) {
-          const chosen = nearestSymbolBySpan(matches, near)
-          if (chosen !== null) {
-            if (chosen.spanComplete === false) return spanIncomplete(chosen)
-            const shared = sharedLineContent(source, index, chosen, lang)
-            if (shared !== null) return sharedLineRefusal(chosen, shared, 'intent')
-            return done(chosen.startLine, chosen.endLine, 'intent~symbol', true)
-          }
-        }
-        const why =
-          near === null || near === undefined
-            ? `intent ${JSON.stringify(intent)} matched ${matches.length} symbols — pick one with target=<name>, or add near=<line>`
-            : `intent ${JSON.stringify(intent)} matched ${matches.length} symbols and near=${near} did not single one out`
-        return failure(
-          'LOCATOR_INTENT_AMBIGUOUS',
-          why,
-          matches.map((s) => ({
-            name: s.name,
-            kind: s.kind,
-            startLine: s.startLine,
-            endLine: s.endLine,
-            enclosing: s.enclosing,
-          })),
-        )
-      }
-    }
-    // ── ③ 文本兜底：与 `anchor` 同一份引擎（`locateWith`）；tier 里带上它命中的那一档
-    try {
-      const loc = locateWith(indexFile(source), intent, near)
-      return done(loc.start + 1, loc.end, `intent~text~${loc.tier}`, loc.byNear === true)
-    } catch (error) {
-      if (error.code === 'PATCH_AMBIGUOUS') {
-        /**
-         * 行候选统一成 `{line, text}`（`failure` 只认这一形状才会印出行号与原文）：
-         * `locateWith` 抛的是 `number[]`，直接递下去会印成 `line undefined`。
-         */
-        const listed = (Array.isArray(error.candidates) ? error.candidates : [])
-          .filter((n) => typeof n === 'number' && n >= 1 && n <= lines.length)
-          .map((n) => ({ line: n, text: lines[n - 1].slice(0, 80) }))
-        return failure('LOCATOR_INTENT_AMBIGUOUS', `intent ${JSON.stringify(intent)}: ${error.message}`, listed)
-      }
-      if (error.code === 'PATCH_NOT_FOUND' || error.code === 'PATCH_EMPTY_ANCHOR') {
-        return {
-          ok: false,
-          code: 'LOCATOR_INTENT_NOT_FOUND',
-          message: `no symbol or text matches intent ${JSON.stringify(intent)} in ${label}; try target=<name>, lines=, or line_cue=`,
-          // 符号目录是实测支撑的恢复路径（与 anchor 失败同一条）：只有认识这门语言时才给得出。
-          ...(lang === null ? {} : { hint: directoryHint(source, lang) }),
-        }
-      }
-      return failure(error.code ?? 'LOCATOR_FAILED', error.message, error.candidates)
-    }
-  }
 
   // ── 第 1 层：符号身份。不读文本，因此对内容记错免疫。
   if (typeof request.target === 'string' && request.target.trim().length > 0) {
@@ -1028,7 +866,7 @@ export function locate(source, request = {}) {
     }
   }
 
-  return { ok: false, code: 'LOCATOR_NO_REQUEST', message: 'provide one of: intent, target, lines, lineCue, anchor' }
+  return { ok: false, code: 'LOCATOR_NO_REQUEST', message: 'provide one of: target, lines, lineCue, anchor' }
 }
 
 /**

package/locator-lab/write-path.mjs

@@ -2577,35 +2577,6 @@ function locateByHandle(lines, hunk, parsed, ctx) {
   })
 }
 
-/**
- * `intent` 与哪些字段**不能同时出现**（T16）。
- *
- * `intent` 是**自成一体的一层地址**：它由引擎决定落到哪个精确区间。若同时给出任何别的地址，
- * 谁说了算就没有正确答案——挑一个执行就是一次静默换语义（调用方写的两个地址指向不同地方时，
- * 改错的那次不会有任何提示）。所以参数面直接拒绝，而不是挑一个。
- *
- * 名单与 {@link planHunks} 的地址判据同源：`target` / `lines`（含别名 `range`）/ `start_line` /
- * `end_line` / `line_cue` / `anchor` / `old` / `context` / `handle`。
- * `near` / `expect` / `replace` **不在**名单里：前两个是修饰，第三个是动作。
- *
- * 「在场」的判据逐字段照搬它自己那一层的：字符串看非空（`anchor` 看长度、其余看 trim），
- * 坐标看 `!== undefined && !== null`。判据写宽或写窄都会让某个形状在参数面与引擎里得到两种结论。
- *
- * @returns 冲突的字段名（按上面的固定顺序）；没有冲突时为空数组
- */
-function intentAddressConflicts(hunk) {
-  const clashes = []
-  if (typeof hunk.target === 'string' && hunk.target.trim().length > 0) clashes.push('target')
-  for (const key of ['lines', 'range', 'start_line', 'end_line']) {
-    if (hunk[key] !== undefined && hunk[key] !== null) clashes.push(key)
-  }
-  if (typeof hunk.line_cue === 'string' && hunk.line_cue.trim().length > 0) clashes.push('line_cue')
-  if (typeof hunk.anchor === 'string' && hunk.anchor.length > 0) clashes.push('anchor')
-  if (oldAddressOf(hunk) !== null) clashes.push('old')
-  if (typeof hunk.context === 'string' && hunk.context.trim().length > 0) clashes.push('context')
-  if (typeof hunk.handle === 'string' && hunk.handle.trim().length > 0) clashes.push('handle')
-  return clashes
-}
 
 /**
  * 规划所有 hunk：逐个定位 → expect 核对 → 重叠检查 → 倒序拼接。
@@ -2661,7 +2632,7 @@ export function planHunks(content, hunks, filePath = null, options = {}) {
      *
      * 它不是第六种地址，而是 `old` 的一种作用范围；因此只认 `old` + 动作字段（`replace` /
      * `expect` / `eol`）。把 `target`/`lines`/`context`/`near` 混进来意味着"既想全改又想收敛到一处"，
-     * 没有正确答案 —— 参数面直接拒绝，与 `intent` 的互斥同一条理由。
+     * 没有正确答案 —— 参数面直接拒绝，与地址字段互斥同一条理由。
      */
     const replaceAll = hunk.replace_all
     if (replaceAll !== undefined && typeof replaceAll !== 'boolean') {
@@ -2673,7 +2644,7 @@ export function planHunks(content, hunks, filePath = null, options = {}) {
     if (replaceAll === true) {
       const clashes = []
       if (hasTarget) clashes.push('target')
-      if (typeof hunk.intent === 'string' && hunk.intent.trim().length > 0) clashes.push('intent')
+
       for (const key of ['lines', 'range', 'start_line', 'end_line']) {
         if (hunk[key] !== undefined && hunk[key] !== null) clashes.push(key)
       }
@@ -2708,23 +2679,6 @@ export function planHunks(content, hunks, filePath = null, options = {}) {
         )
       }
     }
-    /**
-     * 意图地址（T16）：`intent` 是**自成一体**的一层地址，与其余地址字段互斥。
-     *
-     * 冲突在**定位之前**就拒（参数面没成形，与 `PATCH_NO_ADDRESS` 同族），而不是在引擎里挑一个：
-     * 调用方写了两个地址说明它自己也没定，工具替它选一次就是一次看不见的换语义。
-     * `near` / `expect` / `replace` 不在此列——前两个是修饰，第三个是动作。
-     */
-    const hasIntent = typeof hunk.intent === 'string' && hunk.intent.trim().length > 0
-    if (hasIntent) {
-      const clashed = intentAddressConflicts(hunk)
-      if (clashed.length > 0) {
-        throw new PatchError(
-          `\`intent\` is a complete address by itself — it cannot be combined with ${clashed.join(', ')} (near / expect / replace are fine); drop either intent or those fields — nothing was written`,
-          'PATCH_INTENT_CONFLICT',
-        )
-      }
-    }
     /** 句柄的形状在这里判（不对就抛错）；`{handle, old}` 那一支的 `old` 仍然要命中区间内部。 */
     const parsedHandle = handleAddressOf(hunk)
     /**
@@ -2752,9 +2706,9 @@ export function planHunks(content, hunks, filePath = null, options = {}) {
         'PATCH_NO_ADDRESS',
       )
     }
-    if (oldText === null && parsedHandle === null && !hasTarget && range === undefined && !hasCue && !hasAnchor && !hasIntent) {
+    if (oldText === null && parsedHandle === null && !hasTarget && range === undefined && !hasCue && !hasAnchor) {
       throw new PatchError(
-        gaveLineAddress(hunk) ? LINE_ADDRESS_HINT : 'each hunk needs one of: old, intent, target, lines, line_cue, anchor',
+        gaveLineAddress(hunk) ? LINE_ADDRESS_HINT : 'each hunk needs one of: old, target, lines, line_cue, anchor',
         'PATCH_NO_ADDRESS',
       )
     }
@@ -2776,29 +2730,16 @@ export function planHunks(content, hunks, filePath = null, options = {}) {
         ? locateAllByOld(lines, hunk, oldText, filePath === null ? 'this file' : filePath, handleCtx)
         : [locateByOld(lines, hunk, oldText, filePath === null ? 'this file' : filePath, handleCtx)]
     } else {
-      /**
-       * 意图地址（T16）单独走一条请求：只带 `intent` / `near` / `expect` / `filePath`。
-       * 冲突字段在上面已经拒了，这里刻意**不再把其余地址字段递下去**——即便哪天冲突判据放宽，
-       * 引擎也不该从第二个地址里"顺手"拿到位置（那正是静默换语义的来路）。
-       */
-      const request = hasIntent
-        ? {
-            intent: hunk.intent,
-            ...(hunk.near === undefined ? {} : { near: hunk.near }),
-            ...(hunk.expect === undefined || hunk.expect === null ? {} : { assert: hunk.expect }),
-            ...(filePath === null ? {} : { filePath }),
-            ...(options.allowLoneCr === true ? { allowLoneCr: true } : {}),
-          }
-        : {
-            ...(hasTarget ? { target: hunk.target } : {}),
-            ...(range === undefined ? {} : { lines: range }),
-            ...(hunk.line_cue === undefined ? {} : { lineCue: hunk.line_cue }),
-            ...(hasTarget || range !== undefined || hunk.line_cue !== undefined ? {} : { anchor: hunk.anchor }),
-            ...(hunk.near === undefined ? {} : { near: hunk.near }),
-            ...(hunk.expect === undefined || hunk.expect === null ? {} : { assert: hunk.expect }),
-            ...(filePath === null ? {} : { filePath }),
-            ...(options.allowLoneCr === true ? { allowLoneCr: true } : {}),
-          }
+      const request = {
+        ...(hasTarget ? { target: hunk.target } : {}),
+        ...(range === undefined ? {} : { lines: range }),
+        ...(hunk.line_cue === undefined ? {} : { lineCue: hunk.line_cue }),
+        ...(hasTarget || range !== undefined || hunk.line_cue !== undefined ? {} : { anchor: hunk.anchor }),
+        ...(hunk.near === undefined ? {} : { near: hunk.near }),
+        ...(hunk.expect === undefined || hunk.expect === null ? {} : { assert: hunk.expect }),
+        ...(filePath === null ? {} : { filePath }),
+        ...(options.allowLoneCr === true ? { allowLoneCr: true } : {}),
+      }
       const found = locate(content, request)
       if (!found.ok) {
         throw new PatchError(found.message, found.code, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aura-basetools",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "Byte-exact read, edit and write tools for coding agents. Standalone CLI and MCP server; no DSH required. 面向 coding agent 的逐字节读写工具；独立 CLI / MCP，可选 DSH 适配器。",
   "license": "MIT",
   "type": "module",

package/test/standalone-test.mjs

@@ -179,7 +179,7 @@ say('B2 能力清单：capabilities 从引擎常量派生')
   check(caps.ok === true && caps.langsCount === caps.langs?.length, `langsCount=${caps.langsCount}`, JSON.stringify(caps.langs?.length))
   check(caps.langsCount === 65, '语言表 65 种（与 LANGS 同源）', String(caps.langsCount))
   check(readTool?.modes?.includes('auto') && readTool.modes.includes('map') && readTool.modes.includes('changed'), '读模式含 auto/map/changed', JSON.stringify(readTool?.modes))
-  check(editTool?.addressKinds?.includes('intent') && editTool.addressKinds.includes('target') && editTool.addressKinds.includes('handle'), '编辑地址档含 intent/target/handle', JSON.stringify(editTool?.addressKinds))
+  check(editTool?.addressKinds?.includes('target') && editTool.addressKinds.includes('handle'), '编辑地址档含 target/handle', JSON.stringify(editTool?.addressKinds))
   check(editTool?.options?.includes('replace_all'), '编辑选项含 replace_all', JSON.stringify(editTool?.options))
   check(editTool?.options?.includes('require_observation'), '编辑选项含 require_observation', JSON.stringify(editTool?.options))
   check(caps.limits?.multiTargetsMax === 32 && caps.limits?.defaultPruneBudget === 8192 && caps.limits?.contentBudget === 7492, '限制与常量一致', JSON.stringify(caps.limits))
@@ -385,7 +385,7 @@ say('F MCP：initialize / tools/list / tools/call')
   })()
   if (manifest !== null) check(byId.get(1)?.result?.serverInfo?.version === manifest.version, `serverInfo.version 跟包一致（${manifest.version}）`, String(byId.get(1)?.result?.serverInfo?.version))
   const tools = byId.get(2)?.result?.tools ?? []
-  check(tools.length === 5 && tools.some((t) => t.name === 'aura_basetools_read') && tools.some((t) => t.name === 'aura_basetools_edit') && tools.some((t) => t.name === 'aura_basetools_write') && tools.some((t) => t.name === 'aura_basetools_undo') && tools.some((t) => t.name === 'aura_basetools_transactions'), `tools/list 五个工具（${tools.map((t) => t.name).join(',')}`)
+  check(tools.length === 3 && tools.some((t) => t.name === 'aura_basetools_read') && tools.some((t) => t.name === 'aura_basetools_edit') && tools.some((t) => t.name === 'aura_basetools_write'), `tools/list 三个工具（${tools.map((t) => t.name).join(',')}`)
   const readEnv = JSON.parse(byId.get(3)?.result?.content?.[0]?.text ?? '{}')
   check(readEnv.ok === true && Array.isArray(readEnv.symbols ?? []), 'aura_basetools_read 经 MCP 可用', JSON.stringify(readEnv).slice(0, 120))
   const editEnv = JSON.parse(byId.get(4)?.result?.content?.[0]?.text ?? '{}')
@@ -1537,49 +1537,9 @@ say('N provider：mode / symlink / hardlink / range / 上限 / cache')
   }
 }
 
-say('O 写事务：journal / undo / 多目标回滚')
+say('O 写失败回滚与锁（0.14.0 已移除公开 undo/transactions）')
 {
-  const txFile = path.join(tmp, 'tx-single.txt')
-  const txOriginal = 'one\ntwo\n'
-  fs.writeFileSync(txFile, txOriginal)
-  const txEdit = json(run(['basetools', 'edit', '--file', txFile, '--lines', '1', '--replace', 'ONE', '--transaction']))
-  check(txEdit.ok === true && typeof txEdit.result?.transaction?.id === 'string', 'O1 单目标编辑返回 transaction id', JSON.stringify(txEdit.result?.transaction ?? txEdit.code))
-  check(fs.readFileSync(txFile, 'utf8') === 'ONE\ntwo\n', 'O1 编辑已落盘')
-  const txId = txEdit.result?.transaction?.id
-  const txUndo = json(run(['basetools', 'undo', '--id', String(txId)]))
-  check(txUndo.ok === true && txUndo.status === 'undone', 'O2 undo 成功', JSON.stringify(txUndo))
-  check(fs.readFileSync(txFile, 'utf8') === txOriginal, 'O2 undo 恢复原始字节')
-
-  const a = path.join(tmp, 'tx-a.txt')
-  const b = path.join(tmp, 'tx-b.txt')
-  fs.writeFileSync(a, 'alpha\n')
-  fs.writeFileSync(b, 'beta\n')
-  const targets = [
-    { file_path: a, hunks: [{ lines: [1, 1], replace: 'ALPHA' }] },
-    { file_path: b, hunks: [{ lines: [1, 1], replace: 'BETA' }] },
-  ]
-  const multi = json(run(['basetools', 'edit', '--targets', JSON.stringify(targets), '--transaction']))
-  check(multi.ok === true && typeof multi.transaction?.id === 'string', 'O3 多目标编辑返回 transaction id', JSON.stringify(multi.transaction ?? multi.code))
-  check(fs.readFileSync(a, 'utf8') === 'ALPHA\n' && fs.readFileSync(b, 'utf8') === 'BETA\n', 'O3 两个文件都已落盘')
-  const multiUndo = json(run(['basetools', 'undo', '--id', String(multi.transaction?.id)]))
-  check(multiUndo.ok === true && multiUndo.restored === 2, 'O4 多目标 undo 恢复两个文件', JSON.stringify(multiUndo))
-  check(fs.readFileSync(a, 'utf8') === 'alpha\n' && fs.readFileSync(b, 'utf8') === 'beta\n', 'O4 两个文件都回到原始字节')
-
-  const list = json(run(['basetools', 'transactions']))
-  check(list.ok === true && Array.isArray(list.transactions) && list.transactions.length > 0, 'O5 transactions 列出当前工作区事务')
-
-  // 事务后又被改过 ⇒ 默认拒绝 undo，force 才覆盖
-  const guardFile = path.join(tmp, 'tx-guard.txt')
-  fs.writeFileSync(guardFile, 'v0\n')
-  const guardEdit = json(run(['basetools', 'edit', '--file', guardFile, '--lines', '1', '--replace', 'v1', '--transaction']))
-  const guardId = guardEdit.result?.transaction?.id
-  fs.writeFileSync(guardFile, 'external\n')
-  const blocked = json(run(['basetools', 'undo', '--id', String(guardId)]))
-  check(blocked.ok === false && blocked.code === 'TRANSACTION_STALE', 'O6 事务后文件被外部改过 ⇒ undo 默认拒绝', JSON.stringify({ code: blocked.code, error: blocked.error }))
-  const forced = json(run(['basetools', 'undo', '--id', String(guardId), '--force']))
-  check(forced.ok === true && fs.readFileSync(guardFile, 'utf8') === 'v0\n', 'O6 force 后仍可恢复')
-
-  // O7 多目标：一个成功、一个写失败 ⇒ 成功那个也必须回滚
+  // O7 多目标：一个成功、一个写失败 ⇒ 成功那个也必须回滚（内部事务日志仍保留）
   const okFile = path.join(tmp, 'tx-rollback-ok.txt')
   const hardBase = path.join(tmp, 'tx-rollback-hard-base.txt')
   const hardFile = path.join(tmp, 'tx-rollback-hard.txt')
@@ -1594,31 +1554,13 @@ say('O 写事务：journal / undo / 多目标回滚')
       { file_path: okFile, hunks: [{ lines: [1, 1], replace: 'ALPHA' }] },
       { file_path: hardFile, hunks: [{ lines: [1, 1], replace: 'BETA' }] },
     ]
-    const rollback = json(run(['basetools', 'edit', '--targets', JSON.stringify(rollbackTargets), '--transaction']))
-    check(rollback.ok === false && rollback.transaction?.status === 'rolled_back', 'O7 多目标部分失败 ⇒ transaction rolled_back', JSON.stringify({ ok: rollback.ok, tx: rollback.transaction, rollback: rollback.rollback }))
+    const rollback = json(run(['basetools', 'edit', '--targets', JSON.stringify(rollbackTargets)]))
+    check(rollback.ok === false && rollback.rollback?.status === 'rolled_back' && rollback.rolled_back === true, 'O7 多目标部分失败 ⇒ 自动回滚', JSON.stringify({ ok: rollback.ok, rollback: rollback.rollback }))
     check(rollback.rollback?.restored === 1 && fs.readFileSync(okFile, 'utf8') === 'alpha\n', 'O7 已落地的那个文件被恢复')
     check(fs.readFileSync(hardBase, 'utf8') === 'beta\n' && fs.readFileSync(hardFile, 'utf8') === 'beta\n', 'O7 硬链接目标未被改动')
-    // 回执必须等于**回滚后的最终磁盘状态**，不能继续报 landed/applied。
     check(rollback.applied === 0 && rollback.landed_paths?.length === 0 && rollback.unchanged === true, 'O7 回滚后 applied=0 / landed_paths=[] / unchanged=true', JSON.stringify({ applied: rollback.applied, landed_paths: rollback.landed_paths, unchanged: rollback.unchanged }))
     check(rollback.rolled_back === true && rollback.edits?.filter((e) => e.outcome === 'rolled_back').every((e) => e.landed === false), 'O7 逐项 outcome=rolled_back 且 landed=false', JSON.stringify(rollback.edits?.map((e) => ({ outcome: e.outcome, landed: e.landed }))))
     check(!/applied [1-9]|landed [1-9]/.test(rollback.summary ?? ''), 'O7 汇总行不再出现 applied N / landed N', rollback.summary)
-
-    // 不带 --transaction 也必须能看出“已回滚”：回执事实不依赖是否索要事务 id。
-    // 用一组**新文件**：上一轮回滚后观测账本里还留着“写下去的那版”，同一文件立刻重试会先被
-    // 区域闸拦下（那是另一条保护，别把它混进回执断言）。
-    const okFile2 = path.join(tmp, 'tx-rollback-ok2.txt')
-    const hardBase2 = path.join(tmp, 'tx-rollback-hard-base2.txt')
-    const hardFile2 = path.join(tmp, 'tx-rollback-hard2.txt')
-    fs.writeFileSync(okFile2, 'alpha\n')
-    fs.writeFileSync(hardBase2, 'beta\n')
-    fs.linkSync(hardBase2, hardFile2)
-    const rollbackTargets2 = [
-      { file_path: okFile2, hunks: [{ lines: [1, 1], replace: 'ALPHA' }] },
-      { file_path: hardFile2, hunks: [{ lines: [1, 1], replace: 'BETA' }] },
-    ]
-    const rollbackNoTx = json(run(['basetools', 'edit', '--targets', JSON.stringify(rollbackTargets2)]))
-    check(rollbackNoTx.ok === false && rollbackNoTx.rollback?.status === 'rolled_back' && rollbackNoTx.rolled_back === true, 'O7 include_transaction=false 仍返回 rollback/rolled_back', JSON.stringify({ rollback: rollbackNoTx.rollback, rolled_back: rollbackNoTx.rolled_back }))
-    check(rollbackNoTx.applied === 0 && rollbackNoTx.landed_paths?.length === 0 && fs.readFileSync(okFile2, 'utf8') === 'alpha\n', 'O7 不索要事务 id 时回执仍与最终磁盘一致', JSON.stringify({ applied: rollbackNoTx.applied, landed_paths: rollbackNoTx.landed_paths }))
   }
 
   // O8 锁：同一工作区已有写事务时，第二个编辑必须超时拒绝