thincoder 0.12.3 → 0.12.5

package/src/session.mjs

@@ -1,10 +1,10 @@
 /**
  * session.mjs — session persistence (slot-based model)
- * Each project (keyed by cwd hash) keeps up to 5 session slots.
+ * Each project (keyed by cwd hash) keeps unlimited session slots.
  * Every session lives in a numbered slot; the manifest tracks which slot is active.
  * There is no separate "current" file — the active slot IS the current session.
  *
- * File layout: {hash}.json.1~5 (slots), {hash}.json.manifest (slot metadata + active pointer).
+ * File layout: {hash}.json.N (slots), {hash}.json.manifest (slot metadata + active pointer).
  * Legacy {hash}.json is migrated to a slot on first access.
  */
 
@@ -14,9 +14,6 @@ import { join, dirname } from "node:path"
 import { execSync } from "node:child_process"
 import { configDir } from "./config.mjs"
 
-const MAX_SLOTS = 5
-const CWD_HASH_LEN = 12
-
 let currentSessionId = null
 
 /** Generate unique session ID for this process */
@@ -27,9 +24,36 @@ export function getSessionId() {
   return currentSessionId
 }
 
-/** Derive base session path from cwd hash (legacy, kept for migration and tests) */
+/** Normalize cwd for hashing: uppercase Windows drive letter so both ends
+ *  (CLI's process.cwd() vs VS Code's uri.fsPath, which lowercases it) agree. */
+export function normalizeCwd(cwd) {
+  return cwd.replace(/^([a-z]):/, (_, d) => d.toUpperCase() + ":")
+}
+
+/** Full sha1 hex (40 chars), not truncated. Shared contract with the VS Code extension. */
+function cwdHash(cwd) {
+  return createHash("sha1").update(normalizeCwd(cwd)).digest("hex")
+}
+
+/** One-time migration: rename legacy 12-char-hash session files to the full 40-char hash.
+ *  Idempotent; runs on first access per cwd. */
+function migrateHashLength(cwd, fullHash) {
+  const dir = join(configDir, "sessions")
+  const legacyBase = join(dir, `${fullHash.slice(0, 12)}.json`)
+  if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) return
+  const newBase = join(dir, `${fullHash}.json`)
+  try {
+    for (const suffix of ["", ".manifest", ...Array.from({ length: 64 }, (_, i) => `.${i + 1}`)]) {
+      const from = legacyBase + suffix
+      if (existsSync(from) && !existsSync(newBase + suffix)) renameSync(from, newBase + suffix)
+    }
+  } catch { /* best-effort; leave files in place on failure */ }
+}
+
+/** Derive base session path from cwd hash. Migrates legacy short-hash files on first access. */
 export function sessionPath(cwd) {
-  const hash = createHash("sha1").update(cwd).digest("hex").slice(0, CWD_HASH_LEN)
+  const hash = cwdHash(cwd)
+  migrateHashLength(cwd, hash)
   return join(configDir, "sessions", `${hash}.json`)
 }
 
@@ -72,7 +96,7 @@ function isRealUserMsg(m) {
 }
 
 /** Extract slot metadata from history (shared by slotDigest and loadSlotMeta) */
-function extractSlotMeta(history, activeProvider, updatedAt) {
+function extractSlotMeta(history, activeProvider, updatedAt, title = "") {
   const userMsgs = history.filter(isRealUserMsg)
   const first = userMsgs[0]?.content ?? ""
   return {
@@ -81,12 +105,13 @@ function extractSlotMeta(history, activeProvider, updatedAt) {
     firstMessage: first.slice(0, 80),
     activeProvider: activeProvider ?? "",
     updatedAt: updatedAt ?? Date.now(),
+    title,
   }
 }
 
 /** Extract preview summary from session data for manifest storage (with current timestamp) */
 function slotDigest(data) {
-  const meta = extractSlotMeta(data.history ?? [], data.activeProvider, data.updatedAt)
+  const meta = extractSlotMeta(data.history ?? [], data.activeProvider, data.updatedAt, data.title ?? "")
   return { ts: Date.now(), ...meta }
 }
 
@@ -109,59 +134,50 @@ function saveManifest(cwd, m) {
  * Ensure an active slot exists in the manifest, migrating legacy data if needed.
  * Called by activeSlot() — idempotent, safe to call repeatedly.
  */
+/**
+ * Claim a slot for this process and set it as active. Idempotent.
+ * Preference order:
+ *  1. The current active slot, if it is unowned / ours / its owner is dead — reuse it.
+ *  2. Any slot that is unowned or owned by a dead process (reclaim).
+ *  3. A brand-new slot when all are owned by live processes.
+ * The owner is recorded in m.slotSessions so other processes (CLI ↔ VS Code) can
+ * see which slots are taken and avoid them.
+ */
 function ensureActive(cwd, m) {
   const mySessionId = getSessionId()
-  
-  // Initialize slotSessions if not present
   if (!m.slotSessions) m.slotSessions = {}
-  
-  // Check if we already own the active slot
-  if (m.active && m.slotSessions[m.active] === mySessionId) {
+
+  // Already own the active slot — nothing to do.
+  if (m.active && m.slotSessions[m.active] === mySessionId) return
+
+  const isFree = (slot) => {
+    const owner = m.slotSessions[slot]
+    if (!owner || owner === mySessionId) return true
+    return !isProcessAlive(parseInt(owner.split('-')[0]))
+  }
+
+  // 1. Prefer the current active slot if we can take it (preserves "resume where you left off").
+  if (m.active && m.slots[m.active] && isFree(m.active)) {
+    m.slotSessions[m.active] = mySessionId
+    saveManifest(cwd, m)
     return
   }
-  
-  // Try to find an available slot:
-  // 1. Empty slots (not in slotSessions)
-  // 2. Slots owned by dead processes (check if PID is still running)
-  // 3. Oldest slot if all are busy
-  
+
+  // 2. Otherwise claim the first slot that is free.
   const allSlots = Object.keys(m.slots).filter(n => /^\d+$/.test(n)).map(Number).sort((a, b) => a - b)
-  
-  // Find first empty or dead slot
   for (const slot of allSlots) {
-    const ownerSessionId = m.slotSessions[slot]
-    if (!ownerSessionId) {
-      // Empty slot - claim it
+    if (isFree(slot)) {
       m.active = slot
       m.slotSessions[slot] = mySessionId
       saveManifest(cwd, m)
       return
     }
-    if (ownerSessionId !== mySessionId) {
-      // Check if owner process is still alive
-      const ownerPid = parseInt(ownerSessionId.split('-')[0])
-      if (!isProcessAlive(ownerPid)) {
-        // Dead process - reclaim slot
-        m.active = slot
-        m.slotSessions[slot] = mySessionId
-        saveManifest(cwd, m)
-        return
-      }
-    }
   }
-  
-  // All slots busy - create new slot if under limit, otherwise use oldest
-  if (allSlots.length < MAX_SLOTS) {
-    const newSlot = allSlots.length > 0 ? Math.max(...allSlots) + 1 : 1
-    m.active = newSlot
-    m.slotSessions[newSlot] = mySessionId
-    saveManifest(cwd, m)
-    return
-  }
-  
-  // All slots busy and at limit - use oldest slot (smallest number)
-  m.active = allSlots[0]
-  m.slotSessions[m.active] = mySessionId
+
+  // 3. All slots owned by live processes — allocate a new one (no limit).
+  const newSlot = allSlots.length > 0 ? Math.max(...allSlots) + 1 : 1
+  m.active = newSlot
+  m.slotSessions[newSlot] = mySessionId
   saveManifest(cwd, m)
 }
 
@@ -187,10 +203,10 @@ function isProcessAlive(pid) {
   }
 }
 
-/** Return the active slot number, migrating legacy data if necessary */
+/** Return the active slot number for this process, claiming one if necessary */
 export function activeSlot(cwd) {
   const m = loadManifest(cwd)
-  if (!m.active) ensureActive(cwd, m)
+  ensureActive(cwd, m)
   return m.active
 }
 
@@ -203,7 +219,7 @@ function loadSlotMeta(cwd, slot, v) {
     if (!existsSync(p)) return { ts }
     const data = JSON.parse(readFileSync(p, "utf8"))
     const history = data.history ?? []
-    const meta = extractSlotMeta(history, data.activeProvider, data.updatedAt ?? ts)
+    const meta = extractSlotMeta(history, data.activeProvider, data.updatedAt ?? ts, data.title ?? "")
     return { ts, ...meta }
   } catch {
     return { ts }
@@ -229,6 +245,7 @@ export function listSlots(cwd) {
         activeProvider: meta.activeProvider ?? "",
         updatedAt: meta.updatedAt ?? meta.ts,
         updatedDate: new Date(meta.updatedAt ?? meta.ts).toLocaleString(),
+        title: meta.title ?? "",
       }
     })
     .sort((a, b) => b.updatedAt - a.updatedAt)
@@ -265,14 +282,20 @@ function isLegacyTransient(m) {
 
 /** Save agent state and display lines to the active slot file (atomic write) */
 export function saveSession(agent, display) {
-  const history = agent.history.filter((m) => !m.transient && !isLegacyTransient(m))
+  // _fullHistory is written at the source via pushReal — no flush needed here.
+  // history        = FULL, never-compacted (human-readable; VS Code panel & CLI resume read this)
+  // contextHistory = machine context (possibly compacted) so CLI resume keeps the token savings
+  const history = (agent._fullHistory ?? agent.history).filter((m) => !m.transient && !isLegacyTransient(m))
+  const contextHistory = agent.history.filter((m) => !m.transient && !isLegacyTransient(m))
   const data = {
     version: 2,
     cwd: agent.cwd,
+    title: agent.title ?? "",
     activeProvider: agent.activeProvider ?? agent.provider?.name,
     activeModel: agent.activeModel ?? null,
     updatedAt: Date.now(),
     history,
+    contextHistory,
     display: display ?? [],
     tasks: agent.tasks ?? [],
     planMode: agent.planMode ?? false,
@@ -350,7 +373,15 @@ export function loadSession(cwd) {
 
 /** Apply loaded session data onto an agent object; returns true if provider was switched */
 export function applySession(agent, data) {
-  agent.history = data.history
+  // data.history is the FULL never-compacted record (human line); data.contextHistory is the
+  // (possibly compacted) machine line. Restore each line from its own source — the machine
+  // context keeps its compaction savings across resume. Legacy files without contextHistory
+  // fall back to seeding the machine line from the full history (it re-compacts when needed).
+  const full = Array.isArray(data.history) ? data.history : []
+  const machine = Array.isArray(data.contextHistory) ? data.contextHistory : full
+  agent._fullHistory = [...full]
+  agent.history = [...machine]
+  agent.title = data.title ?? ""
   agent.tasks = data.tasks ?? []
   agent.planMode = data.planMode ?? false
   agent.autoApprove = data.autoApprove ?? false
@@ -392,34 +423,19 @@ export function applySession(agent, data) {
 /**
  * Create a new session slot: allocate a free slot number,
  * write an empty session, and mark it as the active slot.
- * Evicts the oldest slot if MAX_SLOTS is reached.
+ * No limit on the number of sessions.
  */
 export function newSession(cwd) {
   const m = loadManifest(cwd)
   // Ensure active is set (migrate if needed)
   if (!m.active) ensureActive(cwd, m)
 
-  let slot
-  const entries = Object.entries(m.slots).filter(([n]) => /^\d+$/.test(n))
-  if (entries.length < MAX_SLOTS) {
-    slot = 1
-    while (m.slots[slot]) slot++
-  } else {
-    // Full — evict oldest (but never evict the currently active slot)
-    const candidates = entries.filter(([n]) => Number(n) !== m.active)
-    if (candidates.length === 0) {
-      // Should not happen with MAX_SLOTS >= 2 — manifest corruption or all slots are active
-      console.error(`[session] newSession: all ${entries.length} slots are active, cannot evict. Overwriting oldest non-active slot skipped; reusing slot 1.`)
-      slot = 1
-    } else {
-      slot = Number(candidates.sort(slotCmp)[0][0])
-    }
-    // Delete the evicted slot file
-    try { unlinkSync(slotPath(cwd, slot)) } catch {}
-  }
+  // Find next available slot number
+  let slot = 1
+  while (m.slots[slot]) slot++
 
   // Write empty session
-  const data = { version: 2, cwd, updatedAt: Date.now(), history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null }
+  const data = { version: 2, cwd, title: "", updatedAt: Date.now(), history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null }
   writeSessionFile(slotPath(cwd, slot), data)
   m.slots[slot] = slotDigest(data)
   m.active = slot

package/src/tools/checklist.mjs

@@ -31,14 +31,15 @@ function parse(filePath) {
     const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
     const text = m[3].trim()
 
-    // Extract explicit ID if present (e.g. "T1:", "T1.1:")
-    const idMatch = text.match(/^(T[\d.]+):/)
+    // Extract explicit ID if present (e.g. "T1:", "T1.1:") — strip it from the text
+    // so write() doesn't re-prepend it (round-trip would otherwise accumulate "T1: T1: ...")
+    const idMatch = text.match(/^(T[\d.]+):\s*/)
     const node = {
       id: idMatch ? idMatch[1] : null,
       index: flatIdx,
       depth,
       status,
-      text,
+      text: idMatch ? text.slice(idMatch[0].length) : text,
       children: [],
     }
 

package/src/tools/codemode.mjs

@@ -30,8 +30,11 @@ const MAX_OUTPUT = 50_000
 const MAX_SCRIPT = 50_000
 const DEFAULT_TIMEOUT = 30_000
 
-/** SSRF-safe fetch: only http/https, private IP rejection, 10s timeout. */
-async function sandboxFetch(url) {
+/** SSRF-safe fetch: only http/https, private IP rejection, 10s timeout.
+ *  Validation throws SYNCHRONOUSLY so the vm sandbox's try/catch can catch it —
+ *  an async throw here would become an unhandled rejection and crash the host process,
+ *  and the rejection message would never reach the model. */
+function sandboxFetch(url) {
   const parsed = new URL(url)
   if (!["http:", "https:"].includes(parsed.protocol)) {
     throw new Error(`CodeMode fetch: protocol not allowed: ${parsed.protocol}`)
@@ -40,6 +43,10 @@ async function sandboxFetch(url) {
   if (isPrivateHost(parsed.hostname)) {
     throw new Error(`CodeMode fetch: private/internal host not allowed: ${parsed.hostname}`)
   }
+  return doFetch(url)
+}
+
+async function doFetch(url) {
   const ctrl = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), 10_000)
   try {
@@ -158,11 +165,10 @@ export const codeModeTool = {
     })
 
     try {
-      const script = new Script(code, {
-        filename: "codemode.js",
-        timeout: timeoutMs,
-      })
-      script.runInContext(sandbox)
+      const script = new Script(code, { filename: "codemode.js" })
+      // timeout belongs on runInContext — the Script constructor ignores it,
+      // so passing it there let runaway scripts (while(true)) hang the process forever.
+      script.runInContext(sandbox, { timeout: timeoutMs })
       return output.join("\n") || "(no output)"
     } catch (err) {
       const out = output.join("\n")

package/src/tui/agent-turn.mjs

@@ -355,6 +355,21 @@ export async function runAgentTurn(ctx, text) {
     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)

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

@@ -153,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" },
     ]
@@ -201,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-session.mjs

@@ -18,14 +18,14 @@ export async function handleSessionCommand(ctx) {
   const entries = [
     { type: "header", text: `Sessions (● = active, ↑↓ select, Enter switch, Esc cancel)` },
     ...slots.map((s) => {
-      const preview = s.firstMessage ? `"${truncate(s.firstMessage, 40)}"` : "(empty)"
+      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} │ ${preview}${model}${marker}`,
+        text: `Slot ${s.slot} │ ${turns} │ ${when} │ ${label}${model}${marker}`,
         slot: s.slot,
       }
     }),

package/src/tui/index.mjs

@@ -27,7 +27,7 @@ import { createWizard } from "./wizard.mjs"
 import { createPickers } from "./pickers.mjs"
 import { runDistill as runDistillImpl } from "./distill-cmd.mjs"
 import { createInteraction } from "./interaction.mjs"
-import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText } from "./clipboard.mjs"
+import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText, translateShiftEnter } from "./clipboard.mjs"
 import { runAgentTurn } from "./agent-turn.mjs"
 import { createKeyHandler } from "./key-handler.mjs"
 import { showStartup, backgroundIndex } from "./startup.mjs"
@@ -64,6 +64,7 @@ export async function startTUI(agent, opts = {}) {
     cursor: 0,
     history: [],
     historyIndex: -1,
+    _draft: null, // stashed unsent input while navigating history (restored on down past newest)
     scroll: 0, // scroll lines from bottom upward
     processing: false,
     controller: null, // AbortController for current agent run
@@ -88,6 +89,7 @@ export async function startTUI(agent, opts = {}) {
     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
+    exitArmed: false, // Ctrl+C double-confirm: first press arms, second (within window) exits
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)
@@ -108,7 +110,11 @@ export async function startTUI(agent, opts = {}) {
   const startupRows = process.stdout.rows || 24
   emitKeypressEvents(keyStream)
   process.stdin.setRawMode(true)
-  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn)
+  // Keyboard enhancement — enable BOTH protocols (unsupported terminals ignore them):
+  // kitty push (\x1b[>1u): Shift+Enter → \x1b[13;2u (Windows Terminal 1.19+, VS Code, kitty, iTerm2)
+  // modifyOtherKeys lvl 2 (\x1b[>4;2m): Shift+Enter → \x1b[27;2;13~ (mintty / Git Bash)
+  // translateShiftEnter (stdin layer) maps both to \x1b\r → meta+return → multiline branch.
+  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn + ansi.keyboardPush + ansi.modifyOtherKeysOn)
 
   const utf8Decoder = new TextDecoder("utf-8", { fatal: false })
 
@@ -181,6 +187,9 @@ export async function startTUI(agent, opts = {}) {
       text = text.slice(0, -tail[0].length)
     }
 
+    // Shift+Enter (keyboard-enhanced terminals) → Alt+Enter path (\x1b\r = meta+return)
+    text = translateShiftEnter(text)
+
     if (state.scroll !== lastRenderedScroll) {
       lastRenderedScroll = state.scroll
       render()
@@ -210,7 +219,7 @@ export async function startTUI(agent, opts = {}) {
       // Can't close? fine, process is exiting anyway
     }
     process.stdin.setRawMode(false)
-    process.stdout.write(ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
+    process.stdout.write(ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.keyboardPop + ansi.modifyOtherKeysOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
   }
   process.on("exit", cleanup)
 
@@ -260,6 +269,7 @@ export async function startTUI(agent, opts = {}) {
     state.cursor = 0
     state.history.push(text)
     state.historyIndex = -1
+    state._draft = null // submitted — the draft is now history
     state.scroll = 0
 
     // Slash commands: handled locally, don't enter agent loop