thincoder 0.12.2 → 0.12.3

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 preview = 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} │ ${preview}${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 {

package/src/tui/index.mjs

@@ -18,7 +18,7 @@
 
 import { emitKeypressEvents } from "node:readline"
 import { PassThrough } from "node:stream"
-import { saveSession, archiveCurrent, listSlots } from "../session.mjs"
+import { saveSession } from "../session.mjs"
 import { closeAllMcp } from "../mcp.mjs"
 import { ansi, C } from "./ansi.mjs"
 import { createRenderLoop } from "./render-loop.mjs"
@@ -59,6 +59,7 @@ export async function startTUI(agent, opts = {}) {
   const state = {
     lines: [], // conversation lines: { text, color }
     streaming: "", // current streaming buffer
+    advisorStreaming: "", // advisor streaming buffer (formatted like main response)
     input: [], // input buffer (codepoint array)
     cursor: 0,
     history: [],
@@ -78,14 +79,13 @@ export async function startTUI(agent, opts = {}) {
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
-    toolStreams: {}, // per-tool live output (isolated by tool name, parallel tools don't interleave)
     subTasks: {}, // sub-agent panel: { roleName: { role, text, done } }, one line per role, marked done briefly after completion
-    outputPanels: {}, // tool output panels: { toolName: { parts: [{kind, text}], len, done, closeAt } } — streamed live during execution, kept visible for a grace period after completion
     currentTool: null, // currently executing tool name (shown in status bar)
     processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
     queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
     interruptPrompt: null, // Ctrl+I interrupt message input: { text: "" } or null
+    search: null, // Ctrl+F search mode: { query: "", matches: [{lineIndex, charIndex}], index: 0 } or null
     expandedBlocks: new Set(), // block hashes that are expanded (Enter toggles)
     foldEnabled: true, // global fold toggle — /fold on|off
   }
@@ -195,9 +195,10 @@ export async function startTUI(agent, opts = {}) {
   const cleanup = () => {
     if (cleanedUp) return
     cleanedUp = true
-    // Save session before exit (synchronous write); archive current to a slot first, then save new — never lose data
+    // Save session before exit (synchronous write).
+    // Archiving to a slot is handled by /new and /session switch — not on every exit,
+    // otherwise simply opening and closing the TUI repeatedly would fill all slots with duplicates.
     try {
-      archiveCurrent(agent.cwd)
       saveSession(agent, state.lines)
     } catch {
       // Save failure shouldn't block exit
@@ -353,7 +354,7 @@ export async function startTUI(agent, opts = {}) {
     agent, state, render, popPicker, renderPickerLines,
     handleSlash, handleTab, submit, pasteClipboardImage,
     wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
-    renderWizard, pushLine, cleanup,
+    renderWizard, pushLine, cleanup, showPicker,
   })
   keyStream.on("keypress", (str, key) => {
     try {

package/src/tui/key-handler.mjs

@@ -2,14 +2,59 @@ import { ansi, C } from "./ansi.mjs"
 import { readClipboardText, insertPastedText } from "./clipboard.mjs"
 import { computeLayout } from "./layout.mjs"
 
+/** Perform search on state.lines, update state.search.matches and clamp index */
+function performSearch(state) {
+  if (!state.search) return
+  const query = state.search.query.toLowerCase()
+  state.search.matches = []
+  // Clear old highlights
+  state.lines.forEach(l => delete l._searchMatches)
+
+  if (!query) { state.search.index = 0; return }
+
+  state.lines.forEach((line, lineIndex) => {
+    const text = (line.text || "").toLowerCase()
+    let charIndex = text.indexOf(query)
+    if (charIndex !== -1) {
+      line._searchMatches = []
+    }
+    while (charIndex !== -1) {
+      state.search.matches.push({ lineIndex, charIndex })
+      line._searchMatches.push(charIndex)
+      charIndex = text.indexOf(query, charIndex + 1)
+    }
+  })
+
+  if (state.search.matches.length === 0) {
+    state.search.index = 0
+  } else {
+    state.search.index = Math.min(state.search.index, state.search.matches.length - 1)
+  }
+}
+
+/** Estimate scroll position to make a line visible (simplified) */
+function scrollToMatch(state, lineIndex) {
+  if (lineIndex == null) return
+  // Rough estimate: each state.line takes 1-2 rendered lines
+  let estimatedLine = 0
+  for (let i = 0; i < lineIndex && i < state.lines.length; i++) {
+    estimatedLine += Math.max(1, Math.ceil((state.lines[i].text?.length || 0) / 80))
+  }
+  const rows = process.stdout.rows || 24
+  const visibleH = Math.max(5, rows - 10) // reserve space for header, input, status, etc.
+  // scroll is number of lines hidden above viewport
+  // We want estimatedLine to be near the bottom of the viewport
+  state.scroll = Math.max(0, state.lines.length - estimatedLine - visibleH + 3)
+}
+
 /** Keyboard event dispatch: permission confirm / question / picker / wizard / edit / scroll / history / paste.
  *  Extracted from index.mjs.
  *  ctx: { agent, state, render, renderPickerLines, popPicker,
  *         handleSlash, handleTab, submit, pasteClipboardImage,
  *         wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
- *         renderWizard, pushLine, cleanup } */
+ *         renderWizard, pushLine, cleanup, showPicker } */
 export function createKeyHandler(ctx) {
-  const { agent, state, render, popPicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup } = ctx
+  const { agent, state, render, popPicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup, showPicker } = ctx
 
   return function onKeypress(str, key = {}) {
     // permission confirm state: y approve / n deny / a approve + turn ON AUTO (no further prompts)
@@ -102,7 +147,66 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    if (key.ctrl && key.name === "c") {
+    // Search mode: Ctrl+F to enter, Esc/n/N to navigate/exit
+  if (key.ctrl && key.name === "f" && !state.permission && !state.question) {
+    if (!state.search) {
+      state.search = { query: "", matches: [], index: 0 }
+    }
+    render()
+    return
+  }
+
+  if (state.search) {
+    if (key.name === "escape") {
+      state.search = null
+      render()
+      return
+    }
+    if (key.name === "n" || (key.ctrl && key.name === "g")) {
+      // Next match
+      if (state.search.matches.length > 0) {
+        state.search.index = (state.search.index + 1) % state.search.matches.length
+        scrollToMatch(state, state.search.matches[state.search.index].lineIndex)
+      }
+      render()
+      return
+    }
+    if (key.name === "p" || (key.ctrl && key.name === "r")) {
+      // Previous match
+      if (state.search.matches.length > 0) {
+        state.search.index = (state.search.index - 1 + state.search.matches.length) % state.search.matches.length
+        scrollToMatch(state, state.search.matches[state.search.index].lineIndex)
+      }
+      render()
+      return
+    }
+    if (key.name === "return") {
+      // Exit search mode but keep highlighting until next Ctrl+F
+      state.search = null
+      render()
+      return
+    }
+    if (key.name === "backspace") {
+      if (state.search.query.length > 0) {
+        state.search.query = state.search.query.slice(0, -1)
+        performSearch(state)
+        render()
+      }
+      return
+    }
+    // Regular character input
+    if (str && str.length === 1 && !key.ctrl && !key.alt && !key.meta) {
+      state.search.query += str
+      performSearch(state)
+      if (state.search.matches.length > 0) {
+        scrollToMatch(state, state.search.matches[state.search.index].lineIndex)
+      }
+      render()
+      return
+    }
+  }
+
+  if (key.ctrl && key.name === "c") {
       // picker 打开时 Ctrl+C = 取消当前 picker（等同 Esc），不杀进程
       if (state.picker) {
         popPicker(null)
@@ -120,6 +224,23 @@ export function createKeyHandler(ctx) {
       ctx.exitTimer.unref?.()
     }
 
+    // F1: 显示快捷键帮助
+    if (key.name === "f1" && !state.picker && !state.permission && !state.question) {
+      showPicker("Keyboard Shortcuts", [
+        { type: "item", text: "Ctrl+C — Cancel/Abort current operation" },
+        { type: "item", text: "Ctrl+I — Interrupt and inject message" },
+        { type: "item", text: "Ctrl+F — Search conversation history" },
+        { type: "item", text: "Ctrl+L — Clear screen" },
+        { type: "item", text: "Ctrl+U — Clear input line" },
+        { type: "item", text: "Esc — Cancel current input/picker" },
+        { type: "item", text: "↑/↓ — Navigate input history" },
+        { type: "item", text: "PgUp/PgDn — Scroll conversation" },
+        { type: "item", text: "Enter — Send message or confirm selection" },
+        { type: "item", text: "F1 — Show this help" },
+      ])
+      return
+    }
+
     // Ctrl+I (or Tab during processing): interrupt and inject a message
     if ((key.ctrl && !key.alt && key.name === "i") || (key.name === "tab" && state.processing && !state.interruptPrompt)) {
       if (state.processing && state.controller && !state.interruptPrompt) {
@@ -335,7 +456,14 @@ export function createKeyHandler(ctx) {
       return
     }
     if (key.name === "return" || key.name === "enter" || str === "\r") {
-      submit().catch((e) => pushLine(`[error] ${e.message}`, C.error))
+      if (key.shift) {
+        // Shift+Enter: insert newline for multiline input
+        state.input.splice(state.cursor, 0, '\n')
+        state.cursor++
+        render()
+      } else {
+        submit().catch((e) => pushLine(`[error] ${e.message}`, C.error))
+      }
       return
     }
 

package/src/tui/layout.mjs

@@ -22,8 +22,8 @@ export function computeLayout(state, { cols, rows }) {
   const W = Math.max(20, cols - 1)
 
   // --- input box ---
-  const inputBuf = state.interruptPrompt ? [...state.interruptPrompt.text] : state.input
-  const inputCursor = state.interruptPrompt ? inputBuf.length : state.cursor
+  const inputBuf = state.search ? [...state.search.query] : (state.interruptPrompt ? [...state.interruptPrompt.text] : state.input)
+  const inputCursor = state.search ? inputBuf.length : (state.interruptPrompt ? inputBuf.length : state.cursor)
   const inputLayout = layoutInput(inputBuf, inputCursor, W - 4)
   let inputOffset = 0
   if (inputLayout.lines.length > MAX_INPUT_LINES) {
@@ -69,10 +69,10 @@ export function computeLayout(state, { cols, rows }) {
     ? Math.min(allSubs.length, MAX_SUB_LINES) + (allSubs.length > MAX_SUB_LINES ? 1 : 0)
     : 0
 
-  // Tool output panels: max 8 lines per panel, capped at reasonable total.
+  // Tool output panels: max 9 lines per panel (1 title + 8 content), capped at reasonable total.
   // Done panels stay visible until their closeAt grace elapses (render loop prunes them).
-  const panels = Object.values(state.outputPanels).filter((p) => !p.done || (p.closeAt ?? 0) > Date.now())
-  const outputPanelsH = panels.length > 0 ? Math.min(panels.length * 8, rows - 10) : 0
+  const panels = Object.values(state.outputPanels ?? {}).filter((p) => !p.done || (p.closeAt ?? 0) > Date.now())
+  const outputPanelsH = panels.length > 0 ? Math.min(panels.length * 9, rows - 10) : 0
 
   // Permission preview (height depends on wrapped content)
   let permPreviewLines = []