thincoder 0.12.35 → 0.12.37

package/package.json

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

package/src/advisor/messages.mjs

@@ -185,13 +185,27 @@ export function buildAdvisorUserMessage(agent, prior, reviewType, designToken =
       } catch { /* file doesn't exist — skip */ }
     }
 
+    // Document map (docs/design/README.md) — inject when the discovered
+    // project root has one: the reviewer checks document ownership against it
+    // (a change for an existing section must amend that section's document,
+    // not spawn a new file for it). Absent map → skip (nothing to check against).
+    try {
+      const mapPath = resolve(guideRoot ?? agent.cwd, "docs", "design", "README.md")
+      if (existsSync(mapPath)) {
+        parts.push("## Document Map")
+        parts.push("The document map below registers which document files exist per section. Use it for the Document ownership criterion: a change for an existing section must amend that section's document, not create a new file.")
+        parts.push(readFileSync(mapPath, "utf8"))
+        parts.push("")
+      }
+    } catch { /* file doesn't exist or is unreadable — skip */ }
+
     parts.push("## Instructions")
     if (docList.length > 0) {
       parts.push("1. Read every document in the Documents to Review list in full — review ONLY those files. Read METHODOLOGY.md to understand the project's standards.")
     } else {
       parts.push("1. Read the design document fully. Read METHODOLOGY.md to understand the project's standards.")
     }
-    parts.push("2. Review against: completeness (all requirements covered?), feasibility (can this be built?), clarity (specific enough?), acceptance criteria (verifiable?), scope (appropriate?).")
+    parts.push("2. Review against: completeness (all requirements covered?), feasibility (can this be built?), methodology compliance (does it follow the project's METHODOLOGY.md?), clarity (specific enough?), acceptance criteria (verifiable?), scope (appropriate?).")
     parts.push("3. If the ## Project Guide (AGENTS.md) section above is present, also check requirement fit: does the design match what the requirements documents it points to actually ask for?")
     parts.push("4. Do NOT run git diff or look for code changes — there are none at this stage.")
     parts.push("5. If you find issues, produce your review table with the format: | # | Category | Severity | Issue | Suggestion |. If the design passes, no table is needed.")

package/src/advisor.mjs

@@ -47,6 +47,7 @@ import { fileURLToPath } from "node:url"
 import { extractAgentResponseTable } from "./advisor/history.mjs"
 import { buildAdvisorUserMessage, resolveScopeFiles } from "./advisor/messages.mjs"
 import { buildConvergenceBody } from "./advisor/convergence.mjs"
+import { escapeLiteralEscapes } from "./escape.mjs"
 // Re-export for run.mjs and tests (keeps their imports from "../advisor.mjs" stable)
 export { ADVISOR_MD_PATH, extractAgentResponseTable, extractConversationBackground } from "./advisor/history.mjs"
 export { buildAdvisorUserMessage } from "./advisor/messages.mjs"
@@ -72,14 +73,11 @@ const ADVISOR_ROUND1 = loadPrompt("advisor-round1.md", "advisor-round1.md")
 // buildAdvisorSystemPrompt when _advisorRound > 0.
 const ADVISOR_ROUND2 = loadPrompt("advisor-round2.md", "advisor-round2.md")
 const ADVISOR_ROUND3 = loadPrompt("advisor-round3.md", "advisor-round3.md")
-// Fallback when advisor-design.md is missing — keep in sync with the real
-// file (table format + workflow steps).
-const ADVISOR_DESIGN_FALLBACK = `You are an independent design reviewer for an engineering-mode project. Review the design document in the changes below. Evaluate: completeness, feasibility, clarity, scope, acceptance criteria. Read METHODOLOGY.md if provided. Produce a review table with | # | Category | Severity | Issue | Suggestion | format.`
-let ADVISOR_DESIGN = ""
-// Design review is OPTIONAL (engineering mode only) — silent fallback to the
-// in-code constant is intentional, unlike the mandatory round prompts which
-// must exist for every review (loadPrompt throws a descriptive error there).
-try { ADVISOR_DESIGN = readFileSync(join(__dirname, "prompts", "advisor-design.md"), "utf8") } catch { /* fallback below */ }
+// Design-review prompt — hard-loaded like the round prompts (decision
+// 2026-08-21): a missing file means a broken installation, and silently
+// degrading to a lesser in-code prompt would quietly strip the approval-signal
+// and citation rules, disabling design approval entirely. loadPrompt throws.
+const ADVISOR_DESIGN = loadPrompt("advisor-design.md", "advisor-design.md")
 
 // ────────────────────────────────────────
 // System prompt building
@@ -109,7 +107,7 @@ export function buildAdvisorSystemPrompt(agent, prior, reviewType) {
   // approval token); rounds 2+ converge like code reviews (verify agent fix claims).
   if (reviewType === "design") {
     if (!hasPrior) {
-      return ADVISOR_DESIGN || ADVISOR_DESIGN_FALLBACK
+      return ADVISOR_DESIGN
     }
     const round = (agent._advisorRound || 0) + 1
     if (round === 2) return ADVISOR_ROUND2
@@ -174,28 +172,9 @@ export function buildAdvisorFollowUp(agent, prior, scopeFiles = null) {
  * messages.mjs so the legacy path shares it (see there).
  */
 
-/**
- * Neutralize literal backslash escape sequences ("\x", "\u") that some
- * OpenAI-compatible servers interpret inside message content ("unexpected end
- * of hex escape" → 400 — observed 2026-08-06 when the conversation background
- * quoted "\x" literals). Only sequences that would be INVALID when expanded
- * are doubled ("\\x" → literal "\x" after server expansion); well-formed
- * "\xNN" / "\uNNNN" pass through untouched (they expand to a byte/codepoint).
- */
-export function escapeLiteralEscapes(text) {
-  // (?<!\\) — only a SINGLE backslash counts ("\\x" already doubles the
-  // escape and must pass through untouched); lookbehind is fine on Node 24.
-  // Known limitation (documented, accepted): an ODD backslash run of 3+ (e.g.
-  // "\\\x") leaves the trailing "\x" un-doubled — vanishingly rare in real
-  // conversation text, and the sequence is still valid JSON either way.
-  // The lookahead treats "\x" followed by AT LEAST 2 hex as valid (servers
-  // expand only the first two: "\x1b3" → ESC + "3"); only truncated runs
-  // ("\x" + <2 hex) are doubled.
-  text = String(text ?? "")
-  return text
-    .replace(/(?<!\\)\\(x)(?![0-9a-fA-F]{2})/g, "\\\\$1")
-    .replace(/(?<!\\)\\(u)(?![0-9a-fA-F]{4})/g, "\\\\$1")
-}
+// escapeLiteralEscapes 已抽到 ./escape.mjs（advisor 与主 agent 发送路径共用），
+// 这里 re-export 保持既有 import 稳定。
+export { escapeLiteralEscapes }
 
 
 /**

package/src/config.mjs

@@ -36,7 +36,7 @@ export const PROVIDER_PRESETS = {
   groq:     { baseURL: "https://api.groq.com/openai/v1", model: "llama-3.3-70b-versatile", maxTokens: 32768, desc: "Groq" },
 }
 
-const DEFAULTS = {
+export const DEFAULTS = {
   activeModel: null,  // optional: override provider.model (set via /model picker or /model provider:model)
   agent: {
     maxTurns: 100,

package/src/context.mjs

@@ -214,7 +214,7 @@ export async function compressIfNeeded(agent, threshold, callbacks, extras = {},
   const middle = history.slice(split.headEnd, split.tailStart)
   const serialized = middle
     .map((m) => {
-      const toolNote = m.tool_calls ? ` [called tools: ${m.tool_calls.map((t) => t.function.name).join(", ")}]` : ""
+      const toolNote = m.tool_calls ? ` [called tools: ${m.tool_calls.map((t) => t.function?.name).join(", ")}]` : ""
       // user messages get a wider cap (8000): cutting off a long user-pasted requirement loses original intent; tool/assistant capped at 2000 is enough
       const cap = m.role === "user" ? 8000 : 2000
       // Multimodal messages (array content): extract the TEXT parts — the image itself can't be

package/src/escape.mjs

@@ -0,0 +1,49 @@
+/**
+ * escape.mjs — 中和 OpenAI 兼容服务端在 message content 内做的非标二次转义解析。
+ *
+ * 某些服务端（Kimi 等）会把 content 里的字面 "\x" / "\u" 当作 hex escape 再解释一遍，
+ * 遇到 "\x" 后不足 2 个 hex（或 "\u" 后不足 4 个 hex）时服务端报
+ * "unexpected end of hex escape" → 400（首次观察于 2026-08-06，见 advisor.mjs 历史）。
+ *
+ * 对策：把这类"一旦被服务端二次展开就会非法"的字面序列提前 double 成 "\\x" / "\\u"，
+ * 服务端二次解析后还原为字面量；合法完整的 "\xNN" / "\uNNNN" 原样放过（它们能展开成
+ * 一个字节/码点）。JSON.stringify 层面的反斜杠转义由发送方负责，本模块不碰。
+ */
+
+/** 中和单段文本里的非法字面转义序列。 */
+export function escapeLiteralEscapes(text) {
+  text = String(text ?? "")
+  return text
+    // (?<!\\) — 只有单个反斜杠才处理（"\\x" 已经是 double 的，必须原样放过）
+    // 前瞻：\x 后至少 2 个 hex 视为合法（服务端只展开前两个），只有不足 2 个的才 double
+    .replace(/(?<!\\)\\(x)(?![0-9a-fA-F]{2})/g, "\\\\$1")
+    .replace(/(?<!\\)\\(u)(?![0-9a-fA-F]{4})/g, "\\\\$1")
+}
+
+/** 对单条消息的 content 应用 escapeLiteralEscapes（支持字符串或 OpenAI 多模态 part 数组）。 */
+export function escapeMessageContent(message) {
+  const content = message?.content
+  if (typeof content === "string") {
+    return { ...message, content: escapeLiteralEscapes(content) }
+  }
+  if (Array.isArray(content)) {
+    let changed = false
+    const parts = content.map((p) => {
+      if (p && typeof p === "object" && p.type === "text" && typeof p.text === "string") {
+        const escaped = escapeLiteralEscapes(p.text)
+        if (escaped !== p.text) {
+          changed = true
+          return { ...p, text: escaped }
+        }
+      }
+      return p
+    })
+    return changed ? { ...message, content: parts } : message
+  }
+  return message
+}
+
+/** 对整个 messages 数组逐条应用 escapeMessageContent。 */
+export function escapeMessages(messages) {
+  return messages.map(escapeMessageContent)
+}

package/src/generate-title.mjs

@@ -2,8 +2,13 @@
  * generate-title.mjs — LLM-generated session titles (CLI side)
  * Called after the first user message to auto-title the session.
  * Mirrors thincoder-vscode/src/extension/generate-title.mjs but uses the CLI provider shape.
+ *
+ * CLI is OpenAI-compatible ONLY: a single direct fetch (no anthropic/google format dispatch) —
+ * see docs/design/SESSION.md §IK9UZ8-D.
  */
 
+const MAX_TITLE_TOKENS = 100
+
 /** Generate a session title from the first user message using an LLM. Returns title string or null. */
 export async function generateTitle(userContent, provider) {
   // Extract text even from multimodal content (array of parts)
@@ -20,7 +25,12 @@ export async function generateTitle(userContent, provider) {
         { role: "system", content: "Generate a concise title (max 40 chars, no quotes) for this conversation. Reply ONLY with the title." },
         { role: "user", content: userText.slice(0, 200) },
       ],
-      max_tokens: 30,
+      // Disable thinking so reasoning_content doesn't consume the whole output budget and
+      // leave content empty (IK9UZ8). Providers that don't accept the field ignore it
+      // (OpenAI-compatible convention). A 40-char title wants ~60–80 tokens, so 100 is
+      // ~2.5x headroom (design decision — docs/design/SESSION.md §IK9UZ8-D).
+      thinking: { type: "disabled" },
+      max_tokens: MAX_TITLE_TOKENS,
       stream: false,
     })
     const chatPath = provider.chatPath ?? "/chat/completions"
@@ -41,4 +51,4 @@ export async function generateTitle(userContent, provider) {
   } catch {
     return null
   }
-}
+}

package/src/prompts/advisor-design.md

@@ -12,6 +12,7 @@ Evaluate the design against these dimensions:
 4. **Clarity** — Is the design specific enough to implement? Are the affected files identified?
 5. **Acceptance criteria** — Are they verifiable? Do they cover normal paths, edge cases, and error conditions?
 6. **Scope** — Is the scope appropriate? Are there opportunities to simplify? Is there scope creep?
+7. **Document ownership** — Does the change amend the design document that already owns its topic (per the document map in `docs/design/README.md`), or does it fragment by creating a new file for an existing section? Does the wording duplicate or contradict existing documents?
 
 ## Output Format
 
@@ -27,6 +28,14 @@ Severity levels:
 - 🟡 Advisory — design could be improved; NOT a blocker for approval
 - 🔵 Note — optional observation; NOT a blocker
 
+Document ownership severity:
+- Wording that CONTRADICTS an existing document (same mechanism described differently in two places) → 🔴
+- Creating a new file for an existing section, or duplicating a description that already exists elsewhere → 🟡
+
+## Citation Discipline
+
+When you cite design-document text, use the exact `file:line` format (e.g. `docs/design/AGENT-LOOP.md:180`) — host-side verification will check the citation against the current disk state. If you have not read/verified the cited content, mark it `unverified` instead of presenting it as fact.
+
 ## Approval Signal
 
 The user message contains an exact token in an `## Approval Signal` section (format `[DESIGN-TOKEN:...]`).

package/src/prompts/discipline.md

@@ -17,4 +17,11 @@ UI & interface design:
 - Free-text is correct ONLY when the input is genuinely open-ended (a name, a path, a message).
 
 Review discipline (standard mode only — engineering mode has its own review timing rules):
-- **Advisor:** call after changing code. Must provide scope: `paths` (files/dirs to review) or `documents` (context). Response table: `| # | Action | Detail |`. Round 2 verifies the prior issue table + flags obvious new issues; round 3+ strictly verifies only the prior issue table (no new-issue hunting). Max 5 rounds total.
+- **Advisor:** call after changing code. Must provide scope: `paths` (files/dirs to review) or `documents` (context).
+- **After each advisor review, reply with a response table** — exact header `| # | Action | Detail |` (the runtime extracts this header; keep it verbatim). One row per issue; `#` = the advisor's issue number (`Orig#` on rounds 2+).
+  - `Action` is one of exactly three values: `Fixed` (you edited the code), `Not an issue` (technical rebuttal with evidence), `Deferred` (admitted, not fixed now — with a reason).
+  - `Detail` = what changed and where (file:line), or your evidence/reason.
+- **No "pre-existing" cop-out.** You own the whole code. "It was already broken" / "I didn't introduce it" is never a reason to skip a fix — when a defect appeared does not decide whether it should be fixed, and earlier agent turns created it. Rebut only on technical grounds, otherwise fix it.
+- **Do not bury 🔴.** A 🔴 you neither fix nor rebut 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.
+- Round 2 verifies the prior table + flags obvious new issues; round 3+ strictly verifies only the prior table (no new-issue hunting). Max 5 rounds total.
+- When the advisor reports all clear (no 🔴 remaining), run `verify`.

package/src/prompts/engineering.md

@@ -122,6 +122,19 @@ cannot enumerate. When using the `question` tool:
   `/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+).
+  - `Action` is one of exactly three values: `Fixed` (you edited the code), `Not an issue` (technical rebuttal with evidence), `Deferred` (admitted, not fixed now — with a reason).
+  - `Detail` = what changed and where (file:line), or your evidence/reason.
+  - No "pre-existing" cop-out: "it was already broken" is never a reason to drop
+    a finding — you own the whole design/code, and when a defect appeared does
+    not decide whether it should be fixed. If a finding is outside the approved
+    design's scope, surface it or propose a design update — do not silently
+    ignore it.
+  - 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 —

package/src/prompts/system.md

@@ -8,10 +8,12 @@ Programming is collaborative labor between you and the human. The human decides
 
 **How you work — before you write any code:**
 - **Read design docs first.** Use `doc_search` to find relevant design docs, AGENTS.md, and architecture decisions. Code without design context is guesswork. If docs conflict with code, docs are right. If the user's instruction conflicts with the docs, tell the user first — discuss, update the docs, then code.
+- **Document ownership — find the doc that owns the topic before writing.** Before writing to `docs/design/`, check the `docs/design/README.md` document map (no map → check AGENTS.md and the docs directory) to locate the document that owns the topic — if it exists, update it; never create a new file for an existing section. Create a new file only when no section owns the topic, and register it in the map. Describe each mechanism in detail in exactly ONE place (the authoritative source); other documents reference it, never copy it.
 - **Check existing code.** Search for existing functions, helpers, patterns before writing new ones. Duplicates are technical debt.
 - **Understand intent.** Ask why this change is needed — the "why" reveals scope the literal request hides.
 - **Confirm understanding.** State what you believe the user asked for and what you plan to deliver, including the most important acceptance criteria. Wait for confirmation. No task is too small — a wrong assumption always costs more than the round-trip. Once confirmed, deliver exactly what was agreed — no simplifying, no substituting, no taking shortcuts after the fact. Simplifying a confirmed requirement frustrates the user and wastes time; they will just tell you to do it right anyway.
-- **Confirm before any file-writing action — no exemptions.** Before ANY file-writing action (write / edit / apply_patch / insert_after / delete / hashline_edit, or any bash that writes files), restate in plain text your understanding of the task plus the key points of your plan, and WAIT for the user's explicit confirmation (an "OK / 可以 / continue"-type reply) before executing. No confirmation, silence, or the user answering with a new question or a new requirement → do not touch anything, no matter how small or obvious the change seems. Even after rounds of clarification, when you are completely sure you understand, you must still write the plan out and wait — "this is obvious enough to skip asking" is never a valid reason to skip, and a new question from the user is not a confirmation; it means the understanding has changed.
+- **Confirm before any file-writing action.** Before ANY file-writing action (write / edit / apply_patch / insert_after / delete / hashline_edit, or any bash that writes files), restate in plain text your understanding of the task plus the key points of your plan, and WAIT for the user's explicit confirmation (an "OK / 可以 / continue"-type reply) before executing. For the changes you propose, there are no exemptions: no confirmation, silence, or the user answering with a new question or a new requirement → do not touch anything, no matter how small or obvious the change seems. Even after rounds of clarification, when you are completely sure you understand, you must still write the plan out and wait — "this is obvious enough to skip asking" is never a valid reason to skip, and a new question from the user is not a confirmation; it means the understanding has changed.
+  - **Doc/code consistency outranks this gate (the one carve-out).** The gate above governs the changes you PROPOSE for the task — a new deliverable, a change of scope or approach. It does NOT govern standing obligations you already owe: (a) updating the document that already owns the topic (per the document map) so it stays consistent with code/logic the user already confirmed; (b) recording a decision the user just made ("Discussion → docs"); (c) closing an advisor-flagged doc-code gap. These complete the SAME confirmed task — do them in the same turn, without re-asking.
 - **Re-confirm when the requirement changes.** If what was confirmed is later changed by a new requirement in the conversation, restate your understanding and plan and wait for fresh confirmation before touching files.
 
 **How you work — while coding:**

package/src/provider/core.mjs

@@ -6,6 +6,7 @@
 
 import { specForModel } from "../config.mjs"
 import { proxyFetch } from "../proxy.mjs"
+import { escapeMessages } from "../escape.mjs"
 import { readSSE } from "./sse.mjs"
 export { readSSE } from "./sse.mjs"
 import {
@@ -68,6 +69,10 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
   }
 
   messages = normalizeToolPairing(messages)
+  // 中和服务端的非标二次转义：会话里若出现字面 "\x"/"\u"（如讨论转义、grep 到含
+  // 转义的代码），Kimi 等会把它们当 hex escape 再解析 → "unexpected end of hex escape" 400。
+  // 发送前统一 double 掉会形成非法转义的序列（合法 \xNN/\uNNNN 不受影响）。
+  messages = escapeMessages(messages)
   // Compile string-pattern rules to RegExp at call time
   const rules = compileStreamRules(streamRules)
   const body = {

package/src/provider/sse.mjs

@@ -19,6 +19,56 @@ export function normalizeUsageCache(u) {
   }
   return u
 }
+/** Defensive tool-call merge (PROVIDER.md §10): skip null/malformed elements and count them;
+ *  merge slots by index / id / name / tail, accumulate arguments. */
+function mergeToolCalls(result, delta) {
+  for (const tc of delta.tool_calls ?? []) {
+    if (!tc || typeof tc !== "object") { result.droppedToolCalls++; continue }
+    let slot
+    if (Number.isInteger(tc.index) && tc.index >= 0) {
+      slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
+    } else if (tc.id) {
+      slot = result.toolCalls.find((s) => s && s.id === tc.id)
+      if (!slot) { slot = { id: tc.id, name: "", arguments: "" }; result.toolCalls.push(slot) }
+    } else if (tc.function?.name) {
+      slot = { id: "", name: "", arguments: "" }
+      result.toolCalls.push(slot)
+    } else {
+      slot = result.toolCalls[result.toolCalls.length - 1]
+      if (!slot) { result.droppedToolCalls++; continue }
+    }
+    if (tc.id && !slot.id) slot.id = tc.id
+    if (tc.function?.name && !slot.name) slot.name = tc.function.name
+    const arg = tc.function?.arguments
+    if (typeof arg === "string") slot.arguments += arg
+    else if (arg != null) slot.arguments += JSON.stringify(arg)
+  }
+}
+
+/** Finalize tool calls (PROVIDER.md §10): drop nameless slots, synthesize missing ids,
+ *  count drops, and surface a machine-line warning via the existing `_warnings` channel. */
+function finalizeToolCalls(result) {
+  const entries = result.toolCalls.filter((tc) => tc) // drop sparse holes (rule-1 index jumps)
+  const kept = entries.filter((tc) => tc.name) // drop nameless slots
+  result.droppedToolCalls = (result.droppedToolCalls ?? 0) + (entries.length - kept.length)
+  result.toolCalls = kept
+  const used = new Set(kept.map((tc) => tc.id).filter(Boolean))
+  let seq = 0
+  for (const tc of kept) {
+    if (!tc.id) {
+      let id
+      do { id = `call_${seq++}` } while (used.has(id))
+      tc.id = id
+      used.add(id)
+    }
+  }
+  if (result.droppedToolCalls > 0) {
+    const existing = (result._warnings ??= [])
+    if (!existing.some((w) => w.name === "malformed-tool-calls")) {
+      existing.push({ name: "malformed-tool-calls", message: `${result.droppedToolCalls} malformed tool_calls dropped from provider response` })
+    }
+  }
+}
 
 export async function readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns: sharedFired }) {
   // Early intercept: non-SSE responses — either error bodies (HTTP >= 400) or
@@ -46,19 +96,15 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
       const parsed = JSON.parse(body)
       const choice = parsed.choices?.[0]
       if (choice) {
-        const result = { content: "", reasoning: "", toolCalls: [], usage: normalizeUsageCache(parsed.usage ?? null), finishReason: null }
+        const result = { content: "", reasoning: "", toolCalls: [], droppedToolCalls: 0, usage: normalizeUsageCache(parsed.usage ?? null), finishReason: null }
         const delta = choice.delta ?? {}
         result.content = delta.content ?? ""
         result.reasoning = delta.reasoning_content ?? ""
         result.finishReason = choice.finish_reason ?? null
-        for (const tc of delta.tool_calls ?? []) {
-          const slot = (result.toolCalls[tc.index ?? result.toolCalls.length] ??= { id: "", name: "", arguments: "" })
-          if (tc.id) slot.id = tc.id
-          if (tc.function?.name && !slot.name) slot.name = tc.function.name
-          if (tc.function?.arguments) slot.arguments += tc.function.arguments
-        }
+        mergeToolCalls(result, delta)
         if (result.content) onToken?.(result.content)
         if (result.reasoning) onReasoning?.(result.reasoning)
+        finalizeToolCalls(result)
         return result
       }
     } catch { /* not parseable JSON */ }
@@ -66,7 +112,7 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
     throw new Error(`API error: HTTP ${response.status} — unexpected non-SSE response: ${body.slice(0, 200)}`)
   }
 
-  const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
+  const result = { content: "", reasoning: "", toolCalls: [], droppedToolCalls: 0, usage: null, finishReason: null }
   const decoder = new TextDecoder()
   let buffer = ""
   let hasChoices = false
@@ -96,12 +142,7 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
         result.content += delta.content
         onToken?.(delta.content)
       }
-      for (const tc of delta.tool_calls ?? []) {
-        const slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
-        if (tc.id) slot.id = tc.id
-        if (tc.function?.name && !slot.name) slot.name = tc.function.name
-        if (tc.function?.arguments) slot.arguments += tc.function.arguments
-      }
+      mergeToolCalls(result, delta)
     }
   }
 
@@ -165,5 +206,6 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
     throw new Error(`API error: ${errorMsg}`)
   }
 
+  finalizeToolCalls(result)
   return result
 }

package/src/session-migrate.mjs

@@ -0,0 +1,42 @@
+/**
+ * session-migrate.mjs — one-time migration of legacy short-hash session files to the
+ * full 40-char sha1 hash. Extracted from session.mjs (file-size split).
+ */
+import { createHash } from "node:crypto"
+import { renameSync, existsSync } from "node:fs"
+import { join } from "node:path"
+import { configDir } from "./config.mjs"
+
+/** One-time migration: rename legacy short-hash session files to the full 40-char hash.
+ *  Idempotent; runs on first access per cwd.
+ *  Historical hash algorithms (all sha1, none normalized the drive letter):
+ *    - CLI:      sha1(cwd).slice(0, 12)      — cwd comes from process.cwd() (uppercase drive on Windows)
+ *    - VS Code:  sha1(cwd).slice(0, 16)      — cwd comes from uri.fsPath (LOWERCASE drive on Windows)
+ *  Plus the previous migration attempt's assumption (normalized 12 = first 12 of the full hash).
+ *  Every combination is tried — a migration that only checks one candidate misses real
+ *  legacy files (drive-letter case differs between CLI and VS Code historical paths). */
+export function migrateHashLength(cwd, fullHash) {
+  const dir = join(configDir, "sessions")
+  const lower = cwd.replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + ":")
+  const candidates = [
+    createHash("sha1").update(cwd).digest("hex").slice(0, 12),
+    createHash("sha1").update(cwd).digest("hex").slice(0, 16),
+    createHash("sha1").update(lower).digest("hex").slice(0, 12),
+    createHash("sha1").update(lower).digest("hex").slice(0, 16),
+    fullHash.slice(0, 12),
+  ]
+  const newBase = join(dir, `${fullHash}.json`)
+  let migrated = false
+  for (const short of new Set(candidates)) {
+    const legacyBase = join(dir, `${short}.json`)
+    if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) continue
+    migrated = true
+    try {
+      for (const suffix of ["", ".manifest", ...Array.from({ length: 64 }, (_, i) => `.${i + 1}`)]) {
+        const from = legacyBase + suffix
+        if (existsSync(from) && !existsSync(newBase + suffix)) renameSync(from, newBase + suffix)
+      }
+    } catch { /* best-effort; leave files in place on failure */ }
+  }
+  return migrated
+}

package/src/session.mjs

@@ -13,6 +13,7 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, existsS
 import { join, dirname } from "node:path"
 import { execSync } from "node:child_process"
 import { configDir } from "./config.mjs"
+import { migrateHashLength } from "./session-migrate.mjs"
 
 let currentSessionId = null
 
@@ -35,40 +36,6 @@ function cwdHash(cwd) {
   return createHash("sha1").update(normalizeCwd(cwd)).digest("hex")
 }
 
-/** One-time migration: rename legacy short-hash session files to the full 40-char hash.
- *  Idempotent; runs on first access per cwd.
- *  Historical hash algorithms (all sha1, none normalized the drive letter):
- *    - CLI:      sha1(cwd).slice(0, 12)      — cwd comes from process.cwd() (uppercase drive on Windows)
- *    - VS Code:  sha1(cwd).slice(0, 16)      — cwd comes from uri.fsPath (LOWERCASE drive on Windows)
- *  Plus the previous migration attempt's assumption (normalized 12 = first 12 of the full hash).
- *  Every combination is tried — a migration that only checks one candidate misses real
- *  legacy files (drive-letter case differs between CLI and VS Code historical paths). */
-function migrateHashLength(cwd, fullHash) {
-  const dir = join(configDir, "sessions")
-  const lower = cwd.replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + ":")
-  const candidates = [
-    createHash("sha1").update(cwd).digest("hex").slice(0, 12),
-    createHash("sha1").update(cwd).digest("hex").slice(0, 16),
-    createHash("sha1").update(lower).digest("hex").slice(0, 12),
-    createHash("sha1").update(lower).digest("hex").slice(0, 16),
-    fullHash.slice(0, 12),
-  ]
-  const newBase = join(dir, `${fullHash}.json`)
-  let migrated = false
-  for (const short of new Set(candidates)) {
-    const legacyBase = join(dir, `${short}.json`)
-    if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) continue
-    migrated = true
-    try {
-      for (const suffix of ["", ".manifest", ...Array.from({ length: 64 }, (_, i) => `.${i + 1}`)]) {
-        const from = legacyBase + suffix
-        if (existsSync(from) && !existsSync(newBase + suffix)) renameSync(from, newBase + suffix)
-      }
-    } catch { /* best-effort; leave files in place on failure */ }
-  }
-  return migrated
-}
-
 /** Derive base session path from cwd hash. Migrates legacy short-hash files on first access. */
 export function sessionPath(cwd) {
   const hash = cwdHash(cwd)
@@ -149,10 +116,6 @@ function saveManifest(cwd, m) {
   writeSessionFile(manifestPath(cwd), m)
 }
 
-/**
- * Ensure an active slot exists in the manifest, migrating legacy data if needed.
- * Called by activeSlot() — idempotent, safe to call repeatedly.
- */
 /**
  * Claim a slot for this process and set it as active. Idempotent.
  * Preference order:

package/src/tui/clipboard.mjs

@@ -1,5 +1,12 @@
 import { C } from "./ansi.mjs"
 
+/** Windows clipboard-read command: force UTF-8 console output so Get-Clipboard's bytes
+ *  are decoded by Node's default UTF-8 (not the OEM codepage / GBK) — IK9UWM. Exported
+ *  for unit tests (TUI.md §9.2D). */
+export function buildWindowsClipboardCommand() {
+  return ["-NoProfile", "-Command", "[Console]::OutputEncoding=[Text.Encoding]::UTF8; Get-Clipboard"]
+}
+
 /** Read text from system clipboard. Returns empty string on failure. */
 export async function readClipboardText() {
   try {
@@ -7,7 +14,9 @@ export async function readClipboardText() {
     const isWin = process.platform === "win32"
     const isMac = process.platform === "darwin"
     if (isWin) {
-      return await new Promise((resolve) => execFile("powershell", ["-NoProfile", "-Command", "Get-Clipboard"], { timeout: 5000 }, (err, stdout) => resolve(err ? "" : stdout)))
+      // Strip a leading \uFEFF — PowerShell may prepend a UTF-8 BOM once OutputEncoding
+      // flips to UTF-8 (TUI.md §9.2D BOM defense).
+      return await new Promise((resolve) => execFile("powershell", buildWindowsClipboardCommand(), { timeout: 5000 }, (err, stdout) => resolve(err ? "" : String(stdout).replace(/^\uFEFF/, ""))))
     } else if (isMac) {
       return await new Promise((resolve) => execFile("pbpaste", [], { timeout: 5000 }, (err, stdout) => resolve(err ? "" : stdout)))
     } else {
@@ -18,6 +27,49 @@ export async function readClipboardText() {
   }
 }
 
+/** Write text to the system clipboard. Returns true on success, false on failure. */
+export async function writeClipboardText(text) {
+  if (typeof text !== "string" || text.length === 0) return false
+  try {
+    const { spawn } = await import("node:child_process")
+    const isWin = process.platform === "win32"
+    const isMac = process.platform === "darwin"
+
+    if (isWin) {
+      // -EncodedCommand is base64 UTF-16LE: PowerShell decodes the command (embedded text
+      // included) directly from UTF-16, so no console codepage (e.g. GBK) can garble
+      // non-ASCII characters — the same class of bug as the read path (IK9UWM).
+      const psCmd = `Set-Clipboard -Value '${text.replace(/'/g, "''")}'`
+      const encoded = Buffer.from(psCmd, "utf16le").toString("base64")
+      await spawnWait(spawn, "powershell", ["-NoProfile", "-EncodedCommand", encoded], null)
+      return true
+    }
+    if (isMac) {
+      await spawnWait(spawn, "pbcopy", [], text)
+      return true
+    }
+    // Linux: prefer wl-copy (Wayland), fall back to xclip (X11).
+    await spawnWait(spawn, "sh", ["-c", "command -v wl-copy >/dev/null 2>&1 && wl-copy || xclip -selection clipboard"], text)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Spawn a process and wait for clean exit. When stdinText is provided it is piped to
+ *  the child as UTF-8 (used by pbcopy / xclip / wl-copy); otherwise stdio is ignored. */
+function spawnWait(spawn, cmd, args, stdinText) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: stdinText == null ? "ignore" : ["pipe", "ignore", "ignore"] })
+    child.once("error", reject)
+    child.once("close", (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`))))
+    if (stdinText != null) {
+      child.stdin.on("error", () => {}) // swallow EPIPE when the tool exits without draining
+      child.stdin.end(stdinText, "utf8")
+    }
+  })
+}
+
 /** Insert pasted text into the active text target.
  *  Free-text question active → append to its answer (single-line field: newlines stripped).
  *  Options question active → ignore (no text field; must not leak into the input box).

package/src/tui/cmd-advisor.mjs

@@ -29,7 +29,7 @@ export async function handleAdvisorCommand(ctx) {
       : cfg.thinking?.type === "disabled" ? "off"
       : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
       : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
-    return `Advisor: always available | Model: ${curModel} | Think: ${thinkInfo}`
+    return `Advisor | Model: ${curModel} | Think: ${thinkInfo}`
   }
 
   function headerLine() {
@@ -115,7 +115,7 @@ export async function handleAdvisorCommand(ctx) {
       { type: "header", text: headerLine() },
       { type: "item", text: `Model: ${curModel}`, action: "model", note: `Provider: ${curProvider}` },
       { type: "item", text: `Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, action: "thinking" },
-      { type: "item", text: `Guard: ${guardInfo}`, action: "guard" },
+      { type: "item", text: `Advisor: ${guardInfo}`, action: "guard" },
       { type: "item", text: "View full config", action: "view" },
     ]
 
@@ -125,9 +125,8 @@ export async function handleAdvisorCommand(ctx) {
 
     if (choice.action === "view") {
       pushLabel("❯ Advisor", ansi.bold + C.tool)
-      pushLine(`Status:   always available`, C.dim)
       pushLine(`Model:    ${curModel} (provider: ${curProvider})`, C.dim)
-      pushLine(`Guard:    ${guardInfo}`, C.dim)
+      pushLine(`Advisor:    ${guardInfo}`, C.dim)
       pushLine(`Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, C.dim)
       continue
     }
@@ -136,7 +135,7 @@ export async function handleAdvisorCommand(ctx) {
       cfg.guard = !(cfg.guard === true)
       await persist().catch(err => pushLine(`[error] ${err.message}`, C.error))
       pushLabel("❯ Advisor", ansi.bold + C.tool)
-      pushLine(`Guard: ${cfg.guard === true ? "on" : "off"}`, C.tool)
+      pushLine(`Advisor: ${cfg.guard === true ? "on" : "off"}`, C.tool)
       continue
     }
 

package/src/tui/cmd-config.mjs

@@ -1,10 +1,22 @@
 import { existsSync, readFileSync } from "node:fs"
 import { ansi, C } from "./ansi.mjs"
+/** Merge an embedding-key save into the raw config, backfilling baseURL/model from defaults.
+ *  Keeps existing custom values (Ollama/local embedding); defaults are the single source
+ *  (TUI.md §9.3D — NF1). Exported for unit tests. */
+export function embeddingPatch(raw, embKey, defaults) {
+  const prev = raw?.embedding ?? {}
+  return {
+    ...prev,
+    apiKey: embKey,
+    baseURL: prev.baseURL ?? defaults.baseURL,
+    model: prev.model ?? defaults.model,
+  }
+}
 
 /** /config command: view and set agent/embedding/proxy config. */
 export async function handleConfigCommand(ctx, args = []) {
   const { agent, pushLine, pushLabel, showPicker, askQuestion, persistRaw, maskKey, pickModelForSlot } = ctx
-  const { configPath } = await import("../config.mjs")
+  const { configPath, DEFAULTS } = await import("../config.mjs")
   const ac = agent.config?.agent ?? {}
   const ec = agent.config?.embedding ?? {}
 
@@ -20,7 +32,7 @@ export async function handleConfigCommand(ctx, args = []) {
     if (!embKey) return false
     agent.config.embedding ??= {}
     agent.config.embedding.apiKey = embKey
-    await persistRaw((raw) => { raw.embedding = { ...(raw.embedding ?? {}), apiKey: embKey } })
+    await persistRaw((raw) => { raw.embedding = embeddingPatch(raw, embKey, DEFAULTS.embedding) })
     if (agent.memory) {
       const { createEmbedder } = await import("../embedding.mjs")
       agent.memory.embedder = createEmbedder(agent.config.embedding)

package/src/tui/cmd-copy.mjs

@@ -0,0 +1,29 @@
+/**
+ * cmd-copy.mjs — /copy command: copy the last assistant response to the clipboard.
+ * Copies the RAW markdown reply (agent.history content), not the ANSI-styled display.
+ */
+import { C } from "./ansi.mjs"
+import { writeClipboardText } from "./clipboard.mjs"
+
+/** Most recent assistant reply with non-empty text content (skips tool-calls-only / transient). */
+export function lastAssistantContent(history) {
+  if (!Array.isArray(history)) return null
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i]
+    if (m?.role === "assistant" && typeof m.content === "string" && m.content.trim().length > 0) {
+      return m.content
+    }
+  }
+  return null
+}
+
+export async function handleCopyCommand(ctx) {
+  const { agent, pushLine } = ctx
+  const text = lastAssistantContent(agent?.history)
+  if (!text) {
+    pushLine("No assistant response to copy yet", C.warn)
+    return
+  }
+  const ok = await writeClipboardText(text)
+  pushLine(ok ? `Copied last response (${text.length} chars) to clipboard` : "Clipboard write failed", ok ? C.tool : C.error)
+}

package/src/tui/math.mjs

@@ -0,0 +1,309 @@
+/**
+ * math.mjs — LaTeX → Unicode approximation for the TUI display layer (IK9IXD).
+ *
+ * Zero dependencies, pure functions, no ANSI output. A table-driven subset
+ * converter turns closed `$...$` (inline) and `$$...$$` (block) formula spans
+ * into readable Unicode (x̂, σᵢ, ∑, (a)/(b), …). Unknown LaTeX commands stay
+ * as-is — display-only, semantics untouched. Streaming safety: unclosed
+ * `$`/`$$` spans are left untouched (markdown.mjs unclosed-marker parity).
+ *
+ * Pipeline contract (render-conversation.mjs): math runs BEFORE markdown and
+ * BEFORE wrapping — math treats `$...$`/`$$...$$` as opaque (no markdown
+ * inside), backtick code spans are opaque to math (code is literal).
+ */
+
+// ─── token tables (design: TUI.md §9.1D) ────────────────────────────────
+
+/** Command → literal text (operators, functions, spacing). */
+const DIRECT = new Map([
+  // functions keep their name as text
+  ["min", "min"], ["max", "max"], ["log", "log"], ["ln", "ln"], ["exp", "exp"], ["lim", "lim"],
+  // operators
+  ["sum", "∑"], ["prod", "∏"], ["int", "∫"],
+  ["pm", "±"], ["mp", "∓"], ["times", "×"], ["cdot", "·"], ["div", "÷"],
+  ["le", "≤"], ["ge", "≥"], ["ne", "≠"], ["approx", "≈"], ["equiv", "≡"],
+  ["propto", "∝"], ["in", "∈"], ["notin", "∉"], ["infty", "∞"],
+  ["to", "→"], ["rightarrow", "→"], ["partial", "∂"], ["nabla", "∇"],
+  ["forall", "∀"], ["exists", "∃"], ["cdots", "⋯"], ["ldots", "…"],
+  // spacing
+  ["quad", "  "], ["qquad", "    "], [",", " "], [";", " "],
+])
+
+/** Greek letters, lower + upper. */
+const GREEK = new Map([
+  ["alpha", "α"], ["beta", "β"], ["gamma", "γ"], ["delta", "δ"], ["epsilon", "ε"],
+  ["zeta", "ζ"], ["eta", "η"], ["theta", "θ"], ["iota", "ι"], ["kappa", "κ"],
+  ["lambda", "λ"], ["mu", "μ"], ["nu", "ν"], ["xi", "ξ"], ["omicron", "ο"],
+  ["pi", "π"], ["rho", "ρ"], ["sigma", "σ"], ["tau", "τ"], ["upsilon", "υ"],
+  ["phi", "φ"], ["chi", "χ"], ["psi", "ψ"], ["omega", "ω"],
+  ["Alpha", "Α"], ["Beta", "Β"], ["Gamma", "Γ"], ["Delta", "Δ"], ["Epsilon", "Ε"],
+  ["Zeta", "Ζ"], ["Eta", "Η"], ["Theta", "Θ"], ["Iota", "Ι"], ["Kappa", "Κ"],
+  ["Lambda", "Λ"], ["Mu", "Μ"], ["Nu", "Ν"], ["Xi", "Ξ"], ["Omicron", "Ο"],
+  ["Pi", "Π"], ["Rho", "Ρ"], ["Sigma", "Σ"], ["Tau", "Τ"], ["Upsilon", "Υ"],
+  ["Phi", "Φ"], ["Chi", "Χ"], ["Psi", "Ψ"], ["Omega", "Ω"],
+])
+
+/** One-arg accent commands: argument + combining mark. */
+const ACCENTS = new Map([
+  ["hat", "\u0302"], // U+0302 combining circumflex
+  ["bar", "\u0304"], // U+0304 combining macron
+  ["vec", "\u20d7"], // U+20D7 combining right arrow above
+])
+
+/** Single-char subscript Unicode mapping (common subset). */
+const SUBSCRIPT = new Map([
+  ["0", "₀"], ["1", "₁"], ["2", "₂"], ["3", "₃"], ["4", "₄"],
+  ["5", "₅"], ["6", "₆"], ["7", "₇"], ["8", "₈"], ["9", "₉"],
+  ["a", "ₐ"], ["e", "ₑ"], ["h", "ₕ"], ["i", "ᵢ"], ["j", "ⱼ"], ["k", "ₖ"],
+  ["l", "ₗ"], ["m", "ₘ"], ["n", "ₙ"], ["o", "ₒ"], ["p", "ₚ"], ["r", "ᵣ"],
+  ["s", "ₛ"], ["t", "ₜ"], ["u", "ᵤ"], ["v", "ᵥ"], ["x", "ₓ"],
+])
+
+/** Single-char superscript Unicode mapping (common subset). */
+const SUPERSCRIPT = new Map([
+  ["0", "⁰"], ["1", "¹"], ["2", "²"], ["3", "³"], ["4", "⁴"],
+  ["5", "⁵"], ["6", "⁶"], ["7", "⁷"], ["8", "⁸"], ["9", "⁹"],
+  ["+", "⁺"], ["-", "⁻"], ["=", "⁼"], ["(", "⁽"], [")", "⁾"],
+  ["a", "ᵃ"], ["b", "ᵇ"], ["c", "ᶜ"], ["d", "ᵈ"], ["e", "ᵉ"], ["f", "ᶠ"],
+  ["g", "ᵍ"], ["h", "ʰ"], ["i", "ⁱ"], ["j", "ʲ"], ["k", "ᵏ"], ["l", "ˡ"],
+  ["m", "ᵐ"], ["n", "ⁿ"], ["o", "ᵒ"], ["p", "ᵖ"], ["r", "ʳ"], ["s", "ˢ"],
+  ["t", "ᵗ"], ["u", "ᵘ"], ["v", "ᵛ"], ["w", "ʷ"], ["x", "ˣ"], ["y", "ʸ"], ["z", "ᶻ"],
+])
+
+const CMD_RE = /^\\[a-zA-Z]+/
+
+/** Commands that produce explicit whitespace (LaTeX math mode: ordinary spaces
+ *  around them collapse into the explicit spacing — T5 `\quad` → exactly 2 spaces). */
+const SPACE_PRODUCING = new Set(["quad", "qquad", ",", ";", " "])
+
+/** Non-letter commands after the backslash (control space `\ `, thin spaces `\,`/`\;`). */
+const CHAR_COMMANDS = new Map([
+  [" ", " "], // LaTeX control space
+  [",", " "], [";", " "],
+])
+
+/** Index after the matching `}` for src[i] === "{" (nested-aware); null when unclosed. */
+function matchBraced(src, i) {
+  let depth = 0
+  for (let j = i; j < src.length; j++) {
+    if (src[j] === "{") depth++
+    else if (src[j] === "}") {
+      depth--
+      if (depth === 0) return j + 1
+    }
+  }
+  return null
+}
+
+/** One LaTeX argument: a `{...}` group or a single char. Returns { text, next } or null. */
+function parseArg(src, i) {
+  if (i >= src.length) return null
+  if (src[i] === "{") {
+    const end = matchBraced(src, i)
+    if (end == null) return null
+    return { text: src.slice(i + 1, end - 1), next: end }
+  }
+  return { text: src[i], next: i + 1 }
+}
+
+/**
+ * Convert one LaTeX command starting at src[i] === "\\".
+ * Returns { text, next } when handled; null → caller copies the backslash verbatim
+ * (unknown commands stay as-is, backslash + name + braced args included).
+ */
+function convertCommand(src, i) {
+  const m = CMD_RE.exec(src.slice(i))
+  if (!m) {
+    // Non-letter command: `\,` / `\;` / control space `\ ` → single space.
+    const ch = src[i + 1]
+    if (ch !== undefined && CHAR_COMMANDS.has(ch)) return { text: CHAR_COMMANDS.get(ch), next: i + 2, space: true }
+    return null
+  }
+  const cmd = m[0].slice(1)
+  const next = i + 1 + cmd.length
+
+  if (DIRECT.has(cmd)) return { text: DIRECT.get(cmd), next, space: SPACE_PRODUCING.has(cmd) }
+  if (GREEK.has(cmd)) return { text: GREEK.get(cmd), next }
+  if (cmd === "frac") {
+    const a1 = parseArg(src, next)
+    if (!a1) return null
+    const a2 = parseArg(src, a1.next)
+    if (!a2) return null
+    return { text: `(${convertFormula(a1.text)})/(${convertFormula(a2.text)})`, next: a2.next }
+  }
+  if (cmd === "sqrt") {
+    const a = parseArg(src, next)
+    if (!a) return null
+    return { text: `√(${convertFormula(a.text)})`, next: a.next }
+  }
+  if (cmd === "text") {
+    const a = parseArg(src, next)
+    if (!a) return null
+    return { text: a.text, next: a.next } // content verbatim
+  }
+  if (ACCENTS.has(cmd)) {
+    const a = parseArg(src, next)
+    if (!a) return null
+    return { text: convertFormula(a.text) + ACCENTS.get(cmd), next: a.next }
+  }
+  if (cmd === "left" || cmd === "right") {
+    const nch = src[next]
+    if (nch === "(" || nch === ")") return { text: nch, next: next + 1 }
+  }
+  // Unknown command: keep verbatim — name + any braced args (design: unknown stays
+  // as-is including backslash and arguments).
+  let end = next
+  let text = "\\" + cmd
+  while (end < src.length && src[end] === "{") {
+    const close = matchBraced(src, end)
+    if (close == null) break
+    text += src.slice(end, close)
+    end = close
+  }
+  return { text, next: end }
+}
+
+/** Sub/superscript at src[i] ("_" or "^"). Returns { text, next } or null (keep char as-is). */
+function convertScript(src, i) {
+  const ch = src[i]
+  const isSup = ch === "^"
+  const table = isSup ? SUPERSCRIPT : SUBSCRIPT
+  const wrap = ch
+  if (src[i + 1] === "{") {
+    const end = matchBraced(src, i + 1)
+    if (end != null) return { text: `${wrap}(${convertFormula(src.slice(i + 2, end - 1))})`, next: end }
+    return null
+  }
+  if (i + 1 < src.length) {
+    const nch = src[i + 1]
+    const mapped = table.get(nch)
+    // Single char with a Unicode script char → direct; without → keep paren form.
+    return mapped !== undefined ? { text: mapped, next: i + 2 } : { text: `${wrap}(${nch})`, next: i + 2 }
+  }
+  return null
+}
+
+/** Table-driven subset converter for one closed formula body (exported for unit tests). */
+export function convertFormula(src) {
+  let out = ""
+  let i = 0
+  while (i < src.length) {
+    const ch = src[i]
+    if (ch === "\\") {
+      const handled = convertCommand(src, i)
+      if (handled) {
+        if (handled.space) {
+          // Explicit LaTeX spacing: ordinary spaces AROUND it collapse into it
+          // (math-mode semantics — `\quad` alone contributes exactly its width).
+          out = out.replace(/\s+$/, "")
+          out += handled.text
+          let j = handled.next
+          while (j < src.length && /\s/.test(src[j])) j++
+          i = j
+          continue
+        }
+        out += handled.text
+        i = handled.next
+        continue
+      }
+      out += "\\" // unknown escape — copy verbatim, following chars flow through
+      i++
+      continue
+    }
+    if (ch === "_" || ch === "^") {
+      const handled = convertScript(src, i)
+      if (handled) {
+        out += handled.text
+        i = handled.next
+        continue
+      }
+      out += ch
+      i++
+      continue
+    }
+    out += ch
+    i++
+  }
+  return out
+}
+
+// ─── span scanning ──────────────────────────────────────────────────────
+
+/** Convert closed `$...$` spans in one line (no cross-line pairing). */
+function convertInlineSegments(seg) {
+  let out = ""
+  let i = 0
+  while (i < seg.length) {
+    if (seg[i] !== "$") {
+      out += seg[i]
+      i++
+      continue
+    }
+    if (seg[i + 1] === "$") {
+      out += "$$" // leftover (unmatched) block markers — never inline delimiters
+      i += 2
+      continue
+    }
+    // Find a closing single $ (a $ adjacent to another $ is part of a $$ pair — skip).
+    let close = -1
+    for (let j = i + 1; j < seg.length; j++) {
+      if (seg[j] !== "$") continue
+      if (seg[j + 1] === "$" || seg[j - 1] === "$") continue
+      close = j
+      break
+    }
+    if (close === -1) {
+      out += seg.slice(i) // unclosed — keep verbatim (streaming safety)
+      break
+    }
+    out += convertFormula(seg.slice(i + 1, close))
+    i = close + 1
+  }
+  return out
+}
+
+/** Convert closed `$$...$$` spans (cross-line OK). `\\` inside a span keeps line semantics. */
+function convertBlockSegments(seg) {
+  let out = ""
+  let i = 0
+  while (i < seg.length) {
+    if (seg[i] !== "$" || seg[i + 1] !== "$") {
+      out += seg[i]
+      i++
+      continue
+    }
+    const close = seg.indexOf("$$", i + 2)
+    if (close === -1) {
+      out += seg.slice(i) // unclosed — keep verbatim (streaming safety)
+      break
+    }
+    const inner = seg.slice(i + 2, close)
+    // `\\` → per-line approximation (multi-line preserved; single-line otherwise).
+    out += inner.split("\\\\").map(convertFormula).join("\n")
+    i = close + 2
+  }
+  return out
+}
+
+/** Backtick split helper (markdown.mjs code-span parity): odd segments are code — opaque. */
+function convertEvenSegments(text, fn) {
+  const parts = text.split("`")
+  for (let p = 0; p < parts.length; p += 2) parts[p] = fn(parts[p])
+  return parts.join("`")
+}
+
+/**
+ * Convert closed block-level `$$...$$` spans (cross-line) to Unicode approximation.
+ * Backtick code spans are opaque (code is literal). Unclosed `$$` stays as-is.
+ */
+export function renderMathBlock(text) {
+  return convertEvenSegments(text, convertBlockSegments)
+}
+
+/**
+ * Convert closed inline `$...$` spans (single line each) to Unicode approximation.
+ * Backtick code spans are opaque. Unclosed `$` stays as-is.
+ */
+export function renderMathInline(text) {
+  return convertEvenSegments(text, (seg) => seg.split("\n").map(convertInlineSegments).join("\n"))
+}

package/src/tui/render-conversation.mjs

@@ -5,6 +5,7 @@
 import { ansi, C } from "./ansi.mjs"
 import { formatTables, sanitizeDisplay, stringWidth, wrapText } from "./render.mjs"
 import { renderMarkdownInline, renderMarkdownHeading } from "./markdown.mjs"
+import { renderMathInline, renderMathBlock } from "./math.mjs"
 
 let _convCache = { key: "", cols: 0, lines: [] }
 
@@ -28,6 +29,13 @@ function renderMarkdownPreservingWidth(text) {
     return diff > 0 ? rendered + " ".repeat(diff) : rendered
   }).join("\n")
 }
+
+// Math runs BEFORE markdown (TUI.md §9.1D): `$...$`/`$$...$$` are opaque to markdown
+// (so `x**2` inside a formula isn't misread as bold), and the Unicode approximation
+// is measured by renderMarkdownPreservingWidth's width-compensation math.
+function renderMathAndMarkdown(text) {
+  return renderMarkdownPreservingWidth(renderMathInline(renderMathBlock(text)))
+}
 // Test seam (mirrors the _-prefixed seams in run.mjs).
 export { renderMarkdownPreservingWidth as _renderMarkdownPreservingWidth }
 
@@ -124,7 +132,7 @@ function buildConvLines(state, cols) {
     // ANSI-aware). Rendering after wrapping measured raw markdown
     // (`**bold**` = 8) against displayed text (4) and sliced markers
     // mid-sequence — the table misalignment the user kept reporting.
-    const renderedText = renderMarkdownPreservingWidth(sanitizeDisplay(text))
+    const renderedText = renderMathAndMarkdown(sanitizeDisplay(text))
     for (const line of formatTables(renderedText, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
         block.push({ text: wrapped, color: l.color, _foldId: l._foldId, _src: i })
@@ -183,7 +191,7 @@ function buildConvLines(state, cols) {
       // mid-sequence (`**bo` + `ld**`) so the renderer never saw complete ones.
       const rows = block.kind === "think"
         ? source.split("\n")
-        : formatTables(block.kind === "text" ? renderMarkdownPreservingWidth(source) : source, cols - 3)
+        : formatTables(block.kind === "text" ? renderMathAndMarkdown(source) : source, cols - 3)
       for (const line of rows) {
         for (const wrapped of wrapText(line, cols - 3)) {
           convLines.push({ text: `│ ${wrapped}`, color })
@@ -193,7 +201,7 @@ function buildConvLines(state, cols) {
   }
   if (state.streaming) {
     // Rendered BEFORE formatTables — see the advisor-block comment above.
-    const rendered = renderMarkdownPreservingWidth(sanitizeDisplay(state.streaming))
+    const rendered = renderMathAndMarkdown(sanitizeDisplay(state.streaming))
     for (const line of formatTables(rendered, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
         convLines.push({ text: wrapped, color: C.text })

package/src/tui/render-frame.mjs

@@ -8,7 +8,7 @@
  */
 import { ansi, C, ESC } from "./ansi.mjs"
 import { convCacheKey, renderConversation, countConvLines } from "./render-conversation.mjs"
-import { sliceByWidth, stringWidth, wrapText, formatTables, sanitizeDisplay } from "./render.mjs"
+import { sliceByWidth, stringWidth, sanitizeDisplay } from "./render.mjs"
 import { specForModel } from "../config.mjs"
 import { computeLayout, MAX_SUB_LINES } from "./layout.mjs"
 import { basename } from "node:path"
@@ -268,9 +268,9 @@ export function renderStatus(state, agent, cols, slashCommands) {
   const statusLine = buildStatusLine(state, agent, { cols, slashCommands })
   const autoBanner = agent.autoApprove ? `${C.warn} AUTO${ansi.reset}${ansi.dim}│` : ""
   const planBanner = agent.planMode ? `${C.tool} PLAN${ansi.reset}${ansi.dim}│` : ""
-  const advisorBanner = agent.config?.advisor?.guard === true ? `${C.advisor} GUARD${ansi.reset}${ansi.dim}│` : ""
+  const advisorBanner = agent.config?.advisor?.guard === true ? `${C.advisor} ADVISOR${ansi.reset}${ansi.dim}│` : ""
   const engBanner = agent.config?.agent?.engineering ? `${C.advisor} ENG${ansi.reset}${ansi.dim}│` : ""
-  const bannerPrefix = (agent.planMode ? " PLAN│ " : "") + (agent.autoApprove ? " AUTO│ " : "") + (agent.config?.advisor?.guard === true ? " GUARD│ " : "") + (agent.config?.agent?.engineering ? " ENG│ " : "")
+  const bannerPrefix = (agent.planMode ? " PLAN│ " : "") + (agent.autoApprove ? " AUTO│ " : "") + (agent.config?.advisor?.guard === true ? " ADVISOR│ " : "") + (agent.config?.agent?.engineering ? " ENG│ " : "")
   const statusMax = cols - 1 - (bannerPrefix ? stringWidth(bannerPrefix) : 0)
   return `${ansi.dim}${planBanner}${autoBanner}${advisorBanner}${engBanner}${sliceByWidth(statusLine, Math.max(10, statusMax))}${ansi.reset}`
 }

package/src/tui/slash-commands.mjs

@@ -28,6 +28,7 @@ import { handleModelCommand } from "./cmd-model.mjs"
 import { handleSubmodelCommand } from "./cmd-submodel.mjs"
 import { handleShellCommand } from "./cmd-shell.mjs"
 import { handleConfigCommand } from "./cmd-config.mjs"
+import { handleCopyCommand } from "./cmd-copy.mjs"
 import { handleExtractCommand } from "./cmd-extract.mjs"
 import { handleHelpCommand } from "./cmd-help.mjs"
 import { handleUpgradeCommand } from "./cmd-upgrade.mjs"
@@ -39,7 +40,7 @@ export const SLASH_COMMANDS = [
   { name: "/plan", group: "Agent", desc: "toggle plan mode (design first, then implement)" },
   { name: "/auto", group: "Agent", desc: "toggle auto-approve" },
   { name: "/eng", group: "Agent", desc: "toggle engineering mode — strict methodology enforcement" },
-  { name: "/advisor", group: "Agent", desc: "advisor settings (toggle, model, thinking, guard)" },
+  { name: "/advisor", group: "Agent", desc: "advisor settings (model, thinking, review gate)" },
   { name: "/model", group: "Agent", desc: "select model & manage providers" },
   { name: "/submodel", group: "Agent", desc: "subagent model per type (explore/plan/coder/eng-coder)" },
   { name: "/shell", group: "System", desc: "bash tool shell (git-bash/pwsh path; win11 cmd encoding fix)" },
@@ -51,6 +52,7 @@ export const SLASH_COMMANDS = [
   { name: "/session", group: "Session", desc: "list/switch archived sessions" },
   { name: "/rename", group: "Session", desc: "rename the active session" },
   { name: "/clear", group: "Session", desc: "clear screen" },
+  { name: "/copy", group: "Session", desc: "copy last assistant response to clipboard" },
   { name: "/fold", group: "Session", desc: "toggle result folding on/off" },
   { name: "/undo", group: "Session", desc: "undo recent file modifications" },
   { name: "/init", group: "Project", desc: "generate project AGENTS.md skeleton" },
@@ -87,6 +89,7 @@ export const HANDLERS = {
   "/submodel": handleSubmodelCommand,
   "/shell": handleShellCommand,
   "/config": handleConfigCommand,
+  "/copy": handleCopyCommand,
   "/upgrade": handleUpgradeCommand,
   "/fold": handleFoldCommand,
   "/undo": handleUndoCommand,