aura-basetools 0.13.3 → 0.14.0

package/README.md

@@ -1,8 +1,8 @@
-# aura-basetools 0.13.3
+# aura-basetools 0.14.0
 
-Byte-exact file tools for coding agents: read by intent, edit by intent, and write whole files without corrupting bytes. One engine shared by a standalone CLI and an MCP server.
+Byte-exact file tools for coding agents: read by intent, edit by address, and write whole files without corrupting bytes. One engine shared by a standalone CLI and an MCP server.
 
-面向 coding agent 的逐字节文件工具：按意图读取、按意图编辑、整文件写入；CLI 与 MCP 共用同一套引擎。
+面向 coding agent 的逐字节文件工具：按意图读取、按地址编辑、整文件写入；CLI 与 MCP 共用同一套引擎。
 
 ---
 
@@ -21,7 +21,7 @@ The engine is intentionally not a general file manager: it reads and edits UTF-8
 ### Install
 
 ```bash
-npm i -g aura-basetools@0.13.3
+npm i -g aura-basetools@0.14.0
 aura --version
 ```
 
@@ -31,8 +31,6 @@ aura --version
 aura basetools read  --file src/app.ts --mode map
 aura basetools edit  --file src/app.ts --hunks '[{"target":"main","replace":"..."}]'
 aura basetools write --file generated.ts --content @body.ts
-aura basetools undo
-aura basetools transactions
 aura basetools mcp
 ```
 
@@ -77,10 +75,10 @@ The server exposes:
 | Tool | Purpose |
 |---|---|
 | `aura_basetools_read` | Intent-based views: `map`, `digest`, `full`, `around`, `lines`, `search`, `changed`, `auto` |
-| `aura_basetools_edit` | Anchored multi-hunk edits; `old` + `replace_all`; optional transaction |
+| `aura_basetools_edit` | Anchored multi-hunk edits; `old` + `replace_all` |
 | `aura_basetools_write` | Whole-file create/overwrite with read-before-write and read-back verification |
-| `aura_basetools_undo` | Undo the latest or a named write transaction |
-| `aura_basetools_transactions` | List write transactions for the current workspace |
+
+0.14.0 removed the public `undo` / `transactions` tools (0 uses in 642 sessions); failure rollback remains internal and automatic.
 
 The older tool names (`aura_read`, `aura_edit`, `aura_write`, ...) are no longer exposed by MCP or DSH.
 
@@ -128,7 +126,7 @@ MIT.
 `aura-basetools` 是一个 Node.js（>=18）包，运行时零依赖，提供：
 
 - **CLI**：`aura basetools <verb>`
-- **MCP 服务**：stdio 上的五个工具
+- **MCP 服务**：stdio 上的三个工具
 - **不依赖 DSH**：DeepSeek Harness 适配器是独立的可选包 `aura-basetools-dsh`
 
 它不是通用文件管理器：只处理 UTF-8 文本，保留字节级格式；如果被寻址区域在“授权读取”之后被改动，编辑会被拒绝。
@@ -136,7 +134,7 @@ MIT.
 ### 安装
 
 ```bash
-npm i -g aura-basetools@0.13.3
+npm i -g aura-basetools@0.14.0
 aura --version
 ```
 
@@ -146,8 +144,6 @@ aura --version
 aura basetools read  --file src/app.ts --mode map
 aura basetools edit  --file src/app.ts --hunks '[{"target":"main","replace":"..."}]'
 aura basetools write --file generated.ts --content @body.ts
-aura basetools undo
-aura basetools transactions
 aura basetools mcp
 ```
 
@@ -192,10 +188,10 @@ npx -y --package aura-basetools aura basetools mcp
 | 工具 | 作用 |
 |---|---|
 | `aura_basetools_read` | `map` / `digest` / `full` / `around` / `lines` / `search` / `changed` / `auto` |
-| `aura_basetools_edit` | 多 hunk 锚点编辑；`old` + `replace_all`；可选事务 |
+| `aura_basetools_edit` | 多 hunk 锚点编辑；`old` + `replace_all` |
 | `aura_basetools_write` | 整文件新建/覆写；覆写默认要求先读，写后回读校验 |
-| `aura_basetools_undo` | 撤销最近一次或指定写事务 |
-| `aura_basetools_transactions` | 列出当前工作区写事务 |
+
+0.14.0 移除了公开 `undo` / `transactions`（642 个会话中 0 次使用）；失败回滚仍是内部自动行为。
 
 旧工具名（`aura_read`、`aura_edit`、`aura_write` 等）不再由 MCP/DSH 暴露。
 

package/bin/aura-mcp.mjs

@@ -5,12 +5,10 @@
  * 为什么是它：Codex / Claude Code / Cursor / Zed 这些 agent 都吃 MCP —— 一次写壳，到处能用，
  * 且**不要求对方装 DSH**（本文件只依赖 node:fs 与本包的引擎）。
  *
- * 暴露五个工具：
+ * 暴露三个工具：
  *   aura_basetools_read          七种取景（map/digest/full/around/lines/search/changed）+ 版本令牌
  *   aura_basetools_edit          四层寻址 + expect + dry_run；逐字节写回 + 陈旧区域闸门 + 落盘后回读校验
- *   aura_basetools_write         整份写入（对应内置 Write）：新建或整文件替换，同走事务与回读校验
- *   aura_basetools_undo          撤销最近一次/指定写事务（默认拒绝覆盖后续编辑）
- *   aura_basetools_transactions  列出当前工作区写事务
+ *   aura_basetools_write         整份写入（对应内置 Write）：新建或整文件替换，同走原子写与回读校验
  *
  * 接法（写进各家的 MCP 配置即可）：
  *   codex:        codex mcp add aura -- npx -y --package aura-basetools aura basetools mcp
@@ -21,9 +19,9 @@
  * `aura-basetools`；npx 在"多个 bin 且没有与包名同名的"时候会拒绝猜，直接报
  * `could not determine executable to run`（实测）。`--package` 明确指定包，`aura` 才是命令。
  */
-import { readFileSync } from 'node:fs'
+import { readFileSync, realpathSync } from 'node:fs'
 import process from 'node:process'
-import { pathToFileURL } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 import {
   openProvider,
   readEnvelope,
@@ -32,8 +30,6 @@ import {
   // 多目标（fs-contract-v2）的引擎绑定：与单目标同一处（`lib/ops.mjs`），bin 里不另找引擎。
   readManyWith,
   editManyEnvelope,
-  undoEnvelope,
-  transactionsEnvelope,
   assertReadTargets,
   assertEditTargets,
   assertTargetShape,
@@ -81,11 +77,6 @@ const HUNK_SCHEMA = {
   type: 'object',
   properties: {
     target: { type: 'string', description: '符号名，如 `toTodoList` 或 `function:apply`；跳过全部文本匹配' },
-    intent: {
-      type: 'string',
-      description:
-        '模糊意图地址：符号名片段、短语或近似原文（如 `parseConfig`、`config loader`、`// retry the upload`），由引擎确定性地落成一个精确区间；歧义时报候选并拒绝（不猜）。单独使用（不与 target/lines/line_cue/anchor/old/context/handle 同用）；可用 near 与 expect',
-    },
     lines: {
       oneOf: [
         { type: 'array' },
@@ -137,7 +128,7 @@ const HUNK_SCHEMA = {
     replace_all: {
       type: 'boolean',
       description:
-        '与 old 同用：替换全部非重叠出现（从左到右），不再要求唯一。不能与 target/intent/lines/line_cue/anchor/context/handle/near 同用；读取后出现次数变了会整体拒绝。',
+        '与 old 同用：替换全部非重叠出现（从左到右），不再要求唯一。不能与 target/lines/line_cue/anchor/context/handle/near 同用；读取后出现次数变了会整体拒绝。',
     },
     eol: {
       type: 'string',
@@ -198,14 +189,13 @@ const TOOLS = [
   {
     name: 'aura_basetools_edit',
     description:
-      'Edit or create a UTF-8 text file with hunks in one call. Address each hunk by intent (fuzzy name/phrase), target (symbol), lines, line_cue, anchor, or old (verbatim content + optional context). With `old`, set `replace_all: true` to replace every non-overlapping occurrence. Writes back byte-for-byte (BOM and per-line endings preserved), refuses a hunk whose addressed region changed since your last read, and reads the file back to verify. All hunks must locate or nothing is written.',
+      'Edit or create a UTF-8 text file with hunks in one call. Address each hunk by target (symbol), lines, line_cue, anchor, or old (verbatim content + optional context). With `old`, set `replace_all: true` to replace every non-overlapping occurrence. Writes back byte-for-byte (BOM and per-line endings preserved), refuses a hunk whose addressed region changed since your last read, and reads the file back to verify. All hunks must locate or nothing is written.',
     inputSchema: {
       type: 'object',
       properties: {
         file_path: { type: 'string' },
         hunks: { type: 'array', items: HUNK_SCHEMA },
         dry_run: { type: 'boolean', description: '只定位不落盘' },
-        include_transaction: { type: 'boolean', description: '在回执里返回 transaction id（默认不返回，保持输出稳定）' },
         require_observation: {
           type: 'boolean',
           description: '严格新鲜度：要求这一版文件在本会话里被读过（或由本工具写过）；否则 PATCH_UNOBSERVED。create 不受影响；dry_run 同样执行这条判决。',
@@ -230,7 +220,7 @@ const TOOLS = [
   {
     name: 'aura_basetools_write',
     description:
-      'Write a whole UTF-8 text file at once (create or overwrite), matching a plain Write tool. Preserves an existing file\'s BOM and line endings, goes through the same transaction/undo path as aura_basetools_edit, and reads the file back to verify bytes. Prefer aura_basetools_edit for partial changes.',
+      'Write a whole UTF-8 text file at once (create or overwrite), matching a plain Write tool. Preserves an existing file\'s BOM and line endings, goes through the same atomic write path as aura_basetools_edit, and reads the file back to verify bytes. Prefer aura_basetools_edit for partial changes.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -247,28 +237,10 @@ const TOOLS = [
           enum: ['auto', 'preserve', 'lf', 'crlf'],
           description: '覆写时的换行风格：auto（默认）适配文件已有风格；preserve 按 content 原样写；lf/crlf 强制。新建文件始终按 content 原样写（非 auto 会被拒绝）。',
         },
-        include_transaction: { type: 'boolean', description: '在回执里返回 transaction id（默认不返回）' },
       },
       required: ['file_path', 'content'],
     },
   },
-  {
-    name: 'aura_basetools_undo',
-    description:
-      'Undo the latest committed write transaction, or the transaction with the given id. Refuses if a file changed after the transaction; pass force=true to override. Restores the exact bytes captured before the write.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { type: 'string', description: '事务 id；省略则撤销最近一条 committed 事务' },
-        force: { type: 'boolean', description: '即使文件在事务后又被改过也强制恢复' },
-      },
-    },
-  },
-  {
-    name: 'aura_basetools_transactions',
-    description: 'List write transactions for the current workspace (id, status, file count, time).',
-    inputSchema: { type: 'object', properties: {} },
-  },
 ]
 
 /**
@@ -351,7 +323,6 @@ async function editTargetsCall(provider, args) {
   return await editManyEnvelope(provider, {
     targets,
     dryRun: args.dry_run === true,
-    includeTransaction: args.include_transaction === true,
     ...(args.require_observation === true ? { requireObservation: true } : {}),
   })
 }
@@ -436,7 +407,6 @@ async function callTool(provider, name, args = {}) {
       hunks: Array.isArray(args.hunks) ? args.hunks : [],
       dryRun: args.dry_run === true,
       create: creating ? args.create : undefined,
-      includeTransaction: args.include_transaction === true,
       ...(args.require_observation === true ? { requireObservation: true } : {}),
     })
   }
@@ -446,13 +416,10 @@ async function callTool(provider, name, args = {}) {
       content: args.content,
       dryRun: args.dry_run === true,
       noOverwrite: args.no_overwrite === true,
-      includeTransaction: args.include_transaction === true,
       allowUnobserved: args.allow_unobserved === true,
       ...(typeof args.eol === 'string' ? { eol: args.eol } : {}),
     })
   }
-  if (name === 'aura_basetools_undo') return await undoEnvelope(provider, { id: args.id, force: args.force === true })
-  if (name === 'aura_basetools_transactions') return transactionsEnvelope(provider)
   return { ok: false, error: `unknown tool ${JSON.stringify(name)}`, code: 'UNKNOWN_TOOL' }
 }
 
@@ -561,6 +528,25 @@ export async function serve() {
 
 // 直接运行本文件（`aura-mcp`，package.json 里声明的第二个 bin）也要起服务，与 `aura basetools mcp` 等价。
 // 用 pathToFileURL 比手拼 file:// 靠得住（Windows 盘符就是那种手拼会踩的地方）。
-if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(process.argv[1]).href) {
+/**
+ * 直接执行本文件才起 stdio 服务。
+ *
+ * 不能只比 `import.meta.url === pathToFileURL(argv[1])`：macOS 的临时目录
+ * `/var/folders/...` 是 `/private/var/folders/...` 的符号链接，Node 给模块的 URL 与
+ * argv 的写法可能一侧已 realpath、另一侧没有 ⇒ 服务静默退出，客户端看到 0 个工具
+ * （post-publish / split-package 在 macOS 上正是这条）。两边都过 realpath 再比。
+ */
+function isDirectRun() {
+  const invoked = process.argv[1]
+  if (invoked === undefined) return false
+  if (import.meta.url === pathToFileURL(invoked).href) return true
+  try {
+    return realpathSync.native(fileURLToPath(import.meta.url)) === realpathSync.native(invoked)
+  } catch {
+    return false
+  }
+}
+
+if (isDirectRun()) {
   await serve()
 }

package/bin/aura.mjs

@@ -6,8 +6,6 @@
  *   aura basetools edit  --file F (--hunks '<json>' | --hunks-file P) [--dry-run] [--create <文本|@文件>]
  *   aura basetools read  --targets '[...]|@spec.json'                    一次读多个目标（与 --file 互斥）
  *   aura basetools edit  --targets '[...]|@spec.json'                    一次改多个文件（与 --file 互斥；任一规划失败 ⇒ 零写入）
- *   aura basetools undo [--id <事务 id>] [--force]                      撤销最近一次/指定写事务
- *   aura basetools transactions                                         列出当前工作区写事务
  *   aura basetools mcp
  *   aura --help | --version
  *
@@ -27,8 +25,6 @@ import {
   // 多目标（fs-contract-v2）的引擎绑定：与单目标同一处（`lib/ops.mjs`），bin 里不另找引擎。
   readManyWith,
   editManyEnvelope,
-  undoEnvelope,
-  transactionsEnvelope,
   capabilitiesEnvelope,
   writeEnvelope,
   assertReadTargets,
@@ -74,7 +70,7 @@ let command = argv[0]
  * 有了这份名单，“下一个是已知布尔旗标”才当没带值，**其它以 `--` 开头的东西都当值**。
  * 代价是名单要维护；收益是那个静默丢值的路径从根上消失，而不是靠叫用户改写法。
  */
-const BOOLEAN_FLAGS = new Set(['pretty', 'dry-run', 'plan', 'transaction', 'force', 'no-overwrite', 'replace-all', 'require-observation', 'allow-unobserved', 'json'])
+const BOOLEAN_FLAGS = new Set(['pretty', 'dry-run', 'plan', 'no-overwrite', 'replace-all', 'require-observation', 'allow-unobserved', 'json'])
 const isBooleanFlag = (token) => typeof token === 'string' && BOOLEAN_FLAGS.has(token.replace(/^--/, ''))
 
 /**
@@ -90,15 +86,13 @@ const COMMAND_FLAGS = {
     bool: ['pretty'],
   },
   edit: {
-    value: ['cwd', 'file', 'targets', 'hunks', 'hunks-file', 'create', 'target', 'intent', 'lines', 'start-line', 'end-line', 'line-cue', 'anchor', 'old', 'context', 'handle', 'line', 'position', 'replace', 'expect', 'near', 'eol'],
-    bool: ['pretty', 'dry-run', 'plan', 'transaction', 'replace-all', 'require-observation'],
+    value: ['cwd', 'file', 'targets', 'hunks', 'hunks-file', 'create', 'target', 'lines', 'start-line', 'end-line', 'line-cue', 'anchor', 'old', 'context', 'handle', 'line', 'position', 'replace', 'expect', 'near', 'eol'],
+    bool: ['pretty', 'dry-run', 'plan', 'replace-all', 'require-observation'],
   },
   write: {
     value: ['cwd', 'file', 'content', 'eol'],
-    bool: ['pretty', 'dry-run', 'plan', 'transaction', 'no-overwrite', 'allow-unobserved'],
+    bool: ['pretty', 'dry-run', 'plan', 'no-overwrite', 'allow-unobserved'],
   },
-  undo: { value: ['cwd', 'id'], bool: ['pretty', 'force'] },
-  transactions: { value: ['cwd'], bool: ['pretty'] },
   doctor: { value: ['cwd'], bool: ['pretty', 'json'] },
   capabilities: { value: ['cwd'], bool: ['pretty'] },
   mcp: { value: ['cwd'], bool: ['pretty'] },
@@ -177,20 +171,20 @@ const USAGE = [
   "  aura basetools edit  --file <路径> (--hunks '<json>' | --hunks-file <路径>) [--dry-run|--plan] [--eol auto|preserve|lf|crlf] [--require-observation]",
   '   aura basetools edit  --file <路径> --lines <a,b> --replace <文本> [--expect <文本>] [--near <n>]',
   '   aura basetools edit  --file <路径> --old <原文> --replace <文本> --replace-all        # 改全部非重叠出现',
-  "              （只改一处时不必包成 JSON：--target / --intent / --lines / --start-line+--end-line / --line-cue / --anchor 任选其一）",
+          "              （只改一处时不必包成 JSON：--target / --lines / --start-line+--end-line / --line-cue / --anchor 任选其一）",
   // 句柄（fs-contract-v2 §5）：读侧发的柄 + 三种定位写法。下面三行是三种**用法**，不是三种键。
   '   aura basetools edit  --file <路径> --handle <h…> --replace <文本>                          # 整段替换：区间由柄定，不靠转述',
   '   aura basetools edit  --file <路径> --handle <h…> --line <段内行号> --replace <文本>            # 只换区间内第 k 行（1-based，从区间首行数起）',
   '   aura basetools edit  --file <路径> --handle <h…> --position before|after --replace <文本>  # 在区间边界插入，区间本身不动',
   "              （--line / --position 是从属键：只有与 --handle 同时给才成立，单独给不构成一次编辑）",
   '  aura basetools mcp                    启动 MCP stdio 服务',
-  '  aura basetools write --file <路径> --content <文本|@文件> [--no-overwrite] [--dry-run|--plan] [--transaction] [--allow-unobserved] [--eol auto|preserve|lf|crlf]',
+  '  aura basetools write --file <路径> --content <文本|@文件> [--no-overwrite] [--dry-run|--plan] [--allow-unobserved] [--eol auto|preserve|lf|crlf]',
   '             （覆写默认要求先读过这一版；--allow-unobserved 才允许盲写）',
   '  aura basetools doctor [--json]        自检：Node/版本/MCP 握手/缓存与锁目录可写',
   '  aura basetools capabilities [--pretty] 能力清单：读模式/地址档/语言/限制（JSON）',
   '  aura --help | --version',
   '',
-  'hunks 形状：[{"target":"符号名"|"intent":"模糊意图（符号片段/短语/近似原文）"|"lines":[a,b]|"line_cue":"唯一词"|"anchor":"记得的原文",',
+      'hunks 形状：[{"target":"符号名"|"lines":[a,b]|"line_cue":"唯一词"|"anchor":"记得的原文",',
   '              "replace":"替换文本","expect":"该处应是什么","near":行号}]',
   '',
   '例：',
@@ -311,7 +305,7 @@ if (command === '--version' || command === '-v') emit({ ok: true, version: VERSI
  * 旧顶层动词只给**迁移提示**，不再作为别名执行——保留别名等于保留未来的撞名。
  * 只提示、不执行：`aura basetools read` 不会偷偷改文件。
  */
-const MOVED_COMMANDS = new Set(['read', 'outline', 'edit', 'write', 'undo', 'transactions', 'mcp', 'doctor', 'capabilities'])
+const MOVED_COMMANDS = new Set(['read', 'outline', 'edit', 'write', 'mcp', 'doctor', 'capabilities'])
 if (!namespaced && MOVED_COMMANDS.has(command)) {
   emit(
     {
@@ -356,26 +350,12 @@ if (command === 'write') {
     content,
     dryRun: has('dry-run') || has('plan'),
     noOverwrite: has('no-overwrite'),
-    includeTransaction: has('transaction'),
     allowUnobserved: has('allow-unobserved'),
     ...(typeof eol === 'string' ? { eol } : {}),
   })
   emit(env, env.ok ? 0 : 2)
 }
 
-if (command === 'undo') {
-  const env = await undoEnvelope(provider, {
-    id: typeof flag('id') === 'string' ? flag('id') : undefined,
-    force: has('force'),
-  })
-  emit(env, env.ok ? 0 : 2)
-}
-
-if (command === 'transactions') {
-  const env = transactionsEnvelope(provider)
-  emit(env, 0)
-}
-
 if (command === 'doctor') {
   /**
    * `aura basetools doctor`：把“装完能不能用”的机械检查放在 CLI 自己身上。
@@ -492,7 +472,6 @@ if (command === 'edit') {
     const env = await editManyEnvelope(provider, {
       targets: spec.targets,
       dryRun: has('dry-run') || has('plan') || spec.dryRun,
-      includeTransaction: has('transaction'),
       ...(has('require-observation') ? { requireObservation: true } : {}),
     })
     emit(env, env.ok ? 0 : 2)
@@ -509,8 +488,6 @@ if (command === 'edit') {
    */
   const flat = flatHunk({
     target: flag('target'),
-    // 意图地址（T16）：`--intent 'config loader'` 一句话定位一处改动，不要求符号全名或原文。
-    intent: flag('intent'),
     lines: flag('lines'),
     start_line: flag('start-line'),
     end_line: flag('end-line'),
@@ -593,7 +570,7 @@ if (command === 'edit') {
       {
         ok: false,
         error:
-          'edit 需要 --hunks/--hunks-file，或平铺一组地址旗标（--target / --intent / --lines / --start-line+--end-line / --line-cue / --anchor / --handle（配 --line 或 --position），外加 --replace），或 --create <整份内容>',
+      'edit 需要 --hunks/--hunks-file，或平铺一组地址旗标（--target / --lines / --start-line+--end-line / --line-cue / --anchor / --handle（配 --line 或 --position），外加 --replace），或 --create <整份内容>',
         code: 'USAGE',
       },
       1,
@@ -607,7 +584,6 @@ if (command === 'edit') {
     hunks: hunks ?? [],
     dryRun: has('dry-run') || has('plan'),
     create,
-    includeTransaction: has('transaction'),
     ...(has('require-observation') ? { requireObservation: true } : {}),
   })
   emit(env, env.ok ? 0 : 2)

package/lib/ops.mjs

@@ -13,7 +13,7 @@ import fs from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { createNodeFsProvider, DEFAULT_MAX_TEXT_BYTES } from './fs-provider.mjs'
 import { withWorkspaceLock } from './workspace-lock.mjs'
-import { createTransaction, listTransactions, undoTransaction } from './transaction-store.mjs'
+import { createTransaction } from './transaction-store.mjs'
 import { createDiskStore } from './observation-store.mjs'
 
 /**
@@ -93,8 +93,8 @@ export function capabilitiesEnvelope() {
         addressKinds: [...new Set([...engineArgs.FLAT_ADDRESS_KEYS, 'old', 'context', 'position'])],
         options: ['replace_all', 'require_observation'],
         writeSafety: {
-          cli: ['transaction', 'undo', 'workspace-lock', 'stale-region-gate', 'byte-verify'],
-          mcp: ['transaction', 'undo', 'workspace-lock', 'stale-region-gate', 'byte-verify'],
+          cli: ['workspace-lock', 'stale-region-gate', 'byte-verify'],
+          mcp: ['workspace-lock', 'stale-region-gate', 'byte-verify'],
           dsh: ['stale-region-gate', 'byte-verify'],
         },
       },
@@ -103,14 +103,14 @@ export function capabilitiesEnvelope() {
         operations: ['create', 'overwrite'],
         options: ['eol'],
         writeSafety: {
-          cli: ['transaction', 'undo', 'workspace-lock', 'stale-region-gate', 'observation-gate', 'byte-verify'],
-          mcp: ['transaction', 'undo', 'workspace-lock', 'stale-region-gate', 'observation-gate', 'byte-verify'],
-          // DSH 壳没有事务/undo/工作区锁；它经过引擎的区域闸、严格新鲜度与回读校验。
+          cli: ['workspace-lock', 'stale-region-gate', 'observation-gate', 'byte-verify'],
+          mcp: ['workspace-lock', 'stale-region-gate', 'observation-gate', 'byte-verify'],
+          // DSH 壳没有工作区锁；它经过引擎的区域闸、严格新鲜度与回读校验。
           dsh: ['stale-region-gate', 'observation-gate', 'byte-verify'],
         },
       },
     ],
-    commands: ['basetools read', 'basetools edit', 'basetools write', 'basetools undo', 'basetools transactions', 'basetools mcp', 'basetools doctor', 'basetools capabilities', '--version', '--help'],
+    commands: ['basetools read', 'basetools edit', 'basetools write', 'basetools mcp', 'basetools doctor', 'basetools capabilities', '--version', '--help'],
     langs,
     langsCount: langs.length,
     limits: {
@@ -489,12 +489,9 @@ export async function editEnvelope(provider, request) {
   // 事务需要工作区根与真实文件系统；测试/嵌入式 provider 没有 root 时保持原来的引擎行为。
   if (provider.root === undefined) return editEnvelopeInner(provider, request)
   /**
-   * 预演不建事务：否则 `--dry-run --transaction` 会提交一条 0 文件的 committed 事务，
-   * 把 `aura undo`（最近一次 committed）顶掉——用户以为撤销了真实编辑，实际 restored:0。
-   * 预演也不写盘，不需要工作区锁。
+   * 预演不建事务、不写盘，也不需要工作区锁；0.14.0 起事务日志只用于失败回滚。
    */
   if (request.dryRun === true) return editEnvelopeInner(provider, request)
-  const includeTransaction = request.includeTransaction === true
   try {
     return await withWorkspaceLock(provider.root, async () => {
       const tx = createTransaction(provider.root, 'aura_basetools_edit')
@@ -508,10 +505,10 @@ export async function editEnvelope(provider, request) {
           error.rollback = rollback
           throw error
         }
-        return includeTransaction ? { ...env, result: { ...env.result, transaction: tx.summary() } } : env
+        return env
       }
-      const rollback = await tx.rollback(provider)
-      return includeTransaction ? { ...env, transaction: tx.summary(), rollback } : env
+      await tx.rollback(provider)
+      return env
     })
   } catch (error) {
     return transactionError(error)
@@ -523,7 +520,6 @@ export async function editManyEnvelope(provider, request) {
   if (provider.root === undefined) return editManyEnvelopeInner(provider, request)
   // 与单目标同一条：预演不建事务、不写盘，不能顶掉真正的最近 committed 事务。
   if (request.dryRun === true) return editManyEnvelopeInner(provider, request)
-  const includeTransaction = request.includeTransaction === true
   try {
     return await withWorkspaceLock(provider.root, async () => {
       const tx = createTransaction(provider.root, 'aura_basetools_edit')
@@ -538,14 +534,13 @@ export async function editManyEnvelope(provider, request) {
             error.rollback = rollback
             throw error
           }
-          return includeTransaction ? { ...batch, transaction: tx.summary() } : batch
+          return batch
         }
         const rollback = await tx.rollback(provider)
         const finalBatch = writePath.rebuildAfterRollback(batch, rollback)
         return {
           ...finalBatch,
           ok: false,
-          ...(includeTransaction ? { transaction: tx.summary() } : {}),
         }
       } catch (error) {
         const rollback = await tx.rollback(provider)
@@ -579,7 +574,6 @@ function compactWriteReceipt(env, content) {
       dryRun,
       ...(result.write_verify === undefined ? {} : { write_verify: result.write_verify }),
       ...(result.unverified_region === true ? { unverified_region: true } : {}),
-      ...(result.transaction === undefined ? {} : { transaction: result.transaction }),
     },
   }
 }
@@ -600,7 +594,7 @@ function compactWriteReceipt(env, content) {
  * `preserve` 按 content 原样写（与内置 Write 的“给什么写什么”对齐），`lf` / `crlf` 强制统一。
  * 新建文件永远按 content 原样写；显式传非 `auto` 的 eol 会被拒绝（不做静默忽略）。
  */
-export async function writeEnvelope(provider, { file, content, dryRun = false, noOverwrite = false, includeTransaction = false, allowUnobserved = false, eol = 'auto' } = {}) {
+export async function writeEnvelope(provider, { file, content, dryRun = false, noOverwrite = false, allowUnobserved = false, eol = 'auto' } = {}) {
   if (typeof file !== 'string' || file.length === 0) {
     return { ok: false, error: 'write needs a file path', code: 'WRITE_BAD_ARGS' }
   }
@@ -627,7 +621,7 @@ export async function writeEnvelope(provider, { file, content, dryRun = false, n
       if (dryRun) {
         return { ok: true, result: { path: displayPath, operation: 'create', bytes: Buffer.byteLength(content, 'utf8'), dryRun: true } }
       }
-      return compactWriteReceipt(await editEnvelope(provider, { file, create: content, includeTransaction }), content)
+      return compactWriteReceipt(await editEnvelope(provider, { file, create: content }), content)
     }
     return compactWriteReceipt(
       await editEnvelope(provider, {
@@ -635,7 +629,6 @@ export async function writeEnvelope(provider, { file, content, dryRun = false, n
         wholeFile: content,
         eol,
         dryRun,
-        includeTransaction,
         requireObservation: allowUnobserved !== true,
         skipStaleGate: allowUnobserved === true,
         toolName: 'aura_basetools_write',
@@ -646,17 +639,3 @@ export async function writeEnvelope(provider, { file, content, dryRun = false, n
     return transactionError(error)
   }
 }
-
-export async function undoEnvelope(provider, { id, force } = {}) {  try {
-    return {
-      ok: true,
-      ...(await withWorkspaceLock(provider.root, () => undoTransaction(provider.root, provider, { id, force: force === true }))),
-    }
-  } catch (error) {
-    return transactionError(error)
-  }
-}
-
-export function transactionsEnvelope(provider) {
-  return { ok: true, transactions: listTransactions(provider.root) }
-}

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.3",
+  "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 锁：同一工作区已有写事务时，第二个编辑必须超时拒绝

package/test/write-test.mjs

@@ -4,7 +4,7 @@
  * 覆盖：
  *   A 新建：真正建盘、回执 operation=create、dry-run 不建盘、事务可撤销（撤销后文件消失）
  *   B 覆写：整份替换、BOM 与文件既有行尾保留、有无尾换行精确、no-overwrite、dry-run、
- *     事务 + undo 逐字节恢复、`--content @file`
+ *     `--content @file`（0.14.0 移除公开事务/undo）
  *   C MCP：aura_basetools_write 出现在 tools/list，create/overwrite/no_overwrite/dry_run/坏参数都走同一引擎
  *   D 能力清单：commands 与 tools 都包含 write
  *
@@ -55,7 +55,7 @@ process.on('exit', () => {
 })
 
 // ── A 新建 ────────────────────────────────────────────────────────────────
-say('A 新建：整份建盘，dry-run 不建盘，事务可撤销')
+say('A 新建：整份建盘，dry-run 不建盘')
 {
   const created = json(run(['basetools', 'write', '--file', 'created.txt', '--content', 'alpha\nbeta\n']))
   check(created.ok === true && created.result?.operation === 'create', 'A1 新建回执 operation=create', JSON.stringify(created).slice(0, 160))
@@ -66,13 +66,6 @@ say('A 新建：整份建盘，dry-run 不建盘，事务可撤销')
   check(dry.ok === true && dry.result?.operation === 'create' && dry.result?.dryRun === true && dry.result?.bytes === 1, 'A4 新建 dry-run 回执给 create/bytes，但不落盘', JSON.stringify(dry).slice(0, 160))
   check(fs.existsSync(file('dry-new.txt')) === false, 'A5 新建 dry-run 之后文件仍不存在')
 
-  const tx = json(run(['basetools', 'write', '--file', 'tx-created.txt', '--content', 'gone\n', '--transaction']))
-  const txId = tx.result?.transaction?.id
-  check(tx.ok === true && typeof txId === 'string' && tx.result.transaction.status === 'committed', 'A6 --transaction 返回 committed 事务', JSON.stringify(tx.result?.transaction))
-  const undone = json(run(['basetools', 'undo', '--id', txId]))
-  check(undone.ok === true && undone.status === 'undone', 'A7 undo 成功', JSON.stringify(undone).slice(0, 160))
-  check(fs.existsSync(file('tx-created.txt')) === false, 'A8 撤销“新建”后文件消失（不留下空文件）')
-
   const missingFile = json(run(['basetools', 'write', '--content', 'x']))
   const missingContent = json(run(['basetools', 'write', '--file', 'x.txt']))
   check(missingFile.ok === false && missingFile.code === 'USAGE', 'A9 缺 --file ⇒ USAGE', JSON.stringify(missingFile).slice(0, 140))
@@ -119,14 +112,6 @@ say('B 覆写：整份替换，BOM / 既有行尾 / 尾换行精确')
   const newNoOverwrite = json(run(['basetools', 'write', '--file', 'brand-new.txt', '--content', 'ok\n', '--no-overwrite']))
   check(newNoOverwrite.ok === true, 'B11 no-overwrite 对不存在的文件照常创建')
 
-  fs.writeFileSync(file('tx-restore.txt'), Buffer.concat([BOM, Buffer.from('orig\r\nbytes\r\n', 'utf8')]))
-  prime('tx-restore.txt')
-  const original = fs.readFileSync(file('tx-restore.txt'))
-  const tx = json(run(['basetools', 'write', '--file', 'tx-restore.txt', '--content', 'changed\n', '--transaction']))
-  check(!fs.readFileSync(file('tx-restore.txt')).equals(original), 'B12 覆写真的改了盘')
-  const undone = json(run(['basetools', 'undo', '--id', tx.result?.transaction?.id]))
-  check(undone.ok === true && fs.readFileSync(file('tx-restore.txt')).equals(original), 'B13 undo 逐字节恢复覆写前的原文（含 BOM/CRLF）')
-
   fs.writeFileSync(file('content-source.txt'), 'from @file\nsecond line\n')
   const atFile = json(run(['basetools', 'write', '--file', 'from-at.txt', '--content', '@' + file('content-source.txt')]))
   check(atFile.ok === true && fs.readFileSync(file('from-at.txt'), 'utf8') === fs.readFileSync(file('content-source.txt'), 'utf8'), 'B14 --content @file 读入整份内容')
@@ -225,7 +210,7 @@ say('C MCP：aura_basetools_write 声明面与调用面')
 
   const tools = byId.get(2)?.result?.tools ?? []
   const writeTool = tools.find((tool) => tool.name === 'aura_basetools_write')
-  check(tools.length === 5 && writeTool !== undefined, `C1 tools/list 五个工具且含 aura_basetools_write（${tools.map((tool) => tool.name).join(',')}）`)
+  check(tools.length === 3 && writeTool !== undefined, `C1 tools/list 三个工具且含 aura_basetools_write（${tools.map((tool) => tool.name).join(',')}）`)
   check(JSON.stringify(writeTool?.inputSchema?.required) === JSON.stringify(['file_path', 'content']), 'C2 aura_basetools_write schema 必填 file_path + content', JSON.stringify(writeTool?.inputSchema?.required))
   check(envOf(3).ok === true && envOf(3).result?.operation === 'create', 'C3 经 MCP 新建成功', JSON.stringify(envOf(3)).slice(0, 160))
   check(fs.readFileSync(file('mcp-created.txt'), 'utf8') === 'mcp\ncreate\n', 'C4 MCP 新建的内容真的落盘')