thincoder 0.11.1 → 0.12.0

package/src/skills.mjs

@@ -1,52 +1,80 @@
 /**
  * skills.mjs — skill system
- * Discovers .md skill files from .thincoder/skills/ directory,
+ * Discovers .md skill files AND subdirectory SKILL.md from .thincoder/skills/ directory,
  * injects into system prompt for agent to load on demand.
  * Use the skill tool to activate a specific skill; content is written into conversation history wrapped in <skill-loaded>.
+ *
+ * Supported formats:
+ *   .thincoder/skills/my-skill.md           (flat, name = "my-skill")
+ *   .thincoder/skills/my-skill/SKILL.md     (subdirectory, name = "my-skill")
  */
 
 import { readFile, readdir, stat } from "node:fs/promises"
 import { join } from "node:path"
 
+/** Valid skill name pattern (alphanumeric + hyphens/underscores) */
+const NAME_RE = /^[a-zA-Z0-9_-]+$/
+
+/**
+ * Try to read a skill from a path, return { name, path, description } or null.
+ */
+async function tryReadSkill(dir, name, filePath) {
+  try {
+    const s = await stat(filePath)
+    if (!s.isFile()) return null
+    const head = await readFile(filePath, "utf8")
+    const body = head.slice(0, 400).split("\n")
+    let desc = ""
+    let inFrontmatter = false
+    for (const line of body) {
+      const t = line.trim()
+      if (t === "---") { inFrontmatter = !inFrontmatter; continue }
+      if (inFrontmatter) continue
+      if (t && !t.startsWith("#")) {
+        desc = t.slice(0, 120)
+        break
+      }
+    }
+    return { name, path: filePath, description: desc || "(no description)" }
+  } catch {
+    return null
+  }
+}
+
 /**
  * Scan .thincoder/skills/ directory, return skill list.
- * Each skill: { name, path, description } — name is the filename (without extension).
+ * Supports flat .md files and subdirectories with SKILL.md inside.
+ * Each skill: { name, path, description } — name derived from filename or directory.
  * Returns empty array if directory is missing or empty.
  */
 export async function loadSkills(cwd) {
   const dir = join(cwd, ".thincoder", "skills")
   let entries
   try {
-    entries = await readdir(dir)
+    entries = await readdir(dir, { withFileTypes: true })
   } catch {
     return []
   }
   const skills = []
-  for (const name of entries) {
-    if (!/^[a-zA-Z0-9_-]+\.md$/.test(name)) continue // must match readSkill's name validation; prevents "listed but unreadable"
-    const p = join(dir, name)
-    try {
-      const s = await stat(p)
-      if (!s.isFile()) continue
-      // Extract description (first non-empty, non-heading line in first 400 chars);
-      // skip entire frontmatter block, otherwise frontmatter fields (e.g. "name: x") get mistaken for description
-      const head = await readFile(p, "utf8")
-      const body = head.slice(0, 400).split("\n")
-      let desc = ""
-      let inFrontmatter = false
-      for (const line of body) {
-        const t = line.trim()
-        if (t === "---") { inFrontmatter = !inFrontmatter; continue }
-        if (inFrontmatter) continue
-        if (t && !t.startsWith("#")) {
-          desc = t.slice(0, 120)
-          break
-        }
-      }
-      skills.push({ name: name.replace(/\.md$/, ""), path: p, description: desc || "(no description)" })
-    } catch {
-      // Read failure — skip
-    }
+  const added = new Set()
+
+  // Pass 1: subdirectories (higher priority — standard convention)
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    if (!NAME_RE.test(entry.name)) continue
+    const skill = await tryReadSkill(dir, entry.name, join(dir, entry.name, "SKILL.md"))
+    if (skill) { skills.push(skill); added.add(entry.name) }
+  }
+
+  // Pass 2: flat .md files (backward compat; skipped if subdirectory with same name exists)
+  for (const entry of entries) {
+    if (!entry.isFile()) continue
+    const m = entry.name.match(/^([a-zA-Z0-9_-]+)\.md$/)
+    if (!m) continue
+    const name = m[1]
+    if (added.has(name)) continue
+    const skill = await tryReadSkill(dir, name, join(dir, entry.name))
+    if (skill) { skills.push(skill); added.add(name) }
   }
   return skills
 }
@@ -66,13 +94,21 @@ export function formatSkillListing(skills) {
 
 /**
  * Read the full content of a specific skill file.
+ * Tries subdirectory format (name/SKILL.md) first, then flat format (name.md).
  * Returns text, or null if not found.
  */
 export async function readSkill(cwd, name) {
-  // Safety check: skill name must be alphanumeric + hyphens/underscores only
-  if (!/^[a-zA-Z0-9_-]+$/.test(name)) return null
-  const p = join(cwd, ".thincoder", "skills", `${name}.md`)
+  if (!NAME_RE.test(name)) return null
+
+  // Try subdirectory format: name/SKILL.md
+  try {
+    const p = join(cwd, ".thincoder", "skills", name, "SKILL.md")
+    return await readFile(p, "utf8")
+  } catch { /* not found, try flat */ }
+
+  // Fallback to flat format: name.md
   try {
+    const p = join(cwd, ".thincoder", "skills", `${name}.md`)
     return await readFile(p, "utf8")
   } catch {
     return null

package/src/tools/shared.mjs

@@ -203,9 +203,34 @@ export function shellSegments(command) {
   return command.split(/&&|\|\||>>|\$\(|[;|\n<>]|`|[(]/)
 }
 
-/** Detect shell output/input redirection (> >> < followed by filename) — not excluded inside quotes, conservative block */
+/**
+ * Blank out quoted regions (single/double/backtick) with spaces, preserving length.
+ * Lets safety checks ignore shell metacharacters inside quoted script bodies —
+ * e.g. `node -e "if (a > b) …"` comparisons are not redirections.
+ */
+function blankQuoted(command) {
+  let out = ""
+  let quote = null
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i]
+    if (quote) {
+      if (ch === "\\" && quote !== "'") { out += " "; i++; out += " "; continue }
+      if (ch === quote) quote = null
+      out += " "
+    } else if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch
+      out += " "
+    } else {
+      out += ch
+    }
+  }
+  return out
+}
+
+/** Detect shell output/input redirection (> >> < followed by filename) outside quoted regions */
 export function hasFileRedirection(command) {
-  return /(^|[\s;&|])>{1,2}\s*\S/.test(command) || /(^|[\s;&|])<\s*\S/.test(command)
+  const bare = blankQuoted(command)
+  return /(^|[\s;&|])>{1,2}\s*\S/.test(bare) || /(^|[\s;&|])<\s*\S/.test(bare)
 }
 
 /** Whether a single command segment is a destructive non-git command (conservative: prefer false positives) */

package/src/tui/agent-turn.mjs

@@ -105,7 +105,11 @@ export async function runAgentTurn(ctx, text) {
       flushStream()
       ensureAssistantLabel()
       state.currentTool = name
-      pushLine(`  [tool] ${name} ${summarize(args)}`, C.tool)
+      // Advisor: tag the round in the tool title — the model's own "第N轮" narration
+      // is unreliable (it glues onto the previous line), so the round belongs here.
+      const roundTag = name === "advisor" ? ` (round ${(agent._advisorRound || 0) + 1})` : ""
+      const argSummary = summarize(args)
+      pushLine(`  [tool] ${name}${roundTag}${argSummary ? ` ${argSummary}` : ""}`, C.tool)
     },
     onToolResult: (name, result) => {
       state.currentTool = null
@@ -137,8 +141,12 @@ export async function runAgentTurn(ctx, text) {
       const panel = state.outputPanels[name]
       if (panel) {
         delete state.toolStreams[name]
-        panel._pendingDone = true  // defer done until next render cycle flushes it
-        scheduleRender()  // trigger one final render while panel is still alive
+        // Keep the panel visible for a 3s grace period (layout filters by closeAt);
+        // the render loop prunes it once expired. No defer hacks needed — row-diff
+        // repaints whatever should be on screen.
+        panel.done = true
+        panel.closeAt = Date.now() + 3000
+        scheduleRender()
         if (name === "advisor") {
           const text = String(result ?? "")
           const lines = text.split("\n")
@@ -151,10 +159,8 @@ export async function runAgentTurn(ctx, text) {
           const summary = formatPanelSummary(name, result)
           if (summary) pushLine(`  ${summary}`, C.dim)
         }
-        setTimeout(() => {
-          delete state.outputPanels[name]
-          if (state.processing) render()
-        }, 3000)
+        // Trigger a repaint after the grace period so the pruned panel disappears
+        setTimeout(() => render(), 3000)
       } else if (stream) {
         const tail = stream.trimEnd().slice(-4000)
         if (tail) pushLine(tail, C.dim)
@@ -167,22 +173,45 @@ export async function runAgentTurn(ctx, text) {
     },
     onToolOutput: (name, chunk) => {
       // Route streaming output to a panel if one exists or was requested via outputPanel flag.
+      // Chunk may be a string or { kind, text } — kind ("think" | "text" | "tool") drives
+      // per-kind coloring in renderOutput so reasoning / answer / tool progress are distinct.
       let panel = state.outputPanels[name]
       if (!panel) {
         // Lazy-create panel: defensive against race conditions where setupOutputPanel
         // hasn't fired yet or the callbacks chain dropped it (subagent relay, reconnect, etc.)
-        state.outputPanels[name] = { text: "", done: false }
+        state.outputPanels[name] = { parts: [], len: 0, done: false }
         panel = state.outputPanels[name]
       }
-      panel.text = (panel.text ?? "") + chunk
-      if (panel.text.length > 4000) panel.text = panel.text.slice(-4000)
-      panel.seq = (panel.seq ?? 0) + 1 // render-loop cache key: survives the 4000-char cap
+      const part = typeof chunk === "string"
+        ? { kind: "text", text: chunk }
+        : { kind: chunk?.kind ?? "text", text: String(chunk?.text ?? "") }
+      if (!part.text) return
+      // Separate phase transitions with a newline — think → answer → tool progress
+      // would otherwise glue onto each other mid-line.
+      const last = panel.parts[panel.parts.length - 1]
+      if (last && last.kind !== part.kind && !last.text.endsWith("\n") && !part.text.startsWith("\n")) {
+        part.text = "\n" + part.text
+      }
+      panel.parts.push(part)
+      panel.len += part.text.length
+      // Cap at 4000 chars, trimming oldest parts first
+      while (panel.len > 4000 && panel.parts.length > 1) {
+        const first = panel.parts[0]
+        const excess = panel.len - 4000
+        if (first.text.length <= excess) {
+          panel.len -= first.text.length
+          panel.parts.shift()
+        } else {
+          first.text = first.text.slice(excess)
+          panel.len -= excess
+        }
+      }
       scheduleRender()
     },
     onPermissionRequest: (name, args) => askPermission(name, args),
     onQuestion: (text, options) => askQuestion(text, options),
     setupOutputPanel: (name) => {
-      state.outputPanels[name] = { text: "", done: false }
+      state.outputPanels[name] = { parts: [], len: 0, done: false }
       scheduleRender()
     },
     onCompress: () => {
@@ -307,11 +336,27 @@ export async function runAgentTurn(ctx, text) {
 /** Extract a one-line summary from a panel tool's output */
 function formatPanelSummary(name, result) {
   if (name === "verify") return _verifySummary(result)
+  if (name === "bash") return _bashSummary(result)
   // Default: first non-empty line
   const first = result.split("\n").find((l) => l.trim())
   return first ? `${name}: ${first.slice(0, 100)}` : null
 }
 
+/**
+ * bash result format: "[stdout]:\n<out>\n\n[stderr]:\n<err>\n\n(exit code 0)".
+ * The first non-empty line is always the "[stdout]:" marker — useless as a summary.
+ * Show the LAST output line (usually the meaningful tail) plus the exit status.
+ */
+function _bashSummary(result) {
+  const isMarker = (l) => /^\[(stdout|stderr)\]:$/.test(l) || /^\((exit code|killed)/.test(l)
+  const lines = result.split("\n").map((l) => l.trim()).filter((l) => l && !isMarker(l))
+  const status = result.match(/\((?:exit code|killed)[^)]*\)/)?.[0]
+  const parts = []
+  if (lines.length > 0) parts.push(lines[lines.length - 1].slice(0, 100))
+  if (status) parts.push(status)
+  return parts.length > 0 ? `bash: ${parts.join(" ")}` : null
+}
+
 function _verifySummary(result) {
   const lines = result.split("\n")
   const summary = []

package/src/tui/cmd-advisor.mjs

@@ -1,26 +1,11 @@
 /** /advisor command: toggle advisor on/off, select model, configure thinking.
- *  ctx: { agent, showPicker, pushLine, persistRaw } */
-import { C } from "./ansi.mjs"
+ *  Interactive loop UX — stays in menu after each action, Esc to exit.
+ *  ctx: { agent, showPicker, pushLine, pushLabel, persistRaw } */
+import { ansi, C } from "./ansi.mjs"
 
 export async function handleAdvisorCommand(ctx) {
-  const { agent, showPicker, pushLine } = ctx
+  const { agent, showPicker, pushLine, pushLabel } = ctx
   const cfg = agent.config.advisor ??= {}
-  const enabled = cfg.enabled === true
-  const curProvider = cfg.provider || "(main)"
-  const curModel = cfg.model || agent.provider.model
-  const thinkInfo = cfg.thinking === null ? "off"
-    : cfg.thinking?.type === "disabled" ? "off"
-    : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
-    : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
-
-  const entries = [
-    { type: "item", text: `Advisor: ${enabled ? "ON" : "OFF"}`, action: "toggle" },
-    { type: "item", text: `Model: ${curModel}`, action: "model", note: `Provider: ${curProvider}` },
-    { type: "item", text: `Thinking: ${thinkInfo}`, action: "thinking" },
-  ]
-
-  const e = await showPicker("Advisor", entries)
-  if (!e) return
 
   const persist = async () => {
     if (ctx.persistRaw) {
@@ -31,82 +16,211 @@ export async function handleAdvisorCommand(ctx) {
     }
   }
 
-  if (e.action === "toggle") {
-    cfg.enabled = !cfg.enabled
-    agent._pendingReminders = agent._pendingReminders ?? []
-    if (cfg.enabled) {
-      agent._pendingReminders.push("[System reminder: Advisor review is now ON. You can call the `advisor` tool to get an independent code review before finalising your work. The advisor is an independent read-only sub-agent that explores the codebase, runs git diff, reads files, and traces callers via grep/lsp.]")
-    } else {
-      agent._pendingReminders.push("[System reminder: Advisor review is now OFF. The `advisor` tool will not produce results.]")
-    }
-    await persist().catch(err => pushLine(`[error] Advisor toggle: ${err.message}`, C.error))
-  } else if (e.action === "model") {
-    await openAdvisorModelPicker(ctx, persist).catch(err => pushLine(`[error] ${err.message}`, C.error))
-  } else if (e.action === "thinking") {
-    await openAdvisorThinkingPicker(ctx, persist).catch(err => pushLine(`[error] ${err.message}`, C.error))
+  // Lazy model cache — fetched once per /advisor session
+  let modelCache = null
+
+  // ── State helpers ──
+  function advisorStatus() {
+    const enabled = cfg.enabled === true
+    const curModel = cfg.model || agent.provider.model
+    const thinkInfo = cfg.thinking === null ? "off"
+      : cfg.thinking?.type === "disabled" ? "off"
+      : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
+      : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
+    return `Advisor: ${enabled ? "ON" : "OFF"} | Model: ${curModel} | Think: ${thinkInfo}`
   }
-}
 
-async function openAdvisorModelPicker(ctx, persist) {
-  const { agent, showPicker, pushLine } = ctx
-  const providers = agent.providers || []
-  const cfg = agent.config.advisor ??= {}
+  function headerLine() {
+    return `    ${advisorStatus()}`.replace(/\|/g, ansi.dim + "|" + ansi.reset)
+  }
 
-  const entries = [
-    { type: "item", text: "Use main model", action: "inherit", marker: !cfg.provider ? "●" : "" },
-  ]
-  for (const p of providers) {
-    entries.push({ type: "header", text: p.name, note: `${p.baseURL}${agent.activeProvider === p.name ? " ← active" : ""}  loading…` })
-    const mark = cfg.provider === p.name && cfg.model === p.model ? "● " : "  "
-    entries.push({ type: "item", text: `${mark}${p.model}`, action: "switch", provider: p.name, model: p.model })
+  // ── Model picker sub-loop ──
+  async function modelPicker() {
+    if (!modelCache) {
+      modelCache = await fetchAdvisorModels(agent)
+    }
+    let modelIdx = 0
+    for (;;) {
+      const entries = buildModelEntries(agent, cfg, modelCache)
+      const c = await showPicker("Advisor Model", entries, { defaultIndex: modelIdx })
+      if (!c) return
+      modelIdx = Math.max(0, entries.filter((e) => e.type === "item").indexOf(c))
+
+      if (c.action === "inherit") {
+        delete cfg.provider
+        delete cfg.model
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine("Model: using main model", C.tool)
+      } else if (c.action === "switch") {
+        cfg.provider = c.provider
+        cfg.model = c.model
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine(`Model: ${c.provider}/${c.model}`, C.tool)
+      }
+    }
   }
 
-  // Fetch models first, then show picker
-  await fetchAdvisorModels(entries, providers, agent)
+  // ── Thinking picker sub-loop ──
+  async function thinkingPicker() {
+    let thinkIdx = 0
+    for (;;) {
+      const entries = buildThinkingEntries(agent, cfg)
+      const c = await showPicker("Advisor Thinking", entries, { defaultIndex: thinkIdx })
+      if (!c) return
+      thinkIdx = Math.max(0, entries.filter((e) => e.type === "item").indexOf(c))
+
+      if (c.action === "inherit") {
+        delete cfg.thinking
+        delete cfg.reasoningEffort
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine("Thinking: using main model settings", C.tool)
+      } else if (c.action === "think_on") {
+        const { specForModel } = await import("../config.mjs")
+        const spec = specForModel(getEffectiveModel(agent, cfg))
+        cfg.thinking = { type: spec.thinkEnabledValue ?? "enabled" }
+        if (spec.thinkApi === "effort") delete cfg.thinking
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine(`Thinking: ON`, C.tool)
+      } else if (c.action === "think_off") {
+        const { specForModel } = await import("../config.mjs")
+        const spec = specForModel(getEffectiveModel(agent, cfg))
+        const isCustomThink = (spec.thinkEnabledValue ?? "enabled") !== "enabled"
+        cfg.thinking = isCustomThink ? null : { type: "disabled" }
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine("Thinking: OFF", C.tool)
+      } else if (c.action.startsWith("effort_")) {
+        cfg.reasoningEffort = c.action.slice(7)
+        await persist()
+        pushLabel("❯ Advisor", ansi.bold + C.tool)
+        pushLine(`Reasoning effort: ${cfg.reasoningEffort}`, C.tool)
+      }
+    }
+  }
+
+  // ── Main loop ──
+  let mainIdx = 0
+  for (;;) {
+    const enabled = cfg.enabled === true
+    const curProvider = cfg.provider || "(main)"
+    const curModel = cfg.model || agent.provider.model
+    const guardInfo = cfg.guard === true ? "on" : "off"
+
+    const entries = [
+      { type: "header", text: headerLine() },
+      { type: "item", text: `Advisor: ${enabled ? "ON" : "OFF"}`, action: "toggle" },
+      { 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: "View full config", action: "view" },
+    ]
+
+    const choice = await showPicker("Advisor", entries, { defaultIndex: mainIdx })
+    if (!choice) return // Esc
+    mainIdx = Math.max(0, entries.filter((e) => e.type === "item").indexOf(choice))
+
+    if (choice.action === "view") {
+      pushLabel("❯ Advisor", ansi.bold + C.tool)
+      pushLine(`Status:   ${enabled ? "ON" : "OFF"}`, C.dim)
+      pushLine(`Model:    ${curModel} (provider: ${curProvider})`, C.dim)
+      pushLine(`Guard:    ${guardInfo}`, C.dim)
+      pushLine(`Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, C.dim)
+      continue
+    }
+
+    if (choice.action === "toggle") {
+      cfg.enabled = !cfg.enabled
+      await persist().catch(err => pushLine(`[error] Advisor toggle: ${err.message}`, C.error))
+      pushLabel("❯ Advisor", ansi.bold + C.tool)
+      pushLine(`Advisor: ${cfg.enabled ? "ON" : "OFF"}`, C.tool)
+      continue
+    }
+
+    if (choice.action === "guard") {
+      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)
+      continue
+    }
 
-  const e = await showPicker("Advisor Model", entries)
-  if (!e) return
+    if (choice.action === "model") {
+      await modelPicker()
+      continue
+    }
 
-  if (e.action === "inherit") {
-    delete cfg.provider
-    delete cfg.model
-    pushLine("Advisor: using main model", C.dim)
-  } else if (e.action === "switch") {
-    cfg.provider = e.provider
-    cfg.model = e.model
-    pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
+    if (choice.action === "thinking") {
+      await thinkingPicker()
+      continue
+    }
   }
-  await persist()
 }
 
-async function fetchAdvisorModels(entries, providers, agent) {
+// ── Model helpers ──
+
+function getEffectiveModel(agent, cfg) {
+  const providerForDefaults = cfg.provider
+    ? agent.providers?.find(p => p.name === cfg.provider) || agent.provider
+    : agent.provider
+  return cfg.model || providerForDefaults.model
+}
+
+async function fetchAdvisorModels(agent) {
   const { listModels } = await import("../provider/index.mjs")
-  await Promise.all(providers.map(async (p) => {
+  const result = new Map()
+  await Promise.all((agent.providers || []).map(async (p) => {
     try {
       const envKey = { deepseek: "DEEPSEEK_API_KEY", openai: "OPENAI_API_KEY" }[p.name]
       let apiKey = p.apiKey
       if (!apiKey && envKey && process.env[envKey]) apiKey = process.env[envKey]
       if (!apiKey) apiKey = process.env.THINCODER_API_KEY
       const models = await listModels({ baseURL: p.baseURL, apiKey: apiKey ?? "" }, { signal: AbortSignal.timeout(10000) })
-      const at = entries.findLastIndex((e) => e.type === "header" && e.text === p.name)
-      if (at < 0) return
-      entries.splice(at + 2, 0, ...models
-        .filter((m) => m !== p.model)
-        .map((m) => ({ type: "item", text: `   ${m}`, action: "switch", provider: p.name, model: m })))
-      const header = entries[at]
-      header.note = `${p.baseURL}${p.apiKey ? "" : " (no key)"}${agent.activeProvider === p.name ? " ← active" : ""}`
-  } catch (err) {
-      const header = entries.find((e) => e.type === "header" && e.text === p.name)
-      if (header) header.note = `${p.baseURL}${p.apiKey ? "" : " (no key)"}${agent.activeProvider === p.name ? " ← active" : ""}  (fetch failed: ${err.message.slice(0, 40)})`
+      result.set(p.name, { models, error: null })
+    } catch (err) {
+      result.set(p.name, { models: [], error: err.message.slice(0, 40) })
     }
   }))
+  return result
 }
 
-async function openAdvisorThinkingPicker(ctx, persist) {
-  const { agent, showPicker, pushLine } = ctx
-  const { specForModel } = await import("../config.mjs")
-  const cfg = agent.config.advisor ??= {}
+function buildModelEntries(agent, cfg, cache) {
+  const entries = []
+  entries.push({ type: "item", text: (!cfg.provider ? "● " : "  ") + "Use main model", action: "inherit" })
+
+  for (const p of agent.providers || []) {
+    const cached = cache.get(p.name)
+    const hasKey = !!(p.apiKey
+      || (p.name === "deepseek" && process.env.DEEPSEEK_API_KEY)
+      || (p.name === "openai" && process.env.OPENAI_API_KEY)
+      || process.env.THINCODER_API_KEY)
+    const noteParts = [p.baseURL]
+    if (!hasKey) noteParts.push("(no key)")
+    if (agent.activeProvider === p.name) noteParts.push("← active")
+    if (cached?.error) noteParts.push(`(fetch failed: ${cached.error})`)
+    entries.push({ type: "header", text: p.name, note: noteParts.join(" ") })
+
+    // Default model
+    const isDefault = cfg.provider === p.name && cfg.model === p.model
+    entries.push({ type: "item", text: `${isDefault ? "● " : "  "}${p.model}`, action: "switch", provider: p.name, model: p.model })
+
+    // Additional models from API, excluding the default model
+    if (cached?.models) {
+      for (const m of cached.models) {
+        if (m === p.model) continue
+        const isSelected = cfg.provider === p.name && cfg.model === m
+        entries.push({ type: "item", text: `${isSelected ? "● " : "  "}${m}`, action: "switch", provider: p.name, model: m })
+      }
+    }
+  }
+  return entries
+}
 
+async function buildThinkingEntries(agent, cfg) {
+  const { specForModel } = await import("../config.mjs")
   const providerForDefaults = cfg.provider
     ? agent.providers?.find(p => p.name === cfg.provider) || agent.provider
     : agent.provider
@@ -127,31 +241,12 @@ async function openAdvisorThinkingPicker(ctx, persist) {
   ]
   if (!isEffortOnly) {
     entries.push({ type: "header", text: "Thinking mode" })
-    entries.push({ type: "item", text: `Enabled ${thinkingEnabled ? "← current" : ""}`, action: "think_on" })
-    entries.push({ type: "item", text: `Disabled ${curThinking?.type === "disabled" || curThinking === null ? "← current" : ""}`, action: "think_off" })
+    entries.push({ type: "item", text: `Enabled  ${thinkingEnabled ? "← current" : ""}`, action: "think_on" })
+    entries.push({ type: "item", text: `Disabled ${(curThinking?.type === "disabled" || curThinking === null) ? "← current" : ""}`, action: "think_off" })
   }
   entries.push({ type: "header", text: "Reasoning effort" })
   for (const level of effortLevels) {
     entries.push({ type: "item", text: `${level} ${curEffort === level ? "← current" : ""}`, action: `effort_${level}` })
   }
-
-  const e = await showPicker("Advisor Thinking", entries)
-  if (!e) return
-
-  if (e.action === "inherit") {
-    delete cfg.thinking
-    delete cfg.reasoningEffort
-    pushLine("Advisor: using main model thinking settings", C.dim)
-  } else if (e.action === "think_on") {
-    cfg.thinking = { type: thinkOnValue }
-    if (isEffortOnly) delete cfg.thinking
-    pushLine(`Advisor: thinking ON (${thinkOnValue})`, C.dim)
-  } else if (e.action === "think_off") {
-    cfg.thinking = isCustomThink ? null : { type: "disabled" }
-    pushLine("Advisor: thinking OFF", C.dim)
-  } else if (e.action.startsWith("effort_")) {
-    cfg.reasoningEffort = e.action.slice(7)
-    pushLine(`Advisor: reasoning effort = ${cfg.reasoningEffort}`, C.dim)
-  }
-  await persist()
+  return entries
 }

package/src/tui/cmd-auto.mjs

@@ -1,12 +1,10 @@
 /** /auto command: toggle auto-approve mode.
- *  ctx: { agent } */
+ *  ctx: { agent, pushLine, pushLabel } */
+import { ansi, C } from "./ansi.mjs"
+
 export async function handleAutoCommand(ctx) {
-  const { agent } = ctx
+  const { agent, pushLine, pushLabel } = ctx
   agent.autoApprove = !agent.autoApprove
-  agent._pendingReminders = agent._pendingReminders ?? []
-  if (agent.autoApprove) {
-    agent._pendingReminders.push("[System reminder: AUTO mode is now ON. All tool calls are automatically approved — you may write, edit, and run commands without asking. Use this for long autonomous tasks. The user can still interrupt.]")
-  } else {
-    agent._pendingReminders.push("[System reminder: AUTO mode is now OFF. Destructive tool calls now require user approval again. Confirm before writing files, running commands, or spawning subagents.]")
-  }
+  pushLabel("❯ Auto", ansi.bold + C.tool)
+  pushLine(`Auto-approve: ${agent.autoApprove ? "ON" : "OFF"}`, C.tool)
 }