thincoder 0.12.53 → 0.12.58

package/src/agent-tools/eng.mjs

@@ -22,6 +22,7 @@ export const engTool = {
     if (args.action === "exit") {
       ctx.agent.config.agent.engineering = false
       ctx.agent._engDesignToken = null   // stale token from prior design review invalidated
+      ctx.agent._engDesignTokens = new Map() // multi-design slots die with the mode (2026-09-01 fix #2)
       ctx.agent._engDesignReviewed = false // reset gate state
       ctx.agent._advisorRound = 0          // reset convergence budget
       ctx.agent._touchedFiles = []         // clear mutation tracking
@@ -49,6 +50,7 @@ export const engTool = {
       }
       ctx.agent.config.agent.engineering = true
       ctx.agent._engDesignToken = null   // off→on transition requires a fresh design review
+      ctx.agent._engDesignTokens = new Map() // multi-design slots die with the mode (2026-09-01 fix #2)
       ctx.agent._lastEngState = true
       ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
       ctx.agent._pendingReminders.push(ENG_ON_REMINDER)

package/src/agent-tools/subagent-check.mjs

@@ -0,0 +1,107 @@
+/**
+ * subagent-check.mjs — async subagent 结果消费侧（AGENT-LOOP.md §15 D-A2）。
+ *
+ * 与 subagent.mjs 的生成侧（async 分支 + 槽位队列）分离，保持 subagent.mjs
+ * 在 500 行硬限内；本模块只承载 subagent_check 工具 + 其等待机制。
+ *
+ * 语义（D-A2）：
+ * - id 缺省 → 按 ARRIVAL ORDER 返回下一个已完成的子代理（先完成先返回）
+ * - id 给定 → 阻塞到该 id 完成（queued 项先等启动再等完成）
+ * - n（必填）→ 1-based 递增读数，per-run 计数器（runAgent 非 resume 重置、
+ *   turn-end 清空）；乱序/重复 n 拒绝且不消费结果；超 MAX_ASYNC_CHECKS 上限
+ *   报错引导走回合收尾自动等待
+ * - 消费后从 map 删除——已消费 id 再查 = 与未知 id 同款错误（T12）
+ */
+import { MAX_ASYNC_CHECKS } from "./subagent.mjs"
+
+/** Wait for an async entry to settle (or the parent signal to abort), parked on
+ *  the agent's waiter list — the entry settle finally wakes every waiter (same
+ *  pattern as consult_check's session waiters). Returns "aborted" on signal. */
+function wakeOnAsyncSettle(agent, ctx) {
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      const i = (agent._asyncWaiters ?? []).indexOf(w)
+      if (i >= 0) agent._asyncWaiters.splice(i, 1)
+      ctx.signal?.removeEventListener("abort", onAbort)
+    }
+    const w = () => { cleanup(); resolve("settled") }
+    const onAbort = () => { cleanup(); resolve("aborted") }
+    ;(agent._asyncWaiters ??= []).push(w)
+    if (ctx.signal) {
+      if (ctx.signal.aborted) { onAbort(); return }
+      ctx.signal.addEventListener("abort", onAbort, { once: true })
+    }
+  })
+}
+
+/**
+ * subagent_check (AGENT-LOOP.md §15 D-A2) — fetch async subagent results.
+ * - id omitted → the next completed child in ARRIVAL order (first finished first)
+ * - id given → block until THAT child finishes (queued items wait for their start)
+ * - n (required) → 1-based read counter, strictly incrementing per run (loop
+ *   guard); capped at MAX_ASYNC_CHECKS per turn — beyond that, use the turn-end
+ *   auto-wait. Errors never consume results.
+ * Consumed entries are deleted from the map — a re-check of the same id is the
+ * same "unknown async subagent id" error (T12).
+ */
+export const subagentCheckTool = {
+  name: "subagent_check",
+  readonly: true,
+  description:
+    "Fetch the result of an async subagent (subagent with async:true). Spawn async children to keep working in your own turn while they run in the background, then collect their reports here. Multiple async children return in completion (arrival) order — the first finished is returned first, so fast results are handled immediately instead of waiting for the slowest. Blocks until the target finishes.\n" +
+    "When done is true, no more results are coming (all finished and consumed) — anything left arrives automatically at turn end.\n" +
+    "Parameters:\n" +
+    "- id (optional): the subagent id from the async spawn return. Omit to fetch the next completed child (arrival order).\n" +
+    "- n (required): 1-based read counter — pass 1 on the first check, 2 on the next, and so on. Consecutive checks must be distinct tool calls (loop detector); at most 3 checks per turn — use the turn-end auto-wait for the rest.",
+  parameters: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: "Optional subagent id (from the async spawn return). Omit = next completed child (arrival order)." },
+      n: { type: "number", description: "1-based read counter: 1 for the first check of the turn, incrementing with each subsequent check (loop detector — consecutive checks must be distinct tool calls)." },
+    },
+    required: ["n"],
+  },
+  async execute({ id, n }, ctx) {
+    const agent = ctx.agent
+    const map = agent._asyncSubagents ?? new Map()
+    // Strict 1-based incrementing read counter (D-A2, review #1): out-of-order /
+    // repeated n is rejected WITHOUT consuming a result (T14).
+    const lastN = agent._asyncCheckLastN ?? 0
+    if (!Number.isInteger(n) || n !== lastN + 1) {
+      return JSON.stringify({ status: "error", error: "invalid read counter — pass n = lastN+1" })
+    }
+    if (n > MAX_ASYNC_CHECKS) {
+      return JSON.stringify({ status: "error", error: "check limit exceeded — use turn-end auto-wait for the rest" })
+    }
+    agent._asyncCheckLastN = n
+
+    let target = null
+    if (id !== undefined && id !== null && String(id) !== "") {
+      target = map.get(String(id))
+      // Unknown OR already-consumed ids (consumed entries are deleted) — same error (T12).
+      if (!target) return JSON.stringify({ id: String(id), status: "error", error: `unknown async subagent id: ${id}` })
+    }
+
+    // Block until the target settles (specific id / next completed in arrival order).
+    for (;;) {
+      if (target) {
+        if (target.done) break
+        const woke = await wakeOnAsyncSettle(agent, ctx)
+        if (woke === "aborted") return JSON.stringify({ done: true, stopped: true })
+        continue
+      }
+      const completed = [...map.values()].filter((e) => e.done)
+      if (completed.length > 0) {
+        target = completed.sort((a, b) => (a._settleSeq ?? 0) - (b._settleSeq ?? 0))[0]
+        break
+      }
+      if (map.size === 0) return JSON.stringify({ done: true })
+      const woke = await wakeOnAsyncSettle(agent, ctx)
+      if (woke === "aborted") return JSON.stringify({ done: true, stopped: true })
+    }
+
+    map.delete(String(target.id))
+    if (target.error) return JSON.stringify({ id: String(target.id), status: "error", error: target.error })
+    return JSON.stringify({ id: String(target.id), role: target.role, status: "done", report: target.report ?? "" })
+  },
+}

package/src/agent-tools/subagent.mjs

@@ -7,6 +7,11 @@ import {
 import { makeRelay, wrapChildCallbacks, runWithContinue, TURN_CAP_MARK } from "../agent/spawn-child.mjs"
 import { validateDesignToken } from "./advisor.mjs"
 
+// Async subagent limits (AGENT-LOOP.md §15 D-A4): mechanical concurrency cap for
+// background spawns + the per-turn check budget (consult-style loop guard).
+export const ASYNC_SUBAGENT_LIMIT = 4
+export const MAX_ASYNC_CHECKS = 3
+
 /**
  * subagent tool: spawn a child agent to handle an independent subtask (isolated context, only the report is returned).
  * - role: "explore" — read-only tools, search/read/analyze (suitable for codebase exploration)
@@ -52,6 +57,38 @@ export function resolveChildProvider(parent, modelArg) {
   return { ...parent.provider, model: modelArg }
 }
 
+/**
+ * Resolve the design-token slot for an eng-coder spawn (2026-09-01 multi-design, FR3):
+ * - designId given → exact slot lookup (no match = explicit error, never a fuzzy guess)
+ * - designId omitted → exactly ONE slot must exist (single-design compatibility); with
+ *   multiple slots we refuse rather than pick one (T16: never silently aim the wrong design)
+ * Returns { token } on success; throws with a parent-actionable message otherwise.
+ * The HMAC/TTL check itself stays in validateDesignToken (unchanged).
+ */
+export function resolveDesignSlot(parent, designIdArg) {
+  const slots = parent._engDesignTokens
+  const hasSlots = slots instanceof Map && slots.size > 0
+  const legacy = parent._engDesignToken
+  // eng(exit/enter) resets the single mirror to force a fresh review (eng.mjs) —
+  // a non-empty slot map surviving that reset must NOT resurrect stale tokens:
+  // mirror cleared + slots present = re-entered engineering mode → re-review.
+  if (!legacy && hasSlots) {
+    throw new Error("Design tokens were reset (engineering mode was re-entered) — run advisor with type='design' again and spawn with the fresh designId+token pair.")
+  }
+  if (designIdArg) {
+    if (!hasSlots || !slots.has(designIdArg)) {
+      throw new Error(`designId not found — no approved design review holds this id. Run advisor with type='design' again and pass the designId echoed with the token. (session holds ${hasSlots ? slots.size : 0} approved design slot(s))`)
+    }
+    return { token: slots.get(designIdArg) }
+  }
+  if (hasSlots && slots.size > 1) {
+    throw new Error(`Multiple approved designs in this session (${slots.size}) — pass the designId parameter (echoed with each token) to choose which design this eng-coder spawn belongs to.`)
+  }
+  if (hasSlots && slots.size === 1) return { token: [...slots.values()][0] }
+  if (legacy) return { token: legacy } // single-slot mirror fallback (pre-multi-slot sessions)
+  throw new Error("Invalid or missing design token — run advisor with type='design' first and pass the returned token as designToken.")
+}
+
 export const subagentTool = {
   name: "subagent",
   description:
@@ -61,8 +98,9 @@ export const subagentTool = {
     "- explore — read-only search & analysis. Toolset: the read/search family (grep, read, glob, code_search, doc_search, repo_outline, lsp, tree...). Receives git context auto-injected (branch, recent commits, working-tree state) when the project is a git repo. Its report must list what it searched and what it did NOT find. Fast — specify thoroughness in the task: quick / medium / thorough (default medium).\n" +
     "- plan — read-only implementation planning. Same read/search toolset; NEVER edits files. Returns a step-by-step plan for the parent to execute.\n" +
     "- coder — full implementation. The parent's complete read/write/execute toolset plus verify and advisor for self-review. Its final report must include a delivery transparency table with one row per task requirement (Done / Simplified / Not done — no deferred column).\n" +
-    "- eng-coder — engineering-mode coder (available only in engineering mode, replacing coder). Same full toolset as coder plus the design-driven methodology overlay; REQUIRES a valid designToken arg obtained from a passed advisor(type='design') review.\n" +
+    "- eng-coder — engineering-mode coder (available only in engineering mode, replacing coder). Same full toolset as coder plus the design-driven methodology overlay; REQUIRES a valid designToken arg obtained from a passed advisor(type='design') review. The advisor's Approved reply also echoes a designId — pass it as the designId arg: required to pick between designs when several approved reviews are active, optional for a single design. The delivery report echoes the designId back for the audit fix round.\n" +
     "Mode filtering: normal mode exposes explore/plan/coder; engineering mode exposes explore/plan/eng-coder. The schema enum reflects the active mode.\n\n" +
+    "Async spawn (AGENT-LOOP.md §15): pass async:true to spawn WITHOUT waiting — returns {id, role, status:\"running\"} immediately so you can keep working in your own turn (read/check files, run other tools) while the child runs in the background. Collect results with subagent_check — multiple async children return in completion (arrival) order, first finished first, so fast results are handled immediately. Use async when your own turn must keep moving; use the default blocking spawn when you must see the report before continuing. Async spawns are capped at 4 concurrent (further spawns queue with a position), and top-level only.\n\n" +
     "Writing the prompt:\n" +
     "- The sub-agent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\n" +
     "- Put exact paths and commands in the prompt when you know them. The sub-agent should not search for things you already know.\n" +
@@ -76,6 +114,8 @@ export const subagentTool = {
       role: { type: "string", enum: ["explore", "plan", "coder", "eng-coder"], description: "The sub-agent role — see the tool description for the role capability matrix. Exact spelling required." },
       model: { type: "string", description: "Provider/model override for this sub-agent: 'provider:model', a provider name from config, or a model name on the parent's provider. Defaults to the agent.subagentModel config, then the parent's provider. Useful for offloading heavy work to a cheaper model." },
       designToken: { type: "string", description: "Required when role='eng-coder': the token returned by advisor(type='design') after the design review passed. Without a valid token, eng-coder cannot modify files." },
+      designId: { type: "string", description: "Optional when role='eng-coder': the designId echoed with the approved token by advisor(type='design'). Required to pick between designs when several approved reviews are active in the session — each eng-coder carries its own designId+token pair so parallel implementations never overwrite each other. Optional for a single design." },
+      async: { type: "boolean", description: "true = spawn without waiting — returns {id} immediately, fetch results later via subagent_check. Default false (blocking)." },
     },
     required: ["task"],
   },
@@ -107,9 +147,12 @@ export const subagentTool = {
 
     // eng-coder token gate: the design review must have passed and the caller must
     // present the exact token advisor issued — otherwise the child is not authorized to code.
+    // 2026-09-01: multi-design slots — the token is located by designId (exact slot,
+    // single-slot fallthrough); HMAC/TTL validation itself is unchanged.
+    let issuedToken
     if (role === "eng-coder") {
-      const issued = parent._engDesignToken
-      if (!issued || args.designToken !== issued || !validateDesignToken(args.designToken)) {
+      issuedToken = resolveDesignSlot(parent, args.designId).token
+      if (!issuedToken || args.designToken !== issuedToken || !validateDesignToken(args.designToken)) {
         throw new Error("Invalid or missing design token — run advisor with type='design' first and pass the returned token as designToken.")
       }
     }
@@ -164,6 +207,12 @@ export const subagentTool = {
 
     // Token-verified design review → child is authorized to modify files without re-reviewing
     if (role === "eng-coder") child._engDesignReviewed = true
+    // designId+token ride the child bookkeeping: the delivery report carries the designId
+    // so the divergence-audit fix round re-spawns with the SAME slot (2026-09-01 FR3).
+    if (role === "eng-coder" && issuedToken) {
+      child._engDesignId = args.designId ?? null
+      child._engDesignToken = issuedToken
+    }
 
     // explore/plan: inject git context (branch/recent commits/working tree state) — exploration and planning both relate to current repo state (inspired by kimi-code's promptPrefix)
     let input = args.context ? `Context:\n${args.context}\n\nTask:\n${args.task}` : args.task
@@ -176,13 +225,22 @@ export const subagentTool = {
     // pipeline (AGENT-LOOP.md §7.2 D3). Prefix includes a unique id: parallel child agents
     // with the same role stay independent and don't overwrite each other.
     // Format: role#id/  →  onToken("coder#2/writing..."), onToolCall("coder#2/read", args)
-    const relayPrefix = makeRelay(parent, role ?? "sub", ctx.callbacks?.onToken, childProvider.model ?? "")
+    // Async id allocation (AGENT-LOOP.md §15 D-A1): reserve the relay counter at
+    // spawn time — the returned id must be stable while the item sits in the queue.
+    // The [model] token (TUI block creation) is DEFERRED to actual start so queued
+    // children don't paint an empty panel block ("queued 态不显示").
+    let relayPrefix
+    if (args.async === true) {
+      parent._subAgentCounter = (parent._subAgentCounter ?? 0) + 1
+      relayPrefix = `${role}#${parent._subAgentCounter}/`
+    } else {
+      relayPrefix = makeRelay(parent, role ?? "sub", ctx.callbacks?.onToken, childProvider.model ?? "")
+    }
     const childOpts = {
       onPermissionRequest: childPermission,
       ...wrapChildCallbacks(relayPrefix, ctx.callbacks),
     }
     const childRunOpts = buildChildRunOpts(ctx)
-    let report = ""
     // Turn-cap continue loop (TURN-CAP-CONTINUE.md) via runWithContinue (§7.2 D3):
     // hitting the cap asks the user via the SAME y/n panel the main agent uses —
     // unlimited continues, resume:true keeps the child's history + mutation bookkeeping,
@@ -196,49 +254,154 @@ export const subagentTool = {
       parent._permQueue = (parent._permQueue ?? Promise.resolve()).then(ask, ask)
       return parent._permQueue
     }
-    const declined = { partial: null }
-    report = await runWithContinue(
-      (child, input, cbs, opts) => runAgent(child, input, cbs, opts), // opts = childRunOpts + resume (managed by the pipeline)
-      child, input, childOpts, childRunOpts,
-      {
-        askContinue: askSubagentContinue,
-        onDeclined: (e, output) => {
-          if (role === "eng-coder" && child._mutatedThisRun) mergeChildMutations(parent, child)
-          // Early return semantics (unchanged from the inline loop): the declined
-          // partial-work message is returned WITHOUT the MIN_REPORT_CHARS expansion —
-          // re-prompting a capped child for a longer report is wrong.
-          // Review #2 fix: use the pipeline-captured output (the `report` variable is
-          // still "" at this point — runWithContinue hasn't returned yet).
-          declined.partial = `Subagent (${role}) ${TURN_CAP_MARK} (${e.turn} turns) — work may be partial; review recent_changes before deciding next steps.\nPartial output: ${output || ""}`
-        },
-      },
-    )
-    if (declined.partial !== null) return declined.partial
-
-    // Report too short = incomplete handoff: send back for expansion once (inspired by kimi-code's summaryPolicy: min 200 chars, retry 1 time).
-    // The child agent's history is still intact; the continuation instruction is appended as new input so it can see its own earlier work.
-    if (report.length < MIN_REPORT_CHARS) {
-      report = await runAgent(child, REPORT_CONTINUATION, childOpts, childRunOpts)
-    }
 
-    // Engineering mode mechanical code gate: delegated file changes must not
-    // bypass the parent's advisor/verify guards. Merge the child's mutations
-    // into the parent so "advisor mandatory at both gates" is enforced, not just
-    // promised in the engineering prompt.
-    // CRITICAL: Only merge if child actually mutated files (defense-in-depth against
-    // runAgent throwing before any writes occurred).
-    // Review #8 clarification: eng-coder ONLY is intentional — the mechanical
-    // two-gate merge exists for engineering mode; plain `coder` children carry
-    // their own verify/advisor self-review discipline (per tool description), and
-    // normal mode has no parent advisor/verify gate to feed.
-    if (role === "eng-coder" && child._mutatedThisRun) {
-      mergeChildMutations(parent, child)
+    // ── Async branch (AGENT-LOOP.md §15 D-A1/D-A6): spawn without waiting ──
+    // The child runs the EXACT blocking pipeline (runChildPipeline below — relay /
+    // turn-cap / permission / MIN_REPORT_CHARS / mergeChildMutations all unchanged),
+    // but the parent does not await it: the promise is parked in _asyncSubagents and
+    // consumed via subagent_check or the turn-end auto-wait. Slot queue: running
+    // count < ASYNC_SUBAGENT_LIMIT → start now; ≥ limit → enqueue (status "queued",
+    // position = queue index) — never rejected, never requiring the model to batch.
+    if (args.async === true) {
+      if ((ctx.depth ?? 0) > 0) {
+        throw new Error("async spawn only available at the top level")
+      }
+      parent._asyncSubagents ??= new Map()
+      parent._asyncQueue ??= []
+      const running = [...parent._asyncSubagents.values()].filter((e) => e.status === "running").length
+      const id = parent._subAgentCounter
+      const entry = {
+        id, role, relayPrefix,
+        status: running >= ASYNC_SUBAGENT_LIMIT ? "queued" : "running",
+        position: undefined,
+        report: null, error: null, done: false,
+        promise: null, _settle: null, _settleSeq: 0,
+      }
+      // The settle signal — resolves when the run chain settles (never rejects).
+      entry.promise = new Promise((res) => { entry._settle = res })
+      entry.start = () => {
+        entry.status = "running"
+        entry.position = undefined
+        // Deferred [model] emit: the TUI block is created at ACTUAL start.
+        ctx.callbacks?.onToken?.(relayPrefix + "[model]" + (childProvider.model ?? ""))
+        // Turn-cap on background children NEVER pops the continue panel (D-A3):
+        // auto-decline, the partial-work report carries the cap reason.
+        runChildPipeline(child, input, childOpts, childRunOpts, {
+          parent, role, args,
+          askContinue: () => Promise.resolve(false),
+        })
+          .then((report) => { entry.report = report })
+          .catch((err) => { entry.error = err?.message ?? String(err) })
+          .finally(() => {
+            entry.status = "done" // running 数口径（D-A1/D-A2/T6）：已完成未消费不计入
+            entry.done = true
+            // D-A3 发射时机（2026-09-02 用户实证修正）：settle 同刻发射 ⟦ev⟧done——
+            // TUI routeSubToken 立即冻结区块，冻结位置 = 完成时刻的会话流位置
+            // （回合收尾统一发会把块堆在结论之后）。父会话已 abort 不发：TUI 已按
+            // interrupted 冻结，晚到 token 经 tombstone 丢弃——显式守卫更干净。
+            if (!ctx.signal?.aborted) {
+              ctx.callbacks?.onToken?.(`${entry.relayPrefix}⟦ev⟧done\x1e0\x1e0\x1edone\x1e`)
+            }
+            entry._settleSeq = (parent._asyncSettleSeq = (parent._asyncSettleSeq ?? 0) + 1)
+            entry._settle()
+            for (const w of parent._asyncWaiters?.splice(0) ?? []) { try { w() } catch { /* noop */ } }
+            maybeRefillAsync(parent)
+          })
+      }
+      parent._asyncSubagents.set(String(id), entry)
+      if (entry.status === "queued") {
+        parent._asyncQueue.push(entry)
+        entry.position = parent._asyncQueue.length
+        return JSON.stringify({ id: String(id), role, status: "queued", position: entry.position })
+      }
+      entry.start()
+      return JSON.stringify({ id: String(id), role, status: "running" })
     }
 
-    return report
+    // ── Blocking path (unchanged semantics): await the full pipeline ──
+    return await runChildPipeline(child, input, childOpts, childRunOpts, {
+      parent, role, args,
+      askContinue: askSubagentContinue,
+    })
   },
 }
 
+/**
+ * Shared post-spawn pipeline (blocking AND async — AGENT-LOOP.md §15 D-A1: the
+ * async branch reuses the exact same spawn-child pipeline, "全不变"):
+ * turn-cap continue loop → declined partial-work return → MIN_REPORT_CHARS
+ * expansion → eng-coder mutation merge → designId suffix. Returns the report.
+ * onDeclined lives here (identical for both paths) — only askContinue differs:
+ * blocking asks the user via the permission panel, async auto-declines.
+ */
+async function runChildPipeline(child, input, childOpts, childRunOpts, { parent, role, args, askContinue }) {
+  const declined = { partial: null }
+  let report = await runWithContinue(
+    (child, input, cbs, opts) => runAgent(child, input, cbs, opts), // opts = childRunOpts + resume (managed by the pipeline)
+    child, input, childOpts, childRunOpts,
+    {
+      askContinue,
+      onDeclined: (e, output) => {
+        if (role === "eng-coder" && child._mutatedThisRun) mergeChildMutations(parent, child)
+        // Early return semantics (unchanged from the inline loop): the declined
+        // partial-work message is returned WITHOUT the MIN_REPORT_CHARS expansion —
+        // re-prompting a capped child for a longer report is wrong.
+        // Review #2 fix: use the pipeline-captured output (the `report` variable is
+        // still "" at this point — runWithContinue hasn't returned yet).
+        declined.partial = `Subagent (${role}) ${TURN_CAP_MARK} (${e.turn} turns) — work may be partial; review recent_changes before deciding next steps.\nPartial output: ${output || ""}`
+      },
+    },
+  )
+  if (declined.partial !== null) {
+    // declined eng-coder delivery still carries its designId — the fix round
+    // re-spawns with the same slot (2026-09-01).
+    if (role === "eng-coder") declined.partial += `\ndesignId: ${args.designId ?? "(single-design session — designId optional)"} — reuse it (with the same designToken) when re-spawning this eng-coder.`
+    return declined.partial
+  }
+
+  // Report too short = incomplete handoff: send back for expansion once (inspired by kimi-code's summaryPolicy: min 200 chars, retry 1 time).
+  // The child agent's history is still intact; the continuation instruction is appended as new input so it can see its own earlier work.
+  if (report.length < MIN_REPORT_CHARS) {
+    report = await runAgent(child, REPORT_CONTINUATION, childOpts, childRunOpts)
+  }
+
+  // Engineering mode mechanical code gate: delegated file changes must not
+  // bypass the parent's advisor/verify guards. Merge the child's mutations
+  // into the parent so "advisor mandatory at both gates" is enforced, not just
+  // promised in the engineering prompt.
+  // CRITICAL: Only merge if child actually mutated files (defense-in-depth against
+  // runAgent throwing before any writes occurred).
+  // Review #8 clarification: eng-coder ONLY is intentional — the mechanical
+  // two-gate merge exists for engineering mode; plain `coder` children carry
+  // their own verify/advisor self-review discipline (per tool description), and
+  // normal mode has no parent advisor/verify gate to feed.
+  if (role === "eng-coder" && child._mutatedThisRun) {
+    mergeChildMutations(parent, child)
+  }
+
+  // designId rides the delivery report (2026-09-01): the divergence-audit fix round
+  // re-spawns with the SAME designId+token — the parent copies it from here, and the
+  // prompt tells the model exactly where the matching token came from.
+  if (role === "eng-coder") {
+    report += `\ndesignId: ${args.designId ?? "(single-design session — designId optional)"} — reuse this designId with the same designToken (from the approved advisor type='design' review) when re-spawning this eng-coder for an audit fix round.`
+  }
+
+  return report
+}
+
+/** Slot-queue refill (AGENT-LOOP.md §15 D-A1/D-A6): start queue heads while a
+ *  running slot is free — called from every settle (completion frees a slot) and
+ *  from the turn-end collection's refill loop. Serial by construction: one slot
+ *  frees per settle, one head starts per call. */
+export function maybeRefillAsync(parent) {
+  const queue = parent._asyncQueue ?? []
+  while (queue.length > 0) {
+    const running = [...(parent._asyncSubagents?.values() ?? [])].filter((e) => e.status === "running").length
+    if (running >= ASYNC_SUBAGENT_LIMIT) return
+    queue.shift().start()
+  }
+}
+
 /**
  * Child agent run options — the parent's abort signal MUST propagate to the
  * child: without it, Ctrl+C aborts the parent's controller but the child keeps

package/src/agent.mjs

@@ -18,7 +18,7 @@ import { cleanupConsultSessions } from "./agent-tools/consult.mjs"
 import {
   escapeXml, repairHistory, listWorkDir, ensureAutoReminder,
   readonlyToolNames, collectGitContext, loadProjectInstructions,
-  ContinueError,
+  ContinueError, offloadToolResult,
   DEFAULT_MAX_TURNS, DEFAULT_SUBAGENT_TURNS,
   MIN_REPORT_CHARS, REPORT_CONTINUATION,
 } from "./agent/helpers.mjs"
@@ -140,6 +140,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     agent._advisorSession = null // advisor session is per-run: discard when the task ends, next task starts fresh
     agent._emptyRetries = 0 // empty-response retry budget is per-run: a fresh user turn restarts from zero
     agent._compressFailures = 0 // compaction summary-failure counter is per-run: a fresh user turn restarts from zero
+    agent._asyncCheckLastN = 0 // subagent_check read counter is per-run (§15 D-A2): a fresh user turn restarts from 1
   }
   // eng-coder authorization is set by subagent.mjs AFTER token validation but BEFORE runAgent —
   // only reset for the top-level agent (depth 0); child runs must keep their granted authorization
@@ -164,6 +165,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     tools: toolSchemas,
   }
 
+  let thrownError = null
   try {
     for (let turn = 0; turn < maxTurns; turn++) {
     // Update turn counter for status bar display
@@ -184,16 +186,25 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           agent._compressFailures = 0
           agent._planReminderAtLen = 0 // After compression history shrinks, reset cadence so reminders resume
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
-          callbacks.onCompress?.()
+          // Completion info (CONTEXT-COMPACTION §7 D-C2): { mode: "summary", tokensFreed, elapsedMs }
+          // from compressIfNeeded, or { mode: "fallback", tailMessages } from compressFallback below —
+          // the TUI panel renders the matching completion state. Existing callers that ignore the
+          // argument keep the exact previous onCompress semantics.
+          callbacks.onCompress?.(agent._lastCompressInfo ?? {})
           ensureAutoReminder(agent)
         }
       } catch (compressError) {
         // AbortError must not be swallowed: user cancellation must propagate
         if (compressError?.name === "AbortError" || signal?.aborted) throw compressError
         agent._compressFailures = (agent._compressFailures ?? 0) + 1
+        // Q3 visibility (CONTEXT-COMPACTION §7 D-C1): a failed compression is no longer silent —
+        // the frontend updates the compression panel with the error text (and logs to stderr).
+        // Failure STRATEGY is unchanged: COMPRESS_FAILURE_LIMIT consecutive failures still degrade
+        // to compressFallback — this only adds observability.
+        callbacks?.onCompressFail?.(compressError)
         if (agent._compressFailures >= COMPRESS_FAILURE_LIMIT) {
           agent._compressFailures = 0
-          if (compressFallback(agent)) callbacks.onCompress?.()
+          if (compressFallback(agent)) callbacks.onCompress?.(agent._lastCompressInfo ?? {})
         }
       }
     }
@@ -420,9 +431,63 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     throw new ContinueError(maxTurns)
+  } catch (e) {
+    thrownError = e
+    throw e
   } finally {
     // Turn-end cleanup: abort any leftover consultation children (consult_start spawns
     // fire-and-forget runners; a completed turn must not let them keep burning tokens).
     cleanupConsultSessions(agent)
+    // Async subagent turn-end collection (AGENT-LOOP.md §15 D-A3). Lifecycle:
+    // - Ctrl+C / Ctrl+I (signal aborted): children were aborted with the parent
+    //   signal — clear WITHOUT injecting stale errors (user explicitly stopped).
+    // - ContinueError (turn cap): no wait, no injection — children keep running
+    //   and the RESUME run's turn-end collection takes over.
+    // - anything else: refill loop → wait for all → inject reports → clear.
+    if (signal?.aborted) {
+      agent._asyncSubagents?.clear()
+      agent._asyncQueue = []
+      agent._asyncCheckLastN = 0
+    } else if (thrownError instanceof ContinueError) {
+      // keep _asyncSubagents + the check counter — the resumed run continues them
+    } else {
+      await collectAsyncSubagents(agent)
+      agent._asyncCheckLastN = 0
+    }
+  }
+}
+
+/**
+ * Turn-end async subagent collection (AGENT-LOOP.md §15 D-A3):
+ * 1. refill loop — start queued heads while slots free (each settle already
+ *    refills via its finally; this drains the tail), keeping the cap ≤4 serial.
+ * 2. wait for every entry to settle (queued entries start through the refill
+ *    chain — the drain loop converges when nothing is running and the queue is empty).
+ * 3. inject one user-role reminder per entry: the report/error text XML-escaped
+ *    (child reports may carry content from files/webpages — reminder discipline),
+ *    >64K offloaded to disk with a preview + path.
+ * 4. clear the map. (The ⟦ev⟧done freeze signal is NOT emitted here — D-A3
+ *    2026-09-02: each entry's settle callback emits it at completion time so
+ *    blocks freeze at their completion position in the stream.)
+ */
+async function collectAsyncSubagents(agent) {
+  const map = agent._asyncSubagents
+  if (!map || map.size === 0) return
+  const { maybeRefillAsync } = await import("./agent-tools/subagent.mjs")
+  for (;;) {
+    maybeRefillAsync(agent)
+    const running = [...map.values()].filter((e) => e.status === "running")
+    if (running.length === 0) break
+    await Promise.allSettled(running.map((e) => e.promise))
+  }
+  for (const e of [...map.values()]) {
+    const body = e.error ?? e.report ?? "(no report)"
+    const preview = await offloadToolResult(String(body), `async-subagent-${e.id}`)
+    pushReal(agent, {
+      role: "user",
+      content: `[System reminder: async subagent #${e.id} (${e.role}) finished]\n${escapeXml(preview)}`,
+    })
   }
+  map.clear()
+  agent._asyncQueue = []
 }

package/src/cli/make-agent.mjs

@@ -107,6 +107,31 @@ export async function assembleAgent() {
   agent.activeProvider = config.activeProvider
   agent.activeModel = config.activeModel ?? null
   agent._mcpWarnings = mcpWarnings
+  // SESSION.md §8 D-S1：assembleAgent 后唯一校验点（TUI/chat 两路径同源）——不抛错不退出，
+  // 标记由调用侧消费（TUI 弹重选 / headless 报错）。空 provider 由 TUI 路径在 startTUI 前清空。
+  validateProvider(agent)
+  return agent
+}
+
+/**
+ * SESSION.md §8 D-S1 — provider 有效性校验（assembleAgent 后唯一校验点，TUI/chat 两路径同源）。
+ * 判据（评审 #1/#2）：仅 model/baseURL 缺失判 invalid——**不得用 MODEL_SPECS 成员资格判无效**
+ * （未知模型 = 受支持场景：自定义端点模型不在 spec 表是常态，误判会让自定义模型用户每次恢复都弹重选）。
+ * apiKey 缺失不判（既有 wizard /model 流程处理）。幂等：有效时清标记，无效时置标记 + 原因。
+ * 不抛错、不退出。返回 agent 便于链式调用。
+ */
+export function validateProvider(agent) {
+  const ok = Boolean(agent.provider?.name && agent.provider.model && agent.provider.baseURL)
+  if (ok) {
+    delete agent._providerInvalid
+    delete agent._providerInvalidReason
+  } else {
+    agent._providerInvalid = true
+    agent._providerInvalidReason = !agent.provider?.name
+      ? "provider 不存在"
+      : !agent.provider.model ? "model 缺失"
+      : "缺少 baseURL"
+  }
   return agent
 }
 

package/src/cli/memory-command.mjs

@@ -1,7 +1,12 @@
-import { put, remove, search, list } from "../memory.mjs"
+import { join } from "node:path"
+import { loadConfig } from "../config.mjs"
+import { teamConfig } from "./make-agent.mjs"
+import { put, search, list, deleteByUid } from "../memory/core.mjs"
 
-/** thincoder memory <list|search|put|remove> subcommands */
-export async function memoryCommand(memory, args) {
+/** thincoder memory <list|search|put|remove> subcommands.
+ *  opts.dirs: { project, team } layer directories for project/team file deletion (tests inject their own);
+ *  falls back to the same config-derived dirs the agent uses. */
+export async function memoryCommand(memory, args, opts = {}) {
   const [sub, ...rest] = args
 
   const flags = {}
@@ -37,12 +42,18 @@ export async function memoryCommand(memory, args) {
       break
     }
     case "remove": {
-      const id = Number(positional[0])
-      if (!id) {
-        console.error("Usage: thincoder memory remove <id>")
+      const uid = positional[0]
+      if (!uid) {
+        console.error("Usage: thincoder memory remove <uid>  (uid: personal:<n> | project:<origin>:<path> | team:<origin>:<path>; bare <n> = personal)")
+        return 1
+      }
+      try {
+        const entry = await deleteByUid(memory, uid, { dirs: opts.dirs ?? cliDirs() })
+        console.log(`Removed ${entry.id}: ${entry.title}`)
+      } catch (e) {
+        console.error(e.message)
         return 1
       }
-      console.log((await remove(memory, id)) ? `Removed #${id}` : `No entry #${id}`)
       break
     }
     default:
@@ -51,6 +62,16 @@ export async function memoryCommand(memory, args) {
   }
 }
 
+/** Layer directories for project/team file deletion — derived from the same config the agent uses. */
+function cliDirs() {
+  const config = loadConfig()
+  const dirs = { project: null, team: null }
+  if (config.memory?.projectDir) dirs.project = join(process.cwd(), config.memory.projectDir)
+  const team = teamConfig(config)
+  if (team) dirs.team = team.dir
+  return dirs
+}
+
 function printEntries(entries) {
   if (entries.length === 0) {
     console.log("(no entries)")