thincoder 0.12.10 → 0.12.12

package/src/tui/cmd-submodel.mjs

@@ -0,0 +1,151 @@
+import { ansi, C } from "./ansi.mjs"
+
+/** Subagent role slots — each has an independent model override slot */
+export const SUBMODEL_SLOTS = ["explore", "plan", "coder", "eng-coder"]
+
+/** Human-readable effective display with inheritance source. role=null → global slot.
+ *  source semantics: "type" = role-specific override (subagentModels[role]),
+ *  "global" = falls back to subagentModel, "parent" = no override, inherits the
+ *  parent agent's provider. */
+function slotDisplay(agent, role) {
+  const cfg = agent.config?.agent ?? {}
+  if (role === null) {
+    return cfg.subagentModel ? { value: cfg.subagentModel, source: "global" } : { value: null, source: "parent" }
+  }
+  const type = cfg.subagentModels?.[role]
+  const global = cfg.subagentModel
+  if (type) return { value: type, source: "type" }
+  if (global) return { value: global, source: "global" }
+  return { value: null, source: "parent" }
+}
+
+/** /submodel command: subagent model config — picker menu (default) or direct args.
+ *  ctx: { agent, pushLine, showPicker, askQuestion, persistRaw, pickModelForSlot }
+ *  /submodel                        → picker: global + 4 role slots
+ *  /submodel <value>                → set global default
+ *  /submodel <type> <value>         → set a role slot
+ *  /submodel <type>                 → show a slot
+ *  /submodel reset [type]           → clear global (or a slot)
+ *  value forms: provider:model | provider name | model name (same as subagent tool model arg) */
+export async function handleSubmodelCommand(ctx, args = []) {
+  const { agent, pushLine, showPicker, askQuestion, persistRaw, pickModelForSlot } = ctx
+  const input = args.join(" ").trim()
+
+  // Single write channel: mutate BOTH in-memory agent.config.agent and the disk raw
+  // with the same function (no divergent double-writes). Agent config is created
+  // lazily here — an Esc-cancelled picker never writes anything.
+  const persist = async (mutate) => {
+    agent.config.agent ??= {}
+    const a = agent.config.agent
+    mutate(a)
+    await persistRaw((raw) => {
+      raw.agent ??= {}
+      mutate(raw.agent)
+    }).catch((e) => pushLine(`[error] ${e.message}`, C.error))
+  }
+
+  // ── Direct args ──
+  if (input) {
+    const parts = input.split(/\s+/)
+    const first = parts[0].toLowerCase()
+    if (first === "reset") {
+      const type = parts[1]?.toLowerCase()
+      if (type) {
+        if (!SUBMODEL_SLOTS.includes(type)) {
+          pushLine(`Unknown subagent type: ${type} (available: ${SUBMODEL_SLOTS.join(", ")})`, C.error)
+          return
+        }
+        await persist((a) => { a.subagentModels ??= {}; delete a.subagentModels[type]; if (Object.keys(a.subagentModels).length === 0) delete a.subagentModels })
+        pushLine(`Subagent type ${type}: reset to inherit (${slotDisplay(agent, type).source === "global" ? `global: ${slotDisplay(agent, type).value}` : "parent provider"}).`, C.text)
+      } else {
+        await persist((a) => { a.subagentModel = null })
+        pushLine("Subagent global model: reset to inherit parent provider.", C.text)
+      }
+      return
+    }
+    if (SUBMODEL_SLOTS.includes(first)) {
+      const value = parts.slice(1).join(" ")
+      if (!value) {
+        const d = slotDisplay(agent, first)
+        pushLine(`Subagent ${first}: ${d.value ? `\`${d.value}\` (${d.source} config)` : "(inherit: parent provider)"}`, C.text)
+        return
+      }
+      await persist((a) => { a.subagentModels ??= {}; a.subagentModels[first] = value })
+      pushLine(`Subagent ${first} model set to \`${value}\`.`, C.text)
+      return
+    }
+    if (parts.length >= 2) {
+      // Two+ tokens and the first is not a known slot → user probably meant a type
+      pushLine(`Unknown subagent type: ${first} (available: ${SUBMODEL_SLOTS.join(", ")})`, C.error)
+      return
+    }
+    // Global value (provider:model | provider | model)
+    await persist((a) => { a.subagentModel = input })
+    pushLine(`Subagent global model set to \`${input}\`.`, C.text)
+    return
+  }
+
+  // ── Picker menu: global + 4 role slots ──
+  // for(;;) loop relies on showPicker's async/Promise suspension — every iteration
+  // awaits a user choice; Esc (null) exits. Mirrors openModelPicker's menu-loop pattern.
+  for (;;) {
+    const g = slotDisplay(agent, null)
+    const entries = [
+      { type: "header", text: "Subagent models — pick a slot to edit (Esc exits)" },
+      { type: "item", text: `${g.value ? `Global default: ${g.value}` : "Global default: (inherit parent)"}`, action: "slot", slot: "global", marker: g.value ? "●" : "○" },
+      ...SUBMODEL_SLOTS.map((role) => {
+        const d = slotDisplay(agent, role)
+        const label = d.value ? `${role}: ${d.value}${d.source === "global" ? " (←global)" : ""}` : `${role}: (inherit: ${d.source === "global" ? "global" : "parent"})`
+        return { type: "item", text: label, action: "slot", slot: role, marker: d.source === "type" ? "●" : "○" }
+      }),
+      { type: "header", text: "Actions" },
+      { type: "item", text: "Reset all (inherit parent)", action: "resetall" },
+    ]
+    const picked = await showPicker("Subagent Models", entries)
+    if (!picked) return // Esc
+
+    if (picked.action === "resetall") {
+      await persist((a) => { a.subagentModel = null; delete a.subagentModels })
+      pushLine("All subagent model overrides cleared — inherit parent provider.", C.text)
+      continue
+    }
+
+    const role = picked.slot === "global" ? null : picked.slot
+    const cur = slotDisplay(agent, role)
+    const sub = await showPicker(`Subagent ${picked.slot}`, [
+      { type: "header", text: `Current: ${cur.value ? `\`${cur.value}\` (${cur.source})` : "(inherit)"}` },
+      { type: "item", text: "Set model… (provider → model picker)", action: "set" },
+      { type: "item", text: "Set to parent provider model", action: "parent" },
+      { type: "item", text: "Reset (inherit)", action: "reset" },
+    ])
+    if (!sub) continue // Esc → back to slots
+
+    if (sub.action === "set") {
+      const sel = await pickModelForSlot()
+      if (!sel) continue
+      const value = `${sel.provider}:${sel.model}`
+      if (role) {
+        await persist((a) => { a.subagentModels ??= {}; a.subagentModels[role] = value })
+        pushLine(`Subagent ${role} model set to \`${value}\`.`, C.text)
+      } else {
+        await persist((a) => { a.subagentModel = value })
+        pushLine(`Subagent global model set to \`${value}\`.`, C.text)
+      }
+    } else if (sub.action === "parent") {
+      const value = `${agent.activeProvider}:${agent.activeModel ?? agent.provider?.model}`
+      if (role) {
+        await persist((a) => { a.subagentModels ??= {}; a.subagentModels[role] = value })
+      } else {
+        await persist((a) => { a.subagentModel = value })
+      }
+      pushLine(`Subagent ${picked.slot} set to parent model \`${value}\`.`, C.text)
+    } else if (sub.action === "reset") {
+      if (role) {
+        await persist((a) => { a.subagentModels ??= {}; delete a.subagentModels[role]; if (Object.keys(a.subagentModels).length === 0) delete a.subagentModels })
+      } else {
+        await persist((a) => { a.subagentModel = null })
+      }
+      pushLine(`Subagent ${picked.slot} reset to inherit.`, C.text)
+    }
+  }
+}

package/src/tui/index.mjs

@@ -60,7 +60,7 @@ export async function startTUI(agent, opts = {}) {
   const state = {
     lines: [], // conversation lines: { text, color }
     streaming: "", // current streaming buffer
-    advisorStreaming: "", // advisor streaming buffer (formatted like main response)
+    _advisorBlocks: [], // advisor ordered blocks: [{ kind: "think"|"text", text }] — preserves emission order (think ↔ tool interleaving)
     input: [], // input buffer (codepoint array)
     cursor: 0,
     history: [],
@@ -291,7 +291,7 @@ export async function startTUI(agent, opts = {}) {
         // local TUI/agent config, never the in-flight turn); the rest are queued
         const cmd0 = text.split(/\s+/)[0].toLowerCase()
         const resolved0 = SLASH_ALIASES[cmd0] ?? cmd0
-        const safeDuringProcessing = new Set(["/help", "/exit", "/model", "/think", "/config", "/skills", "/mcp", "/goal", "/session"])
+        const safeDuringProcessing = new Set(["/help", "/exit", "/model", "/submodel", "/shell", "/think", "/config", "/skills", "/mcp", "/goal", "/session"])
         if (safeDuringProcessing.has(resolved0)) {
           await handleSlash(text)
           render()
@@ -341,7 +341,7 @@ export async function startTUI(agent, opts = {}) {
   const { persistRaw, syncProviderField, maskKey } = createConfigHelpers(agent)
 
   // Model picker + generic picker: implemented in pickers.mjs
-  const { closePicker, showPicker, popPicker, renderPickerLines, openModelPicker, selectModel, setProviderKey } = createPickers({
+  const { closePicker, showPicker, popPicker, renderPickerLines, openModelPicker, selectModel, setProviderKey, pickModelForSlot } = createPickers({
     agent, state, render, ansi, C, pushLine, pushLabel, persistRaw, askQuestion, maskKey,
   })
 
@@ -363,6 +363,7 @@ export async function startTUI(agent, opts = {}) {
     openModelPicker: () => openModelPicker(),
     selectModel,
     setProviderKey,
+    pickModelForSlot,
     runDistill,
     exit: () => { cleanup(); setTimeout(() => process.exit(0), 100) },
   })

package/src/tui/markdown.mjs

@@ -5,9 +5,11 @@
  * model replies stop showing literal `**`, `##`, backtick markers (IK5VW3).
  *
  * Design constraints:
- * - Operates on ALREADY-WRAPPED single lines (call after wrapText): inserting ANSI
- *   here cannot break width math, because wrapping already happened.
- * - Uses narrow-scope SGR resets (22 = bold off, 27 = reverse off, 29 = strikethrough off)
+ * - Display-only rendering. renderMarkdownHeading handles multi-line input
+ *   (splits internally); renderMarkdownInline expects single lines (its
+ *   regexes use [^*\n]+ — no cross-line matches). Callers pass pre-wrapped
+ *   lines so the inserted ANSI never skews width math.
+ * - Uses narrow-scope SGR resets (22 = bold off, 24 = underline off, 29 = strikethrough off)
  *   instead of reset(0), so the line's base color (C.text etc.) survives.
  * - Code spans are extracted FIRST: anything inside backticks is styled as code and
  *   its `**`/`__` markers are NOT interpreted (markdown semantics).
@@ -15,6 +17,10 @@
  */
 
 const BOLD = "\x1b[1m"
+// NOTE: \x1b[22m resets BOTH bold and faint/dim (SGR 2). Today no C.reason
+// (dim) line passes through markdown rendering (reasoning/think blocks skip
+// it), so this is latent — if dim text ever gains markdown, bold segments
+// would clear the dim effect after them.
 const BOLD_OFF = "\x1b[22m"
 const UNDERLINE = "\x1b[4m"
 const UNDERLINE_OFF = "\x1b[24m"
@@ -23,7 +29,10 @@ const STRIKE_OFF = "\x1b[29m"
 
 /** Render inline markers on a single text line: `code` spans, **bold**, __bold__, ~~strike~~. */
 export function renderMarkdownInline(line) {
-  if (!line || line.indexOf("*") === -1 && line.indexOf("`") === -1 && line.indexOf("_") === -1 && line.indexOf("~") === -1) {
+  // Single underscore lines (snake_case identifiers) must short-circuit too —
+  // __bold__ needs a DOUBLE underscore; a lone "_" would otherwise run the
+  // whole split/replace pipeline for nothing.
+  if (!line || (line.indexOf("*") === -1 && line.indexOf("`") === -1 && line.indexOf("__") === -1 && line.indexOf("~") === -1)) {
     return line
   }
 
@@ -44,9 +53,18 @@ export function renderMarkdownInline(line) {
   return out
 }
 
-/** Render a heading line: strip leading `#` markers and bold the whole line. Returns original when not a heading. */
+/** Render heading markers: strip leading `#` markers and bold the heading.
+ *  Inline markers inside the heading are stripped too — the heading is already
+ *  fully bold, so `**bold**` inside it would wrap another bold sequence whose
+ *  `\x1b[22m` turns bold OFF for the rest of the heading text.
+ *  Line-by-line (split on \n): without the m flag, `^`/`$` anchor the whole
+ *  string, so a multi-line input never matched and headings stayed raw —
+ *  the old call sites passed single wrapped lines and hid the defect.
+ *  Returns the original text when no line is a heading. */
 export function renderMarkdownHeading(line) {
-  const m = /^\s{0,3}(#{1,6})\s+(.*)$/.exec(line)
-  if (!m || !m[2]) return line
-  return `${BOLD}${m[2]}${BOLD_OFF}`
+  return line.split("\n").map((l) => {
+    const m = /^\s{0,3}(#{1,6})\s+(.*)$/.exec(l)
+    if (!m || !m[2]) return l
+    return `${BOLD}${m[2].replace(/\*\*|__|~~/g, "")}${BOLD_OFF}`
+  }).join("\n")
 }

package/src/tui/pickers.mjs

@@ -40,6 +40,8 @@ export function createPickers(ctx) {
     closePicker()
     return new Promise((resolve) => {
       const itemCount = entries.filter((e) => e.type === "item").length
+      // No selectable items — resolve immediately instead of showing an empty picker
+      if (itemCount === 0) { resolve(null); return }
       const index = Math.max(0, Math.min(defaultIndex, Math.max(0, itemCount - 1)))
       state.picker = { title, entries, lines: [], index, scroll: 0, selectedLine: 0, filter: "", resolve }
       state.pickerStack.push(state.picker)
@@ -389,5 +391,34 @@ export function createPickers(ctx) {
     await persistRaw((raw) => { raw.providers = agent.providers })
   }
 
-  return { showPicker, closePicker, popPicker, renderPickerLines, openModelPicker, selectModel, setProviderKey }
+
+  /** Slot-bound model picker: two-level provider → model selection that RETURNS
+   *  { provider, model } instead of writing main-session state — used by /submodel
+   *  to write into a subagent slot (global or per-role). Esc from the model list
+   *  returns to the provider list (openModelPicker parity); Esc from the provider
+   *  list exits → null. */
+  async function pickModelForSlot() {
+    for (;;) {
+      const providers = agent.providers
+      if (!providers.length) return null
+      const e = await showPicker("Select provider", providers.map((p) => ({
+        type: "item",
+        text: `${p.name.padEnd(12)} ${p.model}`,
+        action: "open-models",
+        provider: p.name,
+      })))
+      if (!e?.provider) return null
+      const providerConfig = providers.find((p) => p.name === e.provider)
+      if (!providerConfig) return null
+      const entries = buildModelEntriesForProvider(e.provider, providerConfig)
+      fetchModelsForProvider(e.provider, entries).catch((err) => {
+        pushLine(`[model] fetch models failed: ${err.message}`, C.error)
+      })
+      const me = await showPicker(`${e.provider} models`, entries)
+      if (!me?.model) continue // Esc from model list → back to provider list
+      return { provider: e.provider, model: me.model }
+    }
+  }
+
+  return { showPicker, closePicker, popPicker, renderPickerLines, openModelPicker, selectModel, setProviderKey, pickModelForSlot }
 }

package/src/tui/render-conversation.mjs

@@ -3,16 +3,43 @@
  * Extracted from render-frame.mjs.
  */
 import { ansi, C } from "./ansi.mjs"
-import { formatTables, sanitizeDisplay, wrapText } from "./render.mjs"
+import { formatTables, sanitizeDisplay, stringWidth, wrapText } from "./render.mjs"
 import { renderMarkdownInline, renderMarkdownHeading } from "./markdown.mjs"
 
 let _convCache = { key: "", cols: 0, lines: [] }
 
+/**
+ * Render markdown markers to ANSI, then pad the line tail back to the pre-render
+ * display width. Markers (`` ` ``, `**`, `~~`) vanish on render — without the
+ * compensation, table rows containing them display shorter than the column widths
+ * computed by formatTables and the borders misalign (reported regression).
+ * @param {string} text — plain text line (no ANSI yet), already wrapped
+ * @returns {string} ANSI-rendered line whose display width equals stringWidth(text)
+ */
+function renderMarkdownPreservingWidth(text) {
+  // Line-by-line: render + compensate per line. The per-line padding serves
+  // NON-table text (so `**bold** text` next to plain text keeps its width).
+  // Table alignment is NOT provided by the padding — formatTables strips cell
+  // padding during trim and recomputes widths from the RENDERED text (that is
+  // the render-before-measure contract).
+  return text.split("\n").map((line) => {
+    const rendered = renderMarkdownInline(renderMarkdownHeading(line))
+    const diff = stringWidth(line) - stringWidth(rendered)
+    return diff > 0 ? rendered + " ".repeat(diff) : rendered
+  }).join("\n")
+}
+// Test seam (mirrors the _-prefixed seams in run.mjs).
+export { renderMarkdownPreservingWidth as _renderMarkdownPreservingWidth }
+
+
 export function convCacheKey(state) {
   const lastLine = state.lines.length > 0 ? state.lines[state.lines.length - 1] : null
   // expandedBlocks participates: expanding/folding a block must invalidate the cache
   const exp = state.expandedBlocks ? [...state.expandedBlocks].sort().join(",") : ""
-  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${state.advisorStreaming?.length ?? 0}|${state._advisorThink?.length ?? 0}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
+  // Content prefix in the signature: same kind+length with different content
+  // would otherwise collide (stale render); 8 chars disambiguate in practice.
+  const blocksSig = (state._advisorBlocks ?? []).map((b) => `${b.kind}:${b.text?.length ?? 0}:${String(b.text ?? "").slice(0, 8)}`).join(",")
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${blocksSig}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
 }
 
 /** Fold marker line: bold-cyan icon + "click to …" phrase underlined (clickable affordance).
@@ -55,6 +82,13 @@ function highlightSearchMatches(text, query, matchesInLine, globalCurrentIndex,
   return result
 }
 
+/**
+ * Build the conversation lines for the given state.
+ * NOTE: module-level _convCache is read/written as a side effect (keyed by
+ * convCacheKey + cols) — the function is pure w.r.t. its input except for
+ * that cache; direct callers outside renderConversation/countConvLines
+ * should be aware the cache persists across calls.
+ */
 function buildConvLines(state, cols) {
   const key = convCacheKey(state)
   if (_convCache.key === key && _convCache.cols === cols) return _convCache.lines
@@ -75,19 +109,25 @@ function buildConvLines(state, cols) {
 
     // Long-message folding: ANY single line (main output C.text, thinking C.reason,
     // tool summaries C.dim — whatever wraps beyond LONG_FOLD_LINES display rows)
-    // collapses to [blank, ▶, first 4, last] — 5 content lines. Main output and
-    // thinking are the REAL long content; bidirectional folding (collapse markers
-    // + click toggle) keeps them readable — the 0.12.7 dim-only restriction was a
-    // temporary fix for the single-direction era and is now reverted. Keyed by the
-    // source-line index (`long-${i}`) so the toggle survives re-renders.
+    // collapses to [first 4, ▶, last]; expanded long blocks render as
+    // [blank, ▼, every line]. Main output and thinking are the REAL long
+    // content; bidirectional folding (collapse markers + click toggle) keeps
+    // them readable — the 0.12.7 dim-only restriction was a temporary fix for
+    // the single-direction era and is now reverted. Keyed by the source-line
+    // index (`long-${i}`) so the toggle survives re-renders.
     const longKey = `long-${i}`
     const folded = state.foldEnabled !== false && !state.expandedBlocks?.has(longKey)
     const block = []
-    for (const line of formatTables(sanitizeDisplay(text), cols - 1)) {
+    // Lightweight markdown display (IK5VW3): render BEFORE measuring — the
+    // table column math (formatTables) and wrapping must see the RENDERED
+    // text (ANSI consumes zero display width; the width functions are
+    // 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))
+    for (const line of formatTables(renderedText, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        // Lightweight markdown display (IK5VW3): headings bold + inline markers styled.
-        // Runs AFTER wrapping so the ANSI it inserts never skews width math.
-        block.push({ text: renderMarkdownInline(renderMarkdownHeading(wrapped)), color: l.color, _foldId: l._foldId, _src: i })
+        block.push({ text: wrapped, color: l.color, _foldId: l._foldId, _src: i })
       }
     }
     if (folded && block.length > LONG_FOLD_LINES) {
@@ -99,15 +139,21 @@ function buildConvLines(state, cols) {
       convLines.push(foldHintLine(`▶ … ${block.length - FOLD_KEEP} more lines — click to expand`, longKey, i))
       convLines.push(block[block.length - 1])
     } else if (block.length > LONG_FOLD_LINES) {
-      // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
-      // before the content. DIM blocks must not re-trigger the consecutive-dim
-      // folding below (folding stacked on folding — reported regression).
-      if (l.color === C.dim) {
-        for (const line of block) line._skipDimFold = true
+      if (state.foldEnabled === false) {
+        // Folding fully off — content already fully visible; a "click to
+        // collapse" hint would be misleading (toggling has no effect).
+        convLines.push(...block)
+      } else {
+        // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
+        // before the content. DIM blocks must not re-trigger the consecutive-dim
+        // folding below (folding stacked on folding — reported regression).
+        if (l.color === C.dim) {
+          for (const line of block) line._skipDimFold = true
+        }
+        convLines.push(blankLine())
+        convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
+        convLines.push(...block)
       }
-      convLines.push(blankLine())
-      convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
-      convLines.push(...block)
     } else {
       convLines.push(...block)
     }
@@ -117,25 +163,40 @@ function buildConvLines(state, cols) {
       convLines.push({ text: wrapped, color: C.reason })
     }
   }
-  if (state._advisorThink || state.advisorStreaming) {
-    const thinkLines = state._advisorThink ? sanitizeDisplay(state._advisorThink).split("\n") : []
-    const mainLines = state.advisorStreaming
-      ? formatTables(sanitizeDisplay(state.advisorStreaming), cols - 3)
-      : []
-    const allLines = [...thinkLines.map(l => ({ text: l, color: C.reason })), ...mainLines.map(l => ({ text: l, color: C.text }))]
-    const truncated = allLines.length > 5
-    if (truncated) convLines.push({ text: "│ …", color: C.dim })
-    const shown = truncated ? allLines.slice(-5) : allLines
-    for (const { text, color } of shown) {
-      for (const wrapped of wrapText(text, cols - 3)) {
-        convLines.push({ text: `│ ${wrapped}`, color })
+  const advisorBlocks = state._advisorBlocks ?? []
+  if (advisorBlocks.length > 0) {
+    // ORDERED block display — the blocks preserve the emission order
+    // (think → tool → think → … → final) and render as one interleaved
+    // stream: thinking in reasoning color, tool progress/final in text color.
+    // Full-length, no preview truncation; long content scrolls via the
+    // conversation window like everything else.
+    // NOTE: formatTables returns an ARRAY of lines (not a string) — calling
+    // .split on it crashed the whole render (tools/final never displayed).
+    for (const block of advisorBlocks) {
+      const color = { think: C.reason, tool: C.tool, text: C.text }[block.kind] ?? C.text
+      const source = sanitizeDisplay(block.text)
+      // kind:"text" (the final review prose) gets the same lightweight markdown
+      // styling as the main agent response. Rendered BEFORE measuring: the
+      // width math (formatTables / wrapText) must see the RENDERED text —
+      // measuring raw markdown (`**bold**` = 8) against displayed text (4)
+      // misaligned table columns; wrapping raw markdown sliced markers
+      // 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)
+      for (const line of rows) {
+        for (const wrapped of wrapText(line, cols - 3)) {
+          convLines.push({ text: `│ ${wrapped}`, color })
+        }
       }
     }
   }
   if (state.streaming) {
-    for (const line of formatTables(sanitizeDisplay(state.streaming), cols - 1)) {
+    // Rendered BEFORE formatTables — see the advisor-block comment above.
+    const rendered = renderMarkdownPreservingWidth(sanitizeDisplay(state.streaming))
+    for (const line of formatTables(rendered, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        convLines.push({ text: renderMarkdownInline(renderMarkdownHeading(wrapped)), color: C.text })
+        convLines.push({ text: wrapped, color: C.text })
       }
     }
   }
@@ -162,10 +223,15 @@ function buildConvLines(state, cols) {
           i = j
           continue
         }
-        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line
-        folded.push(blankLine())
-        folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
-        for (let k = i; k < j; k++) folded.push(convLines[k])
+        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line.
+        // foldEnabled=false → raw block, no hint (toggling would be a no-op).
+        if (state.foldEnabled === false) {
+          for (let k = i; k < j; k++) folded.push(convLines[k])
+        } else {
+          folded.push(blankLine())
+          folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
+          for (let k = i; k < j; k++) folded.push(convLines[k])
+        }
         i = j
         continue
       }

package/src/tui/render.mjs

@@ -31,20 +31,37 @@ export function charWidth(cp) {
 
 /** Compute the display width of a string (CJK characters count as 2) */
 export function stringWidth(text) {
+  // ANSI escape sequences occupy zero display width — strip them before counting.
+  // Without this, markdown-rendered text (ANSI inserted) was measured wider than it
+  // displays, and table lines with inline markers ended up shorter than the computed
+  // column widths (reported: table borders misaligned after `code`/`**bold**` cells).
   let w = 0
-  for (const ch of text) w += charWidth(ch.codePointAt(0))
+  for (const part of text.split(ANSI_SEQUENCE_RE)) {
+    for (const ch of part) w += charWidth(ch.codePointAt(0))
+  }
   return w
 }
 
-/** Slice by display width */
+/** Slice by display width — ANSI sequences count as zero width and are kept whole. */
 export function sliceByWidth(text, maxWidth) {
   let w = 0
   let out = ""
-  for (const ch of text) {
-    const cw = charWidth(ch.codePointAt(0))
+  let i = 0
+  while (i < text.length) {
+    // Copy any ANSI sequence verbatim (zero display width, never sliced mid-sequence)
+    const m = text.slice(i).match(ANSI_SEQUENCE)
+    if (m && m.index === 0) {
+      out += m[0]
+      i += m[0].length
+      continue
+    }
+    const cp = text.codePointAt(i)
+    const ch = String.fromCodePoint(cp)
+    const cw = charWidth(cp)
     if (w + cw > maxWidth) break
     w += cw
     out += ch
+    i += ch.length
   }
   return out
 }
@@ -186,7 +203,9 @@ export function layoutInput(chars, cursor, width) {
  * Display-layer only — raw tool results the model sees are unchanged; dirty displays already in session
  * are also cleaned during replay.
  */
-const ANSI_SEQUENCE_RE = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b[=>#][0-9]?/g
+const ANSI_SEQUENCE = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-B]|\x1b[=>#][0-9]?/
+// Global variant for replace()/split(); the non-global one keeps match.index for slicing
+const ANSI_SEQUENCE_RE = new RegExp(ANSI_SEQUENCE.source, "g")
 export function sanitizeDisplay(s) {
   return s
     .replace(ANSI_SEQUENCE_RE, "")

package/src/tui/slash-commands.mjs

@@ -25,6 +25,8 @@ import { handleAutoCommand } from "./cmd-auto.mjs"
 import { handleAdvisorCommand } from "./cmd-advisor.mjs"
 import { handleThinkCommand } from "./cmd-think.mjs"
 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 { handleExtractCommand } from "./cmd-extract.mjs"
 import { handleHelpCommand } from "./cmd-help.mjs"
@@ -39,6 +41,8 @@ export const SLASH_COMMANDS = [
   { name: "/eng", group: "Agent", desc: "toggle engineering mode — strict methodology enforcement" },
   { name: "/advisor", group: "Agent", desc: "advisor settings (toggle, model, thinking, guard)" },
   { 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)" },
   { name: "/goal", group: "Agent", desc: "set/view/cancel long-term goal" },
   { name: "/think", group: "Agent", desc: "thinking mode & reasoning effort" },
   { name: "/upgrade", group: "System", desc: "check for updates & upgrade" },
@@ -78,6 +82,8 @@ export const HANDLERS = {
   "/advisor": handleAdvisorCommand,
   "/think": handleThinkCommand,
   "/model": handleModelCommand,
+  "/submodel": handleSubmodelCommand,
+  "/shell": handleShellCommand,
   "/config": handleConfigCommand,
   "/upgrade": handleUpgradeCommand,
   "/fold": handleFoldCommand,
@@ -125,6 +131,10 @@ export function createSlashCommands(ctx) {
     const argIndex = parts.length - 2 // which parameter is being typed (0-based)
     const match = (cands) => cands.filter((c) => c.startsWith(last)).map((c) => `${head} ${c}`)
     if (cmd === "/model" && argIndex === 0) return match(agent.providers.map((p) => p.name))
+    if (cmd === "/submodel") {
+      if (argIndex === 0) return match(["explore", "plan", "coder", "eng-coder", "reset"])
+      if (parts[1] && !["reset"].includes(parts[1]) && argIndex === 1) return match(agent.providers.map((p) => p.name))
+    }
     if (cmd === "/think") {
       if (argIndex === 0) return match(["on", "off", "effort"])
       if (argIndex === 1 && parts[1].toLowerCase() === "effort") {