thincoder 0.12.58 → 0.12.59

package/CHANGELOG.md

@@ -1,4 +1,45 @@
-## [0.12.58] — 2026-09-02
+## [0.12.59] — 2026-09-05
+
+> 0.12.58 → 0.12.59（§1.5 连续号——发布时定号）
+
+### Added
+
+- **settings 工具（SETTINGS-TOOL.md——2026-09-05 用户三项裁定）**：agent 配置调整通道——list/get/set（全量 config.json 任意键点分路径）；set = 写盘 + 热应用（运行中即生效）；敏感键（apiKey/token/secret/password 段）回显永遮罩；已知键类型校验（DEFAULTS 自动派生）；list/get 只读动作（planMode 放行）；set 审批门。测试 T-S1.1-11（CLI 11 + VS Code 6）。
+- **subagent-async 模块拆分（§20.9 Module Split Policy——2026-09-05 F-N1.5 两段式首批）**：CLI subagent-async.mjs 1020 → 405 行（subagent-scheduler.mjs 231——§20 调度组 + 文件域组 / subagent-actions.mjs 416——status/panel/escalate 动作执行器组）——纯迁移零行为变化（测试零改动 + 断言计数前后对拍一致）。
+- **P-SL2 停滞机械检测（AGENT-LOOP §21.1 扩展注 P-SL2——2026-09-05）**：混合边环形等待停滞 → check/status 守卫明确报错列阻塞链（cancel 破环引导）——防御性（自然流不可达——人工注入可构造）。测试 T-SL2 ①-⑤（scheduler 22 → 27 用例）。
+
+### Changed
+
+- **轨迹存档隐私默认翻转 + 启动清理（AGENT-LOOP.md §18.6 D-TR6/D-TR10——2026-09-05 用户"不希望用户那边也采集"）**：`traces.enabled` 默认 **on → off**（发布后新用户零采集——本地分析可显式开）；新增 `traces.retentionHours`（默认 24h——保留期可配置）；CLI 启动时删除超过保留期的轨迹文件（`cleanupTraces`——D-TR10——fire-and-forget 不阻塞启动——空日期目录一并清除）；`/config` 菜单新增 traces.enabled（开关）与 traces.retentionHours（保留期）两项。测试 T-TR15。
+- **edit 空白差异自动落点（TOOLS.md §14.2——P15.11——2026-09-05 用户裁定）**：edit not-found 且文件存在**唯一内容相同仅空白不同**窗口 → 自动落点应用 + 结果附 note（`whitespace-only match`——双端同句）；歧义（多窗口）/实质差异仍 not-found（不猜）。测试 P15.11a-d 双端。
+- **编辑纪律三条固化进 discipline.md（AGENT-LOOP.md §21 扩展注 2——2026-09-05 记忆清空实验）**：① 新鲜读来源（never reconstruct from memory）；② hash 来源（never invent one）；③ 重试上限（never retry the identical input a third time）。测试 T-N1.8 双端。
+- **普通模式两段式（AGENT-LOOP.md §21 F-N1.5——2026-09-05 用户"把 coder 用起来……解决自查问题"）**：规模实现批次默认委托 coder 子代理（async——设计书为 task book）——执行/检查心智分离（隔离上下文破自查盲区）；小改动/探索留内联；复核走 F-N1.4（偏差退回 coder ≤2 轮）。测试 T-N1.9 双端。
+- **委托操作标准（AGENT-LOOP.md §21 扩展注 4——F-N1.6——2026-09-05 用户"spawn coder 干活现在并没有明确的标准是吗"）**：规模判据可操作化（≥2 文件/单文件 >30 行逻辑/模块边界/双端镜像 → 委托；≤30 行/文档同步/探索 → 内联）；任务书七字段标准（目标/已知事实/设计+禁止/约束/硬验收/报告格式/调度元数据——缺字段=委托缺陷）；委托模式判据（async 默认/sync 仅依赖链/并行仅文件域互斥）；通用验收基线。测试 T-N1.10 双端。
+- **/config 交互修复（2026-09-05）**：改配置项保存后回主菜单（不再退到输入框）——每轮刷新 ac/tc 配置引用（reloadConfig 换对象后显示新值）；view 浏览态同回菜单。
+- **版本号连续性规则（RELEASE.md §1.5——2026-09-05 用户裁定"不要跳号"）**：号在发布时定、开发期不预占（CHANGELOG 挂 [Unreleased]）；待发号 = registry 最高 + 1；缺口不补。
+
+### Fixed
+
+- **§18.14 域拆分 import 残留两处（2026-09-05 发版 test:full 门禁抓出——slow 门控测试快层永不执行致漏网）**：session.test.mjs 缺 existsSync + advisor-review.test.mjs 缺 prepareAdvisorMessages。
+- **压缩 fixture 阈值重校准 14000 → 15500（T3b——2026-09-05）**：提示词批（F-N1.4/1.5/1.6 main.md 委托句 + discipline 三条纪律 ≈550 token）抬升 systemPrompt 估算越刀锋——沿革惯例 +1500 档。
+
+### Changed (追加——2026-09-04 后半批)
+
+- **advisor 角色定位锚（AGENT-LOOP.md §12.1）**：四模板（advisor-design/round1/round2/round3）开头插入"Your role"段（独立评审者/证据纪律/边界/中立——Known behavior 记忆断言禁止）——修复"评审对象模糊/定级拉锯/行为验证捷径/出界犹豫"人格缺口。
+- **子代理人格锚（AGENT-LOOP.md §7.3）**：coder.md（IMPLEMENTER——证据纪律/设计冲突停报/边界）+ consult-base.md（证据纪律/I-don't-know 合法/无权威）——审计发现"职责越重人格越薄"倒挂。
+- **审计范围引导（AGENT-LOOP.md §18.13）**：eng-coder 内部审计 explore 改 quick 档 + 任务书加机械预算句（只读 touched 文件+点名节——10 轮上限——超时报 PROBLEM）——治理"审计 explore 跑非常久"。
+- **工具输出预览保头保尾（TOOL-OUTPUT-LIMITS-TUNING.md §5）**：超 64K 落盘预览 = 头 16K + 中间省略注 + 尾（tail 优先——测试统计/错误在尾不再被截）——与压缩/蒸馏同口径。
+- **bash 重定向护栏删除（TOOLS.md §13）**：`hasFileRedirection` 整条删除（用户裁定"拦截只误伤正常操作"——零文本拦截与 §5 安全剧场决策彻底对齐）——`2>&1` 误报、测试收窄被拦整链消除。
+
+### Added
+
+- **完整轨迹存档（AGENT-LOOP.md §18.6）**：`chat()` 出口统一收集——每次模型调用落 JSONL 到 `~/.thincoder/traces/YYYY-MM-DD/`（本地时区分日/seq=当日 max+1/脱敏复用 log.mjs 黑名单+SECRET_FORM/错误路径也落盘/`traces.enabled` 开关默认 on）——覆盖主/子代理/advisor/compress/distill/consult/auto-think 全部调用；续写标记 `isContinuation`。
+
+### Changed
+
+- **子代理零 git（§18.5）**：explore/plan spawn 不再注入 `<untrusted_git_context>`（全角色零 git——审计证据=设计文档+磁盘状态+_touchedFiles 并集；审计任务书附零 git 范围权威声明；explore.md 删除 git 注入声明/命令承诺，描述改为“No git context injected”）；顶层主 agent git 上下文不变（§3）。
+- **审计任务书零 git 声明**（D-AG3）：`_touchedFiles` 为审计范围——工作区未列改动不作超清单依据。
+
 
 ### Changed
 

package/README.md

@@ -41,7 +41,7 @@ Three layers, all "query if present, skip if absent", unified hybrid retrieval:
 - **Hybrid retrieval**: FTS5 (BM25, per-character CJK indexing, bigrams matchable) + embedding vectors (brute-force cosine) + RRF(k=60) fusion ranking
 - **Embeddings**: OpenAI-compatible `/v1/embeddings`, defaults to SiliconFlow `BAAI/bge-m3` (free tier, good CJK support); Ollama works as an offline option. Vectors generated lazily — not computed on write, backfilled and persisted on first search
 - **Entry format**: Markdown + frontmatter (type/title/tags/author/created), readable and reviewable directly on GitHub; one file per entry, naturally avoiding merge conflicts; real conflicts produce honest errors, never auto-merged
-- **Dual-track accumulation**: conventions written manually (`memory_put`), experience extracted from sessions via `/extract` — **the LLM proposes candidates, a human confirms each y/n** before anything is stored; never fully automatic
+- **Dual-track accumulation**: conventions written manually (the `memory` tool, action put), experience extracted from sessions via `/extract` — **the LLM proposes candidates, a human confirms each y/n** before anything is stored; never fully automatic
 - **Retrieval isolation**: the Project layer is isolated by project path — project A's memories never leak into project B
 
 - **Agent Client Protocol** ⭐: `thincoder acp` exposes the agent over [ACP](https://agentclientprotocol.com/) v1 on stdio — one terminal login drives sessions from **Zed**, **JetBrains** AI chat, or **Paseo**:

package/bin/thincoder.mjs

@@ -16,6 +16,7 @@ import { readFileSync } from "node:fs"
 import { join } from "node:path"
 import { runAgent } from "../src/agent.mjs"
 import { loadConfig, configPath } from "../src/config.mjs"
+import { cleanupTraces } from "../src/traces/trace-store.mjs"
 import { createMemory, syncDir } from "../src/memory.mjs"
 import { assembleAgent, teamConfig, gitAuthor, validateProvider } from "../src/cli/make-agent.mjs"
 import { memoryCommand } from "../src/cli/memory-command.mjs"
@@ -68,6 +69,13 @@ function exitSoon(code) {
   setTimeout(() => process.exit(code), 100)
 }
 
+// D-TR9（2026-09-05）：启动轨迹清理——删除超过 traces.retentionHours（默认 24h）的
+// 轨迹文件（fire-and-forget——不阻塞启动——失败静默——与轨迹写盘同纪律）。
+try {
+  const startupCfg = loadConfig()
+  cleanupTraces({ retentionHours: startupCfg.traces?.retentionHours ?? 24 }).catch(() => {})
+} catch { /* 配置缺失/损坏 → 跳过清理（零风险） */ }
+
 switch (command) {
   case "chat": {
     const auto = args.includes("--auto")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.58",
+  "version": "0.12.59",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/acp/bridge.mjs

@@ -19,8 +19,8 @@
  * End-of-turn is NOT a notification: `session/prompt` resolves with
  * `{ stopReason: "end_turn" }` (kimi session.ts parity).
  */
-import { join } from "node:path"
-import { detectDanger } from "../tools/shared.mjs"
+import { detectDanger, normalizeEOL, joinWithEol } from "../tools/shared.mjs"
+import { computeEditEntry, validateEditEntry, assertEditArgsExclusive } from "../tools/edit-diff.mjs"
 
 /** ACP ToolKind inference (schema v1 enum) — best-effort, clients render by kind. */
 function inferToolKind(name) {
@@ -56,25 +56,128 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {} }
   const update = (sessionUpdate, extra = {}) =>
     notify("session/update", { sessionId, update: { sessionUpdate, ...extra } })
   let toolSeq = 0
-  const toolIds = new Map() // active tool name → current ACP toolCallId (defined before the literal — no expando)
+  // D15.8（TOOLS.md §15.1）：tool id FIFO 队列——并行同名工具按 call 序配对（dispatch B1
+  // 已测：并行结果回调顺序 = call 顺序——T-TS8/T-TS9）。取代旧 Map 按名覆盖（后写覆盖先写
+  // → tool_call_update 与 tool_call id 错配）。条目 { name, id, toolId }——toolId = 模型级
+  // toolCall.id（dispatch 在 onToolCall/onToolResult 均传第 3 参——同一 item 恒相同）。
+  // 拒绝/中断路径：dispatch 在 onToolCall 之前拒绝（被拒工具从未入队——无孤儿可滞）；
+  // 中断/异常路径（onToolResult 永不回调——dispatch.mjs catch 分支——T-F5 契约）留下的
+  // 孤儿靠 onToolCall 的「同名同 toolId 先弹出」隔离（见 onToolCall）——模型级 id 跨轮
+  // 可重复（sse.mjs 每轮从 call_0 重置）——弹出保证精确配对恒命中最新条目。
+  const toolQueue = [] // FIFO of pending { name, id, toolId }
 
   const toolCallId = () => `t${++toolSeq}`
+  /** D15.8：peek 同名最早项 id——权限面板展示用——不消费（result 仍要与自己的条目配对）。 */
+  const peekToolId = (name) => {
+    for (const e of toolQueue) if (e.name === name) return e.id
+    return null
+  }
+  /** D15.8：消费——①模型级 toolId 精确配对（中断孤儿隔离）②无 id/未命中 → 名称 FIFO 回退
+   *  （B1 保序）③均未命中 → null（调用方回退新 id——防御）。 */
+  const takeToolId = (name, toolId) => {
+    if (toolId != null) {
+      const i = toolQueue.findIndex((e) => e.name === name && e.toolId === toolId)
+      if (i >= 0) return toolQueue.splice(i, 1)[0].id
+    }
+    for (let i = 0; i < toolQueue.length; i++) {
+      if (toolQueue[i].name === name) return toolQueue.splice(i, 1)[0].id
+    }
+    return null
+  }
+
   const contentBlock = (text) => ({ type: "content", content: { type: "text", text } })
   const pathOf = (args) => {
     const p = args?.path ?? args?.filePath
     return typeof p === "string" && p ? p : null
   }
 
+  // §15.1（TOOLS.md）D15.7 委派：edit 判定/应用单一权威 = 本地 computeEditEntry
+  // （edit-diff.mjs——校验→判定序→应用：行级 LCS、零重叠→插入、replace_all 字面替换全部）。
+  // 桥只留「读 IDE 缓冲 → computeEditEntry → 写回 IDE 缓冲」——错误文本经抛错原样透传
+  // ——与本地通道逐字一致（NF15.6b / AC15.10：not found / occurrences / 空 old / 空 new）。
+  const EDIT_ABORT_PREFIX = "edit aborted (atomic — no files written): "
+
+  const readBuffer = async (p) => {
+    try {
+      const read = await request("fs/read_text_file", { sessionId, path: p }, { timeoutMs: 30000 })
+      return read?.text ?? read?.content ?? ""
+    } catch (e) {
+      throw new Error(`fs/read_text_file failed: ${e.message}`)
+    }
+  }
+  const writeBuffer = async (p, content) => {
+    try {
+      await request("fs/write_text_file", { sessionId, path: p, content }, { timeoutMs: 30000 })
+    } catch (e) {
+      throw new Error(`fs/write_text_file failed: ${e.message}`)
+    }
+  }
+  /** 单形态：读 IDE 缓冲 → computeEditEntry（rich——无 abortPrefix——同本地 runSingleEdit）
+   *  → 写回。EOL 权威（F1）：判定/应用在 normalizeEOL 后的 LF 域；写回 joinWithEol 按原文
+   *  首换行恢复（LF 域判定——CRLF 域写回——与本地 edit 工具同判同恢复）。 */
+  const editSingle = async (p, args) => {
+    const raw = await readBuffer(p)
+    const content = normalizeEOL(raw)
+    const out = computeEditEntry(content, args, { path: p })
+    await writeBuffer(p, joinWithEol(normalizeEOL(out.updated).split("\n"), raw))
+    return `OK: edited ${p} via IDE (${out.occurrences} occurrence(s))${out.note ? ` — ${out.note}` : ""}`
+  }
+  /** 数组形态（D15.7）：条目校验（path——顶层默认自 args.path ?? args.filePath（pathOf）——
+   *  2026-09-05 用户裁定 CLI parity——/validateEditEntry/互斥（只对顶层 old/new）——同本地 edit-batch 措辞）→
+   *  读全部涉及文件缓冲（同文件去重——一次读）→ 逐条 computeEditEntry（abortPrefix——批量
+   *  原子前缀；同文件条目按数组序串行累积——第二条基于第一条结果）→ 全部通过 → 逐文件写回
+   *  一次（判失败 → 零写；写失败 → 同本地 edit-batch 既有原子语义）。 */
+  const editBatch = async (args) => {
+    const edits = args.edits
+    if (!Array.isArray(edits) || edits.length === 0) {
+      throw new Error("edits must be a non-empty array of {path, old_string, new_string}")
+    }
+    assertEditArgsExclusive(args)
+    const groups = new Map() // path → { path, raw, content, edits }
+    for (const e of edits) {
+      // 2026-09-05 用户裁定（CLI parity——本地 edit-batch 同句）：条目自带 path 优先；
+      // 缺省回退顶层 path（pathOf——path/filePath 别名同单形态）
+      const p = e.path ?? pathOf(args)
+      if (!p) throw new Error("each edit must have a path — give each entry its own path or pass a top-level path")
+      validateEditEntry(e, { label: `edit for ${p}: `, rich: false })
+      let g = groups.get(p)
+      if (!g) {
+        g = { path: p, raw: "", content: "", edits: [] }
+        groups.set(p, g)
+      }
+      g.edits.push(e)
+    }
+    for (const g of groups.values()) {
+      g.raw = await readBuffer(g.path)
+      g.content = normalizeEOL(g.raw)
+    }
+    const outcomes = []
+    for (const g of groups.values()) {
+      for (const e of g.edits) {
+        const out = computeEditEntry(g.content, e, { path: g.path, abortPrefix: EDIT_ABORT_PREFIX })
+        outcomes.push({ g, out })
+        g.content = out.updated // 同文件串行累积
+      }
+    }
+    for (const g of groups.values()) {
+      await writeBuffer(g.path, joinWithEol(normalizeEOL(g.content).split("\n"), g.raw))
+    }
+    return outcomes.map((o) => `OK: edited ${o.g.path} via IDE (${o.out.occurrences} occurrence(s))${o.out.note ? ` — ${o.out.note}` : ""}`).join("\n")
+  }
+
   const callbacks = {
     onToken: (text) => {
       // Strip the subagent `[model]` metadata token (role#id/[model]<name>) — it's a
       // TUI/webview display signal, not conversation content, and must not reach ACP clients.
-      if (/^[\w-]+#\d+\/\[model\]/.test(text)) return
-      // D7 (AGENT-LOOP.md §7.2): strip ⟦ev⟧ event tokens (bare or prefixed variants) —
-      // they carry RS control characters and are a TUI display signal; structured ACP
+      // §19.5 D-M8 (round2 #6): nested prefixes recurse — eng-coder#2/explore#1/[model]…
+      if (/^(?:[\w-]+#\d+\/)*\[model\]/.test(text)) return
+      // D7 (AGENT-LOOP.md §7.2 + §19.5 round2 #6 + D-M7b): strip ⟦ev⟧ event tokens (bare or
+      // any-depth prefixed variants — turn/approval/done/settled/stopped/async — async
+      // = §19.5 D-M7b zero-field spawn marker) — they
+      // carry RS control characters and are a TUI display signal; structured ACP
       // mapping (tool_call_update) is tracked separately in docs/TODO.md.
-  // 有意为之：控制字符协议/转义序列剥离正则（ANSI/⟦ev⟧/SGR/history 双线分隔）
-      if (/^(?:[\w-]+#\d+\/)?⟦ev⟧(?:turn|approval)\x1e/.test(text)) return
+      // 有意为之：控制字符协议/转义序列剥离正则（ANSI/⟦ev⟧/SGR/history 双线分隔）
+      if (/^(?:[\w-]+#\d+\/)*⟦ev⟧(?:turn|approval|done|settled|stopped|async)\x1e/.test(text)) return
       update("agent_message_chunk", { content: { type: "text", text } })
     },
     onReasoning: (text) => update("agent_thought_chunk", { content: { type: "text", text } }),
@@ -82,9 +185,19 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {} }
     onWait: ({ phase, seconds }) => log(`[rate-limit] ${phase} waiting ~${seconds}s`),
     onCompress: () => log("[context] auto-compacted"),
 
-    onToolCall: (name, args) => {
+    onToolCall: (name, args, toolId) => {
       const id = toolCallId()
-      toolIds.set(name, id)
+      // D15.8（advisor 🔴#1 修复）：模型级 id 每轮重置（sse.mjs finalizeToolCalls 内
+      // seq=0——call_0 call_1… 跨轮/跨消息可重复——设计自注「跨 turn 不保证唯一」）。
+      // 因此 push 前若队列已有同名同 toolId 条目，它必是结果永不回调的陈旧孤儿
+      // （dispatch 失败/中断路径不调 onToolResult——T-F5 契约）——先弹出再入队——
+      // 精确配对恒命中最新——"下个同名结果永不配到旧项"（设计目标，无需动 dispatch）。
+      if (toolId != null) {
+        for (let i = toolQueue.length - 1; i >= 0; i--) {
+          if (toolQueue[i].name === name && toolQueue[i].toolId === toolId) toolQueue.splice(i, 1)
+        }
+      }
+      toolQueue.push({ name, id, toolId: toolId ?? null })
       update("tool_call", {
         toolCallId: id,
         title: name,
@@ -95,9 +208,8 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {} }
       })
     },
 
-    onToolResult: (name, result) => {
-      const id = toolIds.get(name) ?? toolCallId()
-      toolIds.delete(name)
+    onToolResult: (name, result, toolId) => {
+      const id = takeToolId(name, toolId) ?? toolCallId()
       update("tool_call_update", {
         toolCallId: id,
         status: "completed",
@@ -117,7 +229,7 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {} }
       if (danger) content.push(contentBlock(`⚠️ Dangerous: ${danger}`))
       content.push(contentBlock(JSON.stringify(args ?? {})))
       const toolCall = {
-        toolCallId: toolIds.get(name) ?? toolCallId(),
+        toolCallId: peekToolId(name) ?? toolCallId(), // D15.8：peek 不消费——result 仍要与自己的条目配对
         title: name,
         content,
       }
@@ -137,7 +249,8 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {} }
     /**
      * fs reverse-RPC router (dispatch.mjs toolRouter, M2):
      * - write            → fs/write_text_file (full content, no read-back)
-     * - edit              → fs/read_text_file → local single-replacement → fs/write_text_file
+     * - edit              → fs/read_text_file → computeEditEntry（本地权威——单/数组形态）→ fs/write_text_file
+     *                      （§15.1 D15.7 委派——双通道同语义；数组=原子批量——逐条目串行累积）
      * - apply_patch       → local (unified-diff application is not routed in M2)
      * - delete, reads     → local
      */
@@ -156,19 +269,12 @@ export function buildAcpCallbacks({ sessionId, notify, request, log = () => {} }
           return { handled: true, result: `Error: fs/write_text_file failed: ${e.message}` }
         }
       }
-      if (base === "edit" && path && typeof args?.old_string === "string" && typeof args?.new_string === "string") {
+      if (base === "edit" && (Array.isArray(args?.edits) || (path && typeof args?.old_string === "string" && typeof args?.new_string === "string"))) {
         try {
-          const read = await request("fs/read_text_file", { sessionId, path }, { timeoutMs: 30000 })
-          const current = read?.text ?? read?.content ?? ""
-          const idx = current.indexOf(args.old_string)
-          if (idx === -1) {
-            return { handled: true, result: `Error: old_string not found in ${path} (read via IDE buffer)` }
-          }
-          const next = current.slice(0, idx) + args.new_string + current.slice(idx + args.old_string.length)
-          await request("fs/write_text_file", { sessionId, path, content: next }, { timeoutMs: 30000 })
-          return { handled: true, result: `OK: edited ${path} via IDE (1 replacement)` }
+          const text = Array.isArray(args?.edits) ? await editBatch(args) : await editSingle(path, args)
+          return { handled: true, result: text }
         } catch (e) {
-          return { handled: true, result: `Error: edit via IDE failed: ${e.message}` }
+          return { handled: true, result: `Error: ${e.message}` }
         }
       }
       return { handled: false } // read-only tools, delete, apply_patch stay local

package/src/advisor/messages.mjs

@@ -105,6 +105,30 @@ function injectProjectGuide(agent, parts, scopeFiles = []) {
   return root // guide injected — requirement-fit criteria apply (truthy root)
 }
 
+/**
+ * Build the mechanical review-object declaration block (AGENT-LOOP.md §18.8
+ * D-OA2 — English anchored form). Injected at the START of the review user
+ * message every round: round 1 (design + code), the legacy convergence path,
+ * and the round-2+ follow-up (see buildAdvisorFollowUp) — the reviewer must
+ * not re-derive "who is being reviewed / why" from the documents (T-OA2:
+ * every round stays anchored). Absent object → "" (legacy calls degrade to
+ * the current behavior — T-OA3).
+ * @param {Object|null} [object] — { type, target, status, reason, exclude }
+ *   (strings; `exclude` may also be a list — joined with ", ")
+ * @returns {string} the declaration block (empty when no object)
+ */
+export function buildObjectDeclarationBlock(object = null) {
+  if (!object || typeof object !== "object" || Array.isArray(object)) return ""
+  const field = (v) => (Array.isArray(v) ? v.join(", ") : v == null ? "" : String(v))
+  return [
+    "## Review-object declaration (mechanical — do not infer)",
+    `Review type: ${field(object.type)} | Target: ${field(object.target)} | Object state: ${field(object.status)} | Trigger: ${field(object.reason)}`,
+    `Excluded (not in this review): ${field(object.exclude)}`,
+    "Follow this declaration — do not infer the review target from the documents.",
+    "",
+  ].join("\n")
+}
+
 /**
  * Build the user message for an advisor review session.
  * @param {Object} agent — the parent agent
@@ -115,15 +139,24 @@ function injectProjectGuide(agent, parts, scopeFiles = []) {
  *   When set, the review input is built from this list ONLY — no git-diff change-set collection.
  *   When absent, the legacy git-diff-based scope is kept (backward compatible).
  * @param {string[]|null} [paths] — code review only: explicit list of file/dir paths to review (deduped; shown under Review Scope)
+ * @param {Object|null} [object] — review-object declaration (§18.8 D-OA1/D-OA3):
+ *   { type, target, status, reason, exclude } — mechanically injected at the
+ *   start of the user message; absent → no injection (legacy calls unchanged).
  * @returns {string} the user message
  */
-export function buildAdvisorUserMessage(agent, prior, reviewType, designToken = null, documents = null, paths = null) {
+export function buildAdvisorUserMessage(agent, prior, reviewType, designToken = null, documents = null, paths = null, object = null) {
   // prior = the full prior review output (string) when a convergence round is
   // being built (decision 2026-08-08 — verbatim injection, model understands it).
   // Deterministic: only _advisorRound > 0 with stored output counts.
   const p = prior ?? ((agent._advisorRound || 0) > 0 ? agent._lastAdvisorOutput : null)
 
   const parts = []
+  // Review-object declaration FIRST — D-OA1: at the start of the user message
+  // (after the system prompt, before the review content). Covers round 1
+  // design/code and the legacy convergence path; the round-2+ normal path
+  // prepends it in buildAdvisorFollowUp (T-OA2 — every round stays anchored).
+  const declaration = buildObjectDeclarationBlock(object)
+  if (declaration) parts.push(declaration)
   const docList = Array.isArray(documents) ? documents.filter((d) => typeof d === "string" && d.trim()) : []
   const pathList = Array.isArray(paths) ? [...new Set(paths.filter((p) => typeof p === "string" && p.trim()))] : []
 

package/src/advisor/run.mjs

@@ -120,6 +120,9 @@ function renderTimeline(timeline, tail = "") {
 }
 // Test seam (mirrors _advisorToolsFor).
 export { renderTimeline as _renderTimeline }
+// Test seam (T-TS8/9): the tool loop itself — toolsOverride injects a mock tool
+// set with controllable timing/errors (the real set comes from advisorToolsFor).
+export { runAdvisorToolLoop as _runAdvisorToolLoop }
 
 /**
  * Run the advisor's tool loop: chat → execute tools → repeat.
@@ -129,7 +132,7 @@ export { renderTimeline as _renderTimeline }
  * the panel keeps moving while the advisor explores — otherwise the panel sits
  * frozen through every tool-call phase and the review appears to have stalled.
  */
-async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, cwd) {
+async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, cwd, toolsOverride = null) {
   // Kind-tagged wrappers: the TUI panel colors reasoning / answer / tool progress differently.
   // Every chunk is ALSO recorded into an ordered timeline — the persisted record
   // must show the review process (thinking ↔ tool progress ↔ final text) at its
@@ -145,7 +148,9 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
   const onThink = emit("think")
   const onText = emit("text")
   const onTool = emit("tool")
-  const { schemas: toolSchemas, byName: toolByName } = advisorToolsFor(agent)
+  // toolsOverride = test seam (T-TS8/9): the real advisor tool set, or a mock
+  // set with controllable timing/errors.
+  const { schemas: toolSchemas, byName: toolByName } = toolsOverride ?? advisorToolsFor(agent)
   let turns = 0
   const startTime = Date.now()
   
@@ -198,6 +203,18 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
       signal: signal ?? null,
       onToken: onText,
       onReasoning: onThink,
+      // LOGGING（vscode advisor/run.mjs parity——按 stage 可 grep）
+      // §18.6 D-TR4：轨迹元数据增补——kind=advisor（评审独立于子代理——T-TR2）；role
+      // 透出调用方角色（eng-coder 内嵌评审时为 "eng-coder"）；session/cwd 供轨迹对回；
+      // traces 开关沿 agent.config（D-TR6）。
+      logCtx: {
+        stage: "advisor",
+        role: agent?._role ?? null,
+        kind: "advisor",
+        session: agent?._sessionStart ?? null,
+        cwd,
+        traces: agent?.config?.traces?.enabled !== false,
+      },
     })
 
     // No tool calls — this is the final review text. The final answer was
@@ -226,8 +243,19 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
         : {}),
     })
 
-    // Execute each tool call
-    for (const tc of response.toolCalls) {
+    // B1 (AGENT-LOOP.md §18.7 D-TS7): the SAME LLM reply's multiple read-only
+    // tool calls run in PARALLEL (Promise.all) — results are backfilled in
+    // toolCalls order (Promise.all preserves the input order → tool_call_id
+    // never mismatches); each tool's timeout/error is captured independently
+    // (the existing TOOL_TIMEOUT stays — one failing tool does not block the
+    // others); progress lines are emitted in toolCalls order. The read-only
+    // tool set has no side effects — no sequencing/serialization needed.
+    // Scope note (round1 review #10): B1 is ONLY in-loop tool parallelism — it
+    // does NOT solve the TODO "platform execution: advisor parallel calls are
+    // actually serial" mystery (docs/TODO.md — LOGGING evidence item), which
+    // concerns multiple advisor CALLS observed as serial, not one reply's
+    // tool calls.
+    const parsed = response.toolCalls.map((tc) => {
       const tool = toolByName.get(tc.name)
       let args = {}
       let parseError = null
@@ -236,63 +264,69 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
       } catch (e) {
         parseError = `Error: invalid JSON in tool arguments: ${e.message}\nRaw arguments: ${(tc.arguments || "").slice(0, 200)}`
       }
-      
-      // If parse failed, return error to model immediately
-      if (parseError) {
-        messages.push({ role: "tool", tool_call_id: tc.id, content: parseError })
-        continue
-      }
-      
-      const argsLine = describeToolArgs(tc.name, args)
-      onTool(`\n→ ${tc.name}${argsLine ? " " + argsLine : ""}\n`)
-      let result
-      if (!tool) {
-        result = `Error: unknown tool "${tc.name}". Available: ${[...toolByName.keys()].join(", ")}`
-      } else {
-        // Execute with timeout (clear the timer when the tool wins the race —
-        // otherwise up to MAX_ADVISOR_TURNS dangling timers accumulate)
+      return { tc, tool, args, parseError }
+    })
+    // Progress lines first, in toolCalls order (emitted before the parallel
+    // run — display order is independent of completion order).
+    for (const p of parsed) {
+      if (p.parseError) continue // parse-error tools get no progress line (legacy behavior)
+      const argsLine = describeToolArgs(p.tc.name, p.args)
+      onTool(`\n→ ${p.tc.name}${argsLine ? " " + argsLine : ""}\n`)
+    }
+    // Every tool runs CONCURRENTLY; each result/error lands in its own slot —
+    // Promise.all preserves input order, so index i always matches parsed[i].
+    const executed = await Promise.all(parsed.map(async (p) => {
+      // Parse failure → error to model immediately (no execution)
+      if (p.parseError) return p.parseError
+      if (!p.tool) return `Error: unknown tool "${p.tc.name}". Available: ${[...toolByName.keys()].join(", ")}`
+      // Execute with timeout (clear the timer when the tool wins the race —
+      // otherwise up to MAX_ADVISOR_TURNS dangling timers accumulate)
+      try {
+        let timeoutId
+        const timeoutPromise = new Promise((_, reject) => {
+          timeoutId = setTimeout(() => reject(new Error(`tool timeout after ${TOOL_TIMEOUT_MS}ms`)), TOOL_TIMEOUT_MS)
+        })
+        let toolPromise
         try {
-          let timeoutId
-          const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = setTimeout(() => reject(new Error(`tool timeout after ${TOOL_TIMEOUT_MS}ms`)), TOOL_TIMEOUT_MS)
-          })
-          let toolPromise
-          try {
-            toolPromise = tool.execute(args, { cwd, agent, onOutput, signal })
-            result = await Promise.race([toolPromise, timeoutPromise])
-          } finally {
-            clearTimeout(timeoutId)
-            // Timeout won → toolPromise is still pending; a later rejection
-            // would surface as an unhandled rejection. The race already
-            // consumed the result/error in the normal path, so this no-op
-            // catch only fires for the abandoned-tool case.
-            toolPromise?.catch(() => {})
-          }
-        } catch (e) {
-          const errorType = e.message.includes("timeout") ? "timeout"
-            : e.message.includes("ENOENT") ? "file_not_found"
-            : e.message.includes("permission") ? "permission_denied"
-            : "execution_error"
-          result = `Error (${errorType}): ${e.message}`
+          toolPromise = p.tool.execute(p.args, { cwd, agent, onOutput, signal })
+          return await Promise.race([toolPromise, timeoutPromise])
+        } finally {
+          clearTimeout(timeoutId)
+          // Timeout won → toolPromise is still pending; a later rejection
+          // would surface as an unhandled rejection. The race already
+          // consumed the result/error in the normal path, so this no-op
+          // catch only fires for the abandoned-tool case.
+          toolPromise?.catch(() => {})
         }
+      } catch (e) {
+        const errorType = e.message.includes("timeout") ? "timeout"
+          : e.message.includes("ENOENT") ? "file_not_found"
+          : e.message.includes("permission") ? "permission_denied"
+          : "execution_error"
+        return `Error (${errorType}): ${e.message}`
       }
+    }))
+
+    // Backfill in toolCalls order (executed[i] ↔ parsed[i]); per-result
+    // non-string serialization + line-aware truncation stay per-tool.
+    for (let i = 0; i < parsed.length; i++) {
+      let result = executed[i]
       if (typeof result !== "string") result = JSON.stringify(result)
-      
-      // Line-aware truncation: preserve line integrity
+
       if (result.length > MAX_RESULT_CHARS) {
         const lines = result.split("\n")
         let truncated = ""
         let charCount = 0
         let keptLines = 0
-        
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i]
+
+        for (let j = 0; j < lines.length; j++) {
+          const line = lines[j]
           if (charCount + line.length + 1 > MAX_RESULT_CHARS) break
           truncated += line + "\n"
           charCount += line.length + 1
           keptLines++
         }
-        
+
         const remainingLines = lines.length - keptLines
         result = (
           truncated +
@@ -300,8 +334,8 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
           `To see more content, use: read(path, offset=${keptLines + 1}, limit=200)`
         )
       }
-      
-      messages.push({ role: "tool", tool_call_id: tc.id, content: result })
+
+      messages.push({ role: "tool", tool_call_id: parsed[i].tc.id, content: result })
     }
   }
 }
@@ -359,8 +393,12 @@ function extractUnfixedIssues(priorText) {
  * Run an advisor review. reviewType: "code" (default) or "design". Returns review text or null when skipped.
  * @param {string|null} [designToken] — injected into the design-review prompt; the advisor echoes it only on approval.
  * @param {string[]|null} [documents] — design review only: explicit list of doc paths to review; passed through to the message builder.
+ * @param {string[]|null} [paths] — code review only: explicit list of file/dir paths to review.
+ * @param {Object|null} [object] — review-object declaration (§18.8 D-OA1/D-OA3):
+ *   { type, target, status, reason, exclude }; mechanically injected at the
+ *   start of every review round's user message. Absent → legacy behavior (no injection).
  */
-export async function runAdvisorReview(agent, reviewType, callbacks, designToken = null, documents = null, paths = null) {
+export async function runAdvisorReview(agent, reviewType, callbacks, designToken = null, documents = null, paths = null, object = null) {
   const onOutput = callbacks?.onOutput
   const signal = callbacks?.signal
   const startTime = Date.now()
@@ -395,7 +433,7 @@ export async function runAdvisorReview(agent, reviewType, callbacks, designToken
   // Advisor always works in the agent's cwd — scope is defined by paths/documents.
   const advisorCwd = agent.cwd
 
-  const messages = prepareAdvisorMessages(agent, reviewType, designToken, documents, paths)
+  const messages = prepareAdvisorMessages(agent, reviewType, designToken, documents, paths, null, object)
 
   try {
     const result = await runAdvisorToolLoop(provider, messages, onOutput, signal, agent, advisorCwd)