@thincoder/core 0.9.4 → 0.10.1

package/tools/edit-batch.mjs

@@ -12,24 +12,23 @@
  */
 import { readFile } from "node:fs/promises"
 import { resolveInCwd, normalizeEOL, joinWithEol, gitDiffOne, autoSyntaxCheck } from "./shared.mjs"
-// edit-batch ↔ edit-diff 循环引用（#69 后同型）：两侧导入的都是函数声明（提升初始化），
+// edit-batch ↔ edit-diff 循环引用：两侧导入的都是函数声明（提升初始化），
 // 仅在调用期使用——ESM 循环下安全（无模块求值期取值）。
-// 写盘经单一写路径点（§2.13.5）——本档不再直调 fs；回执组装迁 composeEditReceipt（#69）。
+// 写盘经单一写路径点（§2.13.5）——本档不再直调 fs；回执组装共用 edit-diff 的 composeEditReceipt。
 import { writeThroughPath } from "./write-path.mjs"
 // EDIT.md §6：批量条目判定+应用共用 edit-diff（EDIT.md §4 分支 0 单行替换 + 行级 LCS——零重叠→替换即删）；
 // EDIT.md §5：edits 互斥错误文本随前置校验分支迁出至 edit-diff.mjs。
-// #69：回执组装共用 edit-diff 的 composeEditReceipt（回执形态按端注入——缺省 = CLI 形态）。
-import { assertEditArgsExclusive, validateEditEntry, computeEditEntry, splitLines, EMPTY_NEW_STRING_LINE, deleteTarget, composeEditReceipt } from "./edit-diff.mjs"
+// 回执组装共用 edit-diff 的 composeEditReceipt（单点——缺省回执 = base + 写入点上下文）。
+import { assertEditArgsExclusive, assertEditsContainer, assertEditEntries, validateEditEntry, computeEditEntry, splitLines, EMPTY_NEW_STRING_LINE, EDIT_ENTRY_NO_PATH, EDIT_ABORT_PREFIX, editEntryLabel, deleteTarget, composeEditReceipt } from "./edit-diff.mjs"
 
 /**
  * Apply the `edits` array form: multi-file atomic replacement. Throws on any
  * failure (atomic — nothing written). Returns the per-entry result text (joined).
  */
 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 | line/startLine+endLine, new_string}")
-  }
+  assertEditsContainer(args.edits)
   assertEditArgsExclusive(args)
+  assertEditEntries(args.edits) // #325 条目预扫（非对象条目 ⇒ 含下标成形错误；不读盘）
   // 原子：先全量检查（所有文件的替换都可执行）——任一失败全不写。
   // 2026-09-01 缺陷修复（TOOLS.md §9 ②"同文件多条规则"）：同一 path 的多条编辑
   // 按序**串行累积应用**——第 n 条基于前 n-1 条已应用后的累积内容做匹配与替换
@@ -40,9 +39,9 @@ export async function applyEditBatch(args, ctx) {
     // 2026-09-05 用户裁定：顶层 path + edits 并存合法化——`e.path || args.path`（条目优先；
     // 缺省入口仅在此兜底）；两者皆无 → 原错误文本（措辞补顶层选项）。
     const p = e.path || args.path
-    if (!p) throw new Error("each edit must have a path — give each entry its own path or pass a top-level path")
+    if (!p) throw new Error(EDIT_ENTRY_NO_PATH)
     // 前置校验（空 old / 非字符串 new——文本同 edit-diff 批量形态；读盘前校验）
-    validateEditEntry(e, { label: `edit for ${p}: `, rich: false })
+    validateEditEntry(e, { label: editEntryLabel(p), rich: false })
     const abs = resolveInCwd(ctx, p)
     let g = groups.get(abs)
     if (!g) {
@@ -61,7 +60,7 @@ export async function applyEditBatch(args, ctx) {
       const out = computeEditEntry(g.content, e, {
         path: g.path,
         absPath: g.abs,
-        abortPrefix: "edit aborted (atomic — no files written): ",
+        abortPrefix: EDIT_ABORT_PREFIX,
       })
       prepared.push({
         g,
@@ -92,7 +91,7 @@ export async function applyEditBatch(args, ctx) {
   for (const p of prepared) {
     // #4（2026-09-01 交付评审尾巴）：与单文件路径对齐——每条结果附 git diff +
     // autoSyntaxCheck（同文件多条会重复 diff/检查，换取格式一致、实现零分支）
-    const diff = gitDiffOne(ctx.cwd, p.g.abs)
+    const diff = await gitDiffOne(ctx.cwd, 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)}`

package/tools/edit-diff.mjs

@@ -45,6 +45,18 @@ export const EMPTY_NEW_STRING = "empty new_string — for deletion, keep the con
 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"
 
+// ─── #325 入参守卫文案（单源——EDIT.md §5 / §8 D-7：核 edit-batch 与 ACP 桥 bridge.mjs 同调用）───
+/** 容器级成形错误（真值非数组 / 空数组——同一错误面）。 */
+export const EDITS_CONTAINER_ERROR = "edits must be a non-empty array of {path, old_string | line/startLine+endLine, new_string}"
+/** 条目级成形错误（i = 数组下标；非对象条目 = null / 字符串 / 数字 / 数组）。 */
+export const editsEntryError = (i) => `edits[${i}] must be an object of {path, old_string | line/startLine+endLine, new_string}`
+/** 条目缺 path 且无顶层默认路径。 */
+export const EDIT_ENTRY_NO_PATH = "each edit must have a path — give each entry its own path or pass a top-level path"
+/** 批量原子失败前缀（条目判定失败时拼在消息前的 abortPrefix）。 */
+export const EDIT_ABORT_PREFIX = "edit aborted (atomic — no files written): "
+/** 批量条目校验前缀（validateEditEntry 的 opts.label）。 */
+export const editEntryLabel = (path) => `edit for ${path}: `
+
 /** D1（2026-09-08）：条目带按行号改参数（line / startLine / endLine 任一）。 */
 export function hasLineParams(entry) {
   return entry.line !== undefined || entry.startLine !== undefined || entry.endLine !== undefined
@@ -132,13 +144,28 @@ export function assertEditArgsExclusive(args) {
   }
 }
 
+/** 入参容器守卫（#325——EDIT.md §5）：edits 真值非数组 / 空数组 ⇒ 成形错误（同句单源——
+ *  核 edit-batch 与 ACP 桥 bridge.mjs 同调用）。批量判定序：容器 → 互斥 → 条目预扫 → 条目循环。 */
+export function assertEditsContainer(edits) {
+  if (!Array.isArray(edits) || edits.length === 0) throw new Error(EDITS_CONTAINER_ERROR)
+}
+
+/** 入参条目守卫（#325——EDIT.md §5）：条目非对象（null / 字符串 / 数字 / 数组）⇒ 含下标成形
+ *  错误——预扫于条目循环之前（不读盘、不触盘、零部分应用）。 */
+export function assertEditEntries(edits) {
+  for (let i = 0; i < edits.length; i++) {
+    const e = edits[i]
+    if (e === null || typeof e !== "object" || Array.isArray(e)) throw new Error(editsEntryError(i))
+  }
+}
+
 /**
  * 前置校验——内容形态：空 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（单形态完整文本） }
+ * opts: { label = ""（批量前缀 = editEntryLabel(path)）, rich = true（单形态完整文本） }
  */
 export function validateEditEntry(entry, opts = {}) {
   const label = opts.label ?? ""
@@ -213,7 +240,7 @@ function isSingleLineReplace(entry) {
  * LCS 替换 / replace_all 字面）→
  * 元数据（受影响区首行/行数差/次数——recordWrite 与结果回显用）。
  * 返回 { updated, editStartLine, lineShift, occurrences, note?, deleted? }；失败抛错（含路径/引导）。
- * opts: { path, abortPrefix（批量 "edit aborted (atomic — no files written): "） }
+ * opts: { path, abortPrefix（批量 = EDIT_ABORT_PREFIX） }
  */
 /**
  * P15.11（2026-09-05 用户裁定——edit 连续失败分析）：old_string 逐字 not-found 时——
@@ -345,7 +372,7 @@ export async function runSingleEdit(args, ctx) {
     op: "write",
     record: { type: "edit", startLine: out.editStartLine, shift: out.lineShift },
   })
-  const diff = gitDiffOne(ctx.cwd, abs)
+  const diff = await gitDiffOne(ctx.cwd, 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)}`
@@ -360,29 +387,10 @@ export async function runSingleEdit(args, ctx) {
   })
 }
 
-// ─── edit 回执形态注入缝（#69——「回执形态按端注入」，形态参 §2.13.5 注入缝）──────────
 /**
- * 回执组装注入位（**缺省不覆盖** = CLI 回执形态（base + 写入点上下文）——零行为变；
- * 端装配层可覆盖为本端回执形态）。核内零端名分支（契约 5——本档只认 `format` 函数名）。
- * 契约：`format(fields) → string | null | undefined | Promise<同>`——null / undefined =
- * 未处理 ⇒ 回默认回执；其余返回值即该条回执。
- */
-let injectedReceipt = null
-export function configureEditReceipt(impl) {
-  injectedReceipt = impl && typeof impl.format === "function" ? impl : null
-}
-/** 撤销注入（测试与端装配生命周期用——缺省态 = CLI 回执）。 */
-export function resetEditReceipt() { injectedReceipt = null }
-
-/**
- * edit 回执组装单点（单形态 / 数组形态共用——#69）：先组默认回执（base + 写入点上下文），
- * 注入面命中 ⇒ 以其 format(fields) 返回值为准（`fields.default` = 默认回执原文，供端侧改写）。
+ * edit 回执组装单点（单形态 / 数组形态共用）：`base` + 写入点上下文——唯一形态
+ * （#69 注入面已退场；余字段为调用面统一形，不参与组装）。
  */
 export async function composeEditReceipt(fields) {
-  const defaultText = await appendWriteContext(fields.abs, fields.writeLine, fields.base)
-  if (injectedReceipt) {
-    const out = await injectedReceipt.format({ ...fields, default: defaultText })
-    if (out !== null && out !== undefined) return String(out)
-  }
-  return defaultText
+  return await appendWriteContext(fields.abs, fields.writeLine, fields.base)
 }

package/tools/exec-run.mjs

@@ -14,10 +14,17 @@
  *   · `run(cmd, args, opts) → Promise<string> | string`——成功给 stdout；
  *   · 失败以 Error reject——`.stdout` / `.stderr` / `.code` 与 `execFileSync` 错误同形
  *     （端侧现形 = 宿主 `runInterruptible`）；
- *   · `opts = { cwd?, timeout?, signal? }`——**默认径忽略 signal**（execFileSync 不可中断，
- *     与现行 CLI 行为逐字同）；注入径自决（如 abort ⇒ 树杀）。
+ *   · `opts = { cwd?, timeout?, signal?, env? }`——**默认径忽略 signal**（execFileSync 不可中断，
+ *     与现行 CLI 行为逐字同）；`env` 缺省（undefined）不设 = 继承（逐字零变），给定则透传
+ *     （Electron 宿主旗标径 = TOOLS.md §6.18）；注入径自决（如 abort ⇒ 树杀）。
+ *
+ * **可中断执行器上提（R3 · 桌面功能对位批 · #523②）**：`runInterruptible` 自端侧现形
+ * （`thincoder-vscode/src/tools/shared.mjs`）**纯搬**落核（零语义改 —— KD-T2）；两端改指核件
+ * （VSC `configureExecRun({ run: runInterruptible })` 同轮改指；桌面 `src/main/exec-run.mjs` 消费）。
+ * 树杀 = 本仓 `tools/process-tree.mjs` 单源（`killProcessTree` —— 转口，零第二实现）。
  */
-import { execFileSync } from "node:child_process"
+import { execFileSync, spawn } from "node:child_process"
+import { killProcessTree } from "./process-tree.mjs"
 
 let injected = null
 
@@ -29,10 +36,11 @@ export function configureExecRun(impl) {
 /** 撤销注入（测试与端装配生命周期用——缺省态 = execFileSync 默认径）。 */
 export function resetExecRun() { injected = null }
 
-/** 默认径（CLI 语义——utf8 + timeout + stdio ignore/pipe/pipe；cwd 未给则不设）。 */
+/** 默认径（CLI 语义——utf8 + timeout + stdio ignore/pipe/pipe；cwd ∕ env 未给则不设）。 */
 function defaultRun(cmd, args, opts) {
   const options = { encoding: "utf8", timeout: opts.timeout, stdio: ["ignore", "pipe", "pipe"] }
   if (opts.cwd !== undefined) options.cwd = opts.cwd
+  if (opts.env !== undefined) options.env = opts.env
   return execFileSync(cmd, args, options)
 }
 
@@ -41,3 +49,93 @@ export async function runCommand(cmd, args, opts = {}) {
   if (injected) return await injected.run(cmd, args, opts)
   return defaultRun(cmd, args, opts)
 }
+
+/**
+ * 可中断执行器（**上提件** —— 端侧 `configureExecRun` 供值；原住 `thincoder-vscode/src/tools/shared.mjs`，
+ * 逐字搬运 —— R3 · #523②）：`spawn`（非 `execSync` —— 同步执行阻塞事件循环：长 lint ∕ verify 期间
+ * Stop 点击连“送达”都做不到）跑命令，abort ∕ timeout ⇒ 整树杀（本档 `killProcessTree` 单源）。
+ *
+ * 成功 → resolve stdout 串（与 `execFileSync` 调用点兼容）。
+ * 非零退出 ∕ spawn 失败 ∕ 超时 ∕ 中止 → reject 携 `.stdout` / `.stderr` / `.code`（同 `execFileSync` 错误形）。
+ */
+export function runInterruptible(cmd, args, opts = {}) {
+  const { cwd, timeout, signal, env } = opts
+  return new Promise((resolve, reject) => {
+    let child
+    try {
+      child = spawn(cmd, args, {
+        cwd, env: env ?? process.env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true,
+        // First-line abort guard: Node kills the direct child on signal abort.
+        ...(signal ? { signal } : {}),
+      })
+    } catch (e) {
+      reject(e)
+      return
+    }
+    let stdout = "", stderr = "", settled = false, timer = null, kickTimer = null, mode = null
+
+    const KICK_MS = 3000
+    const finish = (err, out) => {
+      if (settled) return
+      settled = true
+      if (timer) clearTimeout(timer)
+      if (kickTimer) clearTimeout(kickTimer)
+      signal?.removeEventListener("abort", onAbort)
+      if (err) {
+        err.stdout = stdout
+        err.stderr = stderr
+        reject(err)
+      } else {
+        resolve(out)
+      }
+    }
+    // Kill the whole tree on abort/timeout — grandchildren (npm test's children)
+    // must die too, or they keep the stdout/stderr pipes and "close" never fires.
+    const killTree = () => { try { killProcessTree(child) } catch { /* already gone */ } }
+    // Kick-clockback: settle even if "close" never arrives (a grandchild that
+    // mocks kill signal, or a wedged pipe). Prevents a hang + leaked pipes.
+    const armKick = (err) => {
+      if (kickTimer) return
+      kickTimer = setTimeout(() => finish(err), KICK_MS)
+    }
+
+    const onAbort = () => {
+      if (mode) return
+      mode = "abort"
+      const e = new Error("aborted by user (Stop)")
+      e.name = "AbortError"
+      killTree()
+      armKick(e)
+    }
+
+    if (timeout) {
+      timer = setTimeout(() => {
+        if (mode) return
+        mode = "timeout"
+        const e = new Error(`timed out after ${timeout}ms`)
+        e.name = "TimeoutError"
+        killTree()
+        armKick(e)
+      }, timeout)
+    }
+
+    child.stdout?.on("data", (d) => { stdout += d })
+    child.stderr?.on("data", (d) => { stderr += d })
+    child.on("error", (e) => { if (e.name === "AbortError") return; finish(e) })
+    child.on("close", (code) => {
+      if (mode === "abort") { const e = new Error("aborted by user (Stop)"); e.name = "AbortError"; return finish(e) }
+      if (mode === "timeout") { const e = new Error(`timed out after ${timeout}ms`); e.name = "TimeoutError"; return finish(e) }
+      if (code === 0) finish(null, stdout)
+      else {
+        const e = new Error(`command failed with exit code ${code}`)
+        e.code = code
+        finish(e)
+      }
+    })
+
+    if (signal) {
+      if (signal.aborted) { onAbort(); return }
+      signal.addEventListener("abort", onAbort, { once: true })
+    }
+  })
+}

package/tools/execute.mjs

@@ -28,13 +28,14 @@ import { spawn } from "node:child_process"
 import { resolve } from "node:path"
 import { DESC } from "./shared.mjs"
 import { killProcessTree } from "./process-tree.mjs"
+import { nodeChildEnv } from "./node-child.mjs"
 
 const MAX_SCRIPT = 50_000
 const MAX_OUTPUT = 50_000
 const DEFAULT_TIMEOUT = 30_000
 
 /**
- * 超时错误文本——带重试引导（TOOLS.md §14.1 D14.1.2——"下一跳"）：数字 = 实际生效的
+ * 超时错误文本——带重试引导（"下一跳"）：数字 = 实际生效的
  * timeoutMs（Math.min(t, 600_000) 或默认 30s）——上限 600000 与 schema/头注/execute.md 一致。
  */
 const timeoutErrorText = (timeoutMs) =>
@@ -83,6 +84,8 @@ function runNode(childArgs, baseDir, timeoutMs, signal) {
   return new Promise((resolvePromise) => {
     const child = spawn(process.execPath, childArgs, {
       cwd: baseDir,
+      // TOOLS.md §6.18：Electron 宿主 execPath 属 Electron 族二进制——补旗标按 node 语义启动
+      env: nodeChildEnv(),
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
       // POSIX detached → 子进程为组首——killProcessTree 的 -pid 组杀可达孙进程（win 用
@@ -223,7 +226,7 @@ export const executeTool = {
       if (code.length > MAX_SCRIPT) {
         return `Error: script too large (${code.length} > ${MAX_SCRIPT} bytes). Split into smaller scripts or use individual tools.`
       }
-      // inline mode: pure node ESM — no prelude, nothing injected (TOOLS.md §12).
+      // inline mode: pure node ESM — no prelude, nothing injected.
       childArgs = ["--input-type=module", "--eval", code]
     }
 

package/tools/file.mjs

@@ -19,7 +19,7 @@ import { runSingleEdit } from "./edit-diff.mjs";
 import { writeThroughPath, clearDirty, clearLastWrite, lastWriteOf, isDirty } from "./write-path.mjs";
 import { specForModel } from "../config.mjs";
 import { createHash } from "node:crypto";
-import { mkdir, readFile, stat, unlink } from "node:fs/promises";
+import { mkdir, readFile, stat } from "node:fs/promises";
 import { join, relative, dirname } from "node:path";
 
 const MAX_FILE_READ_BYTES = 10_000_000
@@ -178,11 +178,6 @@ export const readImageTool = {
       text: `[read_image: ${args.path} (${mime}, ${bytes} bytes)]`,
       images: [{ type: "image_url", image_url: { url: `data:${mime};base64,${b64}` } }],
     })
-    // Paste-created temp files: delete after use, no litter
-    const basename = abs.includes("/") ? abs.slice(abs.lastIndexOf("/") + 1) : abs.slice(abs.lastIndexOf("\\") + 1)
-    if (basename.startsWith(".thincoder-paste-")) {
-      try { await unlink(abs) } catch { /* can't delete, so be it */ }
-    }
     return result
   },
 }
@@ -214,7 +209,7 @@ export const writeTool = {
     const content = eol === "\r\n" ? normalizeEOL(args.content).replace(/\n/g, "\r\n") : args.content
     // 单一写路径点：默认 = writeFile + 记账；端侧注入 ⇒ 编辑器径（§2.13.5）。
     await writeThroughPath(abs, content, { op: "write", record: { type: "write", startLine: 1, shift: 0 } }) // 全文重写——全文件受影响
-    const diff = gitDiffOne(ctx.cwd, abs)
+    const diff = await gitDiffOne(ctx.cwd, abs)
     return `Wrote ${args.content.length} chars to ${args.path}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
   },
 }
@@ -257,11 +252,15 @@ export const editTool = {
   touchedPaths(args) {
     // 2026-09-05 用户裁定：顶层 path = 批默认——仅当有条目缺 path 时计入（条目全带 path
     // 时顶层 path 不实际使用——不虚报进 _touchedFiles）
-    if (args.edits) {
-      const out = args.edits.map((e) => e.path).filter(Boolean)
-      if (args.path && args.edits.some((e) => !e.path)) out.push(args.path)
+    // #325：本钩子**零抛**（execute 之前被多处消费，首个未守卫点即会逸出裸错）——形态
+    // 拒绝统一归 execute（edit-batch/桥 同单源成形错误）；真值非数组 ⇒ 返 []、零触达
+    // （不虚报顶层 path）；非对象条目按「缺 path」尽力提取（e?.path）。
+    if (Array.isArray(args.edits)) {
+      const out = args.edits.map((e) => e?.path).filter(Boolean)
+      if (args.path && args.edits.some((e) => !e?.path)) out.push(args.path)
       return out
     }
+    if (args.edits) return [] // 真值非数组：调用必被 execute 拒绝（成形错误）——零触达
     return args.path ? [args.path] : []
   },
   async execute(args, ctx) {
@@ -361,7 +360,7 @@ export const insertAfterTool = {
       op: "write",
       record: { type: "insert", startLine: targetLine, shift: normalizeEOL(args.content).split("\n").length },
     })
-    const diff = gitDiffOne(ctx.cwd, abs)
+    const diff = await gitDiffOne(ctx.cwd, abs)
     const baseResult = `Inserted after line ${targetLine} in ${args.path}${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}`
     return await appendWriteContext(abs, targetLine + 1, baseResult)
   },
@@ -456,7 +455,7 @@ export const hashlineEditTool = {
       op: "write",
       record: { type: "edit", startLine: pos + 1, shift: newLines.length - target.length },
     })
-    const diff = gitDiffOne(ctx.cwd, abs)
+    const diff = await gitDiffOne(ctx.cwd, abs)
     const baseResult = `Edited ${args.path}: replaced ${target.length} line(s) at L${pos + 1} with ${newLines.length} line(s)${diff ? "\n" + diff : ""}${await autoSyntaxCheck(abs)}${corrupted ? `\n${FFFD_WARNING}` : ""}`
     return await appendWriteContext(abs, pos + 1, baseResult)
   },

package/tools/git-run.mjs

@@ -33,7 +33,7 @@ export const GIT_NET_TIMEOUT_MS = 300_000
 /** 网路面五动作（300s 档——合法耗时可远超本地；依据 = 需求档 §4.7 TTY-DRIVE N3 候选参照值）。 */
 const GIT_NET_ACTIONS = new Set(["push", "fetch", "pull", "clone", "ls-remote"])
 
-/** 测试态缝（模块级 · 缺省 null = 生产零行为变——先例 `manifest.mjs:40-41` · `session-gc.mjs:136`）。
+/** 测试态缝（模块级 · 缺省 null = 生产零行为变——先例 `manifest-discovery.mjs:15-20` · `session-gc.mjs:186`）。
  *  用例 `finally` 复位；不经用户参数面（边界：不新增参数 / 用户选项）。 */
 let gitTimeoutOverride = null
 export function _setGitTimeoutForTest(ms) { gitTimeoutOverride = ms }

package/tools/git.mjs

@@ -26,9 +26,6 @@ async function runGitRaw(cwd, cmdArgs, config = []) {
   }
 }
 
-
-
-
 /** Resolve workdir relative to cwd — no boundary assertion
  *  (§10.1 2026-09-02: workspace confinement removed; git itself is not
  *  directory-limited — same boundary as bash). */
@@ -53,22 +50,6 @@ function ambiguousRepoMessage(candidates, cwd, matched) {
   return `${head} — pass workdir to run git in the intended one (no silent pick):\n` + candidates.map((c) => `- ${c}`).join("\n")
 }
 
-// ─── 审批门注入缝（#59——「只读判定 / 审批门按端注入」，形态参 §2.13.5 注入缝）────────
-/**
- * 审批门注入位（**缺省不覆盖** = 无审批面：全部动作照常执行——CLI 语义，零行为变；端装配层
- * 可覆盖为本端审批 / 只读判定。核内零端名分支（契约 5——本档只认 `gate` 函数名）。
- * 契约：`gate(args, ctx) → string | null | Promise<同>`——非空字符串 = 拒执行（该串原样作为
- * 工具结果返回）；null / undefined / 其他值 = 放行。每个 execute 恰问一次（workdir 归一后）。
- */
-let injectedApproval = null
-export function configureGitApproval(impl) {
-  injectedApproval = impl && typeof impl.gate === "function" ? impl.gate : null
-}
-/** 撤销注入（测试与端装配生命周期用——缺省态 = 无审批门）。 */
-export function resetGitApproval() { injectedApproval = null }
-
-
-
 export const gitTool = {
   name: "git",
   description: DESC("git"),
@@ -127,11 +108,6 @@ export const gitTool = {
         repoNote = `(repo: ${discovered.root})`
       }
     }
-    // #59：审批门（端注入面）——缺省无门（CLI 语义）；非空字符串返回 ⇒ 拒执行（拒串原样、不加注记）。
-    if (injectedApproval) {
-      const refusal = await injectedApproval(args, ctx)
-      if (typeof refusal === "string" && refusal.length > 0) return refusal
-    }
     const out = await gitActionCore.dispatch(args, ctx)
     return repoNote ? `${repoNote}\n${out}` : out
   },

package/tools/glob-dialect.mjs

@@ -1,5 +1,5 @@
 /**
- * glob-dialect.mjs — glob 方言（TOOLS.md §17 — 2026-09-06）单一权威模块（CLI）。
+ * glob-dialect.mjs — glob 方言（TOOLS.md §6.7 — 2026-09-06）单一权威模块（CLI）。
  *
  * `{a,b}` brace expansion is handled BEFORE the sentinel/escape flow (braces must
  * not be literal-escaped — a bare "star-star slash star .{js,txt}" pattern
@@ -12,7 +12,7 @@
  * intersects includes and excludes.
  *
  * Extracted from shared.mjs (2026-09-06 advisor #5 — shared.mjs exceeded the
- * 500-line cap after §17); shared.mjs re-exports these symbols so all existing
+ * 500-line cap after the TOOLS.md §6.7 move); shared.mjs re-exports these symbols so all existing
  * importers (system.mjs / ls filter / tests) keep their import paths.
  */
 
@@ -77,7 +77,7 @@ export function globToRegex(pattern) {
 /** Whitespace-split a glob expression into parts WITHOUT splitting inside {a,b}
  *  brace groups and WITHOUT splitting literal spaces inside a single pattern
  *  (2026-09-06 audit F1 / advisor #4): a whitespace run is a pattern separator
- *  ONLY when the next non-space token starts an exclusion ("!" — the §17
+ *  ONLY when the next non-space token starts an exclusion ("!" — the TOOLS.md §6.7
  *  "include !exclude" form). So a BARE pattern like "docs/my file/*.md" and an
  *  exclude like "!docs/my file/**" each stay ONE part; the standard
  *  "js-pattern 空格 !test-pattern" form still splits into its two parts. */

package/tools/index.mjs

@@ -68,7 +68,8 @@ export async function assembleBuiltinTools({ memory, cwd, projectDir = null, aut
     ...memoryTools(memory, { cwd, projectDir, author, team }),
     codeSearchTool(memory),
     docSearchTool(memory),
-    repoOutlineTool(memory.db, cwd),
+    // memory 缺位容错：组装期零解引用（memory?.db）；缺位不抛（懒失败留执行期——与 memory ∕ code_search ∕ doc_search 同族，dispatch 收成 Error 回模型）；有 memory 逐字零变
+    repoOutlineTool(memory?.db, cwd),
     settingsTool(),
     peerInstancesTool,
     // 台账查询命令族（M2 设计 §2.2 命令面接线——查询命令全角色面；写命令住 family-tools depthOnly 分支）

package/tools/linter.mjs

@@ -4,6 +4,7 @@ import { DESC, resolveInCwd } from "./shared.mjs"
 import { runCommand } from "./exec-run.mjs"
 import { existsSync } from "node:fs"
 import { join } from "node:path"
+import { nodeChildEnv } from "./node-child.mjs"
 
 export const lintTool = {
   name: "lint",
@@ -47,7 +48,7 @@ async function nodeCheckResult(abs, signal) {
     return `lint (check): only JS/TS-family files supported for fast syntax check; use full=true for other languages. Path: ${abs}`
   }
   try {
-    await runCommand(process.execPath, ["--check", abs], { timeout: 10000, signal })
+    await runCommand(process.execPath, ["--check", abs], { timeout: 10000, signal, env: nodeChildEnv() })
     return `Syntax OK: ${abs}`
   } catch (e) {
     const msg = (e.stderr || e.stdout || e.message || "").trim()

package/tools/node-child.mjs

@@ -0,0 +1,21 @@
+/**
+ * tools/node-child.mjs — node 语义子进程启动单源（TOOLS.md §6.18 · D-TO14 · 台账 #602）。
+ *
+ * 缺口：核内 spawn `process.execPath` 的隐含前提 = 「execPath 为 node」。桌面宿主主进程 =
+ * `electron.exe` ⇒ execPath 属 Electron 族二进制——子进程按 Electron 应用启动、不执行代码
+ * （execute 悬挂至超时）。本档 = 那一跳：Electron 宿主补 `ELECTRON_RUN_AS_NODE: "1"`，
+ * 同一二进制以 node 语义启动。
+ *
+ * 判据 = `process.versions.electron`（运行时能力探测——非端名分支）：三端同判据、同式执行；
+ * 已处 node 模式的 Electron 宿主（VS Code 扩展宿主——env 携旗标）为同值幂等。
+ * 消费 = `execute.runNode` spawn 选项 ∕ `lint` 快路径（经 `exec-run` `opts.env` 透传）。
+ */
+
+/**
+ * node 语义子进程 env：Electron 宿主 ⇒ `{ ...base, ELECTRON_RUN_AS_NODE: "1" }` 副本
+ * （不改父进程 env）；否则原样返回 `base`（同引用——与 spawn 缺省继承逐字等价，零行为变）。
+ * 第二参 = 判据注入（机检用——先例 `_setGitTimeoutForTest` 族）。
+ */
+export function nodeChildEnv(base = process.env, isElectron = !!process.versions.electron) {
+  return isElectron ? { ...base, ELECTRON_RUN_AS_NODE: "1" } : base
+}