thincoder 0.12.10 → 0.12.11

package/README.md

@@ -20,7 +20,7 @@ Design philosophy (the entire meaning of the name): if the Node standard library
 - **Memory system**: three layers (personal/project/team), FTS5 + vector RRF hybrid retrieval, git-friendly markdown format
 - **Two-phase tool scheduling**: permission prompts serialized, read-only tools parallelized, side-effect tools serialized
 - **Session persistence** ⭐0.5.0: up to 5 archive slots, `/session` to switch anytime, tool results visible after restore. Process-level isolation — multiple instances in the same directory each get their own session slot
-- **Concurrent subagents**: three roles — `explore`/`plan`/`coder` — dispatched in parallel, streaming output visible, reports land in the conversation
+- **Concurrent subagents**: three roles — `explore`/`plan`/`coder` — dispatched in parallel, streaming output visible, reports land in the conversation; per-subagent model override (`subagent` tool `model` arg or `agent.subagentModel` config — e.g. discuss with `glm-5.2`, let `deepseek-v4-flash` implement)
 - **Plan Mode**: read-only exploration + design, implement after user approval
 - **AUTO mode**: `/auto` full authorization, no confirmations on long tasks
 - **Task tracking**: `task` tool breaks down multi-step work, status bar ✓n/m live progress, auto-filters completed items
@@ -85,7 +85,7 @@ thincoder upgrade
 
 Running from source: replace `thincoder` above with `node bin/thincoder.mjs`.
 
-Slash commands in the TUI: `/help`, `/model` (two-level picker: first select provider, then model; `/model <provider>:<name>` switches directly), `/provider` (add/remove providers, set keys, custom endpoints), `/think` (thinking mode toggle and reasoning effort), `/config` (view config, `/config embedkey` for the embedding key, `/config set` for parameters), `/session` (list/switch archived sessions), `/reindex` (rebuild the index), `/extract` (extract knowledge from the current session), `/restore` (restore checkpoint), `/clear`, `/exit`. High-frequency commands support abbreviations: `/h` `/x` `/m` `/p` `/t` `/c` `/n`. Typing `/` shows live matching hints in the status bar. Model picker supports search/filter — type to narrow down results.
+Slash commands in the TUI: `/help`, `/model` (two-level picker: first select provider, then model; `/model <provider>:<name>` switches directly), `/submodel` (subagent models per type — picker over global + explore/plan/coder/eng-coder slots, or `/submodel <type> <provider:model>` directly), `/shell` (platform-aware picker of available shells — e.g. `/shell` → pick Git Bash/pwsh, or `/shell "C:\Program Files\Git\bin\bash.exe"`, `/shell reset`; fixes win11 cmd encoding/command issues), `/provider` (add/remove providers, set keys, custom endpoints), `/think` (thinking mode toggle and reasoning effort), `/config` (view config, `/config embedkey` for the embedding key, `/config set` for parameters), `/session` (list/switch archived sessions), `/reindex` (rebuild the index), `/extract` (extract knowledge from the current session), `/restore` (restore checkpoint), `/clear`, `/exit`. High-frequency commands support abbreviations: `/h` `/x` `/m` `/p` `/t` `/c` `/n`. Typing `/` shows live matching hints in the status bar. Model picker supports search/filter — type to narrow down results.
 
 Environment variables: `THINCODER_API_KEY` (or `DEEPSEEK_API_KEY` / `OPENAI_API_KEY`), `THINCODER_BASE_URL`, `THINCODER_MODEL`, `SILICONFLOW_API_KEY`.
 
@@ -112,6 +112,7 @@ Environment variables: `THINCODER_API_KEY` (or `DEEPSEEK_API_KEY` / `OPENAI_API_
     },
   ],
   "activeProvider": "deepseek", // currently active provider name
+  "shell": null, // bash tool shell (win11: e.g. "C:\\Program Files\\Git\\bin\\bash.exe" or "pwsh"); null = system default — cmd on Windows (UTF-8 forced per command), /bin/sh elsewhere. TUI: /shell
   "embedding": {
     // optional: without it, retrieval is pure FTS
     "baseURL": "https://api.siliconflow.cn/v1",
@@ -120,6 +121,8 @@ Environment variables: `THINCODER_API_KEY` (or `DEEPSEEK_API_KEY` / `OPENAI_API_
   },
   "agent": {
     "maxTurns": 100, // tool-loop cap
+    "subagentModel": null, // default subagent provider/model override: "provider:model" | provider name | model name; null = inherit parent provider. Per-call: subagent tool `model` arg
+    "subagentModels": {}, // per-type override: { "explore": "...", "plan": "...", "coder": "...", "eng-coder": "..." }; priority: tool model arg > this > subagentModel > parent provider
     "compactThreshold": 100000, // context compaction threshold (approx. tokens)
   },
   "memory": {
@@ -209,6 +212,12 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.12.11 (2026-08)
+- **Subagent model per type** — `subagent` tool `model` arg, `config.agent.subagentModels` (per explore/plan/coder/eng-coder) and `config.agent.subagentModel` (global fallback); priority: tool arg > type > global > parent provider. `/submodel` TUI command: picker over 5 slots (global + 4 roles) with provider→model selection, or direct args (`/submodel coder deepseek:deepseek-v4-flash`).
+- **Configurable bash shell** — `config.shell` or `/shell` TUI command: platform-aware picker (Windows: pwsh/Git Bash/WSL bash; POSIX: bash/zsh/fish — availability-detected, custom path supported). Windows default cmd now forces UTF-8 per command (`chcp 65001`) — fixes garbled Chinese output on win11.
+- **Markdown table alignment fix** — `stringWidth` strips ANSI (zero display width) and rendered table rows are padded back to the computed width; inline markers (`` `code` ``, `**bold**`) no longer shift the borders.
+- **sliceByWidth keeps ANSI sequences whole** — never slices mid-escape-sequence.
+
 ### 0.12.10 (2026-08)
 - **Code-quality pass (advisor subsystem):**
   - **Drop 11 unused exports** — internal-use symbols no longer leak through the module API (advisor table headers/constants, plan reminders, token-UUID helper, shrinkOversized).

package/package.json

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

package/src/advisor.mjs

@@ -2,11 +2,13 @@
  * advisor.mjs — advisor system-prompt selection, follow-up building, session assembly.
  * User-message building lives in advisor/messages.mjs; execution (tool loop, provider
  * resolution, review entry) in advisor/run.mjs; git discovery/collection in
- * advisor/repos.mjs; history extraction in advisor/history.mjs.
+ * advisor/repos.mjs (design-review diffs only — code-review follow-ups deliberately
+ * inject NO git information); history extraction in advisor/history.mjs.
  *
  * The advisor runs as a read-only exploration sub-agent with tools
- * (read, glob, grep, ls, git, lsp, code_search). It discovers changes
- * via git diff, reads files for context, and traces callers via grep/lsp.
+ * (read, glob, grep, ls, git, lsp, code_search). Round 1 discovers changes
+ * via git diff and reads files for context; convergence rounds (2+) verify
+ * fix status with `read` only — no git output is injected or trusted.
  *
  * Config:
  *   { advisor: { enabled: true, provider: "deepseek", model: "deepseek-chat" } }
@@ -37,7 +39,6 @@
 import { readFileSync } from "node:fs"
 import { join, dirname } from "node:path"
 import { fileURLToPath } from "node:url"
-import { findReviewRepos } from "./advisor/repos.mjs"
 import { extractPriorIssueTable, extractAgentResponseTable } from "./advisor/history.mjs"
 import { buildAdvisorUserMessage } from "./advisor/messages.mjs"
 // Re-export for run.mjs and tests (keeps their imports from "../advisor.mjs" stable)
@@ -87,7 +88,10 @@ export function buildAdvisorSystemPrompt(agent, _prior, reviewType) {
 
 /**
  * Build a follow-up user message for round 2+ — the agent's response table +
- * the refreshed diff, without re-sending the full round-1 context.
+ * round-aware instructions, without re-sending the full round-1 context.
+ * Deliberately NO git information injected (no diff snapshot, no git context):
+ * git output misled re-reviews — committed fixes never show in `git diff HEAD`,
+ * so the model read "no changes" as "no fixes". Verification is `read`-only.
  */
 export function buildAdvisorFollowUp(agent, _prior) {
   const prior = _prior ?? extractPriorIssueTable(agent.history)
@@ -116,12 +120,9 @@ export function buildAdvisorFollowUp(agent, _prior) {
     // Round-aware evidence rule: "New" entries only exist in round 2 (round 3+ forbids them).
     `STALE-CONTEXT WARNING: only fresh \`read\` results describe the current state — never judge from earlier snapshots or from \`git diff\` (committed fixes never show in \`git diff HEAD\`). Read the files to verify. Any "Unfixed" entry${round === 2 ? ' (and any "New" entry)' : ""} MUST quote the exact line content from THIS round's \`read\` output (e.g. \`run.mjs:180: timeoutId = setTimeout(...)\`); line numbers alone are NOT evidence (they may come from the stale prior table). Uncited findings are unverified and will be ignored.`,
     "",
-    "Do NOT re-read AGENTS.md / design docs. Verify fix status with \`read\` only — do not rely on git output: a clean working tree does not mean fixes are absent (they may be committed).",
+    "Do NOT re-read AGENTS.md / design docs. Verify fix status with `read` only — do not rely on git output: a clean working tree does not mean fixes are absent (they may be committed).",
     "",
   ]
-  // Deliberately NO git information injected here (no diff snapshot, no git context):
-  // git output misled re-reviews — committed fixes never show in `git diff HEAD`, so
-  // the model read "no changes" as "no fixes". Verification is `read`-only by design.
   return parts.join("\n")
 }
 
@@ -151,7 +152,6 @@ export function prepareAdvisorMessages(agent, reviewType, designToken = null, do
     // a follow-up "Verify Prior Table" would be meaningless; start a fresh full review
     if (!prior) {
       agent._advisorSession = null
-      session = null
       // Only reset the round counter on a truly fresh start (no prior reviews at all).
       // If _advisorRound > 0, there WAS a prior review — it just passed (all-clear).
       if (!agent._advisorRound) agent._advisorRound = 0

package/src/agent-tools/advisor.mjs

@@ -79,7 +79,7 @@ export const advisorTool = {
     "Run an independent review on your work. " +
     "Use type='design' to review design documents before implementation — pass documents=[...] with the explicit list of doc paths to review; use documents in code review too (the task's Docs involved list). " +
     "Use type='code' (default) to review code changes after implementation — pass paths=[...] to specify which files or directories to review, or documents=[...] for acceptance criteria context. " +
-    "The advisor is an independent read-only sub-agent that explores the codebase, runs git diff, " +
+    "The advisor is an independent read-only sub-agent that explores the codebase, " +
     "reads files, and traces callers via grep/lsp. " +
     "For code review: round 1 does a full review, round 2 verifies the prior table, " +
     "round 3+ strictly checks only the prior table — convergence, not divergence. " +

package/src/agent-tools/subagent.mjs

@@ -14,6 +14,48 @@ import { validateDesignToken } from "./advisor.mjs"
  * - parallel subagent calls via the parallel channel (parallel: true)
  * - non-recursive: child agents do not get the subagent tool (depth > 0 is not injected)
  */
+
+/**
+ * Effective subagent model override for a role (CLI parity shared with VS Code):
+ * priority — subagent tool `model` arg > config.agent.subagentModels[role] > config.agent.subagentModel > null (inherit parent).
+ */
+export function effectiveSubagentModel(parent, role, modelArg) {
+  if (modelArg) return modelArg
+  const cfg = parent.config?.agent ?? {}
+  return cfg.subagentModels?.[role] ?? cfg.subagentModel ?? null
+}
+
+/**
+ * Resolve the sub-agent's provider from a model override string (shared with the
+ * VS Code port). Forms accepted:
+ *   "provider:model"  → the named provider with the named model
+ *   "provider"        → the named provider's configured model
+ *   "model"           → same provider as the parent, different model
+ * null → parent's provider unchanged.
+ * API keys follow the config fallback order (provider.apiKey → THINCODER_API_KEY → provider-specific env).
+ */
+export function resolveChildProvider(parent, modelArg) {
+  if (!modelArg) return { ...parent.provider }
+  const providers = parent.config?.providersList ?? []
+  const withKey = (p) => {
+    if (p.apiKey?.trim()) return { ...p, apiKey: p.apiKey.trim() }
+    if (process.env.THINCODER_API_KEY) return { ...p, apiKey: process.env.THINCODER_API_KEY }
+    const envMap = { deepseek: "DEEPSEEK_API_KEY", openai: "OPENAI_API_KEY" }
+    const keyVar = envMap[p.name]
+    if (keyVar && process.env[keyVar]) return { ...p, apiKey: process.env[keyVar] }
+    return { ...p }
+  }
+  if (modelArg.includes(":")) {
+    const [pname, mname] = modelArg.split(":")
+    const p = providers.find((x) => x.name === pname)
+    if (!p) throw new Error(`subagent model: unknown provider "${pname}" (available: ${providers.map((x) => x.name).join(", ") || "none"})`)
+    return { ...withKey(p), model: mname || p.model }
+  }
+  const byName = providers.find((x) => x.name === modelArg)
+  if (byName) return withKey(byName)
+  return { ...parent.provider, model: modelArg }
+}
+
 export const subagentTool = {
   name: "subagent",
   description:
@@ -30,6 +72,7 @@ export const subagentTool = {
       task: { type: "string", description: "Self-contained task description for the sub-agent" },
       context: { type: "string", description: "Optional background the sub-agent needs (it cannot see this conversation)" },
       role: { type: "string", enum: ["explore", "plan", "coder", "eng-coder"], description: "Sub-agent role: 'explore' (read-only search/analysis), 'plan' (read-only implementation planning), 'coder' (full implementation), 'eng-coder' (engineering-mode coder — strict methodology, design-driven). ENUM IS OVERRIDDEN IN setup.mjs PER ENGINEERING MODE." },
+      model: { type: "string", description: "Provider/model override for this sub-agent: 'provider:model', a provider name from config, or a model name on the parent's provider. Defaults to the agent.subagentModel config, then the parent's provider. Useful for offloading heavy work to a cheaper model." },
       designToken: { type: "string", description: "Required when role='eng-coder': the token returned by advisor(type='design') after the design review passed. Without a valid token, eng-coder cannot modify files." },
     },
     required: ["task"],
@@ -49,6 +92,9 @@ export const subagentTool = {
       throw new Error("Engineering mode is not active — use role='coder' for implementation tasks.")
     }
 
+    // Provider/model override: tool `model` arg > subagentModels[role] > subagentModel > parent provider
+    const childProvider = resolveChildProvider(parent, effectiveSubagentModel(parent, role, args.model))
+
     // eng-coder token gate: the design review must have passed and the caller must
     // present the exact token advisor issued — otherwise the child is not authorized to code.
     if (role === "eng-coder") {
@@ -97,7 +143,7 @@ export const subagentTool = {
       : parent.config
 
     const child = createAgent({
-      provider: parent.provider,
+      provider: childProvider,
       tools,
       config: childConfig,
       cwd: parent.cwd,

package/src/config.mjs

@@ -43,6 +43,8 @@ const DEFAULTS = {
   agent: {
     maxTurns: 100,
     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
     goalTurns: 200,
     compactThreshold: 100000,
     verifyGuard: false,  // push model back to verify when files were mutated but verify not run (opt-in)
@@ -56,6 +58,7 @@ const DEFAULTS = {
     projectDir: ".thincoder/memory",
     team: null,
   },
+  shell: null,            // bash tool shell executable (e.g. "C:\\Program Files\\Git\\bin\\bash.exe" or "pwsh"); null = system default (cmd on Windows, /bin/sh elsewhere)
   embedding: {
     baseURL: "https://api.siliconflow.cn/v1",
     model: "BAAI/bge-m3",

package/src/tools/system.mjs

@@ -48,7 +48,7 @@ function checkBashSafety(command, cwd) {
  * Sets PYTHONIOENCODING on Windows to override GBK default for Python scripts.
  */
 function buildBashEnv() {
-  const winCmd = process.platform === "win32"
+  const isWindows = process.platform === "win32"
   return {
     ...process.env,
     GIT_EDITOR: "true",
@@ -57,7 +57,7 @@ function buildBashEnv() {
     GIT_PAGER: "cat",
     PAGER: "cat",
     TERM: "dumb",
-    ...(winCmd ? { PYTHONIOENCODING: "utf-8" } : {}),
+    ...(isWindows ? { PYTHONIOENCODING: "utf-8" } : {}),
   }
 }
 
@@ -118,11 +118,18 @@ async function gitGuardSnapshot(command, cwd) {
   }
 }
 
-function runBash(command, cwd, { timeout, signal, onOutput }) {
+function runBash(command, cwd, { timeout, signal, onOutput, shell }) {
   return new Promise((resolve) => {
-    const child = spawn(command, {
+    // Windows + default cmd: force UTF-8 code page for this child process (each spawn
+    // is an independent cmd, so chcp has no side effects on other shells) — otherwise
+    // cmd emits GBK bytes that the UTF-8 decoder turns into mojibake, and the model
+    // fights encoding errors instead of the actual command (reported UX on win11).
+    const effectiveCommand = process.platform === "win32" && !shell
+      ? `chcp 65001 >nul && ${command}`
+      : command
+    const child = spawn(effectiveCommand, {
       cwd,
-      shell: true,
+      shell: shell ?? true,
       windowsHide: true,
       detached: process.platform !== "win32",
       stdio: ["ignore", "pipe", "pipe"],
@@ -239,6 +246,7 @@ export const bashTool = {
       timeout: args.timeout ?? BASH_TIMEOUT_MS,
       signal: ctx.signal,
       onOutput: ctx.onOutput,
+      shell: ctx.agent?.config?.shell ?? null,
     })
     return guard ? `${guard.notice}\n\n${result}` : result
   },

package/src/tui/cmd-shell.mjs

@@ -0,0 +1,104 @@
+import { spawnSync } from "node:child_process"
+import { existsSync } from "node:fs"
+import { C } from "./ansi.mjs"
+
+/** Platform shell candidates: { name, value (config.shell payload), detect() }.
+ *  detect() returns truthy when the shell is available (static check, never throws).
+ *  The FULL filtered result (available shells) is cached at module level — shell
+ *  availability does not change during a session, and re-running spawnSync on every
+ *  /shell would freeze the TUI (up to 3 × timeout per open). */
+let _shellCandidatesCache = null
+function platformShellCandidates() {
+  if (_shellCandidatesCache) return _shellCandidatesCache
+  const win = process.platform === "win32"
+  const commandExists = (cmd) => {
+    try {
+      // 'command -v' is a POSIX shell builtin; sh -c runs it (Windows uses `where`)
+      const r = spawnSync(win ? "where" : "sh", win ? [cmd] : ["-c", `command -v ${cmd}`], { encoding: "utf8", timeout: 3000 })
+      return r.status === 0 && r.stdout.trim().length > 0
+    } catch { return false }
+  }
+  const GIT_BASH_PATHS = [
+    "C:\\Program Files\\Git\\bin\\bash.exe",
+    "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    `${process.env.LOCALAPPDATA ?? ""}\\Programs\\Git\\bin\\bash.exe`,
+  ]
+  const candidates = []
+  // System default always first
+  candidates.push({ name: "System default", value: null, detect: () => true })
+  if (win) {
+    candidates.push({ name: "PowerShell (pwsh)", value: "pwsh", detect: () => commandExists("pwsh") })
+    candidates.push({ name: "Windows PowerShell (powershell)", value: "powershell", detect: () => commandExists("powershell") })
+    const gb = GIT_BASH_PATHS.find((p) => existsSync(p))
+    if (gb) candidates.push({ name: `Git Bash (${gb})`, value: gb, detect: () => true })
+    candidates.push({ name: "WSL bash (wsl)", value: "wsl", detect: () => commandExists("wsl") })
+  } else {
+    for (const sh of ["bash", "zsh", "fish"]) {
+      candidates.push({ name: sh, value: sh, detect: () => commandExists(sh) })
+    }
+  }
+  // Known limitation: POSIX detection requires `sh` in PATH (extremely minimal
+  // containers may lack it — then only "System default" is offered).
+  _shellCandidatesCache = candidates.filter((c) => c.detect())
+  return _shellCandidatesCache
+}
+
+/** /shell command: bash tool shell — platform-aware picker (default) or direct args.
+ *  ctx: { agent, pushLine, showPicker, askQuestion, persistRaw }
+ *  /shell                    → picker: available shells for this platform + custom path
+ *  /shell <path|name>        → set directly (quotes stripped)
+ *  /shell reset              → system default (case-insensitive) */
+export async function handleShellCommand(ctx, args = []) {
+  const { agent, pushLine, showPicker, askQuestion, persistRaw } = ctx
+  // Strip surrounding quotes (slash args are whitespace-split; /shell "C:\Program Files\Git\bin\bash.exe"
+  // would otherwise persist the literal quote characters and spawn would fail)
+  const input = args.join(" ").trim().replace(/^["'](.+)["']$/, "$1")
+
+  const persist = async (value) => {
+    agent.config.shell = value
+    await persistRaw((raw) => { raw.shell = value }).catch((e) => pushLine(`[error] ${e.message}`, C.error))
+  }
+
+  // ── Direct args ──
+  if (input) {
+    if (input.toLowerCase() === "reset") {
+      await persist(null)
+      pushLine("Shell reset to system default.", C.text)
+      return
+    }
+    await persist(input)
+    pushLine(`Shell set to \`${input}\` — bash tool commands will run through it.`, C.text)
+    return
+  }
+
+  // ── Platform-aware picker ──
+  const available = platformShellCandidates() // cached — detection runs once per session
+  const current = agent.config?.shell ?? null
+  const entries = [
+    { type: "header", text: current ? `Current: ${current}` : "Current: (system default)" },
+    ...available.map((c) => ({
+      type: "item",
+      text: `${c.name}${c.value ? `  →  ${c.value}` : "  (cmd + UTF-8 on Windows / /bin/sh elsewhere)"}`,
+      action: "pick",
+      value: c.value,
+      marker: (c.value ?? null) === current ? "●" : "",
+    })),
+    { type: "header", text: "Other" },
+    { type: "item", text: "Custom path… (type any shell path/command)", action: "custom" },
+  ]
+  const defaultIndex = Math.max(0, available.findIndex((c) => (c.value ?? null) === current))
+  const picked = await showPicker("Shell", entries, { defaultIndex })
+  if (!picked) return // Esc
+
+  if (picked.action === "custom") {
+    const path = await askQuestion("Enter shell path or command (e.g. C:\\Program Files\\Git\\bin\\bash.exe, pwsh, cmd):")
+    if (!path) return
+    await persist(path.trim().replace(/^["'](.+)["']$/, "$1"))
+    pushLine(`Shell set to \`${path.trim()}\` — bash tool commands will run through it.`, C.text)
+    return
+  }
+  await persist(picked.value)
+  pushLine(picked.value === null
+    ? "Shell reset to system default."
+    : `Shell set to \`${picked.value}\` — bash tool commands will run through it.`, C.text)
+}

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

@@ -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/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,11 +3,26 @@
  * 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) {
+  const rendered = renderMarkdownInline(renderMarkdownHeading(text))
+  const diff = stringWidth(text) - stringWidth(rendered)
+  return diff > 0 ? rendered + " ".repeat(diff) : rendered
+}
+
+
 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
@@ -87,7 +102,7 @@ function buildConvLines(state, cols) {
       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: renderMarkdownPreservingWidth(wrapped), color: l.color, _foldId: l._foldId, _src: i })
       }
     }
     if (folded && block.length > LONG_FOLD_LINES) {
@@ -135,7 +150,7 @@ function buildConvLines(state, cols) {
   if (state.streaming) {
     for (const line of formatTables(sanitizeDisplay(state.streaming), cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        convLines.push({ text: renderMarkdownInline(renderMarkdownHeading(wrapped)), color: C.text })
+        convLines.push({ text: renderMarkdownPreservingWidth(wrapped), color: C.text })
       }
     }
   }

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") {