thincoder 0.12.19 → 0.12.20

package/package.json

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

package/src/memory/docs.mjs

@@ -227,7 +227,7 @@ export function memoryTools(memory, opts = {}) {
             tags: (args.tags ?? "").split(/\s+/).filter(Boolean),
             author: opts.author ?? "unknown",
           })
-          return `Saved to project memory (${filename}): [${args.type}] ${args.title}\nNote: file written to the repo; commit it yourself when ready.`
+          return `Saved to project memory (${filename}): [${args.type}] ${args.title}`
         }
         if (!opts.team?.dir) {
           throw new Error("team scope not configured: set memory.team in ~/.thincoder/config.json")

package/src/prompts/engineering.md

@@ -3,7 +3,7 @@
 ## Your Role: Designer, not Implementer
 
 You are the ARCHITECT. In this mode your deliverables are:
-1. the design document (docs/),
+1. the requirements + design documents (docs/),
 2. the design review (via `advisor` with `type="design"`),
 3. the approved implementation plan handed to an eng-coder.
 
@@ -13,29 +13,39 @@ subagents only.
 
 ## Mandatory Flow (every task, no skipping)
 
-1. **Design first.** Write the design document in `docs/` (problem statement,
+1. **Clarify requirements.** Ask open-ended questions (see Questioning Style)
+   until who/what/why are unambiguous, then write the REQUIREMENTS doc — three
+   layers per METHODOLOGY: overall goal / functional user stories /
+   non-functional standards. Clarification is DONE when each layer is concrete
+   enough to design against (the user confirms, or the answers stop changing
+   the requirement). Do NOT start the design before this.
+2. **Design.** Write the design document in `docs/` (problem statement,
    solution approach, full affected-file list, verifiable acceptance criteria).
    Do NOT open any code file for editing before this document exists.
-2. **Design review.** Call `advisor` with `type="design"` to review it, passing
+3. **Design review.** Call `advisor` with `type="design"`, passing
    `documents=[...]` — the explicit list of doc paths to review (requirements +
-   design + referenced docs). The advisor reviews ONLY those docs; it does not
-   scan git diff. This runs a dedicated design review in an isolated context.
-   - If advisor finds issues: fix the design, re-submit. Repeat until advisor approves.
+   design + referenced docs; METHODOLOGY.md is read by the advisor itself).
+   This runs a dedicated design review in an isolated context.
+   - If advisor finds issues: fix the design, re-submit.
    - If advisor approves: it returns a design token in plain text in its response.
-3. **User sign-off.** Present the design to the user and WAIT for explicit
-   approval before any implementation step.
-4. **Implement via eng-coder.** Spawn a subagent with `role="eng-coder"`,
+   - If the advisor keeps rejecting after 3 rounds, STOP and report the open
+     issues to the user — do not loop silently.
+4. **User sign-off.** Present the design summary AND the advisor's findings
+   (any remaining 🟡 advisories the user should know about) and WAIT for
+   explicit approval before any implementation step.
+5. **Implement via eng-coder.** Spawn a subagent with `role="eng-coder"`,
    providing the METHODOLOGY task structure: the **Docs involved** list (design
    doc + requirements + referenced docs), the file list, the acceptance
-   criteria — AND the designToken verbatim (the exact token string from the
-   advisor output). The token is required — eng-coder cannot modify files
+   criteria. Pass the designToken via the `designToken` PARAMETER — never in
+   the task text. The token is required — eng-coder cannot modify files
    without it.
-5. **Delivery review.** After eng-coder returns, verify the delivery against
-   the acceptance criteria from the design. The eng-coder self-reviewed inside
-   the subagent — its advisor(code) call happens there. Re-review with the
-   `advisor` tool (`type="code"`, `documents=[...]` = the task's Docs involved
-   list) only when the user asks or the delivery looks wrong.
-6. **Verify.** Run `verify` — it must pass before you claim the task complete.
+6. **Delivery review.** After eng-coder returns, verify the delivery against
+   the acceptance criteria from the design (run the tests it claims pass, read
+   the changed files). The eng-coder self-reviewed inside the subagent — its
+   advisor(code) call happens there. Re-review with the `advisor` tool
+   (`type="code"`, `documents=[...]` = the task's Docs involved list) only when
+   the user asks or the delivery looks wrong.
+7. **Verify.** Run `verify` — it must pass before you claim the task complete.
 
 ## Work Loop (every user message)
 
@@ -45,9 +55,9 @@ passed?
 
 | State | Default action |
 |---|---|
-| Requirements exploration | Clarify (who/what/why — never how), explore the current state, then write the REQUIREMENTS doc — three layers per METHODOLOGY: overall goal / functional user stories / non-functional standards |
-| Design | Write or refine the DESIGN doc (approach + rationale, architecture/interface, affected files, key decisions), organized by business domain per METHODOLOGY, ask for confirmation |
-| Awaiting approval | Present design summary, WAIT for explicit approval |
+| Requirements exploration | Clarify (who/what/why — never how), explore the current state, then write the REQUIREMENTS doc — three layers per METHODOLOGY: overall goal / functional user stories / non-functional standards (flow step 1) |
+| Design | Write or refine the DESIGN doc (approach + rationale, architecture/interface, affected files, key decisions), organized by business domain per METHODOLOGY, ask for confirmation (flow steps 2-3) |
+| Awaiting approval | Present design summary + advisor findings, WAIT for explicit approval (flow step 4) |
 | Implementation | eng-coder is working — do not redesign in parallel |
 | Delivery review | Verify the delivery against the acceptance criteria (the eng-coder self-reviewed inside the subagent); re-review with advisor (type="code", documents = Docs involved) only when the user asks or the delivery looks wrong; report |
 | Wrapped up | Report, wait for next instruction |
@@ -68,7 +78,23 @@ Then handle the message:
 
 End every turn with three checks: ① decisions written to docs? ② current state
 named and next step stated? ③ what the user must do (approve / clarify / continue)?
-No code edits outside approved minor fixes. No unprompted advisor calls.
+No code edits outside approved minor fixes (typos in docs you own, etc. —
+never implementation code). No unprompted advisor calls.
+
+## Questioning Style (requirement clarification)
+
+Clarify with OPEN-ENDED questions — the user's own words carry constraints you
+cannot enumerate. When using the `question` tool:
+
+- Default to free text (no `options`). "What should X do when…?" invites the
+  real answer; a preset list can only contain what you already guessed.
+- Use `options` ONLY for finite enumerations: choose a tech stack, pick A/B/C,
+  select from a closed set. (The UI always offers a custom-answer channel, so
+  a preset list never blocks a written answer.)
+- Ask ONE question per tool call; wait for the answer before asking the next.
+  Chain questions in sequence: each answer drives the next question.
+- Never make the user fight the UI: if a question needs explanation or nuance,
+  free text, not a multiple-choice guess.
 
 ## Hard Rules
 

package/src/session.mjs

@@ -317,8 +317,11 @@ export { isLegacyTransient }
 
 // ========== core read/write ==========
 
-/** Save agent state and display lines to the active slot file (atomic write) */
-export function saveSession(agent, display) {
+/** Save agent state to the active slot file (atomic write). `display` (the old
+ *  WYSIWYG render snapshot) is DEPRECATED — it drifted out of sync with history
+ *  whenever VS Code wrote the slot, and the TUI resumed from a stale snapshot.
+ *  Restore now always rebuilds from history (lazy, see startup.mjs). */
+export function saveSession(agent) {
   // _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
@@ -333,7 +336,6 @@ export function saveSession(agent, display) {
     updatedAt: Date.now(),
     history,
     contextHistory,
-    display: display ?? [],
     tasks: agent.tasks ?? [],
     planMode: agent.planMode ?? false,
     autoApprove: agent.autoApprove ?? false,
@@ -367,9 +369,6 @@ export function loadSession(cwd) {
       if (!Array.isArray(data.history)) return null
       if (data.cwd && data.cwd.toLowerCase() !== cwd.toLowerCase()) return null
       data.history = data.history.filter((m) => !isLegacyTransient(m))
-      data.display = Array.isArray(data.display)
-        ? data.display.filter((l) => l && typeof l.text === "string").map((l) => ({ text: l.text, color: l.color }))
-        : []
       data._recovered = false
       return data
     } catch (e) {
@@ -473,7 +472,7 @@ export function newSession(cwd) {
   while (m.slots[slot]) slot++
 
   // Write empty session
-  const data = { version: 2, cwd, title: "", 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: [], 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/codemode.mjs

@@ -1,36 +1,42 @@
 /**
- * tools/codemode.mjs — CodeMode: sandboxed JS execution tool
+ * tools/codemode.mjs — CodeMode: JavaScript execution tool
  *
  * Gives the model an `execute` tool backed by Node.js vm.Script.runInNewContext.
  * Multiple tool calls can be composed into a single script, reducing API round-trips
  * and keeping large intermediate results out of context.
  *
- * Sandbox API (all sync, no callbacks):
+ * Sandbox API:
  *   readFile(path)      — read a file relative to cwd, return string
  *   writeFile(path, c)  — write content to a file (auto-creates parent dirs)
  *   glob(pattern)        — return array of matching paths
  *   grep(pattern, file)  — return array of matching lines
  *   log(...args)         — append to output buffer
- *   fetch(url)           — HTTP GET, return string (SSRF-protected)
+ *   fetch(url)           — HTTP GET, return string
  *
- * Not available: require, import, process, child_process, setTimeout, any Node API.
+ * Full Node access via require()/process — no fake sandbox. The bash tool can
+ * already reach any Node API, so blocking require here only misled the model
+ * about its real capability boundary (project philosophy: no command-level
+ * sandbox; transparency + trust + audit).
  *
- * Limits:
+ * Limits (engineering guards, not security):
  *   timeout: 30s (configurable via timeoutMs param)
  *   maxOutput: 50000 bytes
  *   maxScriptSize: 50000 bytes
+ *   file paths confined to cwd (accidental out-of-workspace writes)
  */
 
 import { Script, createContext } from "node:vm"
+import { createRequire } from "node:module"
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs"
 import { join, dirname, relative, resolve } from "node:path"
-import { DESC, globToRegex, normalizeEOL, isPrivateHost } from "./shared.mjs"
+import { DESC, globToRegex, normalizeEOL } from "./shared.mjs"
 
 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.
+/** fetch: only http/https (protocol guard kept; no private-host rejection — the
+ *  bash tool can reach anything anyway, so the SSRF check was a fake boundary).
  *  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. */
@@ -39,10 +45,6 @@ function sandboxFetch(url) {
   if (!["http:", "https:"].includes(parsed.protocol)) {
     throw new Error(`CodeMode fetch: protocol not allowed: ${parsed.protocol}`)
   }
-
-  if (isPrivateHost(parsed.hostname)) {
-    throw new Error(`CodeMode fetch: private/internal host not allowed: ${parsed.hostname}`)
-  }
   return doFetch(url)
 }
 
@@ -66,7 +68,7 @@ export const codeModeTool = {
     properties: {
       code: {
         type: "string",
-        description: "JavaScript code to execute in the sandbox. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args).",
+        description: "JavaScript code to execute. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args). require()/process/Node modules are available.",
       },
       timeoutMs: {
         type: "integer",
@@ -88,12 +90,10 @@ export const codeModeTool = {
     const output = []
     const timeoutMs = Math.min(args.timeoutMs ?? DEFAULT_TIMEOUT, 60_000)
 
-    // File path guard: ensure paths are within cwd
+    // File path guard: ensure paths are within cwd (accidental out-of-workspace writes)
     function safePath(p) {
       if (typeof p !== "string") throw new Error(`Path must be a string, got ${typeof p}`)
-      // Normalize and resolve
       const abs = resolve(cwd, p)
-      // Check containment
       const rel = relative(cwd, abs)
       if (rel.startsWith("..") || (rel.includes("..") && process.platform === "win32")) {
         throw new Error(`Path traversal denied: ${p}`)
@@ -101,11 +101,6 @@ export const codeModeTool = {
       return abs
     }
 
-    // Block dynamic imports: check for import() syntax before execution
-    if (/\bimport\s*\(/.test(code)) {
-      return "Error: dynamic import() is not allowed in CodeMode sandbox. Use the provided readFile/writeFile/glob/grep/fetch functions instead."
-    }
-
     const sandbox = createContext({
       readFile: (p) => {
         const abs = safePath(p)
@@ -159,9 +154,11 @@ export const codeModeTool = {
         }
       },
       fetch: sandboxFetch,
-      // Block process and require access
-      require: () => { throw new Error("require() is not available in CodeMode sandbox") },
-      process: undefined,
+      // Full Node access — no fake sandbox (bash can reach it anyway).
+      require: createRequire(join(cwd, "__codemode__.js")),
+      process,
+      setTimeout,
+      clearTimeout,
     })
 
     try {

package/src/tools/execute.md

@@ -1,5 +1,5 @@
-Execute sandboxed JavaScript code. Use this to compose multiple file operations into one call — read, write, glob, grep, and log results. No network or system access. Max 30s timeout, 50KB output.
+Execute JavaScript code with full Node access. Use this to compose multiple file operations into one call — read, write, glob, grep, log, or require() any module. Max 30s timeout, 50KB output.
 
 Parameters:
-- code (required): JavaScript code to execute in the sandbox. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args).
+- code (required): JavaScript code to execute. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args). require()/process/Node modules are available.
 - timeoutMs: Timeout in milliseconds (default 30000, max 60000)

package/src/tui/cmd-session.mjs

@@ -1,5 +1,6 @@
 import { listSlots, switchToSlot, applySession } from "../session.mjs"
 import { ansi, C } from "./ansi.mjs"
+import { restoreLines } from "./startup.mjs"
 
 /** /session command: list/switch session slots.
  *  ctx: { agent, state, showPicker, pushLine, pushLabel, render } */
@@ -38,7 +39,9 @@ export async function handleSessionCommand(ctx) {
     return
   }
   applySession(agent, data)
-  state.lines = data.display.length ? [...data.display] : []
+  // Rebuild from history (lazy) — the display snapshot is deprecated.
+  state.lines = []
+  restoreLines(state, data.history)
   state.tasks = agent.tasks ?? []
   if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
     state.tasks = []

package/src/tui/index.mjs

@@ -31,7 +31,8 @@ import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText, trans
 import { parseMouseClicks, handleMouseClick } from "./mouse.mjs"
 import { runAgentTurn } from "./agent-turn.mjs"
 import { createKeyHandler } from "./key-handler.mjs"
-import { showStartup, backgroundIndex } from "./startup.mjs"
+import { showStartup, backgroundIndex, historyToLines, HISTORY_PAGE_MESSAGES } from "./startup.mjs"
+import { countConvLines } from "./render-conversation.mjs"
 import { createConfigHelpers } from "./config-helpers.mjs"
 
 /** 升级失败提示文案：附 npm 输出尾部（最多 3 行），方便定位失败原因。 */
@@ -92,6 +93,11 @@ export async function startTUI(agent, opts = {}) {
     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
+    // Lazy history window (parity with VS Code): only the latest messages are
+    // materialized on restore; PgUp-at-top loads earlier pages via loadOlder.
+    _historyLoaded: 0, // messages loaded from the TAIL of _fullHistory
+    _historyTotal: 0, // total messages in the restored session
+    _hasOlder: false, // more earlier messages remain unloaded
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)
@@ -221,7 +227,7 @@ export async function startTUI(agent, opts = {}) {
     // 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 {
-      saveSession(agent, state.lines)
+      saveSession(agent)
     } catch {
       // Save failure shouldn't block exit
     }
@@ -252,6 +258,39 @@ export async function startTUI(agent, opts = {}) {
     render()
   }
 
+  /**
+   * Load the next earlier page of restored history (lazy, parity with VS Code
+   * loadOlder). Prepends earlier source lines and compensates scroll so the
+   * visible content does not jump. Called from key-handler when PgUp hits the top.
+   */
+  const loadOlder = () => {
+    if (!state._hasOlder) return
+    const full = agent._fullHistory ?? []
+    const loaded = state._historyLoaded
+    const start = Math.max(0, full.length - loaded - HISTORY_PAGE_MESSAGES)
+    const end = full.length - loaded
+    if (start >= end) return
+
+    const cols = process.stdout.columns || 80
+    const before = countConvLines(state, cols)
+
+    // Drop the old placeholder, prepend the older page, re-add the placeholder
+    // (with an updated count) only if more remain.
+    if (state.lines[0]?.text?.startsWith("… ")) state.lines.shift()
+    state.lines.unshift(...historyToLines(full, start, end))
+    state._historyLoaded += end - start
+    state._hasOlder = start > 0
+    if (state._hasOlder) {
+      state.lines.unshift({ text: `… ${start} more earlier messages (PgUp at top to load)`, color: C.dim })
+    }
+
+    // Scroll compensation: prepending N display rows must move scroll by N to
+    // keep the previously-visible bottom-anchored content in place.
+    const after = countConvLines(state, cols)
+    state.scroll += Math.max(0, after - before)
+    render()
+  }
+
   // Only emit the assistant label once per turn (on first token or first tool call)
   let assistantLabeled = false
   const ensureAssistantLabel = () => {
@@ -380,7 +419,7 @@ export async function startTUI(agent, opts = {}) {
     agent, state, render, popPicker, renderPickerLines,
     handleSlash, handleTab, submit, pasteClipboardImage,
     wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
-    renderWizard, pushLine, cleanup, showPicker,
+    renderWizard, pushLine, cleanup, showPicker, loadOlder,
   })
   keyStream.on("keypress", (str, key) => {
     try {

package/src/tui/interaction.mjs

@@ -4,6 +4,11 @@ import { detectDanger } from "../tools/shared.mjs"
 /** Interaction primitives: permission approval + question input.
  *  Extracted from index.mjs, receives closure dependencies via createInteraction(ctx).
  *  ctx: { agent, state, pushLine, pushLabel, render, summarize } */
+
+/** Sentinel appended to question option lists — selecting it switches to free-text
+ *  answer mode (the user supplements/corrects the AI's preset choices). */
+export const QUESTION_CUSTOM = "\u0001custom-answer"
+
 export function createInteraction(ctx) {
   const { agent, state, pushLine, pushLabel, render, summarize } = ctx
 
@@ -74,11 +79,13 @@ export function createInteraction(ctx) {
         render()
       })
     }
-    // options mode: show list in input box, arrow keys to select, Enter to confirm
+    // options mode: show list in input box, arrow keys to select, Enter to confirm.
+    // A "custom answer" sentinel is appended so the user can always type their own
+    // answer instead of picking a preset — the AI's options are never exhaustive.
     pushLabel(`❯ Question`, ansi.bold + C.tool)
     for (const line of text.split("\n")) pushLine(`  ${line}`, C.text)
     return new Promise((resolve) => {
-      state.question = { text, options, selected: 0, resolve }
+      state.question = { text, options: [...options, QUESTION_CUSTOM], selected: 0, resolve }
       state.status = "Waiting for choice..."
       render()
     })

package/src/tui/key-handler.mjs

@@ -2,6 +2,16 @@ import { ansi, C } from "./ansi.mjs"
 import { readClipboardText, insertPastedText } from "./clipboard.mjs"
 import { computeLayout } from "./layout.mjs"
 import { handleSearchKey } from "./key-handler-search.mjs"
+import { countConvLines } from "./render-conversation.mjs"
+import { QUESTION_CUSTOM } from "./interaction.mjs"
+
+/** Current conversation max scroll offset (display lines beyond the visible panel). */
+function convMaxScroll(state) {
+  const cols = process.stdout.columns || 80
+  const rows = process.stdout.rows || 24
+  const layout = computeLayout(state, { cols, rows })
+  return Math.max(0, countConvLines(state, cols) - layout.panels.conversation.h)
+}
 
 /** Keyboard event dispatch: permission confirm / question / picker / wizard / edit / scroll / history / paste.
  *  Extracted from index.mjs.
@@ -10,7 +20,7 @@ import { handleSearchKey } from "./key-handler-search.mjs"
  *         wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
  *         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, showPicker } = ctx
+  const { agent, state, render, popPicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup, showPicker, loadOlder } = ctx
 
   return function onKeypress(str, key = {}) {
     // permission confirm state: y approve / n deny / a approve + turn ON AUTO (no further prompts)
@@ -58,6 +68,15 @@ export function createKeyHandler(ctx) {
           render()
         } else if (key.name === "return") {
           const answer = q.options[q.selected ?? 0]
+          if (answer === QUESTION_CUSTOM) {
+            // Switch to free-text mode — the user wants to type their own answer.
+            q.options = []
+            q.answer = ""
+            q.selected = undefined
+            state.status = "Waiting for answer..."
+            render()
+            return
+          }
           q.resolve(answer)
           state.question = null
           state.status = "Processing..."
@@ -268,7 +287,13 @@ export function createKeyHandler(ctx) {
 
     // page scroll
     if (key.name === "pageup") {
-      state.scroll += Math.max(1, (process.stdout.rows || 24) - 8)
+      // At the top of the conversation → load the next earlier history page
+      // (lazy restore, parity with VS Code's scroll-back loadOlder).
+      if (state._hasOlder && loadOlder && state.scroll >= convMaxScroll(state)) {
+        loadOlder()
+      } else {
+        state.scroll += Math.max(1, (process.stdout.rows || 24) - 8)
+      }
       render()
       return
     }

package/src/tui/layout.mjs

@@ -8,6 +8,7 @@
  * Fixed panels deducted first, conditional panels allocated by priority, remaining space to conversation.
  */
 import { layoutInput, wrapText } from "./render.mjs"
+import { QUESTION_CUSTOM } from "./interaction.mjs"
 
 const MAX_INPUT_LINES = 5
 const MAX_TASK_LINES = 5
@@ -36,7 +37,8 @@ export function computeLayout(state, { cols, rows }) {
     if (q.options.length > 0) {
       const sel = q.selected ?? 0
       const start = Math.max(0, Math.min(sel - 2, q.options.length - QWIN))
-      boxLines = q.options.slice(start, start + QWIN).map((opt, i) => (start + i === sel ? "▸ " : "  ") + opt)
+      boxLines = q.options.slice(start, start + QWIN).map((opt, i) =>
+        (start + i === sel ? "▸ " : "  ") + (opt === QUESTION_CUSTOM ? "✍ Custom answer…" : opt))
     } else {
       boxLines = ["▸ " + (q.answer ?? "")]
     }

package/src/tui/startup.mjs

@@ -2,6 +2,60 @@ import { listSlots } from "../session.mjs"
 import { sliceByWidth } from "./render.mjs"
 import { ansi, C } from "./ansi.mjs"
 
+/** Lazy history window (parity with VS Code HISTORY_PAGE_SIZE): first paint loads
+ *  the latest INITIAL_HISTORY_MESSAGES, then PgUp-at-top loads HISTORY_PAGE_MESSAGES
+ *  more. Rebuilding an 8000-message session eagerly froze startup + first render. */
+export const INITIAL_HISTORY_MESSAGES = 200
+export const HISTORY_PAGE_MESSAGES = 50
+
+/**
+ * Convert history[startIdx, endIdx) into conversation source lines (label lines
+ * with a leading blank separator, content lines, tool summaries). `history` is the
+ * FULL array so the tool-result lookahead (history[i+1]) works across the page edge.
+ */
+export function historyToLines(history, startIdx, endIdx) {
+  const lines = []
+  for (let i = startIdx; i < endIdx; i++) {
+    const m = history[i]
+    if (m.role === "user") {
+      if (typeof m.content === "string" && m.content.startsWith("[System reminder:")) continue
+      if (lines.length > 0) lines.push({ text: "", color: C.dim })
+      lines.push({ text: "❯ You:", color: ansi.bold + C.user })
+      if (typeof m.content === "string" && m.content) lines.push({ text: m.content, color: C.text })
+    } else if (m.role === "assistant") {
+      if (lines.length > 0) lines.push({ text: "", color: C.dim })
+      lines.push({ text: "❯ ThinCoder:", color: ansi.bold + C.assistant })
+      if (typeof m.content === "string" && m.content) lines.push({ text: m.content, color: C.text })
+      for (const tc of m.tool_calls ?? []) {
+        const toolResult = history[i + 1]
+        const hasResult = toolResult?.role === "tool" && toolResult?.tool_call_id === tc.id
+        const summary = hasResult ? " → " + sliceByWidth(String(toolResult.content).split("\n")[0], 80) : ""
+        lines.push({ text: `  [tool] ${tc.function?.name ?? "?"}${summary}`, color: C.tool })
+      }
+    }
+  }
+  return lines
+}
+
+
+/**
+ * Lazy-restore a session into state.lines: materialize only the latest
+ * INITIAL_HISTORY_MESSAGES, set the _history* counters the loadOlder closure
+ * reads, and prepend the "… N more earlier messages" placeholder. Shared by
+ * startup restore and /session switching (the display snapshot is deprecated).
+ */
+export function restoreLines(state, history) {
+  const total = Array.isArray(history) ? history.length : 0
+  if (total === 0) return
+  const start = Math.max(0, total - INITIAL_HISTORY_MESSAGES)
+  state.lines.push(...historyToLines(history, start, total))
+  state._historyLoaded = total - start
+  state._historyTotal = total
+  state._hasOlder = start > 0
+  if (state._hasOlder) {
+    state.lines.unshift({ text: `… ${start} more earlier messages (PgUp at top to load)`, color: C.dim })
+  }
+}
 /** Startup screen + session recovery + background indexing.
  *  Extracted from index.mjs.
  *  ctx: { agent, state, opts, pushLine, pushLabel, render, startWizard } */
@@ -18,33 +72,10 @@ export function showStartup(ctx) {
   }
   pushLine(`Tools: ${agent.tools.map((t) => t.name).join(", ")}`, C.dim)
 
-  // Recover previous session: rebuild conversation display (tool result lines omitted, keep it clean)
-  if (opts.restored?.display?.length) {
-    // User-facing recovery: display is a WYSIWYG snapshot of the conversation before exit
-    state.lines = [...opts.restored.display.map((l) => ({ text: l.text, color: l.color })), ...state.lines]
-    const recoveryNote = opts.restored._recovered ? " (recovered from backup)" : ""
-    pushLabel(`── Restored previous session${recoveryNote}; /new for a fresh session ──`, C.warn)
-  } else if (opts.restored?.history?.length) {
-    // Rebuild conversation: user/assistant messages shown one by one, tool result lines show only first-line summary
-    for (let i = 0; i < opts.restored.history.length; i++) {
-      const m = opts.restored.history[i]
-      if (m.role === "user") {
-        if (typeof m.content === "string" && m.content.startsWith("[System reminder:")) continue
-        pushLabel(`❯ You:`, ansi.bold + C.user)
-        if (typeof m.content === "string" && m.content) pushLine(m.content, C.text)
-      } else if (m.role === "assistant") {
-        pushLabel(`❯ ThinCoder:`, ansi.bold + C.assistant)
-        if (typeof m.content === "string" && m.content) pushLine(m.content, C.text)
-        for (const tc of m.tool_calls ?? []) {
-          // Find the next corresponding tool result, show first-line summary
-          const toolResult = opts.restored.history[i + 1]
-          const hasResult = toolResult?.role === "tool" && toolResult?.tool_call_id === tc.id
-          const summary = hasResult ? " → " + sliceByWidth(String(toolResult.content).split("\n")[0], 80) : ""
-          pushLine(`  [tool] ${tc.function?.name ?? "?"}${summary}`, C.tool)
-        }
-      }
-      // Tool messages aren't rendered separately — already shown as summary after assistant's tool_calls
-    }
+  // Recover previous session: rebuild from history (lazy — display snapshot is
+  // deprecated; it drifted out of sync with history on VS Code writes).
+  if (opts.restored?.history?.length) {
+    restoreLines(state, opts.restored.history)
     pushLabel(`── Restored previous session (${opts.restored.history.length} messages); /new for a fresh session ──`, C.warn)
   }