@thincoder/core 0.9.1

package/tools/ops.mjs

@@ -0,0 +1,293 @@
+/**
+ * ops.mjs — operational tools: file_ops (move/copy/rename), process (list),
+ * get_current_time, wait_for (condition wait). Each exists so the model reaches
+ * for a dedicated tool instead of shelling out to `bash` for the same operation
+ * (parity with thinworker).
+ */
+import { DESC, resolveInCwd, truncate } from "./shared.mjs"
+// 单一写路径点（编辑器编辑径注入缝——CORE-UNIFICATION §2.13.5）：路径操作也经它落盘
+// （默认径 = 既有 cp / rename / EXDEV 回退语义，零行为变）。
+import { writeThroughPath } from "./write-path.mjs"
+import { existsSync } from "node:fs"
+import { execFileSync } from "node:child_process"
+import net from "node:net"
+
+// ─── file_ops ──────────────────────────────────────────────────
+
+export const fileOpsTool = {
+  name: "file_ops",
+  description: DESC("file_ops"),
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["move", "copy", "rename"], description: "move | copy | rename" },
+      source: { type: "string", description: "Source path, relative to cwd or absolute" },
+      dest: { type: "string", description: "Destination path" },
+    },
+    required: ["action", "source", "dest"],
+  },
+  readonly: false,
+  async execute({ action, source, dest }, ctx) {
+    if (typeof source !== "string" || !source) return "Error: source is required"
+    if (typeof dest !== "string" || !dest) return "Error: dest is required"
+    if (!["move", "copy", "rename"].includes(action)) return `Error: action must be move | copy | rename (got "${action}")`
+    const src = resolveInCwd(ctx, source)
+    const dst = resolveInCwd(ctx, dest)
+    if (src === dst) return "Error: source and dest resolve to the same path"
+
+    // move & rename share the rename syscall; cross-device move falls back to copy+rm
+    // （回退语义住写路径点——§2.13.5）。
+    await writeThroughPath(src, null, { op: action, dest: dst })
+    const verb = action === "copy" ? "Copied" : action === "rename" ? "Renamed" : "Moved"
+    return `${verb} ${source} → ${dest}`
+  },
+}
+
+// ─── process ───────────────────────────────────────────────────
+
+export const processTool = {
+  name: "process",
+  description: DESC("process"),
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Optional name substring filter (case-insensitive)" },
+    },
+  },
+  readonly: true,
+  async execute({ name }, ctx) {
+    const filter = typeof name === "string" && name.trim() ? name.trim().toLowerCase() : null
+    let rows
+    try {
+      rows = process.platform === "win32" ? listWindows() : listPosix()
+    } catch (e) {
+      return `process listing failed: ${e?.message ?? String(e)}`
+    }
+    if (filter) rows = rows.filter((r) => r.name.toLowerCase().includes(filter))
+    if (rows.length === 0) return filter ? `No running processes match "${name}"` : "(no processes)"
+    return truncate(rows.map((r) => `${r.name}\tPID ${r.pid}${r.mem ? `\t${r.mem}` : ""}`).join("\n"))
+  },
+}
+
+function listWindows() {
+  // tasklist /FO CSV /NH → lines: "name.exe","1234","Console","1","12,345 K"
+  const out = execFileSync("tasklist", ["/FO", "CSV", "/NH"], { encoding: "utf8", timeout: 10000 })
+  const rows = []
+  for (const line of out.split("\n")) {
+    const parts = line.split('","')
+    if (parts.length < 2) continue
+    const name = parts[0].replace(/^"/, "").trim()
+    const pid = parts[1].replace(/"/, "").trim()
+    const mem = parts[4] ? parts[4].replace(/"/, "").trim() : ""
+    if (!name || !pid) continue
+    rows.push({ name, pid, mem })
+  }
+  return rows
+}
+
+function listPosix() {
+  const out = execFileSync("ps", ["-eo", "pid=,comm="], { encoding: "utf8", timeout: 10000 })
+  const rows = []
+  for (const line of out.split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+(.+)$/)
+    if (m) rows.push({ name: m[2], pid: m[1], mem: "" })
+  }
+  return rows
+}
+
+// ─── get_current_time ──────────────────────────────────────────
+
+export const getCurrentTimeTool = {
+  name: "get_current_time",
+  description: DESC("get_current_time"),
+  parameters: { type: "object", properties: {} },
+  readonly: true,
+  async execute() {
+    const now = new Date()
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone ?? "unknown"
+    const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+    return `Date: ${now.toISOString()} (UTC)\nTimezone: ${tz}\nWeekday: ${days[now.getDay()]}\nLocal: ${now.toLocaleString()}`
+  },
+}
+
+// ─── wait_for ───────────────────────────────────────────────────
+
+/** wait_for bounds (TOOLS.md §16): a BUILT-IN ceiling replaces the unbounded
+ *  sleep-then-wait — timeout_ms defaults to 30s (config.json agent.waitForTimeoutMs
+ *  overrides), capped at WAIT_FOR_MAX_TIMEOUT_MS (600s — the execute-tool timeout
+ *  convention, Math.min(t, 600_000)); interval_ms defaults to 1s with a 100ms
+ *  floor so polling never busy-spins. */
+export const WAIT_FOR_DEFAULT_TIMEOUT_MS = 30_000
+export const WAIT_FOR_MAX_TIMEOUT_MS = 600_000
+export const WAIT_FOR_DEFAULT_INTERVAL_MS = 1_000
+export const WAIT_FOR_MIN_INTERVAL_MS = 100
+
+// Condition-source seam (§16 评审 #4): production uses the real evaluator
+// (evaluateWaitForCondition); tests inject a deterministic fake source via
+// setWaitForConditionSource (default null — production path unchanged).
+let injectedConditionSource = null
+export function setWaitForConditionSource(source) {
+  injectedConditionSource = typeof source === "function" ? source : null
+}
+
+/** Parse a wait_for condition into { kind, arg }. Unknown conditions are an
+ *  EXPLICIT error enumerating the supported forms (评审 #2 — never a silent
+ *  wait on a misspelled condition). */
+export function parseWaitForCondition(condition) {
+  const c = String(condition ?? "").trim()
+  let m
+  if (c === "advisor settled") return { kind: "advisor", arg: null }
+  if (c === "consult done") return { kind: "consult", arg: null }
+  if ((m = c.match(/^subagent id:\s*(\d+) done$/))) return { kind: "subagent", arg: String(Number(m[1])) }
+  if ((m = c.match(/^file exists:\s*(.+)$/))) return { kind: "file", arg: m[1].trim() }
+  if ((m = c.match(/^port open:\s*(\d+)$/))) return { kind: "port", arg: Number(m[1]) }
+  throw new Error(
+    `wait_for: unsupported condition "${c}" — supported: "advisor settled", "subagent id:N done", "consult done", "file exists:path", "port open:N"`,
+  )
+}
+
+/** Async-subagent pool of an agent — ctx.agent 可达性（评审 #1）：dispatch 把
+ *  agent 实例放进工具 ctx（agent/dispatch.mjs toolCtx.agent），池挂在 agent 上
+ *  （深度 0 的 VS Code 侧 agent._asyncSubagents 与 history._asyncSubagents 同
+ *  一 Map——见 agent.mjs；CLI 侧直接是 agent._asyncSubagents）。 */
+function asyncPool(agent) {
+  if (!agent) return new Map()
+  if (agent._asyncSubagents instanceof Map) return agent._asyncSubagents
+  return agent.history?._asyncSubagents instanceof Map ? agent.history._asyncSubagents : new Map()
+}
+
+/** "subagent id:N done" — the async entry for N settled (status done / done flag)
+ *  or already left the pool (moved to pending results / digested / never spawned —
+ *  nothing is left to wait on). Absent ids are done by vacuity: the model waits on
+ *  ids its own spawn ack just returned, so an id no longer in the pool means done.
+ *  Dual key lookup (2026-09-06 advisor #1): VS Code pool keys are the numeric
+ *  spawn-time id, the CLI keys them as String(id) — accept both. */
+function asyncEntryDone(agent, id) {
+  const pool = asyncPool(agent)
+  const key = String(id)
+  const entry = pool.get(key) ?? pool.get(Number(key)) ?? null
+  if (!entry) return true
+  return entry.done === true || entry.status === "done"
+}
+
+/** 评审池双载体（第 10 批 §18.3 #2）：agent ∪ history——未初始化的载体不进集合。 */
+function advisorPools(agent) {
+  return [agent?._asyncAdvisors, agent?.history?._asyncAdvisors].filter((m) => m instanceof Map)
+}
+
+/** Any entry matching pred that is still running/queued (not done) — in the given pool. */
+function hasRunningIn(pool, pred) {
+  for (const e of pool?.values() ?? []) {
+    if (pred(e) && !(e.done === true || e.status === "done")) return true
+  }
+  return false
+}
+
+/** "advisor settled" 真判据（第 10 批 §18.3 #2 修正）：**评审池真实态**——双载体
+ *  （agent._asyncAdvisors ∪ history._asyncAdvisors）无 running/queued 条目（与 §11.2 的
+ *  未决评审判定 advisorReviewPending 同源语义）。修前读**子代理池**的 role==="advisor"
+ *  条目——评审条目只在 _asyncAdvisors → 恒无命中 → 恒真 0ms 秒过（用户实证）。 */
+function advisorSettled(agent) {
+  return !advisorPools(agent).some((pool) => hasRunningIn(pool, (e) => e.status === "running" || e.status === "queued"))
+}
+
+/** "consult done" — every consult session has drained (pending 0) or was
+ *  explicitly stopped (its children were aborted). No sessions → true (vacuously). */
+function consultAllDone(agent) {
+  const sessions = agent?._consultSessions
+  if (!sessions || sessions.size === 0) return true
+  for (const s of sessions.values()) {
+    if (!s.stopped && (s.pending ?? 0) > 0) return false
+  }
+  return true
+}
+
+/** "port open:N" — 127.0.0.1 probe with a short connect timeout (never hangs a poll). */
+function portOpenProbe(port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: "127.0.0.1", port, timeout: 400 })
+    let settled = false
+    const finish = (v) => {
+      if (settled) return
+      settled = true
+      socket.destroy()
+      resolve(v)
+    }
+    socket.once("connect", () => finish(true))
+    socket.once("error", () => finish(false))
+    socket.once("timeout", () => finish(false))
+  })
+}
+
+/** Real condition evaluator (production path) — returns a boolean; throws on an
+ *  unsupported condition string. Polling is async (await setTimeout) — the event
+ *  loop keeps running so background async work (subagents/consult) can settle
+ *  between polls (评审 #1 — no blocking spin). */
+export async function evaluateWaitForCondition(condition, ctx) {
+  const parsed = parseWaitForCondition(condition)
+  const agent = ctx?.agent
+  switch (parsed.kind) {
+    case "advisor":
+      // 第 10 批修正（§18.3 #2——修前恒真 0ms 秒过）：判据 = 评审池真实态（双载体）——
+      // 不再读子代理池的 role==="advisor" 条目（该池永无此类条目）；语义与 §11.2 未决
+      // 评审判定同源（advisorReviewPending）。
+      return advisorSettled(agent)
+    case "subagent":
+      return asyncEntryDone(agent, parsed.arg)
+    case "consult":
+      return consultAllDone(agent)
+    case "file":
+      return existsSync(resolveInCwd(ctx, parsed.arg))
+    case "port":
+      return await portOpenProbe(parsed.arg)
+    default:
+      return false
+  }
+}
+
+async function evalConditionSource(condition, ctx) {
+  if (injectedConditionSource) return injectedConditionSource(condition, ctx)
+  return evaluateWaitForCondition(condition, ctx)
+}
+
+export const waitForTool = {
+  name: "wait_for",
+  description: DESC("wait_for"),
+  parameters: {
+    type: "object",
+    properties: {
+      condition: { type: "string", description: 'Condition expression — "advisor settled", "subagent id:N done", "consult done", "file exists:path", "port open:N"' },
+      interval_ms: { type: "integer", description: "Poll interval in ms (default 1000, floor 100)" },
+      timeout_ms: { type: "integer", description: "Overall timeout in ms (default 30000, cap 600000; config.json agent.waitForTimeoutMs overrides the default)" },
+    },
+    required: ["condition"],
+  },
+  readonly: true,
+  async execute(args, ctx = {}) {
+    const condition = typeof args?.condition === "string" ? args.condition.trim() : ""
+    if (!condition) return "Error: condition is required"
+    const intervalMs = Math.max(WAIT_FOR_MIN_INTERVAL_MS, Math.floor(args?.interval_ms ?? WAIT_FOR_DEFAULT_INTERVAL_MS))
+    const cfgTimeout = ctx?.agent?.config?.agent?.waitForTimeoutMs
+    const base = Number.isFinite(args?.timeout_ms)
+      ? args.timeout_ms
+      : Number.isFinite(cfgTimeout) && cfgTimeout > 0 ? cfgTimeout : WAIT_FOR_DEFAULT_TIMEOUT_MS
+    const timeoutMs = Math.min(Math.max(1, Math.floor(base)), WAIT_FOR_MAX_TIMEOUT_MS)
+    const started = Date.now()
+    let polls = 0
+    for (;;) {
+      // Cancel/interrupt-safe exit（T-W7）：Ctrl+C / 定向 abort 传播——不吞信号、
+      // 不把用户停变成工具错误（dispatch 对 aborted signal 原样再抛）。
+      if (ctx.signal?.aborted) throw new Error("wait_for: interrupted by abort signal")
+      polls++
+      const ok = await evalConditionSource(condition, ctx)
+      if (ok === true) {
+        return `wait_for: condition satisfied after ${Date.now() - started}ms (${polls} check${polls === 1 ? "" : "s"}): "${condition}"`
+      }
+      const remaining = started + timeoutMs - Date.now()
+      if (remaining <= 0) {
+        return `wait_for: timed out after ${timeoutMs}ms waiting for "${condition}" (${polls} checks — condition never became true)`
+      }
+      await new Promise((r) => setTimeout(r, Math.min(intervalMs, remaining)))
+    }
+  },
+}

package/tools/patch.mjs

@@ -0,0 +1,290 @@
+import {
+  DESC,
+  autoSyntaxCheck,
+  resolveInCwd,
+  normalizeEOL,
+  detectFileEol,
+  majorityEol
+} from "./shared.mjs";
+import { writeThroughPath, TMP_SUFFIX, markDirty } from "./write-path.mjs";
+import { execFileSync } from "node:child_process";
+import { mkdir, readFile, lstat, unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { relative, dirname } from "node:path";
+
+/**
+ * Parse a unified diff: returns [{ path, isNew, hunks: [{ ops: [{type:" "|"-"|"+", text}] }] }]
+ * Consume hunk lines by the line counts in the @@ header — LLMs often strip context blank lines to pure empty lines,
+ * so we use counts rather than first characters to determine hunk boundaries.
+ * APPLY-PATCH.md §3: a bare "@@" header (no coordinates) is accepted — the hunk body runs until the next hunk/file header
+ * ("@@" / "--- " / "+++ " / "diff " / "index "), purely located by its ops.
+ */
+/**
+ * P15.10（2026-09-05 用户裁定——「符合模型直觉」）：文件头判定——
+ * 完整头（`--- x` 后随 `+++ `）任意老路径形态均认（git 规范）；
+ * 容缺头（`+++ b/<path>` 配对行省略——模型单文件补丁自然形态）仅认 a//b/ 前缀——
+ * newPath 推导 = oldPath；`/dev/null` 容缺仍拒（新文件名从 --- 侧不可推导——parsePatch 内特报）；
+ * 其他 `--- x` = 普通删行内容（行首标记 - + 内容 `-- x`）——不是文件头——hunk 体不得误断。
+ */
+function isFileHeader(line, nextLine) {
+  if (!line.startsWith("--- ")) return false
+  if (nextLine?.startsWith("+++ ")) return true
+  return /^[ab]\//.test(line.slice(4).trim())
+}
+
+function parsePatch(patch) {
+  // Patch text often comes from CRLF terminals/model output; trailing \r mixed into hunk content breaks context matching, strip uniformly
+  const lines = patch.replace(/\r(?=\n|$)/g, "").split("\n")
+  const files = []
+  let cur = null
+  let i = 0
+  const stripPrefix = (p) => p.replace(/^[ab]\//, "")
+  while (i < lines.length) {
+    const line = lines[i]
+    if (line.startsWith("--- ")) {
+      const oldPath = line.slice(4).trim()
+      const plus = lines[i + 1]
+      if (plus?.startsWith("+++ ")) {
+        const newPath = plus.slice(4).trim()
+        if (newPath === "/dev/null") throw new Error("Deleting files via patch is not supported — use the delete tool")
+        cur = { path: stripPrefix(newPath), isNew: oldPath === "/dev/null", hunks: [] }
+        files.push(cur)
+        i += 2
+        continue
+      }
+      // P15.10：容缺头——`--- a/<path>`（或 b/ 前缀）后直接跟 hunk = 对同路径的修改。
+      if (/^[ab]\//.test(oldPath)) {
+        cur = { path: stripPrefix(oldPath), isNew: false, hunks: [] }
+        files.push(cur)
+        i += 1
+        continue
+      }
+      if (oldPath === "/dev/null") {
+        throw new Error(`"--- /dev/null" needs a "+++ b/<path>" line naming the new file — the --- side does not carry the file name`)
+      }
+      throw new Error(`Malformed patch: expected "+++" line after "${line}"`)
+    }
+    if (line.startsWith("@@")) {
+      if (!cur) throw new Error("Malformed patch: hunk header before any file header")
+      const m = line.match(/^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/)
+      if (!m) {
+        // APPLY-PATCH.md §3：坐标裸 "@@" 头——hunk 完全靠操作行定位。
+        // 无行数可用：操作行以 " " / "-" / "+" 开头（空行宽容为上下文行），
+        // 直到下一个 hunk 头 / 文件头 "@@"/"--- "/"+++ "/"diff "/"index " 为止。
+        if (!/^@@(?: @@)?\s*$/.test(line)) {
+          throw new Error(`Malformed patch: bad hunk header "${line}" (need @@ -old,count +new,count @@ or bare @@)`)
+        }
+        const hunk = { ops: [] }
+        i++
+        while (i < lines.length) {
+          const hl = lines[i]
+          if (hl.startsWith("@") || isFileHeader(hl, lines[i + 1]) || hl.startsWith("+++ ") || hl.startsWith("diff ") || hl.startsWith("index ")) break
+          if (hl.startsWith("\\")) { i++; continue } // ""
+          // 宽容空行=上下文行——但 patch 文本末尾（或 hunk 之间/文件头之前）的 "" 是
+          // 分隔产物而非内容：仅当后继仍是操作行时才当作上下文消费。
+          // 复评 #1（2026-09-04）：文件头 "--- "/"+++ " 以 -/+ 开头会被 op 前缀判定误收——
+          // 文件头前的分隔空行不得吞成幽灵上下文行（会把 - 锚序列尾部拼上 ""——跨文件
+          // 零上下文 hunk 因此误报 not-found）。
+          const next = lines[i + 1]
+          if (hl === "" && (next == null || !/^[ +\-\\]/.test(next) || isFileHeader(next, lines[i + 2]) || next.startsWith("+++ "))) break
+          const tag = hl === "" ? " " : hl[0]
+          if (tag !== " " && tag !== "-" && tag !== "+") break // metadata / file section end
+          hunk.ops.push({ type: tag, text: hl === "" ? "" : hl.slice(1) })
+          i++
+        }
+        if (hunk.ops.length === 0) throw new Error(`Malformed patch: empty coordinate-less hunk "${line.trim()}"`)
+        const ctxCount = hunk.ops.filter((o) => o.type === " ").length
+        // §3 (APPLY-PATCH.md——2026-09-04)：context<2 且含 ≥1 个 - 行 → 接受——定位锚 = hunk 内
+        // 匹配行序列（空格上下文行 + - 行——按出现序）连续——唯一匹配即应用（applyHunks 既有锚匹配域——
+        // 多匹配 / not-found 语义不变）。0 上下文与 1 上下文同待遇（评审 #4a）。
+        // 纯 +（无 - 锚）且 context<2 仍拒——插入位置不可判——报错引导加锚（NF15.8c）。
+        const removedCount = hunk.ops.filter((o) => o.type === "-").length
+        if (ctxCount < 2 && removedCount === 0) {
+          throw new Error(
+            `Coordinate-less hunk ${cur.hunks.length + 1} in ${cur.path} has ${ctxCount} context line(s) — add more context lines`,
+          )
+        }
+        cur.hunks.push(hunk)
+        continue
+      }
+      let oldNeed = m[1] == null ? 1 : Number(m[1])
+      let newNeed = m[2] == null ? 1 : Number(m[2])
+      const hunk = { ops: [] }
+      i++
+      while (oldNeed > 0 || newNeed > 0) {
+        if (i >= lines.length) throw new Error("Malformed patch: hunk truncated (line counts in @@ header not satisfied)")
+        const hl = lines[i]
+        if (hl.startsWith("\\")) { i++; continue } // ""
+        const tag = hl === "" ? " " : hl[0] // pure blank line: treat leniently as context line
+        const text = hl === "" ? "" : hl.slice(1)
+        if (tag === " ") { hunk.ops.push({ type: " ", text }); oldNeed--; newNeed-- }
+        else if (tag === "-") { hunk.ops.push({ type: "-", text }); oldNeed-- }
+        else if (tag === "+") { hunk.ops.push({ type: "+", text }); newNeed-- }
+        else throw new Error(`Malformed patch: unexpected line "${hl.slice(0, 60)}" inside hunk`)
+        i++
+      }
+      cur.hunks.push(hunk)
+      continue
+    }
+    i++ // skip diff --git / index / blank lines and other metadata
+  }
+  // P15.10：容缺/完整空段头（头后无任何 hunk）过滤——不虚报 touchedPaths、不触发无谓 read+write
+  const withHunks = files.filter((f) => f.hunks.length > 0)
+  if (withHunks.length === 0) throw new Error("No file changes found in patch (need --- / +++ headers)")
+  return withHunks
+}
+
+/** Apply hunks sequentially onto an in-memory line array; any failure throws (caller guarantees nothing is written to disk). Ignores trailing \r when comparing; context lines retain original bytes */
+function applyHunks(fileLines, hunks, eol, path) {
+  const cr = eol === "\r\n" ? "\r" : ""
+  for (let h = 0; h < hunks.length; h++) {
+    const oldSeq = hunks[h].ops.filter((o) => o.type !== "+").map((o) => o.text)
+    if (oldSeq.length === 0) throw new Error(`Hunk ${h + 1} in ${path} has no context/removed lines to locate`)
+    const matches = []
+    for (let pos = 0; pos + oldSeq.length <= fileLines.length; pos++) {
+      let ok = true
+      for (let j = 0; j < oldSeq.length; j++) {
+        if (fileLines[pos + j].replace(/\r$/, "") !== oldSeq[j]) { ok = false; break }
+      }
+      if (ok) matches.push(pos)
+    }
+    if (matches.length === 0) {
+      const preview = oldSeq.slice(0, 3).join(" ⏎ ")
+      throw new Error(`Hunk ${h + 1} in ${path} does not apply — context not found: "${preview}${oldSeq.length > 3 ? "…" : ""}". Read the file first and regenerate the patch from actual content.`)
+    }
+    if (matches.length > 1) {
+      const preview = oldSeq.slice(0, 3).join(" ⏎ ")
+      throw new Error(`Hunk ${h + 1} in ${path} matches ${matches.length} locations — add more context lines to make it unique. Anchor: "${preview}${oldSeq.length > 3 ? "…" : ""}"`)
+    }
+    const pos = matches[0]
+    const out = []
+    let src = pos
+    for (const op of hunks[h].ops) {
+      if (op.type === " ") out.push(fileLines[src++]) // preserve original context line (trailing whitespace as-is)
+      else if (op.type === "-") src++
+      else out.push(op.text + cr)
+    }
+    fileLines.splice(pos, oldSeq.length, ...out)
+  }
+}
+
+export const applyPatchTool = {
+  name: "apply_patch",
+  description: DESC("apply_patch"),
+  parameters: {
+    type: "object",
+    properties: {
+      patch: { type: "string", description: "Unified diff. May span multiple files (multiple --- / +++ header pairs — including creating MULTIPLE new files via --- /dev/null); --- / +++ headers per file, @@ -old,count +new,count @@ hunks (a bare @@ header is also accepted — coordinate-less hunks are located by their anchor lines: context lines plus the removed (-) lines, matched as a contiguous sequence — a unique match applies; a zero/one-context hunk is accepted only when it removes (-) at least one line and that anchor sequence is unique, while anchor-free pure-+ (insert) hunks need at least 2 context lines). The +++ b/<path> pair may be omitted for existing files — a lone --- a/<path> (or --- b/<path>) header followed directly by hunks applies to that path (new files still need --- /dev/null + +++ b/<path>)." },
+    },
+    required: ["patch"],
+  },
+  readonly: false,
+  /** For the agent layer to track touched files (multi-path, replaces single path parameter) */
+  touchedPaths(args) {
+    try { return parsePatch(args.patch ?? "").map((f) => f.path) } catch { return [] }
+  },
+  async execute(args, ctx) {
+    const files = parsePatch(args.patch ?? "")
+    // Read all into memory first for trial: if any hunk fails, abort entirely — never write a partial patch (atomicity)
+    const planned = []
+    for (const f of files) {
+      const abs = resolveInCwd(ctx, f.path)
+      if (f.isNew) {
+        if (existsSync(abs)) throw new Error(`Cannot create ${f.path}: file already exists`)
+        // New file: follow the directory's majority EOL style (default LF).
+        const eol = majorityEol(dirname(abs))
+        const content = f.hunks.flatMap((h) => h.ops.filter((o) => o.type === "+").map((o) => o.text)).join(eol) + eol
+        planned.push({ abs, path: f.path, content, isNew: true })
+      } else {
+        const original = await readFile(abs, "utf8").catch(() => { throw new Error(`File not found: ${f.path}`) })
+        const eol = detectFileEol(original)
+        // Apply hunks in the normalized LF domain, then write back joined with the
+        // file's ORIGINAL EOL style — join("\n") here used to rewrite CRLF files as LF.
+        const lines = normalizeEOL(original).split("\n")
+        applyHunks(lines, f.hunks, "\n", f.path)
+        planned.push({ abs, path: f.path, content: lines.join(eol), isNew: false })
+      }
+    }
+    // Multi-file write: write all to .tmp first, rename only after all succeed — failure cleans up written .tmp without affecting committed files
+    // 两段式经单一写路径点（§2.13.5）：阶段一全部 staging（写入各自 `<abs>.thincoder-tmp`）
+    // ⇒ 阶段二逐档 commit（rename 到目标）。**默认径 = 改前语义逐字同**（任一失败无档落盘：
+    // 阶段一失败时目标档全未动、阶段二失败时已提交档保持——同改前）。
+    // 编辑器径（注入面）例外：内容在阶段一即提交（宿主侧同款——applyEdit + save）⇒ 阶段
+    // 二跳过该档；已提交档不回滚（与宿主侧现行为一致，非本档引入的语义）。
+    const staged = []
+    const committedByEditor = new Set()
+    try {
+      for (const p of planned) {
+        await mkdir(dirname(p.abs), { recursive: true })
+        const r = await writeThroughPath(p.abs, p.content, { op: "write", stage: true })
+        if (r.via === "editor") committedByEditor.add(p.abs)
+        else staged.push(p.abs)
+      }
+      for (const p of planned) {
+        if (committedByEditor.has(p.abs)) continue
+        await writeThroughPath(p.abs, null, { op: "commit" })
+      }
+    } catch (renameError) {
+      // rename phase failed: clean up leftover .tmp files
+      for (const abs of staged) {
+        try { await unlink(abs + TMP_SUFFIX) } catch {}
+      }
+      throw renameError
+    }
+    const summary = planned.map((p) => `  ${p.isNew ? "created " : "modified"} ${p.path}`).join("\n")
+    // Mark every touched file dirty — insert_after must not run on stale line numbers.
+    // 整批记账（dirty）= apply_patch 的批级语义（两段式全成功后一次落账——与改前逐字同）。
+    for (const p of planned) markDirty(p.abs)
+    const syntaxChecks = await Promise.all(planned.map(async (p) => {
+      const r = await autoSyntaxCheck(p.abs)
+      return r ? `${p.path}:${r.replace("Syntax: ", "")}` : ""
+    }))
+    const syntaxResults = syntaxChecks.filter(Boolean).join("\n")
+    return `Applied patch to ${planned.length} file(s):\n${summary}${syntaxResults ? "\n\nSyntax checks:\n" + syntaxResults : ""}`
+  },
+}
+
+
+
+// ---------------------------------------------------------------- bash
+
+export const deleteTool = {
+  name: "delete",
+  description: DESC("delete"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path (relative to cwd or absolute)" },
+      force: { type: "boolean", description: "Allow deleting git-tracked files (default false)" },
+    },
+    required: ["path"],
+  },
+  readonly: false,
+  touchedPaths(args) { return args.path ? [args.path] : [] },
+  async execute(args, ctx) {
+    const abs = resolveInCwd(ctx, args.path)
+    let s
+    try {
+      s = await lstat(abs)
+    } catch {
+      throw new Error(`File not found: ${args.path}`)
+    }
+    if (s.isDirectory()) throw new Error(`"${args.path}" is a directory — use bash to remove directories`)
+    // git-tracked files: refuse direct deletion (safety net); untracked: allow
+    // Use resolved relative path (normalized forward slashes) to prevent backslash/unusual paths from bypassing ls-files matching
+    const rel = relative(ctx.cwd, abs).replace(/\\/g, "/")
+    let tracked = false
+    try {
+      execFileSync("git", ["ls-files", "--error-unmatch", "--", rel], { cwd: ctx.cwd, stdio: "ignore" })
+      tracked = true
+    } catch {
+      // untracked / non-git repo
+    }
+    if (tracked && !args.force) throw new Error(`"${args.path}" is git-tracked. Set force=true to delete anyway.`)
+    // 单一写路径点（§2.13.5）：删除也经注入面（打开且脏 ⇒ 拒删）；默认径 = unlink + 记账。
+    await writeThroughPath(abs, null, { op: "delete" })
+    return `Deleted ${args.path}`
+  },
+}
+
+// ---------------------------------------------------------------- git_diff

package/tools/question.mjs

@@ -0,0 +1,26 @@
+import { DESC } from "./shared.mjs";
+
+export const questionTool = {
+  name: "question",
+  description: DESC("question"),
+  parameters: {
+    type: "object",
+    properties: {
+      question: { type: "string", description: "The question to ask the user" },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "Single-choice options for the user to pick from (optional)",
+      },
+    },
+    required: ["question"],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    if (!ctx.onQuestion) throw new Error("question tool not supported in this context (no UI to ask)")
+    // §22 D-Q3 机械限制（2026-09-06 用户裁定：100 字符 / 4 条——超限拒绝回模型，不弹卡、不调 onQuestion）
+    if (args.question.length > 100) return "(error: question too long (>100 chars) — ask ONE short question; background belongs in your normal reply text)"
+    if (Array.isArray(args.options) && args.options.length > 4) return "(error: too many options (>4) — offer at most 4 plain-string options)"
+    return ctx.onQuestion(args.question, args.options ?? [])
+  },
+}