thincoder 0.12.54 → 0.12.59

package/src/agent.mjs

@@ -15,6 +15,7 @@ import { prepareRun } from "./agent/setup.mjs"
 import { injectPostTurn } from "./agent/post-turn.mjs"
 import { handleCompletion } from "./agent/completion.mjs"
 import { cleanupConsultSessions } from "./agent-tools/consult.mjs"
+import { logEvent } from "./log.mjs"
 import {
   escapeXml, repairHistory, listWorkDir, ensureAutoReminder,
   readonlyToolNames, collectGitContext, loadProjectInstructions,
@@ -66,6 +67,12 @@ export const ENG_OFF_REMINDER =
   "Changes go through the normal workflow: you may edit files directly, advisor/verify " +
   "guards apply per config.]"
 
+/** Manual-tier auto-turn digest domain (AGENT-LOOP.md §17 D-S6): organize-only.
+ *  Injected per manual auto-turn run — writes/execute/spawns/questions are also
+ *  mechanically denied (no permission handler + spawn gate); this steers first. */
+const AUTO_TURN_DIGEST_DOMAIN =
+  "[System reminder: auto-turn — background async subagents finished while there was no user message, and this turn runs automatically to digest their reports (the finished-report reminders above). No one is waiting for this reply, so organize only: 1) summarize each finished report's key points into this conversation for the user to read later; 2) update the task list with the task tool (allowed) to mark finished work done; 3) write decision points with a suggested next step as text — do not execute it. FORBIDDEN this turn (mechanically enforced): modifying files, bash/execute/verify, spawning subagents, asking questions — those need a real user message. End the turn once the summaries are written.]"
+
 /** Engineering-mode status injection — one reminder on EVERY transition (2026-08-25:
  *  OFF is announced too — the model must know the gates lifted; silence after /eng-off
  *  left it guessing. Covers TUI /eng, resume, and any path bypassing the eng tool.) */
@@ -107,72 +114,92 @@ export function createAgent({
 }
 
 /** Run the agent loop: LLM ↔ tool-call cycle until task completion or turn limit. Returns final text content. */
-export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal, maxTurns: overrideTurns, resume = false } = {}) {
-  // Previous run's async exploration distillation must settle before this run pushes new
-  // input (SEND-STALL-DISTILL §2.2, N1): the compressed machine line is this run's starting
-  // point — await BEFORE prepareRun, or the history replacement would wipe the new input.
+export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal, maxTurns: overrideTurns, resume = false, autoTurn = false, suspDriven = false } = {}) {
+  // Previous run's async exploration distillation must settle before this run pushes
+  // input (SEND-STALL-DISTILL §2.2 N1) — await first, or its history replace wipes it.
   if (agent._pendingDistill) {
     const p = agent._pendingDistill
     agent._pendingDistill = null
     await p
   }
+  // §17 D-S3: suspension-settled async results inject before EVERY run's prepareRun
+  // (user + auto-turn); spliced = consumed. collectSettledAsync owns a different
+  // container, so no double-inject across the two consumption points.
+  const pendingAsync = agent._pendingAsyncResults
+  if (pendingAsync?.length) {
+    const { injectAsyncResult } = await import("./agent-tools/subagent.mjs")
+    for (const e of pendingAsync.splice(0)) await injectAsyncResult(agent, e)
+  }
+  agent._inAutoTurn = autoTurn // spawn gate for manual-tier digests (§17 D-S6/N3)
   const { maxTurns, threshold, tools, toolSchemas, toolByName, systemPrompt } = await prepareRun(
     agent, input, callbacks,
-    { depth, signal, overrideTurns, resume, systemPrompt: SYSTEM_PROMPT, disciplineRules: DISCIPLINE_RULES, mainOverlay: MAIN_OVERLAY },
+    { depth, signal, overrideTurns, resume: resume || autoTurn, systemPrompt: SYSTEM_PROMPT, disciplineRules: DISCIPLINE_RULES, mainOverlay: MAIN_OVERLAY },
   )
 
-  // End-of-run exploration distillation boundary (CONTEXT-COMPACTION §5): prepareRun has already
-  // pushed the user input + injections, so everything appended from here is "this run's" work.
+  // Exploration-distillation boundary (CONTEXT-COMPACTION §5): prepareRun already
+  // pushed input + injections — appended from here counts as "this run's" work.
   agent._runStartHistoryLen = agent.history.length
 
-  // Per-run bookkeeping reset. On `resume` (ContinueError continuation) these are
-  // PRESERVED: the resumed run must keep mutation tracking so the advisor/verify
-  // guards stay active (a guard pushback on the last turn must not silently vanish),
-  // and the convergence budget must not be resettable by continuing the session.
+  // Per-run bookkeeping reset — PRESERVED on `resume` (ContinueError continuation):
+  // mutation/guard continuity and the convergence budget must survive a continuation.
   if (!resume) {
-    agent._mutatedThisRun = false
-    agent._verifiedThisRun = false
-    agent._verifyPassed = undefined
-    agent._calledAdvisorThisRun = false
-    agent._touchedFiles = []
-    agent._verifyRetries = 0
-    agent._advisorRound = 0
-    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
+    // §17 D-S6: an auto-turn's guard marks are inherited by the next USER run (not
+    // reset) so auto-turn changes never escape the guard silently.
+    const g = agent._inheritedGuard
+    if (g) {
+      for (const k of ["_mutatedThisRun", "_verifiedThisRun", "_verifyPassed", "_calledAdvisorThisRun", "_touchedFiles", "_verifyRetries", "_advisorRound"]) agent[k] = g[k]
+      agent._inheritedGuard = null
+    } else {
+      agent._mutatedThisRun = false
+      agent._verifiedThisRun = false
+      agent._verifyPassed = undefined
+      agent._calledAdvisorThisRun = false
+      agent._touchedFiles = []
+      agent._verifyRetries = 0
+      agent._advisorRound = 0
+      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 // check action 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
+  // §17 D-S6 manual tier: digest action-domain reminder (system-driven turn — organize only).
+  if (autoTurn && !agent.autoApprove) {
+    agent.history.push({ role: "user", content: AUTO_TURN_DIGEST_DOMAIN, transient: true })
+  }
+  // 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 keep theirs
   if (depth === 0) agent._engDesignReviewed = false
-  // _engDesignToken survives across turns within the same agent (design review → user approval → spawn eng-coder).
-  // Lifecycle: invalidated on a failed re-review (advisor.mjs), issued on a passing review.
+  // _engDesignToken survives across turns (design review → approval → eng-coder spawn);
+  // lifecycle: invalidated on failed re-review (advisor.mjs), issued on a passing one.
   let guardPushbacks = 0
   let advisorPushbacks = 0
   let honestReminderInjected = false
   const recentCallSigs = []
-  // repeat: "once" stream rules fire at most once per runAgent call (user turn):
-  // this set survives across chat() calls (rule abort-retry, tool loop) within the turn.
+  // "once" stream rules fire at most once per runAgent call; the set survives across
+  // chat() calls (rule abort-retry, tool loop) within the turn.
   const streamRuleFired = new Set()
 
   // Compaction overhead for the pure-estimation path: system prompt + tools schema are
-  // part of every request but not in history — without them the first-turn/restored/just-
-  // compacted estimate under-counts and may never trigger compaction. Measured baseline
-  // path already includes both (prompt_tokens is the full context), so this only applies
-  // when _lastPromptTokens is null.
+  // in every request but not in history — without them the first-turn/just-compacted
+  // estimate under-counts and may never trigger. Measured path already includes both.
   const compactionOverhead = {
     systemPrompt,
     tools: toolSchemas,
+    // §18.6 D-TR4：compress 轨迹 depth 元数据（runAgent 的 depth 在此作用域——
+    // context.mjs compressIfNeeded 经 extras 透出到 logCtx）
+    traceDepth: depth,
   }
 
+  let thrownError = null
   try {
     for (let turn = 0; turn < maxTurns; turn++) {
     // Update turn counter for status bar display
     agent._currentTurn = turn + 1
     agent._maxTurns = maxTurns
-    // D2 (AGENT-LOOP.md §7.2): depth>0 children emit a ⟦ev⟧turn progress token on every
-    // turn — a single emit point covering all three spawn tools (natural heartbeat for the
-    // TUI subagent block header: "turn N/max"). phase=llm (tool/done progress rides the
-    // existing onToolCall/onToolResult prefix relay — no token for those).
+    // D2 (AGENT-LOOP.md §7.2): depth>0 children emit a ⟦ev⟧turn progress token each turn —
+    // single emit point covering all three spawn tools; phase=llm (tool/done progress rides
+    // the onToolCall/onToolResult relay — no token for those).
     if (depth > 0 && callbacks.onToken) {
       callbacks.onToken(`⟦ev⟧turn\x1e${turn + 1}\x1e${maxTurns}\x1ellm\x1e`)
     }
@@ -184,23 +211,27 @@ 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, tokensFreed, elapsedMs } —
+          // the TUI panel renders it; callers that ignore the arg keep prior 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 (CONTEXT-COMPACTION §7 D-C1): a failed compression is surfaced to the panel;
+        // COMPRESS_FAILURE_LIMIT consecutive failures still degrade to compressFallback.
+        callbacks?.onCompressFail?.(compressError)
         if (agent._compressFailures >= COMPRESS_FAILURE_LIMIT) {
           agent._compressFailures = 0
-          if (compressFallback(agent)) callbacks.onCompress?.()
+          if (compressFallback(agent)) callbacks.onCompress?.(agent._lastCompressInfo ?? {})
         }
       }
     }
 
     // Plan-mode reminder cadence: re-inject constraint reminders while plan mode is active
-    // (sparse every 2 turns, full every 5 turns or when the user sends a new message),
-    // so the read-only restriction never fades from context.
+    // (sparse every 2 turns, full every 5 / on new user message) so the restriction never fades.
     if (agent.planMode) {
       const lastMsg = agent.history.at(-1)
       const realUserMsg = lastMsg?.role === "user"
@@ -216,9 +247,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
     }
 
-    // Engineering-mode status injection: every new user message carries a
-    // reminder so the model always knows whether it's in design-before-code
-    // mode or standard discipline mode.
+    // Engineering-mode status injection on every new user message (design-before-code
+    // vs standard discipline) — see injectEngineeringReminder.
     if (depth === 0) {
       injectEngineeringReminder(agent)
     }
@@ -226,8 +256,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     const messages = [{ role: "system", content: systemPrompt }, ...agent.history]
     let response
 
-    // Auto-think: classify task difficulty and set reasoning effort before the real prompt.
-    // Runs only on turn 0 of user input; failure is silent — falls back to current setting.
+    // Auto-think: classify difficulty and set reasoning effort on turn 0; silent on failure.
     if (agent.config?.agent?.autoThink && turn === 0) {
       const { classifyAndApply } = await import("./auto-think.mjs")
       await classifyAndApply(agent, turn).catch(() => {})
@@ -242,14 +271,29 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
         signal,
         streamRules: agent.config.agent?.streamRules ?? [],
         firedPatterns: streamRuleFired,
+        // LOGGING（LOGGING.md）：llm:* 事件的语义上下文（stage=turn 主循环回合——含
+        // digest 消化轮 auto=true；child=子代理 id（spawn 时 stamp 于 child._logId））
+        // §18.6 D-TR4：轨迹元数据增补（role/depth/kind/session/cwd——trace-store 只读
+        // logCtx，签名不变）；kind：depth>0 = subagent（consult 孩子 = consult）——子代理
+        // 对回靠 role+depth+child id（children 无 _sessionStart——不经 depth-0 设置——
+        // session 字段对子代理轨迹为 null——见 trace-store/agent.mjs 注释）。
+        logCtx: {
+          stage: "turn", turn: turn + 1, auto: autoTurn, child: agent._logId,
+          role: agent._role ?? null,
+          depth,
+          kind: depth > 0 ? (agent._role === "consult" ? "consult" : "subagent") : "turn",
+          session: agent._sessionStart ?? null,
+          cwd: agent.cwd,
+          traces: agent.config?.traces?.enabled !== false,
+        },
       })
     } catch (e) {
-      // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
-      // Inject the message into history and let the outer loop recreate the controller.
+      // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message }).
+      // Inject into history; the outer loop recreates the controller and resumes.
       if (e.name === "AbortError" && signal?.reason?.interrupt) {
         const msg = `[User interrupt: ${signal.reason.message}]`
-        // Dedup: if the interrupt was already handled during tool execution (L302-310),
-        // don't push a duplicate — the outer loop will still recreate the controller.
+        // Dedup: if already handled during tool execution (interrupt branch below),
+        // don't push a duplicate — the outer loop still recreates the controller.
         if (agent.history.at(-1)?.content !== msg) {
           agent.history.push({ role: "user", content: msg })
         }
@@ -257,11 +301,9 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       throw e
     }
 
-    // 内置工具（Responses web_search）结果本地化：服务端已执行——入历史为 tool 消息，
-    // 模型下一轮可见；全量回传时 transport 依 tool_call_id 前缀还原 web_search_call item。
-    // 注意：服务端 item id 是 msg_xxx 非 web_search_call_ 前缀——必须合成前缀（toItems 识别锚点），
-    // 原始 id 存入 content（真机冒烟 2026-08-31：直接用 msg_xxx 会被转成 function_call_output
-    // 与服务端不配对，属蒙对）。
+    // 内置工具（Responses web_search）结果本地化：服务端已执行——入历史为 tool 消息；
+    // 服务端 item id 是 msg_xxx 非 web_search_call_ 前缀——必须合成前缀（toItems 识别锚点），
+    // 原始 id 存入 content（真机冒烟 2026-08-31 验证）。
     for (const btr of response.builtinToolResults ?? []) {
       if (!btr?.id) continue
       pushReal(agent, {
@@ -271,8 +313,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       })
     }
 
-    // Stream rule triggered mid-generation (action: "abort"): halt current output,
-    // inject rule's message as a reminder, and retry from the same context.
+    // Stream rule triggered mid-generation (action: "abort"): halt, inject the rule's
+    // message as a reminder, retry from the same context.
     if (response.ruleTriggered) {
       if (response.content) {
         pushReal(agent, { role: "assistant", content: response.content })
@@ -285,9 +327,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       continue
     }
 
-    // Stream rule warnings (action: "warn"): the stream completed, but one or more
-    // non-interrupting rules matched. Inject warnings after the turn so the model
-    // sees them before its next response — without aborting mid-generation.
+    // Stream rule warnings (action: "warn"): stream completed; inject de-duplicated
+    // warnings so the model sees them before its next response.
     if (response._warnings?.length) {
       const deDuplicated = [...new Map(response._warnings.map(w => [w.name || w.pattern, w])).values()]
       agent.history.push({
@@ -296,9 +337,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       })
     }
 
-    // User interrupted mid-generation (Ctrl+I): the SSE stream was aborted while content
-    // was partially generated. Commit partial output + inject user message, then signal
-    // the outer loop to recreate the controller and resume.
+    // User interrupted mid-generation (Ctrl+I): commit partial output + inject the
+    // message, then signal the outer loop to recreate the controller and resume.
     if (response.interrupted) {
       if (response.content) {
         pushReal(agent, { role: "assistant", content: response.content })
@@ -318,8 +358,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
     }
 
-    // Warn on abnormal finish reasons — the model stopped for a reason other than
-    // "stop" or "tool_calls", meaning the response may be incomplete or truncated.
+    // Warn on abnormal finish reasons — the response may be incomplete/truncated.
     if (response.finishReason && response.finishReason !== "stop" && response.finishReason !== "tool_calls") {
       const reasonMap = {
         length: "output token limit reached after exhausting continuations",
@@ -340,13 +379,11 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       advisorPushbacks = cr.advisorPushbacks
       if (cr.action === "continue") continue
       if (depth === 0) {
-        // End-of-run exploration distillation (CONTEXT-COMPACTION §5): this run's inline
-        // exploration results become one semantic note before the final return. Async
-        // (SEND-STALL-DISTILL §2.1): the turn-end signal goes out first — the promise hangs
-        // on agent._pendingDistill and settles at the next runAgent's start or the TUI's
-        // exit flush. Silent (N3): distillation failure must never block the return or lose
-        // history.
-        const distill = summarizeRunExplorations(agent, callbacks, signal).catch(() => {})
+        // End-of-run exploration distillation (CONTEXT-COMPACTION §5 + SEND-STALL-DISTILL
+        // §2.1): async — the promise hangs on _pendingDistill, settling at the next run's
+        // start or the TUI exit flush. Silent (N3): failure never blocks return/history.
+        // §18.6 D-TR4：depth 透传（distill 轨迹元数据——与 compress 同通道）
+        const distill = summarizeRunExplorations(agent, callbacks, signal, depth).catch(() => {})
         agent._pendingDistill = distill
       }
       return cr.content
@@ -369,8 +406,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
 
     const results = await executeToolCalls(agent, toolByName, response.toolCalls, callbacks, depth, signal)
 
-    // Ctrl+I interrupt during tool execution: skip committing partial results —
-    // the tool failure messages would mislead the model. Inject the interrupt and retry.
+    // Ctrl+I interrupt during tool execution: skip committing partial results — inject
+    // the interrupt and retry (placeholder results keep strict providers pairable).
     if (signal?.reason?.interrupt) {
       // 中断变更记账（2026-08-31 评审 #4）：此分支的工具已全部执行完成（磁盘已变，execute 已完成），
       // 真实结果按语义不进历史（placeholder 替代）——但变更必须记账：否则 guard 看到
@@ -391,11 +428,9 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           }
         } catch { /* 畸形 args 不影响记账（touchedFiles 尽力而为） */ }
       }
-      // The assistant tool_calls were already committed above (L347) — a strict
-      // provider 400s on dangling tool_calls, so synthesize placeholder tool
-      // results BEFORE the interrupt message (tool result must immediately
-      // follow its assistant tool_calls). The retry turn then sees a clean,
-      // pairable history (consult P1, 2026-08-30).
+      // The assistant tool_calls were committed above — synthesize placeholder tool
+      // results BEFORE the interrupt message (strict providers 400 on dangling
+      // tool_calls; consult P1, 2026-08-30).
       for (const tc of response.toolCalls) {
         agent.history.push({ role: "tool", tool_call_id: tc.id, content: "[Tool execution interrupted — results discarded]" })
       }
@@ -407,22 +442,88 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       continue
     }
 
-    // Model is executing tools → doing real work, reset guard pushback counter
+    // Model is executing tools → real work: reset guard pushback counters
     guardPushbacks = 0
     advisorPushbacks = 0
 
-    // Commit tool results (pairing, multimodal deferral, mutation accounting,
-    // touched files, reindex) — split into record-results.mjs (consult P2,
-    // 2026-08-30).
+    // Commit tool results (pairing, multimodal deferral, mutation accounting, reindex)
     await recordToolResults(agent, toolByName, results)
 
     injectPostTurn(agent, results, recentCallSigs, callbacks, turn)
     }
 
     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 handling (AGENT-LOOP.md §15 D-A3 + §17 D-S1). Lifecycle:
+    // - Ctrl+C (plain abort): children were aborted with the parent signal — clear
+    //   WITHOUT injecting stale errors (user explicitly stopped). Ctrl+I (interrupt)
+    //   keeps the pool: the turn resumes with the interrupt message, children stay
+    //   tracked (in a suspension session children hold agent._sessionSignal and a
+    //   digest's own Ctrl+I must not orphan them).
+    // - ContinueError (turn cap): no wait, no injection — children keep running and
+    //   the RESUME run's turn-end collection takes over.
+    // - anything else: inject the SETTLED entries only; running/queued stay in the
+    //   pool for the suspension session (D-S1 — no allSettled turn-end wait).
+    if (signal?.aborted && !signal?.reason?.interrupt) {
+      if (agent._asyncSubagents?.size > 0) {
+        logEvent("ev:stopped", { poolN: agent._asyncSubagents?.size ?? 0, where: "turn-end-abort" })
+      }
+      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 collectSettledAsync(agent, { suspDriven })
+      agent._asyncCheckLastN = 0
+    }
+    agent._inAutoTurn = false
+    // §17 D-S6: auto-turn guard marks survive into the next USER run (restored at its
+    // !resume reset above). Normal ends only — abort discards; ContinueError lets the
+    // auto-resumed run snapshot at its own end.
+    if (autoTurn && !(signal?.aborted && !signal?.reason?.interrupt) && !(thrownError instanceof ContinueError)) {
+      agent._inheritedGuard = {
+        _mutatedThisRun: agent._mutatedThisRun, _verifiedThisRun: agent._verifiedThisRun,
+        _verifyPassed: agent._verifyPassed, _calledAdvisorThisRun: agent._calledAdvisorThisRun,
+        _touchedFiles: agent._touchedFiles, _verifyRetries: agent._verifyRetries,
+        _advisorRound: agent._advisorRound,
+      }
+    }
+  }
+}
+
+/**
+ * Turn-end async subagent collection (AGENT-LOOP.md §17 D-S1 + §17.5 supersede):
+ * two modes, selected by the caller's driver context (17.5.2/17.5.4 #2):
+ * - suspDriven=false (fallback — headless/direct runAgent callers without a
+ *   suspension driver): inject every entry that SETTLED during this run
+ *   (XML-escaped report/error — child reports may carry file/webpage content;
+ *   >64K offloaded with preview + path) and remove it from the pool. Running/
+ *   queued STAY — no allSettled wait. Results never lost without a session.
+ * - suspDriven=true (the interaction layer runs suspensionSession after this
+ *   run): NO direct inject — settled entries STAY pooled (settled not consumed)
+ *   for the session's first sweepSettledToPending → digest turn (§17.5 — done
+ *   条目留池等消化轮注入；check/status 在 sweep 前仍从池读——17.5.2 不变面)。
+ * maybeRefillAsync runs in both modes (starts queued heads whose slot freed).
+ * Single ownership: entries settled inside a suspension session were moved to
+ * _pendingAsyncResults by the settle callback, so this only sees user-turn
+ * settles (no double inject — D-S3 points ①/②). The ⟦ev⟧done freeze is NOT
+ * emitted here — each settle callback emits it (§15 D-A3). */
+async function collectSettledAsync(agent, { suspDriven = false } = {}) {
+  const map = agent._asyncSubagents
+  if (!map || map.size === 0) return
+  const { maybeRefillAsync, injectAsyncResult } = await import("./agent-tools/subagent.mjs")
+  maybeRefillAsync(agent) // start queued heads now that slots may have freed — no waiting
+  if (suspDriven) return // §17.5: settled stays pooled — the suspension session digests it
+  for (const e of [...map.values()]) {
+    if (!e.done) continue // still running — stays in the pool (D-S1)
+    await injectAsyncResult(agent, e)
+    map.delete(String(e.id))
   }
 }

package/src/auto-think.mjs

@@ -81,6 +81,20 @@ export async function classifyAndApply(agent, turn) {
       ],
       tools: [],
       signal: AbortSignal.timeout(5_000),
+      // D-TS12 (AGENT-LOOP.md §18.7): full logCtx field set at the chat call
+      // point — traces/session/cwd/role/depth/kind (this call point carried
+      // only {stage,turn,child}). The traces field closes the D-TR6 "off = no
+      // persist" switch: without it the tracer treated the auto-think call as
+      // enabled and persisted even when agent.config.traces.enabled was false.
+      logCtx: {
+        stage: "autothink", turn, child: agent._logId,
+        traces: agent.config?.traces?.enabled !== false,
+        session: agent._sessionStart ?? null,
+        cwd: agent.cwd,
+        role: agent._role ?? null,
+        depth: agent._depth ?? 0, // agent state carries no depth stamp (the call site passes none) — 0 for the top-level agent
+        kind: "autothink",
+      },
     })
     const word = (response.content ?? "").trim().toLowerCase()
     if (word.startsWith("low")) level = "low"

package/src/cli/make-agent.mjs

@@ -3,6 +3,7 @@ import { join } from "node:path"
 import { createAgent } from "../agent.mjs"
 import { loadConfig, configDir } from "../config.mjs"
 import { createMemory, memoryTools, syncDir, codeSearchTool, docSearchTool } from "../memory.mjs"
+import { settingsTool } from "../agent-tools/settings.mjs"
 import { repoOutlineTool } from "../tools/repomap.mjs"
 import { builtinTools } from "../tools/index.mjs"
 import { discoverRules } from "../rules.mjs"
@@ -48,7 +49,7 @@ export async function assembleAgent() {
     await ensureClone(team)
     await syncDir(memory, { layer: "team", dir: team.dir })
   }
-  const baseTools = [...builtinTools, ...memoryTools(memory, { cwd, projectDir: config.memory.projectDir, author: gitAuthor(), team }), codeSearchTool(memory), docSearchTool(memory), repoOutlineTool(memory.db, cwd)]
+  const baseTools = [...builtinTools, ...memoryTools(memory, { cwd, projectDir: config.memory.projectDir, author: gitAuthor(), team }), codeSearchTool(memory), docSearchTool(memory), repoOutlineTool(memory.db, cwd), settingsTool()]
 
   // MCP servers: connect in parallel (a dead server won't block startup), collect failures as warnings (stderr invisible in TUI, passed via agent object)
   const mcpServers = config.mcp?.servers ?? []
@@ -107,6 +108,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)")

package/src/cli/permission.mjs

@@ -19,7 +19,14 @@ export function formatPermission(name, args) {
   }
   if (base === "delete") return `${args.path}${args.force ? "（force：跟踪文件也删）" : ""}`
   if (base === "subagent") return cap(args.task ?? "", 500)
-  if (base === "memory_put") return `[${args.type ?? ""}] ${args.title ?? ""}\n${cap(args.content ?? "", 500)}`
+  if (base === "memory") {
+    // §6 action-routed preview: put shows content, batch delete/clear show the gate args
+    const action = String(args.action ?? "")
+    if (action === "put") return `[${args.type ?? ""}] ${args.title ?? ""}\n${cap(args.content ?? "", 500)}`
+    if (action === "delete") return args.id ? `id=${args.id} scope=${args.scope}` : `batch delete scope=${args.scope} type=${args.type ?? ""} keyword=${args.keyword ?? ""} confirm=${args.confirm}`
+    if (action === "clear") return `clear scope=${args.scope} confirm=${args.confirm}`
+    return cap(summarize(args), 300)
+  }
   return cap(summarize(args), 300)
 }