thincoder 0.12.59 → 0.12.60

package/src/tools/execute.mjs

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

package/src/tools/file.mjs

@@ -217,21 +217,26 @@ export const editTool = {
     type: "object",
     properties: {
       path: { type: "string", description: "File path — single form: required; with the edits array: optional top-level default for entries without their own path" },
-      old_string: { type: "string", description: "Exact text to replace" },
-      new_string: { type: "string", description: "Replacement text" },
+      old_string: { type: "string", description: "Exact text to replace (tolerant matching: exact → whitespace-only variant → fuzzy match at ≥90% line equality after whitespace/indent/quote normalization). Mutually exclusive with line/startLine/endLine" },
+      new_string: { type: "string", description: "Replacement text — content-based edits require it (empty is an explicit error); with line-based targeting (line/startLine/endLine) give it to replace the line/range, or OMIT it to delete (an explicit empty string is an error — omission is the delete signal)" },
+      line: { type: "integer", description: "1-based line number — replace that single line with new_string, or OMIT new_string to DELETE the line; no old_string needed (mutually exclusive with old_string and startLine/endLine)" },
+      startLine: { type: "integer", description: "1-based first line of the range to replace with new_string (inclusive — requires endLine; mutually exclusive with old_string); OMIT new_string to DELETE the range" },
+      endLine: { type: "integer", description: "1-based last line of the range to replace with new_string (inclusive — requires startLine; mutually exclusive with old_string); OMIT new_string to DELETE the range" },
       replace_all: { type: "boolean", description: "Replace all occurrences (default false)" },
       edits: {
         type: "array",
-        description: "Batch form — multiple edits in ONE call, atomic (any failure writes nothing; same-file entries apply serially, each based on the previous result). Use it for multiple changes to the same file AND for independent changes across multiple files — prefer one batched call over N single edits. A top-level path is allowed — it defaults entries without their own path (entry paths win). Mutually exclusive with top-level old_string/new_string — provide each change's old/new inside its edits entry.",
+        description: "Batch form — multiple edits in ONE call, atomic (any failure writes nothing; same-file entries apply serially, each based on the previous result). Use it for multiple changes to the same file AND for independent changes across multiple files — prefer one batched call over N single edits. A top-level path is allowed — it defaults entries without their own path (entry paths win). Mutually exclusive with top-level old_string/new_string/line/startLine/endLine — provide each change's targeting (old_string, or line / startLine+endLine) inside its edits entry; new_string replaces when given, and line-targeted entries may omit it to DELETE the line/range.",
         items: {
           type: "object",
           properties: {
             path: { type: "string" },
             old_string: { type: "string" },
             new_string: { type: "string" },
+            line: { type: "integer" },
+            startLine: { type: "integer" },
+            endLine: { type: "integer" },
             replace_all: { type: "boolean" },
           },
-          required: ["old_string", "new_string"],
         },
       },
     },
@@ -253,8 +258,8 @@ export const editTool = {
     // （应用逻辑在 edit-batch.mjs——2026-09-01 拆出，500 行硬限，先例 git-ext.mjs）
     if (args.edits) return applyEditBatch(args, ctx)
 
-    // 单文件（现状路径）——执行体整段迁出至 edit-diff.mjs（TOOLS.md §15 D15.1——
-    // 行级 LCS 判定：零重叠→插入 / 一般 diff→LCS / 空 new→显式报错）
+    // 单文件（现状路径）——执行体整段迁出至 edit-diff.mjs（EDIT.md §6——
+    // 行级 LCS 判定：零重叠→替换即删 / 一般 diff→LCS / 空 new→显式报错）
     return runSingleEdit(args, ctx)
   },
 }

package/src/tools/git.mjs

@@ -42,7 +42,7 @@ export const gitTool = {
       action: { type: "string", enum: ["diff", "status", "log", "show", "checkpoint", "add", "rm", "commit", "push", "tag", "branch", "checkout", "restore", "stash", "fetch", "pull", "reset", "revert", "merge", "cherry-pick", "ls-remote", "clone", "init", "rebase", "remote", "clean", "switch", "apply", "worktree", "archive", "blame", "mv"], description: "diff / status / log / show / checkpoint / add / rm / commit / push / tag / branch / checkout / restore / stash / fetch / pull / reset / revert / merge / cherry-pick / ls-remote / clone / init / rebase / remote / clean / switch / apply / worktree / archive / blame / mv — clean/rebase 操作前自动快照，checkpointAction=rewind 恢复" },
       // diff/log params
       staged: { type: "boolean", description: "(diff) Show staged changes instead of working tree" },
-      path: { type: "string", description: "(diff/log/add/commit/checkout/restore/checkpoint:cat/versions/rewind/rm/apply/archive/blame/mv/worktree) File or directory to scope to / stage / restore（checkout/restore 操作前自动快照，checkpointAction=rewind 恢复）" },
+      path: { type: "string", description: "(diff/log/add/commit/checkout/restore/checkpoint:cat/versions/rewind/rm/apply/archive/blame/mv/worktree) File or directory to scope to / stage / restore（checkout/restore 操作前自动快照，checkpointAction=rewind 恢复）— add/rm/commit: space-separated for multiple（git add a b c——2026-09-05 发版痛点；含空格的文件名会被按多路径拆分——请用 bash git 处理）" },
       ref: { type: "string", description: "(diff/show/checkout/reset/revert/merge/cherry-pick/tag:create/branch:create/rebase/worktree:add/archive) Commit/branch/ref; (push/pull/fetch) the branch or tag (space-separated for multiple)" },
       count: { type: "number", description: "(log) Number of commits (default 10)" },
       oneline: { type: "boolean", description: "(log) One-line-per-commit format" },
@@ -143,13 +143,16 @@ export const gitTool = {
       }
       case "rm": {
         if (!args.path) return "Error: rm requires path (the file/directory to untrack, relative to repo root)"
-        const r = runGitStrict(ctx.cwd, ["rm", "--cached", "-r", "--", args.path])
-        return r.ok ? truncate(r.out || `Untracked ${args.path} (kept on disk)`) : truncate(`git rm failed: ${r.err || r.out}`)
+        const paths = args.path.split(/\s+/).filter(Boolean)
+        const r = runGitStrict(ctx.cwd, ["rm", "--cached", "-r", "--", ...paths])
+        return r.ok ? truncate(r.out || `Untracked ${paths.join(" ")} (kept on disk)`) : truncate(`git rm failed: ${r.err || r.out}`)
       }
       case "commit": {
         if (!args.message) return "Error: commit requires message"
         // Granular staging when path given (only stage these); otherwise stage all (add -A).
-        const add = runGitStrict(ctx.cwd, args.path ? ["add", "--", args.path] : ["add", "-A"])
+        // 多路径：空格分隔（ref 先例——2026-09-05 发版痛点）
+        const staged = args.path ? args.path.split(/\s+/).filter(Boolean) : null
+        const add = runGitStrict(ctx.cwd, staged?.length ? ["add", "--", ...staged] : ["add", "-A"])
         if (!add.ok) return truncate(`git add failed: ${add.err || add.out || "(no output)"}`)
         const commit = runGitStrict(ctx.cwd, ["commit", "-m", args.message])
         const parts = []
@@ -189,9 +192,11 @@ export const gitTool = {
       }
       case "add": {
         // Granular staging: stage `path` when given, else all changes (add -A).
-        const cmdArgs = args.path ? ["add", "--", args.path] : ["add", "-A"]
+        // 多路径：空格分隔（ref 先例 L175——2026-09-05 发版痛点——git add 单路径被迫 N 次调用）
+        const paths = args.path ? args.path.split(/\s+/).filter(Boolean) : null
+        const cmdArgs = paths?.length ? ["add", "--", ...paths] : ["add", "-A"]
         const r = runGitStrict(ctx.cwd, cmdArgs)
-        return r.ok ? truncate(r.out || `Staged ${args.path || "all changes"}`) : truncate(`git add failed: ${r.err || r.out}`)
+        return r.ok ? truncate(r.out || `Staged ${paths?.join(" ") || "all changes"}`) : truncate(`git add failed: ${r.err || r.out}`)
       }
       case "tag": {
         const sub = args.tagAction
@@ -361,6 +366,9 @@ export const questionTool = {
   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 ?? [])
   },
 }

package/src/tools/glob-dialect.mjs

@@ -0,0 +1,130 @@
+/**
+ * glob-dialect.mjs — glob 方言（TOOLS.md §17 — 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
+ * previously escaped to a literal that silently matched nothing). Unsupported
+ * extglob dialects (`?(x)`/`@(a|b)`/`+(x)`/`*(x)`/`!(x)`) and malformed braces
+ * (empty `{}`, unclosed `{`, nested `{a,{b,c}}`) are EXPLICIT errors — never a
+ * silent no-match. Exclude prefixes (`!pattern`) are the CALLER's job: the
+ * glob/grep tools whitespace-split the pattern expression (splitGlobPatterns —
+ * never inside a brace group) and pass the parts to compileGlobMatchers, which
+ * 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
+ * importers (system.mjs / ls filter / tests) keep their import paths.
+ */
+
+const BRACE_OPEN = "\u0003", BRACE_SEP = "\u0004", BRACE_CLOSE = "\u0005"
+const EXT_GLOB_RE = /[@?+*!]\(/
+
+export const GLOB_EXTGLOB_ERROR =
+  "glob syntax error: unsupported extglob syntax — ?(x)/@(a|b)/+(x)/*(x)/!(x) are not supported; use {a,b} brace expansion or multiple space-separated patterns instead"
+export const GLOB_EMPTY_BRACE_ERROR =
+  'glob syntax error: empty brace group "{}" — put at least one alternative between the braces (e.g. {js,txt})'
+export const GLOB_UNCLOSED_BRACE_ERROR =
+  'glob syntax error: unclosed brace group — add a matching "}" (e.g. {js,txt})'
+export const GLOB_NESTED_BRACE_ERROR =
+  "glob syntax error: nested brace groups are not supported (e.g. {a,{b,c}}) — use a flat alternative list (e.g. {a,b,c})"
+
+function assertNoExtglob(pattern) {
+  if (EXT_GLOB_RE.test(pattern)) throw new Error(GLOB_EXTGLOB_ERROR)
+}
+
+/** Replace every {a,b,c} group with placeholder alternation markers. Runs BEFORE
+ *  the sentinel/escape flow so the inserted alternation survives literal escaping. */
+function expandBraces(pattern) {
+  for (;;) {
+    const open = pattern.indexOf("{")
+    if (open === -1) return pattern
+    let close = -1
+    for (let j = open + 1; j < pattern.length; j++) {
+      if (pattern[j] === "{") throw new Error(GLOB_NESTED_BRACE_ERROR)
+      if (pattern[j] === "}") { close = j; break }
+    }
+    if (close === -1) throw new Error(GLOB_UNCLOSED_BRACE_ERROR)
+    const inner = pattern.slice(open + 1, close)
+    if (inner === "") throw new Error(GLOB_EMPTY_BRACE_ERROR)
+    const alts = inner.split(",").map((a) => a.trim())
+    pattern = pattern.slice(0, open) + BRACE_OPEN + alts.join(BRACE_SEP) + BRACE_CLOSE + pattern.slice(close + 1)
+  }
+}
+
+/** Convert a single glob pattern to a RegExp (anchored full match). Supports the
+ *  recursive "star-star" forms, single-star, "?", "[..]" character classes and
+ *  {a,b} brace expansion. Malformed braces and unsupported extglob syntax throw
+ *  explicit errors (no silent mismatch). */
+export function globToRegex(pattern) {
+  pattern = String(pattern)
+  assertNoExtglob(pattern)
+  pattern = expandBraces(pattern)
+  // Sentinel chars: \u0001/\u0002 never appear in real glob patterns (they
+  // come from model output or the filesystem) — safe as **/ and ** placeholders.
+  const DS = "\u0001", DP = "\u0002"
+  const escaped = pattern
+    .replace(/\*\*\//g, DS).replace(/\*\*/g, DP)
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")
+    .replace(new RegExp(DS, "g"), "(?:.+/)?")
+    .replace(new RegExp(DP, "g"), ".*")
+    .replace(new RegExp(BRACE_OPEN, "g"), "(?:")
+    .replace(new RegExp(BRACE_SEP, "g"), "|")
+    .replace(new RegExp(BRACE_CLOSE, "g"), ")")
+  return new RegExp(`^${escaped}$`)
+}
+
+/** 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
+ *  "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. */
+export function splitGlobPatterns(expr) {
+  const s = String(expr ?? "").trim()
+  if (!s) return []
+  const parts = []
+  let depth = 0
+  let cur = ""
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    if (ch === "{") depth++
+    else if (ch === "}") depth = Math.max(0, depth - 1)
+    if (/\s/.test(ch) && depth === 0) {
+      let j = i
+      while (j < s.length && /\s/.test(s[j])) j++
+      if (s[j] === "!") {
+        if (cur) { parts.push(cur); cur = "" }
+        i = j - 1 // next loop iteration continues at the "!"
+        continue
+      }
+      // literal space inside a pattern (or trailing) — keep it in the current part
+      cur += ch
+      continue
+    }
+    cur += ch
+  }
+  if (cur) parts.push(cur)
+  return parts
+}
+
+/** Compile whitespace-split pattern parts (see splitGlobPatterns) into a matcher:
+ *  non-"!" parts are includes, leading-"!" parts are excludes — a rel path matches
+ *  when it matches ≥1 include (or there are no includes) and no exclude. Every
+ *  part runs the full brace/error dialect through globToRegex (excludes too). */
+export function compileGlobMatchers(parts) {
+  const includes = []
+  const excludes = []
+  for (const p of parts) {
+    const part = String(p)
+    if (part.startsWith("!")) excludes.push(part.slice(1))
+    else if (part !== "") includes.push(part)
+  }
+  const include = includes.map((p) => globToRegex(p))
+  const exclude = excludes.map((p) => globToRegex(p))
+  const test = (relPath) =>
+    (include.length === 0 || include.some((re) => re.test(relPath))) &&
+    !exclude.some((re) => re.test(relPath))
+  return { include, exclude, test }
+}

package/src/tools/glob.md

@@ -1,11 +1,11 @@
-Find files by glob pattern. Returns matching paths. Supports `**` for recursive matching (e.g. `src/**/*.mjs` for all .mjs in src/, `**/*.test.mjs` for all test files).
+Find files by glob pattern. Returns matching paths (relative to the search path), sorted, capped at 1000. Use this to discover file structure; use grep to search file contents.
 
 Parameters:
-- pattern (required): Glob pattern — supports **, *, ?, and character classes
+- pattern (required): Glob pattern — supports `**` (recursive), `**/`, `*` (within a segment), `?` (single char), `[..]` character classes, and `{a,b}` brace expansion (e.g. `**/*.{js,txt}` matches .js and .txt files at any depth). Space-separated multiple patterns with a leading `!` are EXCLUSIONS — `**/*.js !test/**` matches .js files except those under test/. Pattern matching is relative to `path`. A pattern containing a literal space is fine on its own (spaces only separate patterns when a `!` exclusion is present). An expression splits ONLY before `!`-exclusion tokens — to match several extensions in one include, use a `{a,b}` group (e.g. `**/*.{js,md}`); adjacent space-separated includes are not a supported form.
 - path: Directory to search in (default cwd)
 
 Notes:
+- Invalid glob syntax is an EXPLICIT error — never a silent no-match. Unsupported extglob dialects (`?(x)`/`@(a|b)`/`+(x)`) and malformed braces (empty `{}`, unclosed `{`, nested `{a,{b,c}}`) return `glob error: ...` — use `{a,b}` or a space-separated `!exclude` pattern instead.
 - Skips node_modules, .git, dist, build, .turbo, coverage
 - Results capped at 1000 matches
-- Use this to discover file structure; use grep to search file contents
 - Prefer patterns with a literal anchor (extension or subdirectory) over bare wildcards

package/src/tools/grep.md

@@ -5,7 +5,7 @@ Search file contents with a regex. Returns matching lines as path:line: content.
 Parameters:
 - pattern (required): JavaScript regular expression, or a literal string when literal=true
 - path: Directory or file to search (default cwd)
-- glob: Only search files matching this glob (e.g. '*.mjs')
+- glob: Only search files matching this glob — supports `**`, `*`, `?`, `[..]`, `{a,b}` braces and space-separated exclusion (`"**/*.js !test/**"` = .js files outside test/); e.g. '*.mjs'
 - ignoreCase: Case-insensitive match (default false)
 - literal: Literal string match — no regex interpretation (default false; use for strings with `. \` etc.)
 - before: Lines of context to show before each match (grep -B). Default 0

package/src/tools/index.mjs

@@ -2,7 +2,6 @@
 export { toOpenAISchema } from "./shared.mjs";
 
 import { readTool, writeTool, editTool, insertAfterTool, readImageTool, hashlineEditTool } from "./file.mjs";
-import { readPdfTool } from "./pdf.mjs";
 import { applyPatchTool, deleteTool } from "./patch.mjs";
 import { bashTool, globTool, grepTool, lsTool } from "./system.mjs";
 import { websearchTool, fetchTool } from "./web.mjs";
@@ -11,25 +10,25 @@ import { checklistTool } from "./checklist.mjs";
 import { lintTool } from "./linter.mjs";
 import { lspTool } from "./lsp.mjs";
 import { executeTool } from "./execute.mjs";
-import { fileOpsTool, processTool, getCurrentTimeTool } from "./ops.mjs";
+import { fileOpsTool, processTool, getCurrentTimeTool, waitForTool } from "./ops.mjs";
 import { treeTool } from "./tree.mjs";
 
 export const builtinTools = [
   readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
-  readImageTool, readPdfTool, bashTool, globTool, grepTool,
+  readImageTool, bashTool, globTool, grepTool,
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, executeTool,
-  fileOpsTool, processTool, getCurrentTimeTool,
+  fileOpsTool, processTool, getCurrentTimeTool, waitForTool,
   treeTool,
 ];
 
 export {
   readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
-  readImageTool, readPdfTool, bashTool, globTool, grepTool,
+  readImageTool, bashTool, globTool, grepTool,
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, executeTool,
-  fileOpsTool, processTool, getCurrentTimeTool,
+  fileOpsTool, processTool, getCurrentTimeTool, waitForTool,
   treeTool,
 };

package/src/tools/ops.mjs

@@ -1,11 +1,14 @@
 /**
  * ops.mjs — operational tools: file_ops (move/copy/rename), process (list),
- * get_current_time. Each exists so the model reaches for a dedicated tool
- * instead of shelling out to `bash` for the same operation (parity with thinworker).
+ * 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"
 import { cp, rename, rm } from "node:fs/promises"
+import { existsSync } from "node:fs"
 import { execFileSync } from "node:child_process"
+import net from "node:net"
 
 // ─── file_ops ──────────────────────────────────────────────────
 
@@ -111,4 +114,173 @@ export const getCurrentTimeTool = {
     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"
+}
+
+/** Any async entry matching pred that is still running/queued (not done). */
+function hasRunningAsync(agent, pred) {
+  for (const e of asyncPool(agent).values()) {
+    if (pred(e) && !(e.done === true || e.status === "done")) return true
+  }
+  return false
+}
+
+/** "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":
+      // Advisor reviews run as blocking tool calls (runAdvisorReview) or as
+      // advisor-role async children — "settled" = no advisor-role entry still
+      // running/queued in the async pool.
+      return !hasRunningAsync(agent, (e) => e.role === "advisor")
+    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/src/tools/patch.mjs

@@ -16,7 +16,7 @@ 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.
- * D15.6: a bare "@@" header (no coordinates) is accepted — the hunk body runs until the next hunk/file header
+ * 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.
  */
 /**
@@ -68,7 +68,7 @@ function parsePatch(patch) {
       if (!cur) throw new Error("Malformed patch: hunk header before any file header")
       const m = line.match(/^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/)
       if (!m) {
-        // D15.6 (TOOLS.md §15)：坐标裸 "@@" 头——hunk 完全靠操作行定位。
+        // APPLY-PATCH.md §3：坐标裸 "@@" 头——hunk 完全靠操作行定位。
         // 无行数可用：操作行以 " " / "-" / "+" 开头（空行宽容为上下文行），
         // 直到下一个 hunk 头 / 文件头 "@@"/"--- "/"+++ "/"diff "/"index " 为止。
         if (!/^@@(?: @@)?\s*$/.test(line)) {
@@ -94,7 +94,7 @@ function parsePatch(patch) {
         }
         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
-        // §15.3 (TOOLS.md D15.10.1——2026-09-04)：context<2 且含 ≥1 个 - 行 → 接受——定位锚 = hunk 内
+        // §3 (APPLY-PATCH.md——2026-09-04)：context<2 且含 ≥1 个 - 行 → 接受——定位锚 = hunk 内
         // 匹配行序列（空格上下文行 + - 行——按出现序）连续——唯一匹配即应用（applyHunks 既有锚匹配域——
         // 多匹配 / not-found 语义不变）。0 上下文与 1 上下文同待遇（评审 #4a）。
         // 纯 +（无 - 锚）且 context<2 仍拒——插入位置不可判——报错引导加锚（NF15.8c）。

package/src/tools/question.md

@@ -9,4 +9,7 @@ Notes:
 - The answer is injected as the next user message
 - Returns the user's answer — the chosen option or free text — as the next message; the loop resumes when it arrives.
 - Use sparingly — prefer making reasonable decisions when possible
+- Ask ONE question per call — never bundle multiple sub-questions into one question string; ask the next one after the answer arrives.
+- Keep the question text short — one or two sentences. Background, context, and analysis belong in your normal reply text, NOT in the question.
+- Routine confirmations (confirm gates) belong in your plain reply text — the user answers in their next message. Use this tool ONLY when you need the user's decision or input to proceed.
 - After receiving an answer about a design convention, tool preference, or recurring pattern: save it with the memory tool (action: put). This prevents asking the same question in future sessions — the user shouldn't have to repeat their preferences.

package/src/tools/read.md

@@ -7,7 +7,6 @@ Read a text file. Returns numbered lines. Use offset/limit to page large files.
 - Know the symbol but not the location? → `code_search` or `lsp definition`
 - Know the file but not the lines? → `grep` to find line numbers, then read that range with offset/limit
 - Reading an image? → `read_image` instead
-- Reading a PDF? → `read_pdf` instead (read would decode the binary as UTF-8 garbage)
 
 Parameters:
 - path (required): File path, relative to cwd or absolute (alias: filePath)

package/src/tools/shared.mjs

@@ -363,19 +363,20 @@ export function detectDanger(command) {
 }
 
 
-/** Convert glob pattern to regex */
-export function globToRegex(pattern) {
-  // Sentinel chars: \u0001/\u0002 never appear in real glob patterns (they
-  // come from model output or the filesystem) — safe as **/ and ** placeholders.
-  const DS = "\u0001", DP = "\u0002"
-  const escaped = pattern
-    .replace(/\*\*\//g, DS).replace(/\*\*/g, DP)
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-    .replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")
-    .replace(new RegExp(DS, "g"), "(?:.+/)?")
-    .replace(new RegExp(DP, "g"), ".*")
-  return new RegExp(`^${escaped}$`)
-}
+/** Glob dialect (TOOLS.md §17) lives in glob-dialect.mjs — single authority for
+ *  brace expansion / exclusion / explicit syntax errors (extracted 2026-09-06 —
+ *  advisor #5: shared.mjs exceeded 500 lines). Re-exported so existing importers
+ *  (system.mjs tools, ls filter, tests) keep their import paths unchanged. */
+export {
+  globToRegex,
+  splitGlobPatterns,
+  compileGlobMatchers,
+  GLOB_EXTGLOB_ERROR,
+  GLOB_EMPTY_BRACE_ERROR,
+  GLOB_UNCLOSED_BRACE_ERROR,
+  GLOB_NESTED_BRACE_ERROR,
+} from "./glob-dialect.mjs"
+
 
 /** Decode a numeric HTML entity to its code point — invalid/out-of-range
  *  values (e.g. �) must not throw RangeError; keep the source