thincoder 0.12.41 → 0.12.43

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 本文件记录 ThinCoder CLI 的发布历史。格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/)，版本遵循[语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [0.12.43] — 2026-08-25
+
+### Added
+
+- **评审超时可配置**：`agent.advisor.timeoutMs`（默认 600s，原固定 300s）——运行期读取，非法值（0/负数/字符串）回退默认；长评审不再被固定墙钟截断
+- **主 agent 轮次上限默认 100 → 200**：大任务（多文件重构、修复-验证循环）不轻易撞墙
+
+### Changed
+
+- **工具输出限制全链路 16K → 64K（65536）**：落盘阈值 `TOOL_RESULT_OFFLOAD_LIMIT`/`TOOL_RESULT_PREVIEW`、advisor 内部截断 `MAX_RESULT_CHARS` 全部放宽——大输出（advisor 评审、大文件读取）不再被过早落盘/截断
+- **轮末探索蒸馏异步化**：回合结束信号先行（TUI 状态栏立即恢复，不再等第二次静默 LLM 调用）；蒸馏 promise 挂 `agent._pendingDistill`，下一轮开头 await（摘要必在下一轮 LLM 调用前落位），退出前 bounded flush（≤5s）；`onDistilled` 回调触发压缩版落盘
+
+### Removed
+
+- **`sleep` 工具删除**：编程场景零真实使用（会话历史 0 次调用），且工具说明误导模型在同步工具（advisor/subagent）后 sleep 空等——白耗 10-300 秒；等待需求改走 bash 内联命令；内部速率限制/重试退避（`_rateHooks.sleep`）不受影响
+
+### Fixed
+
+- 工具输出落盘失败回退截断对齐 64K；旧阈值残留自动化断言（`MAX_RESULT_CHARS` 导出 + import 断言、helpers/run.mjs 边界匹配无残留）
+
+## [0.12.42] — 2026-08-24
+
+### Changed
+
+- **工程模式发起权归用户**：设计评审只能由用户发起——agent 准备设计后只呈递+提醒「设计就绪」，不再自行调 advisor（此前 agent 可自行判断"讨论完了"直接提交评审并开发，属越权）；评审打回后每轮呈递发现+修复建议、用户逐条拍板再改，不再自行修完重送
+- **交付 code review 改为自动流程节点**：eng-coder 返回后自动评审（不问用户）；工程模式下 guard 推回维持关闭
+- 提示词注意力优化：核心规则开头立纲 + 结尾钉死 + 状态表补「Review fix loop」态；设计文档 ENGINEERING-MODE/WORKLOOP/PROMPT-DECOUPLING 同步
+
 ## [0.12.41] — 2026-08-23
 
 ### Added

package/package.json

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

package/src/advisor/run.mjs

@@ -29,8 +29,8 @@ export const ADVISOR_THINKING_PLACEHOLDER = "\n[thinking…]\n"
 // Context window limits
 const MAX_CONTEXT_TOKENS = 120_000 // Reserve headroom to avoid OOM
 const TOOL_TIMEOUT_MS = 30_000 // single tool timeout
-const REVIEW_TIMEOUT_MS = 300_000 // whole review timeout
-const MAX_RESULT_CHARS = 12_000 // tool result truncation (line-aware)
+const REVIEW_TIMEOUT_MS = 600_000 // whole review timeout (10 minutes)
+export const MAX_RESULT_CHARS = 64 * 1024 // tool result truncation (line-aware; 64K, aligned with main offload limit)
 const MAX_UNFIXED_DISPLAY = 10 // unfixed issues shown in the cap message
 const MAX_KEY_FILES_IN_COMPACTION = 5 // files named in the compaction summary
 
@@ -156,9 +156,13 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
     // Interrupted (Ctrl+I) — stop immediately instead of spinning a fresh uncancellable signal
     if (signal?.aborted) return renderTimeline(timeline, "Advisor: interrupted.")
     
-    // Check review timeout (5 minutes)
-    if (Date.now() - startTime > REVIEW_TIMEOUT_MS) {
-      return renderTimeline(timeline, `Advisor: review timeout after ${Math.round(REVIEW_TIMEOUT_MS / 1000)}s. Partial results may be available. Try again with a narrower scope.`)
+    // Check review timeout (10 minutes by default; agent.advisor.timeoutMs overrides)
+    // 运行时校验（设计评审 #1，2026-08-24）：手写 config.json 的非法值（0/负数/字符串）
+    // 不得静默禁用或立即触发超时——非法一律回退默认。
+    const cfg = agent.config?.advisor?.timeoutMs
+    const timeoutMs = (Number.isFinite(cfg) && cfg > 0) ? cfg : REVIEW_TIMEOUT_MS
+    if (Date.now() - startTime > timeoutMs) {
+      return renderTimeline(timeline, `Advisor: review timeout after ${Math.round(timeoutMs / 1000)}s. Partial results may be available. Try again with a narrower scope.`)
     }
     
     if (++turns > MAX_ADVISOR_TURNS) {

package/src/agent/helpers.mjs

@@ -8,7 +8,7 @@ import { writeFile, mkdir, readdir, stat, unlink } from "node:fs/promises"
 import { join } from "node:path"
 import { execSync } from "node:child_process"
 
-export const DEFAULT_MAX_TURNS = 100
+export const DEFAULT_MAX_TURNS = 200
 export const DEFAULT_SUBAGENT_TURNS = 100
 export const DEFAULT_GOAL_TURNS = 200
 export const MIN_REPORT_CHARS = 200
@@ -20,8 +20,8 @@ export const REPORT_CONTINUATION =
   "3. How you verified (tests run, commands executed, with results)\n" +
   "4. Anything left undone or worth follow-up"
 
-const TOOL_RESULT_OFFLOAD_LIMIT = 16_000
-const TOOL_RESULT_PREVIEW = 2_000
+const TOOL_RESULT_OFFLOAD_LIMIT = 64 * 1024 // 65536 chars — offload only above 64K (2026-08-24)
+const TOOL_RESULT_PREVIEW = 64 * 1024 // chars shown inline when offloaded (aligns with CLI/VS Code webview)
 
 /** Offload-dir write-time self-cleanup retention window (2026-08-21): files older than 3 days are deleted on the next offload. */
 export const TMP_RETENTION_MS = 3 * 24 * 3600 * 1000
@@ -65,7 +65,7 @@ export async function cleanupOldToolResults(dir) {
   }
 }
 
-/** Offload oversized tool results (>16k chars) to disk, returning a preview + file path.
+/** Offload oversized tool results (>64K chars) to disk, returning a preview + file path.
  *  Writes trigger write-time self-cleanup of the offload dir first (dir param overridable for tests). */
 export async function offloadToolResult(text, callId, dir = join(configDir, "tool-results")) {
   if (text.length <= TOOL_RESULT_OFFLOAD_LIMIT) return text

package/src/agent.mjs

@@ -97,12 +97,21 @@ export function createAgent({
     _compressFailures: 0,
     _emptyRetries: 0, // empty-response retry budget (per-run; reset on a fresh user turn)
     _runStartHistoryLen: 0, // machine-line length at the start of the current run — end-of-run exploration distillation slices from here
+    _pendingDistill: null, // in-flight end-of-run exploration distillation (SEND-STALL-DISTILL §2.1) — awaited at next run start / TUI exit flush
     _currentTurn: 0, _maxTurns: 100, // turn counter for status bar display
   }
 }
 
 /** 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.
+  if (agent._pendingDistill) {
+    const p = agent._pendingDistill
+    agent._pendingDistill = null
+    await p
+  }
   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 },
@@ -309,9 +318,13 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       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. Silent (N3):
-        // distillation failure must never block the return or lose history.
-        try { await summarizeRunExplorations(agent, callbacks, signal) } catch { /* silent (N3) */ }
+        // 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(() => {})
+        agent._pendingDistill = distill
       }
       return cr.content
     }

package/src/config.mjs

@@ -39,7 +39,7 @@ export const PROVIDER_PRESETS = {
 export const DEFAULTS = {
   activeModel: null,  // optional: override provider.model (set via /model picker or /model provider:model)
   agent: {
-    maxTurns: 100,
+    maxTurns: 200,
     subagentTurns: 100,
     subagentModel: null,  // default subagent model: "provider:model" | provider name | model name (parent provider); null = inherit parent provider
     subagentModels: {},   // per-type override: { explore, plan, coder, "eng-coder" } — priority: subagent tool model arg > this[role] > subagentModel > parent provider
@@ -52,7 +52,7 @@ export const DEFAULTS = {
     consultTurns: 40,      // per-consultant tool-turn budget (diagnosis tasks)
     consultTimeoutMs: 600000, // wall-clock ceiling per consultant (10min)
     streamRules: [],      // time-traveling stream rules: [{ pattern: "regex", message: "reminder", action: "abort"|"warn", repeat: "always"|"once" }]
-    advisor: { guard: false },  // code review is always available; guard: true pushes completion back until reviewed (opt-in). Also accepts provider/model/thinking/reasoningEffort overrides. Deprecated: enabled (2026-08-21)
+    advisor: { guard: false },  // code review is always available; guard: true pushes completion back until reviewed (opt-in). Also accepts provider/model/thinking/reasoningEffort/timeoutMs overrides. Deprecated: enabled (2026-08-21)
     autoThink: false,     // auto-classify task difficulty and set reasoning effort per-turn
     engineering: false,   // strict methodology enforcement — read METHODOLOGY.md, design-before-code
   },

package/src/context.mjs

@@ -424,8 +424,9 @@ async function distillExplorations(history, start, provider, signal) {
  * End-of-run exploration distillation (runAgent's final return). Shrinks the MACHINE line
  * (agent.history) only; agent._fullHistory is never touched. Triggers when this run added ≥3
  * exploration tool results; on LLM failure it silently keeps the original history (N3).
- * `callbacks` is accepted for call-site parity with the other lifecycle hooks — the distillation
- * is silent by design and never streams (D11).
+ * The distillation itself is silent and never streams (D11); `callbacks.onDistilled` fires
+ * ONLY after the replacement actually lands (never on no-op/failure) — callers persist the
+ * compressed session (SEND-STALL-DISTILL §2.3).
  */
 export async function summarizeRunExplorations(agent, callbacks, signal) {
   const next = await distillExplorations(agent.history, agent._runStartHistoryLen ?? 0, agent.provider, signal)
@@ -435,4 +436,7 @@ export async function summarizeRunExplorations(agent, callbacks, signal) {
   // Invalidate so the next compaction check re-estimates instead of over-counting stale history.
   agent._lastPromptTokens = null
   agent._usageAtLen = null
+  // The compressed machine line must reach the disk: the run's own save already happened,
+  // so without this hook the async distill would leave the session un-compressed on exit.
+  callbacks.onDistilled?.()
 }

package/src/prompts/discipline.md

@@ -25,7 +25,7 @@ Tool routing — use the dedicated tool, not bash:
 - **JavaScript** → `execute` (inline code; or `scriptFile`+`nodeArgs` for `node <file>` / `node --test` / `node --check`). Never `bash node -e`.
 - **File reads/searches** → `read` / `grep` / `ls` / `glob` — never `cat` / `type` / `findstr` / `dir` / shell-grep.
 - **File mutations** → `write` / `edit` / `apply_patch` / `hashline_edit` / `insert_after` / `file_ops` (move/copy/rename) / `delete`.
-- **Process / time / sleep / tree** → the dedicated tools (never `tasklist`/`ps`/`date`/`tree` via bash).
+- **Process / time / tree** → the dedicated tools (never `tasklist`/`ps`/`date`/`tree` via bash); waiting (e.g. `sleep`/`timeout`) is fine via bash when truly needed.
 - Each tool's description carries a "Route to X instead of bash" mapping.
 - **bash IS correct for**: package-manager/CLI subprocesses (`npm`/`vsce`/`ovsx`, git-CLI-only flags the tool lacks), servers, interactive/TTY programs, and one-off shell pipelines no dedicated tool expresses.
 

package/src/prompts/engineering.md

@@ -4,8 +4,12 @@
 
 You are the ARCHITECT. In this mode your deliverables are:
 1. the requirements + design documents (docs/),
-2. the design review (via `advisor` with `type="design"`),
-3. the approved implementation plan handed to an eng-coder.
+2. the approved implementation plan handed to an eng-coder.
+
+You PREPARE and REMIND — you never FIRE. The design review and the start of
+implementation are both initiated by the user, not by you (2026-08-24
+decision: an agent that judges "discussion is done" by itself and fires
+review + development is not engineering mode).
 
 You do NOT write implementation code yourself. Writing or editing code files
 directly violates this workflow — implementation is done by `eng-coder`
@@ -32,30 +36,39 @@ subagents only.
 2. **Design.** Write the design document in `docs/` (problem statement,
    solution approach, full affected-file list, verifiable acceptance criteria).
    Do NOT open any code file for editing before this document exists.
-3. **Design review.** Call `advisor` with `type="design"`, passing
-   `documents=[...]` — the explicit list of doc paths to review (requirements +
-   design + referenced docs; METHODOLOGY.md is read by the advisor itself).
-   This runs a dedicated design review in an isolated context.
-   - If advisor finds issues: fix the design, re-submit.
+3. **Remind readiness — never self-initiate review.** Present the design
+   summary and say it is ready for review, then WAIT. You do NOT call the
+   advisor yourself — the initiation right belongs to the user: you prepare
+   and remind, the user fires.
+4. **User-initiated design review.** Only when the user asks for it, call
+   `advisor` with `type="design"`, passing `documents=[...]` — the explicit
+   list of doc paths to review (requirements + design + referenced docs;
+   METHODOLOGY.md is read by the advisor itself). This runs a dedicated
+   design review in an isolated context.
+   - If advisor finds issues: present the findings AND your proposed fix for
+     each item, and let the user decide item by item — design questions are
+     decided WITH the user, not guessed by you (a fix without user input is
+     at best a formal patch). Amend per their call, then remind them it is
+     ready for re-review. Never fix-and-resubmit on your own.
    - If advisor approves: it returns a design token in plain text in its response.
    - If the advisor keeps rejecting after 3 rounds, STOP and report the open
      issues to the user — do not loop silently.
-4. **User sign-off.** Present the design summary AND the advisor's findings
+5. **User sign-off.** Present the design summary AND the advisor's findings
    (any remaining 🟡 advisories the user should know about) and WAIT for
    explicit approval before any implementation step.
-5. **Implement via eng-coder.** Spawn a subagent with `role="eng-coder"`,
+6. **Implement via eng-coder.** Spawn a subagent with `role="eng-coder"`,
    providing the METHODOLOGY task structure: the **Docs involved** list (design
    doc + requirements + referenced docs), the file list, the acceptance
    criteria. Pass the designToken via the `designToken` PARAMETER — never in
    the task text. The token is required — eng-coder cannot modify files
    without it.
-6. **Delivery review.** After eng-coder returns, verify the delivery against
-   the acceptance criteria from the design (run the tests it claims pass, read
-   the changed files). The eng-coder self-reviewed inside the subagent — its
-   advisor(code) call happens there. Re-review with the `advisor` tool
-   (`type="code"`, `documents=[...]` = the task's Docs involved list) only when
-   the user asks or the delivery looks wrong.
-7. **Verify.** Run `verify` — it must pass before you claim the task complete.
+7. **Delivery review — automatic flow node.** After eng-coder returns, verify
+   the delivery against the acceptance criteria from the design (run the
+   tests it claims pass, read the changed files) AND run the code review with
+   the `advisor` tool (`type="code"`, `documents=[...]` = the task's Docs
+   involved list). This review happens automatically — no user initiation
+   needed (2026-08-24 decision).
+8. **Verify.** Run `verify` — it must pass before you claim the task complete.
 
 ## Work Loop (every user message)
 
@@ -66,10 +79,12 @@ passed?
 | State | Default action |
 |---|---|
 | Requirements exploration | Clarify (who/what/why — never how), explore the current state, then write the REQUIREMENTS doc — three layers per METHODOLOGY: overall goal / functional user stories / non-functional standards (flow step 1) |
-| Design | Write or refine the DESIGN doc (approach + rationale, architecture/interface, affected files, key decisions), organized by business domain per METHODOLOGY, ask for confirmation (flow steps 2-3) |
-| Awaiting approval | Present design summary + advisor findings, WAIT for explicit approval (flow step 4) |
+| Design | Write or refine the DESIGN doc (approach + rationale, architecture/interface, affected files, key decisions), organized by business domain per METHODOLOGY, ask for confirmation (flow steps 1-2) |
+| Design ready | Present the design summary, say it is ready for review, WAIT — do NOT call advisor yourself; the user initiates the design review (flow steps 3-4) |
+| Review fix loop | Present findings + proposed fixes, the user decides item by item, amend per their call, remind for re-review (flow step 4) |
+| Awaiting approval | Present design summary + advisor findings, WAIT for explicit approval (flow step 5) |
 | Implementation | eng-coder is working — do not redesign in parallel |
-| Delivery review | Verify the delivery against the acceptance criteria (the eng-coder self-reviewed inside the subagent); re-review with advisor (type="code", documents = Docs involved) only when the user asks or the delivery looks wrong; report |
+| Delivery review | Verify the delivery against the acceptance criteria AND run advisor (type="code", documents = Docs involved) — automatic flow node, no user initiation (flow step 7); report |
 | Wrapped up | Report, wait for next instruction |
 
 Then handle the message:
@@ -83,13 +98,16 @@ Then handle the message:
   design doc path, file list, acceptance criteria; token via the `designToken`
   parameter, never in the task text.
 - **Question / discussion** → answer; write any decision to the relevant doc.
-- **eng-coder delivery** → verify the acceptance criteria (the eng-coder
-  self-reviewed before delivering); re-review only when the user asks, report.
+- **eng-coder delivery** → verify the acceptance criteria AND run the advisor
+  code review (automatic flow node — never wait for the user to ask); report.
 
 End every turn with three checks: ① decisions written to docs? ② current state
-named and next step stated? ③ what the user must do (approve / clarify / continue)?
-No code edits outside approved minor fixes (typos in docs you own, etc. —
-never implementation code). No unprompted advisor calls.
+named and next step stated? ③ what the user must do (initiate review / approve /
+clarify / continue)?
+No code edits outside approved minor fixes (post-delivery-review minor fixes
+once the design is approved, typos in docs you own, etc. — anything larger
+goes back to eng-coder). Design review ONLY when the user initiates it;
+delivery code review is an automatic flow node.
 
 ## Questioning Style (requirement clarification)
 
@@ -118,10 +136,15 @@ cannot enumerate. When using the `question` tool:
   constraint, or preference during design discussion or review, update the
   relevant docs (design doc, METHODOLOGY.md, ENGINEERING-MODE.md) right away —
   do not wait to be asked. A decision that isn't in a doc didn't land.
-- Advisor is mandatory at both design and code gates — regardless of
-  `/advisor` toggle state. Use `advisor`'s configured model if set; otherwise
-  the main model is used automatically. The key property is independent
-  context — every review runs in a fresh isolated session.
+- Review initiation split: the DESIGN review is called ONLY when the user
+  explicitly asks (e.g. "评审吧") — remind them when the design is ready,
+  never fire it yourself; each round of findings goes back to the user for
+  item-by-item decisions, no self-fix-resubmit loops. The CODE review at
+  eng-coder delivery is an automatic flow node — run it without asking.
+  Both hold regardless of `/advisor` toggle state. Use `advisor`'s configured
+  model if set; otherwise the main model is used automatically. The key
+  property is independent context — every review runs in a fresh isolated
+  session.
 - **Advisor response table.** After each advisor review you run, reply with a
   response table — exact header `| # | Action | Detail |`, one row per issue;
   `#` = the advisor's issue number (`Orig#` on rounds 2+).
@@ -135,9 +158,9 @@ cannot enumerate. When using the `question` tool:
   - A 🔴 you neither fix nor surface blocks convergence. `Deferred` fits 🟡/🔵
     improvements or a 🔴 needing a user decision first — never a way to silently
     drop a real defect; surface any unresolved 🔴 to the user.
-- **Review timing**: do NOT call advisor unprompted or repeatedly. Reviews
-  happen only when: the user explicitly asks, the system pushes back, or a
-  mandatory flow node requires it (the eng-coder self-reviews before delivery —
-  its advisor(code) call happens inside the subagent; you verify the delivery
-  against the acceptance criteria instead of re-reviewing).
+- **Review timing**: design review — ONLY user-initiated (you prepare and
+  remind, the user fires); each round of findings goes back to the user for
+  decisions. Delivery code review — automatic flow node after eng-coder
+  returns, run it without asking. Beyond these, do NOT call advisor
+  unprompted or repeatedly.
   If advisor fails or is interrupted, stop retrying — report to the user.

package/src/tools/index.mjs

@@ -10,7 +10,7 @@ import { checklistTool } from "./checklist.mjs";
 import { lintTool } from "./linter.mjs";
 import { lspTool } from "./lsp.mjs";
 import { executeTool } from "./execute.mjs";
-import { fileOpsTool, processTool, getCurrentTimeTool, sleepTool } from "./ops.mjs";
+import { fileOpsTool, processTool, getCurrentTimeTool } from "./ops.mjs";
 import { treeTool } from "./tree.mjs";
 
 export const builtinTools = [
@@ -19,7 +19,7 @@ export const builtinTools = [
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, executeTool,
-  fileOpsTool, processTool, getCurrentTimeTool, sleepTool,
+  fileOpsTool, processTool, getCurrentTimeTool,
   treeTool,
 ];
 
@@ -29,6 +29,6 @@ export {
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, executeTool,
-  fileOpsTool, processTool, getCurrentTimeTool, sleepTool,
+  fileOpsTool, processTool, getCurrentTimeTool,
   treeTool,
 };

package/src/tools/ops.mjs

@@ -1,6 +1,6 @@
 /**
  * ops.mjs — operational tools: file_ops (move/copy/rename), process (list),
- * get_current_time, sleep. Each exists so the model reaches for a dedicated tool
+ * get_current_time. Each exists so the model reaches for a dedicated tool
  * instead of shelling out to `bash` for the same operation (parity with thinworker).
  */
 import { DESC, resolveInCwd, truncate } from "./shared.mjs"
@@ -111,32 +111,4 @@ export const getCurrentTimeTool = {
     const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
     return `Date: ${now.toISOString()} (UTC)\nTimezone: ${tz}\nWeekday: ${days[now.getDay()]}\nLocal: ${now.toLocaleString()}`
   },
-}
-
-// ─── sleep ─────────────────────────────────────────────────────
-
-export const sleepTool = {
-  name: "sleep",
-  description: DESC("sleep"),
-  parameters: {
-    type: "object",
-    properties: {
-      seconds: { type: "number", description: "Seconds to wait (1-300)" },
-      reason: { type: "string", description: "Why wait (shown to the user)" },
-    },
-    required: ["seconds"],
-  },
-  readonly: true,
-  async execute({ seconds, reason }, ctx) {
-    const raw = Number(seconds)
-    const n = Number.isFinite(raw) ? Math.min(Math.max(Math.round(raw), 1), 300) : 1
-    await new Promise((resolve, reject) => {
-      const t = setTimeout(resolve, n * 1000)
-      if (ctx?.signal) {
-        if (ctx.signal.aborted) { clearTimeout(t); reject(new Error("aborted")) }
-        else ctx.signal.addEventListener("abort", () => { clearTimeout(t); reject(new Error("aborted")) }, { once: true })
-      }
-    })
-    return `Waited ${n}s${reason ? ` (${reason})` : ""}`
-  },
 }

package/src/tui/agent-turn.mjs

@@ -5,6 +5,11 @@ import { ansi, C } from "./ansi.mjs"
 import { formatToolSummary } from "./tool-summaries.mjs"
 import { ADVISOR_THINKING_PLACEHOLDER, resolveAdvisorProvider } from "../advisor/run.mjs"
 
+/** Exit-flush bound for the async end-of-run distillation (SEND-STALL-DISTILL §2.5):
+ *  wait at most this long for the in-flight distill before the final session save —
+ *  never let shutdown hang on the background summary call. */
+const DISTILL_FLUSH_TIMEOUT_MS = 5000
+
 /** Tool execution start timestamps (performance.now ms), keyed by tool name. */
 const _toolTicks = Object.create(null)
 
@@ -325,6 +330,12 @@ export async function runAgentTurn(ctx, text) {
     onCompress: () => {
       pushLine("  [context] Context too long, auto-compacted (early conversation summarized by LLM, task state preserved)", C.warn)
     },
+    // Async distillation landed (SEND-STALL-DISTILL §2.3): the machine line was replaced by
+    // the compressed version — persist it so the session file ends up compressed. Silent:
+    // a save failure must never surface after the turn already returned.
+    onDistilled: () => {
+      try { saveSessionImpl(agent, state.lines) } catch { /* 静默 */ }
+    },
     onUsage: (usage) => {
       state.tokens.prompt += usage.prompt_tokens ?? 0
       state.tokens.completion += usage.completion_tokens ?? 0
@@ -429,6 +440,10 @@ export async function runAgentTurn(ctx, text) {
     state._advisorBlocks = []
     state.controller = null
     state.status = "Ready"
+    // FR1: status bar must recover immediately — the awaits below (title-gen, distill flush,
+    // save) may take seconds and the 1s ticker is already stopped, so render NOW or the bar
+    // keeps showing the stale "Processing..." until the turn function fully unwinds.
+    render()
     // Auto-collapse todo panel when all tasks done (matching kimi-code TUI; agent.tasks are preserved)
     if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
       state.tasks = []
@@ -448,6 +463,17 @@ export async function runAgentTurn(ctx, text) {
         // Title generation failure is non-fatal
       }
     }
+    // Exit flush (SEND-STALL-DISTILL §2.5): the round-end distillation runs async — before
+    // the final save, give it a bounded window to land the compressed history on disk.
+    // The next turn's runAgent would await it anyway; this covers the real exit path
+    // (no next turn). Bounded: never let shutdown wait longer than the timeout.
+    // NOTE: the promise is NOT detached (no `agent._pendingDistill = null` here) — a submit
+    // during this window starts the next runAgentTurn concurrently, and its runAgent start
+    // MUST still see the in-flight distill to await it BEFORE pushing input (N1). If the
+    // flush times out, the next runAgent's start-await takes over — safe by construction.
+    if (agent._pendingDistill) {
+      await Promise.race([agent._pendingDistill, new Promise((r) => setTimeout(r, ctx.distillFlushTimeoutMs ?? DISTILL_FLUSH_TIMEOUT_MS))])
+    }
     // Save session after every turn (survives crashes)
     try {
       saveSessionImpl(agent, state.lines)

package/src/tui/cmd-config.mjs

@@ -234,8 +234,8 @@ export async function handleConfigCommand(ctx, args = []) {
   while (running) {
     const consultCount = (ac.consultModels ?? []).length
     const mainEntries = [
-      { type: "header", text: `proxy=${proxySummary()} | maxTurns=${ac.maxTurns ?? 100} | compactThreshold=${ac.compactThreshold ?? 100000} | verifyGuard=${ac.verifyGuard === true ? "on" : "off"} | consult=${consultCount} model(s) | embedding=${agent.memory?.embedder ? "on" : "off"}` },
-      { type: "item", text: `agent.maxTurns = ${ac.maxTurns ?? 100}`, action: "agent.maxTurns" },
+      { type: "header", text: `proxy=${proxySummary()} | maxTurns=${ac.maxTurns ?? 200} | compactThreshold=${ac.compactThreshold ?? 100000} | verifyGuard=${ac.verifyGuard === true ? "on" : "off"} | consult=${consultCount} model(s) | embedding=${agent.memory?.embedder ? "on" : "off"}` },
+      { type: "item", text: `agent.maxTurns = ${ac.maxTurns ?? 200}`, action: "agent.maxTurns" },
       { type: "item", text: `agent.subagentTurns = ${ac.subagentTurns ?? 100}`, action: "agent.subagentTurns" },
       { type: "item", text: `agent.compactThreshold = ${ac.compactThreshold ?? 100000}${agent.config?.agent?.compactThresholdAuto ? " (auto)" : ""}`, action: "agent.compactThreshold" },
       { type: "item", text: `agent.verifyGuard = ${ac.verifyGuard === true ? "on" : "off"}`, action: "agent.verifyGuard" },
@@ -255,7 +255,7 @@ export async function handleConfigCommand(ctx, args = []) {
       pushLabel("❯ Config", ansi.bold + C.tool)
       pushLine(`Active: ${agent.activeProvider} / ${agent.provider.model}`, C.dim)
       pushLine(`Key:    ${maskKey(agent.provider.apiKey)}`, C.dim)
-      pushLine(`agent.maxTurns: ${ac.maxTurns ?? 100}`, C.dim)
+      pushLine(`agent.maxTurns: ${ac.maxTurns ?? 200}`, C.dim)
       pushLine(`agent.subagentTurns: ${ac.subagentTurns ?? 100}`, C.dim)
       pushLine(`agent.compactThreshold: ${ac.compactThreshold ?? 100000}${agent.config?.agent?.compactThresholdAuto ? " (auto)" : ""}`, C.dim)
       pushLine(`agent.verifyGuard: ${ac.verifyGuard === true ? "on" : "off"}`, C.dim)
@@ -304,7 +304,7 @@ export async function handleConfigCommand(ctx, args = []) {
     // Numeric config items
     const label = choice.action
     const isTimeout = label === "agent.consultTimeoutMs"
-    const current = label === "agent.maxTurns" ? (ac.maxTurns ?? 100)
+    const current = label === "agent.maxTurns" ? (ac.maxTurns ?? 200)
       : label === "agent.subagentTurns" ? (ac.subagentTurns ?? 100)
       : label === "agent.compactThreshold" ? (ac.compactThreshold ?? 100000)
       : label === "agent.consultTurns" ? (ac.consultTurns ?? 40)

package/src/tools/sleep.md

@@ -1,5 +0,0 @@
-Wait a number of seconds before continuing. Use to wait for a web page to load, an async task to finish, or to respect a rate limit — cheaper than repeatedly polling.
-
-Parameters:
-- seconds (required): how many seconds to wait (1-300)
-- reason (optional): why you are waiting (shown to the user)