thincoder 0.12.2 → 0.12.4

package/src/tui/agent-turn.mjs

@@ -3,6 +3,22 @@ import { saveSession } from "../session.mjs"
 import { sliceByWidth } from "./render.mjs"
 import { ansi, C } from "./ansi.mjs"
 
+/** Tool execution start timestamps (performance.now ms), keyed by tool name. */
+const _toolTicks = Object.create(null)
+
+/** Per-tool streaming preview line limits — tools with verbose output get more lines */
+const LIVE_LINE_LIMITS = {
+  bash: 10,
+  advisor: 15,
+  read: 3,
+  grep: 8,
+  glob: 8,
+  search: 8,
+  websearch: 8,
+  code_search: 8,
+  doc_search: 8,
+}
+
 /** Execute one agent conversation turn (triggered by submit or queue).
  *  Extracted from index.mjs: agent loop + callback construction + error handling + queue processing.
  *  ctx: { agent, state, pushLine, pushLabel, render, scheduleRender,
@@ -29,6 +45,8 @@ export async function runAgentTurn(ctx, text) {
   state.status = "Processing..."
   state.streaming = ""
   state.reasoning = ""
+  state.advisorStreaming = ""
+  state._advisorThink = ""
   state.subTasks = {}
   state.currentTool = null
   state.processingStarted = Date.now()
@@ -49,6 +67,8 @@ export async function runAgentTurn(ctx, text) {
       pushLine(state.streaming, C.text)
       state.streaming = ""
     }
+    state.advisorStreaming = ""
+    state._advisorThink = ""
   }
 
   const callbacks = {
@@ -102,14 +122,36 @@ export async function runAgentTurn(ctx, text) {
         scheduleRender()
         return
       }
+      if (name === "advisor") { state.advisorStreaming = ""; state._advisorThink = "" }
       flushStream()
       ensureAssistantLabel()
       state.currentTool = name
+      // Update status bar with current tool and key arguments for user visibility
+      if (name === "bash" && args.command) {
+        const cmd = args.command.replace(/\s+/g, " ").trim()
+        state.status = `Running: ${cmd.length > 50 ? cmd.slice(0, 50) + "…" : cmd}`
+      } else if ((name === "read" || name === "write" || name === "edit" || name === "grep" || name === "glob") && args.path) {
+        state.status = `${name}: ${args.path}`
+      } else if (name === "grep" && args.pattern) {
+        state.status = `grep: ${args.pattern}`
+      } else if (name === "glob" && args.pattern) {
+        state.status = `glob: ${args.pattern}`
+      } else if (name === "websearch" && args.query) {
+        state.status = `search: ${args.query.length > 40 ? args.query.slice(0, 40) + "…" : args.query}`
+      } else if (name === "advisor") {
+        state.status = `advisor review (round ${(agent._advisorRound || 0) + 1})`
+      } else {
+        state.status = `tool: ${name}`
+      }
       // 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)
+      // Inline block title — panel tools get both the title AND the
+      // streaming output panel, complementary display.
+      const color = ({ advisor: C.advisor, bash: C.warn, verify: C.tool }[name] ?? C.text)
+      pushLine(`❯ ${name}${roundTag}${argSummary ? ` ${argSummary}` : ""}`, color)
+      _toolTicks[name] = performance.now()
     },
     onToolResult: (name, result) => {
       state.currentTool = null
@@ -137,83 +179,74 @@ export async function runAgentTurn(ctx, text) {
           if (state.processing) render()
         }, 3000)
       }
-      const stream = state.toolStreams[name]
-      const panel = state.outputPanels[name]
-      if (panel) {
-        delete state.toolStreams[name]
-        // 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")
-          const maxShow = Math.min(60, lines.length)
-          // Push as single multiline block so formatTables aligns MD table columns
-          const shown = lines.slice(0, maxShow).map((l) => `  ${l.slice(0, 200)}`).join("\n")
-          pushLine(shown, C.advisor)
-          if (lines.length > maxShow) pushLine(`  ... (${lines.length - maxShow} more lines — call advisor again or scroll through the tool result for full output)`, C.dim)
-        } else {
-          const summary = formatPanelSummary(name, result)
-          if (summary) pushLine(`  ${summary}`, C.dim)
+      if (!isSubagent && name !== "advisor") {
+        // Remove live streaming lines — done line handles the summary.
+        for (let i = state.lines.length - 1; i >= 0; i--) {
+          if (state.lines[i]._live === name) state.lines.splice(i, 1)
         }
-        // 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)
-        delete state.toolStreams[name]
+        const summary = formatToolSummary(name, result)
+        if (summary) pushLine(`  ${summary}`, C.dim)
       }
-      if (!isSubagent && !panel) {
-        const first = result.split("\n")[0]
-        pushLine(`  [done] ${name} → ${sliceByWidth(first, 100)}`, C.dim)
+      if (name === "advisor") { state.advisorStreaming = ""; state._advisorThink = "" }
+      // Done line for ALL tools (panel area abolished — inline only).
+      if (!isSubagent) {
+        const elapsed = _toolTicks[name] ? ` (${Math.round(performance.now() - _toolTicks[name])}ms)` : ""
+        const summary = formatToolSummary(name, result)
+        const tail = summary ? ` → ${sliceByWidth(summary, 60)}` : ""
+        pushLine(`❯ ${name} — done${elapsed}${tail}`, C.dim)
       }
+      delete _toolTicks[name]
     },
     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] = { parts: [], len: 0, done: false }
-        panel = state.outputPanels[name]
-      }
+      // All tools use inline conversation blocks — panel area is abolished.
+      // Stream up to 5 preview lines; the full result is in the tool message.
       const part = typeof chunk === "string"
-        ? { kind: "text", text: chunk }
-        : { kind: chunk?.kind ?? "text", text: String(chunk?.text ?? "") }
+        ? { kind: "text", text: chunk.trimEnd() }
+        : { kind: chunk?.kind ?? "text", text: String(chunk?.text ?? "").trimEnd() }
       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()
+      if (name === "advisor") {
+        // Accumulate to buffer — formatTables + wrapText in render-conversation
+        // handles markdown formatting, same as main agent response.
+        const raw = typeof chunk === "string" ? chunk : String(chunk?.text ?? "")
+        const kind = typeof chunk === "string" ? "text" : (chunk?.kind ?? "text")
+        if (kind === "think") {
+          state._advisorThink = (state._advisorThink || "") + raw
         } else {
-          first.text = first.text.slice(excess)
-          panel.len -= excess
+          state.advisorStreaming += raw
+        }
+        scheduleRender()
+        return
+      }
+      // Rolling output — show latest N lines with fold marker per tool.
+      // _live marker per tool enables per-tool pruning without affecting other content.
+      const color = ({ think: C.reason, tool: C.tool }[part.kind] ?? C.dim)
+      for (const line of part.text.split("\n")) {
+        const trimmed = line.trimEnd()
+        if (!trimmed) continue
+        state.lines.push({ text: `│ ${trimmed}`, color, _live: name })
+      }
+      // Prune: keep at most N lines + "│ …" fold marker per tool (configurable, tool-specific)
+      const configLimit = agent.config?.agent?.streamPreviewLines
+      const toolLimit = LIVE_LINE_LIMITS[name]
+      const previewLines = configLimit ?? toolLimit ?? 5
+      let count = 0
+      let hasFold = false
+      for (let i = state.lines.length - 1; i >= 0; i--) {
+        if (state.lines[i]._live === name) {
+          if (++count > previewLines) {
+            if (!hasFold) {
+              state.lines[i] = { text: "│ …", color: C.dim, _live: name }
+              hasFold = true; count = previewLines
+            } else {
+              state.lines.splice(i, 1)
+            }
+          }
         }
       }
       scheduleRender()
     },
     onPermissionRequest: (name, args) => askPermission(name, args),
     onQuestion: (text, options) => askQuestion(text, options),
-    setupOutputPanel: (name) => {
-      state.outputPanels[name] = { parts: [], len: 0, done: false }
-      scheduleRender()
-    },
     onCompress: () => {
       pushLine("  [context] Context too long, auto-compacted (early conversation summarized by LLM, task state preserved)", C.warn)
     },
@@ -243,6 +276,17 @@ export async function runAgentTurn(ctx, text) {
     onTurnEnd: (() => {
       let n = 0
       return () => {
+        // Flush pending reasoning/streaming before the next turn starts.
+        // Guard pushbacks (verify/advisor) continue the agent loop without
+        // returning to the TUI — without flushing, old thinking bleeds into
+        // the next turn and the guard reminder is invisible.
+        flushStream()
+        // Mirror the last system-reminder from agent.history so guard
+        // pushback messages appear in the conversation at the right spot.
+        const last = agent.history.at(-1)
+        if (last?.role === "user" && typeof last.content === "string" && last.content.startsWith("[System reminder:")) {
+          pushLine(last.content, C.warn)
+        }
         if (++n % 5 !== 0) return
         try { saveSessionImpl(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
       }
@@ -303,12 +347,29 @@ export async function runAgentTurn(ctx, text) {
     clearInterval(ticker)
     state.processing = false
     state.subTasks = {}
+    state.advisorStreaming = ""
+    state._advisorThink = ""
     state.controller = null
     state.status = "Ready"
     // Auto-collapse todo panel when all tasks done (matching kimi-code TUI; agent.tasks are preserved)
     if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
       state.tasks = []
     }
+    // Auto-generate session title from the first user message (once per session)
+    if (!agent.title) {
+      try {
+        const { generateTitle } = await import("../generate-title.mjs")
+        const firstUser = (agent._fullHistory ?? agent.history).find(
+          (m) => m.role === "user" && typeof m.content === "string" && !m.content.startsWith("[System reminder:"),
+        )
+        if (firstUser) {
+          const title = await generateTitle(firstUser.content, agent.provider)
+          if (title) agent.title = title
+        }
+      } catch {
+        // Title generation failure is non-fatal
+      }
+    }
     // Save session after every turn (survives crashes)
     try {
       saveSessionImpl(agent, state.lines)
@@ -333,15 +394,55 @@ export async function runAgentTurn(ctx, text) {
   }
 }
 
-/** Extract a one-line summary from a panel tool's output */
-function formatPanelSummary(name, result) {
+/** Extract a one-line summary from tool output for the done line */
+function formatToolSummary(name, result) {
   if (name === "verify") return _verifySummary(result)
   if (name === "bash") return _bashSummary(result)
+  if (name === "advisor") return _advisorSummary(result)
+  if (name === "read" || name === "read_file") return _readSummary(result)
+  if (name === "write" || name === "write_file") return _writeSummary(result)
+  if (name === "grep" || name === "search") return _grepSummary(result)
+  if (name === "glob") return _globSummary(result)
   // Default: first non-empty line
   const first = result.split("\n").find((l) => l.trim())
   return first ? `${name}: ${first.slice(0, 100)}` : null
 }
 
+function _readSummary(result) {
+  const lines = result.split("\n")
+  // Look for line count in result
+  const countMatch = result.match(/(\d+) lines?/)
+  if (countMatch) return `${countMatch[1]} lines`
+  // Fallback: count actual lines
+  return `${lines.length} lines`
+}
+
+function _writeSummary(result) {
+  // Extract file size or confirmation
+  if (result.includes("wrote") || result.includes("created")) {
+    const sizeMatch = result.match(/(\d+)(?:\s*(?:bytes?|chars?))/i)
+    return sizeMatch ? `wrote ${sizeMatch[1]} bytes` : "wrote file"
+  }
+  const first = result.split("\n").find((l) => l.trim())
+  return first ? first.slice(0, 80) : "wrote"
+}
+
+function _grepSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no matches"
+  if (count === 1) return "1 match"
+  return `${count} matches`
+}
+
+function _globSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no files"
+  if (count === 1) return "1 file"
+  return `${count} files`
+}
+
 /**
  * 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.
@@ -357,6 +458,23 @@ function _bashSummary(result) {
   return parts.length > 0 ? `bash: ${parts.join(" ")}` : null
 }
 
+function _advisorSummary(result) {
+  const text = String(result ?? "")
+  if (/no 🔴|all.*(?:resolved|fixed|pass)/im.test(text)) return "advisor: passed"
+  // Error / skip messages — extract the reason after "Advisor:"
+  const errMatch = text.trimStart().match(/^Advisor:\s*(.+)/)
+  if (errMatch) return `advisor: ${errMatch[1].split(".")[0]}`
+  const critical = (text.match(/\| \d+ \|.*\| 🔴/g) || []).length
+  const advisory = (text.match(/\| \d+ \|.*\| 🟡/g) || []).length
+  const style = (text.match(/\| \d+ \|.*\| 🔵/g) || []).length
+  const parts = []
+  if (critical) parts.push(`${critical} critical`)
+  if (advisory) parts.push(`${advisory} advisory`)
+  if (style) parts.push(`${style} style`)
+  if (parts.length === 0) return null
+  return `advisor: ${parts.join(", ")}`
+}
+
 function _verifySummary(result) {
   const lines = result.split("\n")
   const summary = []

package/src/tui/ansi.mjs

@@ -13,6 +13,10 @@ export const ansi = {
   mouseOff: `${ESC}[?1000l${ESC}[?1006l`,
   bracketedPasteOn: `${ESC}[?2004h`,
   bracketedPasteOff: `${ESC}[?2004l`,
+  keyboardPush: `${ESC}[>1u`,   // kitty keyboard protocol: push disambiguate mode (Shift+Enter → CSI-u)
+  keyboardPop: `${ESC}[<u`,     // pop keyboard mode (restore terminal defaults on exit)
+  modifyOtherKeysOn: `${ESC}[>4;2m`,  // xterm modifyOtherKeys level 2 (Shift+Enter → \x1b[27;2;13~), mintty/Git Bash path
+  modifyOtherKeysOff: `${ESC}[>4m`,   // reset modifyOtherKeys
   home: `${ESC}[H`,
   clearLine: `${ESC}[K`,
   clearToEnd: `${ESC}[J`,

package/src/tui/clipboard.mjs

@@ -38,6 +38,15 @@ export function insertPastedText(state, rawText) {
   state.cursor += chars.length
 }
 
+/** Translate Shift+Enter sequences from keyboard-enhanced terminals into the Alt+Enter path.
+ *  kitty/CSI-u: \x1b[13;2u; xterm modifyOtherKeys: \x1b[27;2;13~. Both become \x1b\r,
+ *  which readline parses reliably as meta+return (the multiline branch in key-handler).
+ *  Terminals without enhancement send a bare \r for Shift+Enter — nothing to translate
+ *  (degrades to a normal submit; Alt+Enter remains the fallback). */
+export function translateShiftEnter(text) {
+  return text.replace(/\x1b\[13;2u/g, "\x1b\r").replace(/\x1b\[27;2;13~/g, "\x1b\r")
+}
+
 /** Ctrl+V / Alt+V: read clipboard image → write temp file in working directory → insert read_image command into input box.
  *  Extracted from index.mjs.
  *  ctx: { agent, state, pushLine, render } */

package/src/tui/cmd-config.mjs

@@ -38,6 +38,7 @@ export async function handleConfigCommand(ctx, args = []) {
     const cfg = loadConfig()
     injectProxy(cfg.providersList, cfg)
     const runtimeName = agent.activeProvider
+    const runtimeModel = agent.activeModel
     agent.providers = cfg.providersList
     agent.config = cfg
     agent.config.agent ??= {}
@@ -45,9 +46,20 @@ export async function handleConfigCommand(ctx, args = []) {
     if (runtimeName && runtimeName !== cfg.activeProvider && keep) {
       // 运行时选择在新配置里仍存在 → 保持（provider 为注入 proxyUri 后的新对象）
       agent.activeProvider = runtimeName
+      agent.activeModel = runtimeModel
       agent.provider = { ...keep }
+      if (agent.activeModel) agent.provider.model = agent.activeModel
+    } else if (runtimeName && runtimeName === cfg.activeProvider && runtimeModel) {
+      // Same provider, runtime had a model override — keep it
+      agent.activeProvider = cfg.activeProvider
+      agent.activeModel = runtimeModel
+      const p = cfg.providersList.find((pr) => pr.name === cfg.activeProvider)
+      agent.provider = p ? { ...p } : cfg.provider
+      agent.provider.model = runtimeModel
+      agent.provider.proxyUri = p?.proxyUri
     } else {
       agent.activeProvider = cfg.activeProvider
+      agent.activeModel = cfg.activeModel ?? null
       agent.provider = cfg.provider
       agent.provider.proxyUri = cfg.providersList.find((p) => p.name === cfg.activeProvider)?.proxyUri
     }
@@ -141,7 +153,6 @@ export async function handleConfigCommand(ctx, args = []) {
       { type: "item", text: `agent.compactThreshold = ${ac.compactThreshold ?? 100000}${agent.config?.agent?.compactThresholdAuto ? " (auto)" : ""}`, action: "agent.compactThreshold" },
       { type: "item", text: `agent.verifyGuard = ${ac.verifyGuard === true ? "on" : "off"}`, action: "agent.verifyGuard" },
       { type: "item", text: "Set embedding API key", action: "embedkey" },
-      { type: "item", text: `embedding.model = ${ec.model ?? "BAAI/bge-m3"}`, action: "embedding.model" },
       { type: "item", text: `proxy = ${proxySummary()}`, action: "proxy" },
       { type: "item", text: "View full config", action: "view" },
     ]
@@ -189,31 +200,8 @@ export async function handleConfigCommand(ctx, args = []) {
       continue
     }
 
-    if (choice.action === "embedding.model") {
-      const models = [
-        { label: "BAAI/bge-m3 (multilingual, 1024d)", value: "BAAI/bge-m3" },
-        { label: "BAAI/bge-large-zh-v1.5 (Chinese, 1024d)", value: "BAAI/bge-large-zh-v1.5" },
-        { label: "BAAI/bge-large-en-v1.5 (English, 1024d)", value: "BAAI/bge-large-en-v1.5" },
-        { label: "text-embedding-3-small (OpenAI, 1536d)", value: "text-embedding-3-small" },
-        { label: "text-embedding-3-large (OpenAI, 3072d)", value: "text-embedding-3-large" },
-      ]
-      const currentVal = ec.model ?? "BAAI/bge-m3"
-      const modelChoice = await showPicker("Embedding Model", [
-        { type: "header", text: `Current: ${currentVal}` },
-        ...models.map(m => ({ type: "item", text: m.label, action: m.value })),
-      ])
-      if (!modelChoice) continue
-      try {
-        await saveProxy((raw) => {
-          raw.embedding ??= {}
-          raw.embedding.model = modelChoice.action
-        })
-        pushLabel("❯ Config", ansi.bold + C.tool)
-        pushLine(`embedding.model = ${modelChoice.action}`, C.tool)
-        running = false
-      } catch (error) { pushLine(`Save failed: ${error.message}`, C.error) }
-      continue
-    }
+    // Embedding model is fixed (BAAI/bge-m3, SiliconFlow) — no picker; it's over-engineering
+    // to expose model choice when the vector index format assumes one embedding space.
 
     // Numeric config items
     const label = choice.action

package/src/tui/cmd-eng.mjs

@@ -0,0 +1,44 @@
+/** /eng command: toggle engineering mode.
+ *  Requires METHODOLOGY.md in project root. Offers to create one if missing.
+ *  ctx: { agent, pushLine, pushLabel, persistRaw, showPicker } */
+import { existsSync, copyFileSync } from "node:fs"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { ansi, C } from "./ansi.mjs"
+
+const templateDir = join(fileURLToPath(import.meta.url), "..", "..", "prompts")
+
+export async function handleEngCommand(ctx) {
+  const { agent, pushLine, pushLabel, persistRaw, showPicker } = ctx
+  agent.config.agent ??= {}
+  const methodologyPath = join(agent.cwd, "METHODOLOGY.md")
+
+  // Toggle on: check METHODOLOGY.md exists
+  if (!agent.config.agent.engineering) {
+    if (!existsSync(methodologyPath)) {
+      pushLabel("❯ Eng", ansi.bold + C.tool)
+      pushLine("METHODOLOGY.md not found in project root.", C.warn)
+      const choice = await showPicker("Create METHODOLOGY.md?", [
+        { type: "header", text: "Engineering mode requires a methodology file" },
+        { type: "item", text: "Yes, create from template", action: "create" },
+        { type: "item", text: "No, cancel", action: "cancel" },
+      ])
+      if (!choice || choice.action !== "create") return
+      const src = join(templateDir, "methodology-template.md")
+      copyFileSync(src, methodologyPath)
+      pushLine(`Created METHODOLOGY.md (from template) → edit it to fit your project`, C.tool)
+    }
+  }
+
+  agent.config.agent.engineering = !agent.config.agent.engineering
+  if (!agent.config.agent.engineering) agent._engDesignToken = null // invalidate stale token
+  await persistRaw((raw) => {
+    raw.agent ??= {}
+    raw.agent.engineering = agent.config.agent.engineering
+  })
+  pushLabel("❯ Eng", ansi.bold + C.tool)
+  pushLine(`Engineering mode: ${agent.config.agent.engineering ? "ON" : "OFF"}`, C.tool)
+  if (agent.config.agent.engineering) {
+    pushLine(`  → strictly following ${methodologyPath}`, C.dim)
+  }
+}

package/src/tui/cmd-exit.mjs

@@ -1,7 +1,7 @@
 /** /exit command: exit TUI (same path as Ctrl+C).
  *  Direct synchronous process.exit — prevents the post-handler render()
  *  from redrawing the TUI over the cleaned terminal. The actual cleanup
- *  (archiveCurrent + saveSession + closeMcp + terminal reset) runs once
+ *  (saveSession + closeMcp + terminal reset) runs once
  *  via the process.on("exit") handler registered in index.mjs.
  */
 export async function handleExitCommand(_ctx) {

package/src/tui/cmd-fold.mjs

@@ -4,17 +4,16 @@
 import { C } from "./ansi.mjs"
 
 export async function handleFoldCommand(ctx, args = []) {
-  const { state } = ctx
+  const { state, pushLabel } = ctx
   const arg = args[0]?.toLowerCase()
   if (arg === "on") {
     state.foldEnabled = true
-    ctx.pushLine("Folding: on (long tool results are collapsed)", C.dim)
   } else if (arg === "off") {
     state.foldEnabled = false
-    ctx.pushLine("Folding: off (all results shown in full)", C.dim)
   } else {
     state.foldEnabled = !state.foldEnabled
-    ctx.pushLine(`Folding: ${state.foldEnabled ? "on" : "off"}`, C.dim)
   }
+  pushLabel("❯ Fold", C.bold + C.tool)
+  ctx.pushLine(`Folding: ${state.foldEnabled ? "on" : "off"}`, C.tool)
   ctx.render()
 }

package/src/tui/cmd-model.mjs

@@ -1,18 +1,23 @@
 import { C } from "./ansi.mjs"
 
-/** /model command: open model picker, or switch provider directly via `/model <provider>`.
+/** /model command: open model picker, or switch provider directly via `/model <provider>[:model]`.
  *  ctx: { agent, openModelPicker, selectModel, pushLine } */
 export async function handleModelCommand(ctx, args = []) {
-  const name = args[0]?.toLowerCase()
-  if (!name) {
+  const raw = args[0]?.toLowerCase()
+  if (!raw) {
     ctx.openModelPicker().catch((e) => ctx.pushLine(`[error] ${e.message}`, C.error))
     return
   }
-  const target = ctx.agent.providers.find((p) => p.name.toLowerCase() === name)
+  // Parse "provider:model" syntax
+  const colonIdx = raw.indexOf(":")
+  const providerName = colonIdx >= 0 ? raw.slice(0, colonIdx) : raw
+  const modelName = colonIdx >= 0 ? raw.slice(colonIdx + 1) : null
+
+  const target = ctx.agent.providers.find((p) => p.name.toLowerCase() === providerName)
   if (!target) {
     const available = ctx.agent.providers.map((p) => p.name).join(", ")
-    ctx.pushLine(`Unknown provider: ${args[0]} (available: ${available})`, C.error)
+    ctx.pushLine(`Unknown provider: ${providerName} (available: ${available})`, C.error)
     return
   }
-  await ctx.selectModel({ provider: target.name, model: target.model }).catch((e) => ctx.pushLine(`[error] ${e.message}`, C.error))
+  await ctx.selectModel({ provider: target.name, model: modelName || target.model }).catch((e) => ctx.pushLine(`[error] ${e.message}`, C.error))
 }

package/src/tui/cmd-new.mjs

@@ -1,12 +1,13 @@
-import { clearSession } from "../session.mjs"
+import { newSession } from "../session.mjs"
 import { C } from "./ansi.mjs"
 
-/** /new command: start new session (old session archived to slot).
+/** /new command: start a new session in a fresh slot.
  *  ctx: { agent, state, pushLine, showPicker, render } */
 export async function handleNewCommand(ctx) {
   const { agent, state, pushLine, showPicker, render } = ctx
 
   const doNewSession = () => {
+    const slot = newSession(agent.cwd)
     agent.history = []
     agent.tasks = []
     agent.planMode = false
@@ -15,14 +16,13 @@ export async function handleNewCommand(ctx) {
     state.tasks = []
     state.lines = []
     state.streaming = ""
-    clearSession(agent.cwd)
     render()
-    pushLine("New session started (old session archived to slot; /session to view)", C.dim)
+    pushLine(`New session started (slot ${slot}; /session to switch back)`, C.dim)
   }
 
   if (agent.history.length > 0) {
     const e = await showPicker("Start new session?", [
-      { type: "item", text: "Yes, archive current and start new", action: "yes" },
+      { type: "item", text: "Yes, start new session in a new slot", action: "yes" },
       { type: "item", text: "Cancel", action: "no" },
     ], { defaultIndex: 1 })
     if (e?.action === "yes") doNewSession()

package/src/tui/cmd-session.mjs

@@ -1,22 +1,34 @@
 import { listSlots, switchToSlot, applySession } from "../session.mjs"
 import { ansi, C } from "./ansi.mjs"
 
-/** /session command: list/switch archived session slots.
+/** /session command: list/switch session slots.
  *  ctx: { agent, state, showPicker, pushLine, pushLabel, render } */
 export async function handleSessionCommand(ctx) {
   const { agent, state, showPicker, pushLine, pushLabel, render } = ctx
   const slots = listSlots(agent.cwd)
   if (slots.length === 0) {
-    pushLine("No archived sessions (use /new and old sessions auto-archive to slots)", C.dim)
+    pushLine("No sessions (use /new to start a new session)", C.dim)
     return
   }
+  const shortDate = (d) => {
+    const dt = new Date(d)
+    return `${dt.getMonth() + 1}/${dt.getDate()} ${String(dt.getHours()).padStart(2, "0")}:${String(dt.getMinutes()).padStart(2, "0")}`
+  }
+  const truncate = (s, n) => s.length <= n ? s : s.slice(0, n - 1) + "…"
   const entries = [
-    { type: "header", text: `Archived sessions (↑↓ select, Enter switch, Esc cancel)` },
-    ...slots.map((s) => ({
-      type: "item",
-      text: `Slot ${s.slot} — ${s.date}`,
-      slot: s.slot,
-    })),
+    { type: "header", text: `Sessions (● = active, ↑↓ select, Enter switch, Esc cancel)` },
+    ...slots.map((s) => {
+      const label = s.title || (s.firstMessage ? `"${truncate(s.firstMessage, 40)}"` : "(empty)")
+      const turns = s.turnCount > 0 ? `${s.turnCount} turns` : "0 turns"
+      const when = shortDate(s.updatedAt)
+      const model = s.activeProvider ? ` — ${s.activeProvider}` : ""
+      const marker = s.isActive ? " ●" : ""
+      return {
+        type: "item",
+        text: `Slot ${s.slot} │ ${turns} │ ${when} │ ${label}${model}${marker}`,
+        slot: s.slot,
+      }
+    }),
   ]
   const e = await showPicker("Sessions", entries)
   if (!e) return
@@ -26,9 +38,7 @@ export async function handleSessionCommand(ctx) {
     return
   }
   applySession(agent, data)
-  state.lines = data.display.length
-    ? data.display.map((l) => ({ text: l.text, color: l.color }))
-    : []
+  state.lines = data.display.length ? [...data.display] : []
   state.tasks = agent.tasks ?? []
   if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
     state.tasks = []

package/src/tui/cmd-think.mjs

@@ -74,6 +74,7 @@ export async function handleThinkCommand(ctx, args = []) {
     if (e.action === "auto") {
       const newAuto = agent.config?.agent?.autoThink === true
       pushLine(`Auto-think: ${newAuto ? "ON" : "OFF"}`, C.tool)
+      return // exit loop — no useful actions remain when auto mode just changed
     } else if (e.action === "effort") {
       pushLine(`Reasoning effort: ${e.level}`, C.tool)
     } else {