thincoder 0.8.13 → 0.9.0

package/README.md

@@ -205,6 +205,17 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.9.0 (2026-07)
+- **Config JSON Schema** — `saveConfig` auto-injects `$schema` reference; `docs/schemas/config.schema.json` provides editor autocompletion/validation for all config fields including the new `hooks` section.
+- **Lifecycle Hooks** — `PreToolUse` / `PostToolUse` / `PostToolUseFailure` / `Notification` events. User-defined shell commands in config, with per-tool regex matching, timeout control, and `block`/`allow`/`notify` actions. Implemented in `src/hooks.mjs`, integrated into tool dispatch.
+- **Built-in Skills (5)** — `pdf-create`, `xlsx-create`, `frontend-design`, `code-review`, `api-design` ship with the installation. Each is a standalone markdown instruction file using zero-dependency approaches (Chrome headless for PDF, PowerShell for Excel, etc.).
+- **Conversation message folding** — Long tool result blocks (>8 consecutive dim lines) auto-collapse to first 2 lines + "… N more lines — Enter to expand". `/fold on|off` toggles globally.
+- **Tree-shaped tasks** — `checklist` tool now supports hierarchical task IDs (`T1`, `T1.1`, `T1.2.1`) with auto-assigned numbering. `add` accepts `parent` parameter for subtree positioning. Indentation-based persistence in `checklist.md`.
+- **AI-native MCP config** — `/mcp add` picker now includes "Describe with AI" option. Describe a server in natural language → model generates config JSON → preview + confirm → save and connect.
+- **Goal judge model** — `goal complete` now runs an independent LLM check: goal criteria + recent agent activity → judge model verifies YES/NO. Prevents false completion claims during autonomous work.
+- **`/undo` command** — Tracks up to 50 write/edit/delete operations in `agent._undoStack`. `/undo` opens a picker showing each operation's file and original content size. Select to revert.
+- **Roadmap**: LSP tool, intelligent context management (checkpoint-based reconstruction), and CodeMode sandboxed JS are planned for 0.10.0.
+
 ### 0.8.13 (2026-07)
 - **TUI: incremental rendering** — panel-level cache (`panelCache`) with sync-update bracketing (`DECSET 2026`). Only redraws changed panels, eliminating flicker. `saveCursor`/`restoreCursor` for efficient cursor positioning. Panel order reorganized: `header → conversation → subagent → output → todo → picker → permission → queue → input → status`.
 - **Ctrl+I inject resume** — Ctrl+I (or Tab during processing) now properly interrupts, injects the message, and *resumes* the agent loop. Controller is recreated after abort. Added active signal check in SSE read loop for faster abort on Windows.

package/package.json

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

package/src/agent/dispatch.mjs

@@ -2,6 +2,8 @@
  * agent/dispatch.mjs — two-phase tool call execution
  */
 import { offloadToolResult } from "./helpers.mjs"
+import { runHooks } from "../hooks.mjs"
+import { snapshotForUndo } from "../tui/cmd-undo.mjs"
 import { writeFileSync, mkdirSync, existsSync } from "node:fs"
 import { join } from "node:path"
 import { homedir } from "node:os"
@@ -80,6 +82,13 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
     }
 
     callbacks.onToolCall?.(toolCall.name, args)
+
+    // PreToolUse hooks: allow user scripts to gate tool execution
+    if (!(await runHooks("PreToolUse", { agent, toolName: toolCall.name, toolArgs: args }))) {
+      prepared.push({ toolCall, tool, denied: true, reason: "blocked by PreToolUse hook" })
+      continue
+    }
+
     prepared.push({ toolCall, tool, args })
   }
 
@@ -91,11 +100,17 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
         ? "Error: plan mode is active — only read-only tools are allowed. Exit plan mode first."
         : item.reason === "denied by user"
           ? "Error: permission denied by user"
-          : "Error: no permission handler configured — this tool requires user approval but the current context doesn't support interaction (e.g. subagent or non-TUI mode)"
+          : item.reason === "blocked by PreToolUse hook"
+            ? "Error: blocked by PreToolUse hook"
+            : "Error: no permission handler configured — this tool requires user approval but the current context doesn't support interaction (e.g. subagent or non-TUI mode)"
       return { ...item, result: reason, ok: false }
     }
     try {
-      if (item.tool.outputPanel) callbacks.setupOutputPanel?.(item.toolCall.name)
+      // Snapshot for undo before side-effect tools
+      if (item.tool?.outputPanel) callbacks.setupOutputPanel?.(item.toolCall.name)
+      if (!item.tool?.readonly && item.args) {
+        snapshotForUndo(agent, item.toolCall.name, item.args, agent.cwd)
+      }
       const rawResult = await item.tool.execute(item.args, {
         cwd: agent.cwd,
         agent,
@@ -110,10 +125,13 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
       const raw = String(rawResult)
       const result = item.toolCall.name === "read_image" ? raw : await offloadToolResult(raw, item.toolCall.id)
       callbacks.onToolResult?.(item.toolCall.name, result)
+      // PostToolUse hooks: fire-and-forget (result not awaited on hook failure)
+      runHooks("PostToolUse", { agent, toolName: item.toolCall.name, toolArgs: item.args, result: raw }).catch(() => {})
       return { ...item, result, ok: true }
     } catch (error) {
       // Persist to ~/.thincoder/tool-errors/ for post-mortem; only pass message to the model (stack traces confuse LLMs and may leak paths)
       logToolError(item.toolCall.name, item.args, error)
+      runHooks("PostToolUseFailure", { agent, toolName: item.toolCall.name, toolArgs: item.args, error }).catch(() => {})
       return { ...item, result: `Error: ${error.message}`, ok: false }
     }
   }

package/src/agent-tools/goal.mjs

@@ -52,8 +52,45 @@ export const goalTool = {
       if (agent._mutatedThisRun && !agent._verifiedThisRun) {
         return "Error: files were modified but verify has not run. Run the check your criteria names AND the verify tool before marking the goal complete — false completion is the worst outcome of autonomous work."
       }
+
+      // Independent judge: verify the goal was actually achieved
+      // Only applies when the agent is at depth 0 (not a subagent) and has history to review
+      if (ctx.depth === 0 && agent.history.length > 2) {
+        try {
+          // Extract recent activity: last 4 assistant messages (summarizing what was done)
+          const recent = agent.history.filter(m => m.role === "assistant").slice(-4)
+          const activity = recent.map(m => (m.content ?? "").slice(0, 500)).join("\n---\n")
+          const { chat } = await import("../provider/index.mjs")
+          const judgeRes = await chat(agent.provider, {
+            messages: [{
+              role: "user",
+              content: `You are an independent goal judge. Evaluate whether this goal has been achieved based on the agent's activity.
+
+Goal: ${agent.goal.objective}
+Success criteria: ${agent.goal.criteria}
+
+Recent agent activity:
+${activity || "(no activity recorded)"}
+
+Has this goal been achieved? Answer ONLY "YES" or "NO" followed by a one-sentence reason.`,
+            }],
+            tools: [],
+            signal: AbortSignal.timeout(10_000),
+          })
+          const verdict = (judgeRes.content ?? "").trim()
+          if (verdict.toUpperCase().startsWith("NO")) {
+            return `Goal NOT complete (judge says NO): ${verdict.slice(2).trim()}\n\nContinue working or report blocked if this is a true impasse.`
+          }
+          if (!verdict.toUpperCase().startsWith("YES")) {
+            return `Goal completion unverified — judge response ambiguous: "${verdict.slice(0, 200)}". Re-check your criteria and try again with clear evidence.`
+          }
+        } catch {
+          // Judge unavailable — allow completion but note it
+        }
+      }
+
       agent.goal.status = "complete"
-      return `Goal marked complete: ${agent.goal.objective}\nIn your next message, summarize the evidence (what check ran, what it showed) — the user should be able to audit this claim.`
+      return `Goal verified complete ✓: ${agent.goal.objective}\nIn your next message, summarize the evidence (what check ran, what it showed) — the user should be able to audit this claim.`
     }
     if (args.action === "blocked") {
       if (!args.reason) return "Error: 'reason' required for 'blocked' action."

package/src/config.mjs

@@ -218,6 +218,8 @@ export function loadConfig() {
  */
 export function saveConfig(config) {
   mkdirSync(configDir, { recursive: true })
+  // Inject $schema for editor autocompletion/validation (strip on load)
+  config.$schema = "https://thincoder.dev/schemas/config.json"
   // 0600: config.json contains API keys, must not be world-readable (POSIX; chmod is best-effort on Windows)
   writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", { encoding: "utf8", mode: 0o600 })
   try { chmodSync(configPath, 0o600) } catch { /* may fail on Windows, ignore */ }

package/src/hooks.mjs

@@ -0,0 +1,93 @@
+/**
+ * hooks.mjs — Lifecycle hook engine
+ *
+ * Hooks are user-defined shell commands executed at key agent lifecycle points.
+ * Configured in ~/.thincoder/config.json under "hooks".
+ *
+ * Event types:
+ *   PreToolUse          — before each tool call (can block execution)
+ *   PostToolUse         — after successful tool execution
+ *   PostToolUseFailure  — after failed tool execution
+ *   Notification        — generic notification (triggered by agent)
+ *
+ * Each hook: { matcher?, command, args?, timeout?, action? }
+ *   matcher: regex against tool name (default: match all)
+ *   command: executable path/name
+ *   args: optional CLI args; without args, stdin receives JSON payload
+ *   timeout: ms (default 10000)
+ *   action: "allow" | "block" | "notify" (default "notify")
+ *
+ * "block" hooks: exit code 0 = allow, non-zero = block.
+ * "allow"/"notify": exit code ignored.
+ */
+
+import { spawn } from "node:child_process"
+
+/** @param {string} event @param {object} ctx @returns {Promise<boolean>} false if blocked */
+export async function runHooks(event, ctx) {
+  const hooks = ctx.agent?.config?.hooks?.[event]
+  if (!hooks?.length) return true
+
+  for (const hook of hooks) {
+    if (hook.matcher) {
+      try {
+        if (!new RegExp(hook.matcher).test(ctx.toolName ?? "")) continue
+      } catch { /* invalid regex → skip */ }
+    }
+
+    const allowed = await runOneHook(event, hook, ctx)
+    if (hook.action === "block" && !allowed) return false
+  }
+  return true
+}
+
+async function runOneHook(event, hook, ctx) {
+  const payload = JSON.stringify({
+    event,
+    toolName: ctx.toolName ?? null,
+    toolArgs: ctx.toolArgs ?? null,
+    result: ctx.result ?? null,
+    error: ctx.error?.message ?? null,
+    timestamp: new Date().toISOString(),
+  })
+
+  return new Promise((resolve) => {
+    const timeout = hook.timeout ?? 10_000
+    let settled = false
+    const done = (code) => {
+      if (settled) return
+      settled = true
+      resolve(code === 0)
+    }
+
+    let proc
+    try {
+      if (hook.args?.length) {
+        proc = spawn(hook.command, hook.args, {
+          stdio: ["pipe", "ignore", "ignore"],
+          timeout,
+          windowsHide: true,
+        })
+      } else {
+        proc = spawn(hook.command, [], {
+          stdio: ["pipe", "ignore", "ignore"],
+          timeout,
+          windowsHide: true,
+        })
+      }
+    } catch {
+      // command not found or spawn failure — don't block, don't crash
+      return resolve(true)
+    }
+
+    proc.on("error", () => done(0))     // spawn failure → allow
+    proc.on("close", (code) => done(code ?? 0))
+    proc.on("exit", (code) => done(code ?? 0))
+
+    // Send payload via stdin
+    try { proc.stdin?.end(payload) } catch { /* */ }
+
+    // Timeout guard
+    setTimeout(() => done(0), timeout + 1000)
+  })
+}

package/src/tools/checklist.md

@@ -1,7 +1,10 @@
 Manage the task checklist in .thincoder/checklist.md. Use at these points: after requirements are confirmed — add one entry per requirement point; when starting work — mark in_progress; when verified complete — mark done. Checklist entries map to requirement/design points — project-level tracking across sessions. For in-session subtask breakdown of a single checklist item, use the `task` tool instead. Completed items are auto-archived to .thincoder/checklist-done.md.
 
+Items support tree hierarchy via indentation (2 spaces per level) and auto-assigned IDs (T1, T1.1, T1.2.1). Use the `parent` parameter to add a child under an existing task.
+
 Parameters:
 - action: "add" | "mark" | "list"
 - item: text for new item (with "add")
-- index: 1-based index (with "mark")
+- index: 1-based index (with "mark")  
 - status: "pending" | "in_progress" | "done" (with "mark")
+- parent: parent task ID for hierarchical tasks, e.g. "T1" (with "add")

package/src/tools/checklist.mjs

@@ -8,38 +8,109 @@ const DONE = "checklist-done.md"
 function checklistPath(cwd) { return join(cwd, ".thincoder", CHECKLIST) }
 function donePath(cwd) { return join(cwd, ".thincoder", DONE) }
 
-/** Parse checklist file into array of { index, status, text } */
+/**
+ * Parse checklist file into tree-structured items.
+ * Indentation (2 spaces per level) determines parent-child relationships.
+ * Each item: { id, index, depth, status, text, children[] }
+ * "index" is the 1-based position in the flat markdown list.
+ */
 function parse(filePath) {
   if (!existsSync(filePath)) return []
   const lines = readFileSync(filePath, "utf-8").split("\n")
   const items = []
-  let idx = 0
+  let flatIdx = 0
+  const stack = [{ children: items, depth: -1 }] // virtual root
+
   for (const line of lines) {
-    const m = line.match(/^- \[(.)\] (.+)$/)
-    if (m) {
-      idx++
-      const raw = m[1]
-      const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
-      items.push({ index: idx, status, text: m[2].trim() })
+    const m = line.match(/^(\s*)- \[(.)\] (.+)$/)
+    if (!m) continue
+    flatIdx++
+    const indent = m[1]
+    const depth = Math.floor(indent.length / 2) // 2 spaces = 1 level
+    const raw = m[2]
+    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.]+):/)
+    const node = {
+      id: idMatch ? idMatch[1] : null,
+      index: flatIdx,
+      depth,
+      status,
+      text,
+      children: [],
     }
+
+    // Find parent by popping stack until we find a node at depth-1
+    while (stack.length > 1 && stack.at(-1).depth >= depth) stack.pop()
+    const parent = stack.at(-1)
+    parent.children.push(node)
+    // Auto-assign ID if not explicit
+    if (!node.id) {
+      const siblingCount = parent.children.length
+      const base = parent.id ? `${parent.id}` : "T"
+      if (parent.id) {
+        node.id = `${base}.${siblingCount}`
+      } else {
+        // Root level: T1, T2, T3...
+        let rootIdx = 0
+        for (const c of items) {
+          if (c.id?.match(/^T\d+$/)) rootIdx = Math.max(rootIdx, parseInt(c.id.slice(1)))
+        }
+        node.id = `T${rootIdx + 1}`
+      }
+    }
+    stack.push({ children: node.children, depth, id: node.id })
   }
   return items
 }
 
-/** Write items back to file */
-function write(filePath, items) {
-  mkdirSync(dirname(filePath), { recursive: true })
+/** Write items back to file, preserving tree structure */
+function write(filePath, items, _depth = 0) {
+  if (_depth === 0) mkdirSync(dirname(filePath), { recursive: true })
   const lines = []
+  const indent = "  ".repeat(_depth)
   for (const item of items) {
     const mark = item.status === "done" ? "x" : item.status === "in_progress" ? "~" : " "
-    lines.push(`- [${mark}] ${item.text}`)
+    const label = item.id ? `${item.id}: ${item.text}` : item.text
+    lines.push(`${indent}- [${mark}] ${label}`)
+    if (item.children?.length) {
+      lines.push(...write(filePath, item.children, _depth + 1).split("\n").filter(Boolean))
+    }
+  }
+  if (_depth === 0) {
+    writeFileSync(filePath, lines.join("\n") + "\n")
+    return ""
+  }
+  return lines.join("\n")
+}
+
+/** Find a node by ID in the tree */
+function findById(items, id) {
+  for (const item of items) {
+    if (item.id === id) return { parent: items, item, idx: items.indexOf(item) }
+    if (item.children?.length) {
+      const found = findById(item.children, id)
+      if (found) return found
+    }
   }
-  writeFileSync(filePath, lines.join("\n") + "\n")
+  return null
+}
+
+/** Flatten tree for mark action (index-based) */
+function flatten(items, out = []) {
+  for (const item of items) {
+    out.push(item)
+    if (item.children?.length) flatten(item.children, out)
+  }
+  return out
 }
 
 /** Parse pending items only (for context injection) */
 export function pendingItems(cwd) {
-  return parse(checklistPath(cwd)).filter(i => i.status !== "done")
+  const flat = flatten(parse(checklistPath(cwd)))
+  return flat.filter(i => i.status !== "done")
 }
 
 export const checklistTool = {
@@ -66,6 +137,10 @@ export const checklistTool = {
         enum: ["pending", "in_progress", "done"],
         description: "New status (required for mark)"
       },
+      parent: {
+        type: "string",
+        description: "Parent task ID for tree-structured tasks (e.g. 'T1')"
+      },
     },
     required: ["action"],
   },
@@ -75,9 +150,33 @@ export const checklistTool = {
       case "add": {
         if (!args.item || typeof args.item !== "string") return "Error: 'item' is required for add"
         const items = parse(checklistPath(ctx.cwd))
-        items.push({ index: items.length + 1, status: "pending", text: args.item })
+
+        let target = items
+        let parentId = null
+        if (args.parent) {
+          const found = findById(items, args.parent)
+          if (!found) return `Error: parent '${args.parent}' not found. Use 'list' to see all task IDs.`
+          target = found.item.children
+          parentId = found.item.id
+        }
+
+        // Auto-assign ID
+        let id
+        if (parentId) {
+          id = `${parentId}.${target.length + 1}`
+        } else {
+          let maxIdx = 0
+          for (const c of items) {
+            const m = c.id?.match(/^T(\d+)$/)
+            if (m) maxIdx = Math.max(maxIdx, parseInt(m[1]))
+          }
+          id = `T${maxIdx + 1}`
+        }
+
+        const node = { id, index: 0, depth: parentId ? 1 : 0, status: "pending", text: args.item, children: [] }
+        target.push(node)
         write(checklistPath(ctx.cwd), items)
-        return `Added: [ ] ${args.item}`
+        return `Added: [ ] ${id}: ${args.item}${parentId ? ` (under ${parentId})` : ""}`
       }
       case "mark": {
         if (args.index == null) return "Error: 'index' is required for mark"
@@ -85,8 +184,9 @@ export const checklistTool = {
         if (!status || !["pending", "in_progress", "done"].includes(status)) return "Error: 'status' is required (pending|in_progress|done)"
         const cp = checklistPath(ctx.cwd)
         const items = parse(cp)
-        if (args.index < 1 || args.index > items.length) return `Error: index ${args.index} out of range (1-${items.length})`
-        const item = items[args.index - 1]
+        const flat = flatten(items)
+        if (args.index < 1 || args.index > flat.length) return `Error: index ${args.index} out of range (1-${flat.length})`
+        const item = flat[args.index - 1]
         const old = item.status
         if (old === status) return `Already ${status}: ${item.text}`
         item.status = status
@@ -94,18 +194,30 @@ export const checklistTool = {
           // Move to done file
           const dp = donePath(ctx.cwd)
           const doneItems = parse(dp)
-          doneItems.push(item)
+          doneItems.push({ id: item.id, index: 0, depth: 0, status: "done", text: item.text, children: [] })
           write(dp, doneItems)
-          items.splice(args.index - 1, 1)
+          // Remove from tree
+          const found = findById(items, item.id)
+          if (found) found.parent.splice(found.idx, 1)
         }
         write(cp, items)
-        return `Marked #${args.index} ${old} → ${status}: ${item.text}`
+        return `Marked #${args.index} ${old} → ${status}: ${item.id}: ${item.text}`
       }
       case "list": {
         const items = parse(checklistPath(ctx.cwd))
         if (items.length === 0) return "(checklist is empty)"
         const marks = { pending: " ", in_progress: "~", done: "x" }
-        return items.map(i => `- [${marks[i.status]}] ${i.text}`).join("\n")
+        const lines = []
+        function render(nodes, depth) {
+          const indent = "  ".repeat(depth)
+          for (const n of nodes) {
+            const idTag = n.id ? `${n.id}: ` : ""
+            lines.push(`${indent}- [${marks[n.status]}] ${idTag}${n.text}`)
+            if (n.children?.length) render(n.children, depth + 1)
+          }
+        }
+        render(items, 0)
+        return lines.join("\n")
       }
       default:
         return `Error: unknown action '${args.action}'`

package/src/tui/ansi.mjs

@@ -38,4 +38,5 @@ export const C = {
   dim: ansi.gray,
   warn: ansi.fg(3),
   advisor: `${ESC}[92m`,  // bright green — visible on dark backgrounds
+  fold: `${ESC}[2m${ESC}[37m`,   // dim white — fold hints
 }

package/src/tui/cmd-fold.mjs

@@ -0,0 +1,21 @@
+/**
+ * cmd-fold.mjs — /fold command: toggle conversation result folding
+ */
+import { C } from "./ansi.mjs"
+
+export async function handleFoldCommand(ctx) {
+  const { state } = ctx
+  const text = state.input.join("").trim()
+  const arg = text.split(/\s+/)[1]
+  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)
+  }
+  ctx.render()
+}

package/src/tui/cmd-mcp.mjs

@@ -124,12 +124,53 @@ export async function handleMcpCommand(ctx) {
         openPicker({
           title: "MCP Transport",
           entries: [
-            { type: "header", text: "Select server transport" },
+            { type: "header", text: "Select transport or use AI assist" },
+            { type: "item", text: "🤖 Describe with AI — natural language → config", action: "ai" },
             { type: "item", text: "HTTP (https://…)", action: "http" },
             { type: "item", text: "WebSocket (ws://…)", action: "ws" },
             { type: "item", text: "stdio (local command)", action: "stdio" },
           ],
           onSelect: async (te) => {
+            if (te.action === "ai") {
+              const description = await askQuestion("Describe the MCP server you want to add (e.g. 'a filesystem server that gives access to /tmp'):")
+              if (!description) return
+              pushLine("[mcp] Generating config from description...", C.dim)
+              try {
+                const { chat } = await import("../provider/index.mjs")
+                const res = await chat(agent.provider, {
+                  messages: [{
+                    role: "user",
+                    content: `Generate an MCP server configuration JSON from this description. Return ONLY the JSON object, no explanation.
+
+Description: "${description}"
+
+The JSON should have these fields:
+- name: a short identifier
+- One of: url (HTTP), wsUrl (WebSocket), or command + args (stdio)
+- headers: optional key-value object
+
+Example HTTP: {"name":"filesystem","url":"https://example.com/mcp","headers":{"Authorization":"Bearer xxx"}}
+Example stdio: {"name":"filesystem","command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","/tmp"]}
+
+Return ONLY the JSON object:`,
+                  }],
+                  tools: [],
+                  signal: AbortSignal.timeout(15_000),
+                })
+                const jsonMatch = (res.content ?? "").match(/\{[\s\S]*\}/)
+                if (!jsonMatch) { pushLine("[mcp] AI response not valid JSON", C.error); return }
+                const srv = JSON.parse(jsonMatch[0])
+                if (!srv.name) { pushLine("[mcp] AI response missing 'name' field", C.error); return }
+                // Show preview and confirm
+                pushLine(`[mcp] Generated config: ${JSON.stringify(srv)}`, C.tool)
+                const confirm = await askQuestion("Add this server? (y/n):")
+                if (confirm?.toLowerCase() !== "y") { pushLine("[mcp] Cancelled", C.dim); return }
+                await addAndConnect(ctx, srv)
+              } catch (err) {
+                pushLine(`[mcp] AI generation failed: ${err.message}`, C.error)
+              }
+              return
+            }
             const name = await askQuestion("Server name:")
             if (!name) return
             const existing = (agent.config?.mcp?.servers ?? []).find((s) => s.name === name)

package/src/tui/cmd-undo.mjs

@@ -0,0 +1,91 @@
+/**
+ * cmd-undo.mjs — /undo command: revert recent file modifications
+ *
+ * Tracks write/edit/delete/hashline_edit/apply_patch operations in agent._undoStack.
+ * /undo opens a picker to select and revert an operation.
+ */
+
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { ansi, C } from "./ansi.mjs"
+
+const MAX_UNDO = 50
+
+/**
+ * Snapshot a file before a side-effect tool modifies it.
+ * Called from dispatch.mjs before each write/edit/delete/apply_patch/hashline_edit.
+ */
+export function snapshotForUndo(agent, toolName, args, cwd) {
+  if (!agent._undoStack) agent._undoStack = []
+  const path = args.path ?? args.file
+  if (!path || typeof path !== "string") return
+
+  const abs = join(cwd, ...path.split("/"))
+  let backup = null
+  try {
+    if (existsSync(abs)) {
+      backup = readFileSync(abs, "utf8")
+    }
+  } catch {
+    // can't read — maybe binary, skip
+    return
+  }
+
+  agent._undoStack.push({
+    tool: toolName,
+    path,
+    backup,
+    timestamp: Date.now(),
+  })
+  if (agent._undoStack.length > MAX_UNDO) agent._undoStack.shift()
+}
+
+export async function handleUndoCommand(ctx) {
+  const { agent, pushLine, openPicker } = ctx
+  const stack = agent._undoStack ?? []
+
+  if (stack.length === 0) {
+    pushLine("[undo] Nothing to undo — no file modifications tracked yet.", C.dim)
+    return
+  }
+
+  const entries = [
+    { type: "header", text: `${stack.length} operation(s) available to undo (most recent first)` },
+    ...stack.map((item, i) => {
+      const relIdx = stack.length - i
+      const time = new Date(item.timestamp).toLocaleTimeString()
+      const preview = item.backup === null
+        ? "(was created — undo will delete)"
+        : `(${item.backup.split("\n").length} lines — undo will restore)`
+      return {
+        type: "item",
+        text: `#${relIdx} ${item.tool}: ${item.path} ${preview} — ${time}`,
+        idx: i,
+      }
+    }),
+  ]
+
+  openPicker({
+    title: "Undo",
+    entries,
+    onSelect: async (e) => {
+      const item = stack[e.idx]
+      const abs = join(agent.cwd, ...item.path.split("/"))
+
+      try {
+        if (item.backup === null) {
+          // File was created — undo deletes it
+          if (existsSync(abs)) unlinkSync(abs)
+        } else {
+          // File was modified — undo restores original
+          writeFileSync(abs, item.backup, "utf8")
+        }
+        // Remove this and all newer entries (can't undo out of order)
+        stack.splice(e.idx)
+        pushLine(`[undo] Reverted: ${item.tool} ${item.path}`, C.tool)
+      } catch (err) {
+        pushLine(`[undo] Failed to revert ${item.path}: ${err.message}`, C.error)
+      }
+    },
+  })
+}

package/src/tui/index.mjs

@@ -80,6 +80,8 @@ export async function startTUI(agent, opts = {}) {
     status: "Ready",
     queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
     interruptPrompt: null, // Ctrl+I interrupt message input: { text: "" } or null
+    expandedBlocks: new Set(), // block hashes that are expanded (Enter toggles)
+    foldEnabled: true, // global fold toggle — /fold on|off
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)

package/src/tui/render-frame.mjs

@@ -51,7 +51,7 @@ export function renderHeader(agent, cols) {
  */
 export function convCacheKey(state) {
   const lastLine = state.lines.length > 0 ? state.lines[state.lines.length - 1] : null
-  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${Object.keys(state.toolStreams).length}`
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${Object.keys(state.toolStreams).length}|${state.foldEnabled !== false ? "f" : "u"}`
 }
 
 /** Conversation panel (scrollable, variable height). Returns exactly `visibleH` lines. */
@@ -311,10 +311,12 @@ function buildConvLines(state, cols) {
   for (const l of state.lines) {
     for (const line of formatTables(sanitizeDisplay(l.text), cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        convLines.push({ text: wrapped, color: l.color })
+        convLines.push({ text: wrapped, color: l.color, _foldId: l._foldId })
       }
     }
   }
+  // Messages after the conversation (streaming / thinking / tool output):
+  // appended after history lines so they appear at the bottom.
   if (state.reasoning) {
     for (const wrapped of wrapText(sanitizeDisplay(state.reasoning), cols - 1)) {
       convLines.push({ text: wrapped, color: C.reason })
@@ -334,8 +336,37 @@ function buildConvLines(state, cols) {
       convLines.push({ text: wrapped, color: C.dim })
     }
   }
-  _convCache = { key, cols, lines: convLines }
-  return convLines
+
+  // ---- Fold long blocks (> 8 consecutive dim lines) ----
+  const FOLD_LINES = 8
+  let foldCounter = 0
+  const folded = []
+  let i = 0
+  while (i < convLines.length) {
+    const line = convLines[i]
+    // Only fold dim-colored lines (tool results, subagent previews)
+    if (line.color === C.dim) {
+      let j = i
+      while (j < convLines.length && convLines[j].color === C.dim) j++
+      const blockLen = j - i
+      if (blockLen > FOLD_LINES) {
+        const foldKey = `fold-${foldCounter++}`
+        if (state.foldEnabled !== false && !state.expandedBlocks?.has(foldKey)) {
+          // Show first 2 lines + fold hint
+          folded.push(convLines[i])
+          if (blockLen > 2) folded.push(convLines[i + 1])
+          folded.push({ text: `  … ${blockLen - 2} more lines — Enter to expand`, color: C.fold, _foldToggle: foldKey })
+          i = j
+          continue
+        }
+      }
+    }
+    folded.push(line)
+    i++
+  }
+
+  _convCache = { key, cols, lines: folded }
+  return folded
 }
 
 function inputBoxStyle(state) {

package/src/tui/slash-commands.mjs

@@ -28,6 +28,8 @@ import { handleConfigCommand } from "./cmd-config.mjs"
 import { handleExtractCommand } from "./cmd-extract.mjs"
 import { handleHelpCommand } from "./cmd-help.mjs"
 import { handleUpgradeCommand } from "./cmd-upgrade.mjs"
+import { handleFoldCommand } from "./cmd-fold.mjs"
+import { handleUndoCommand } from "./cmd-undo.mjs"
 
 export const SLASH_COMMANDS = [
   { name: "/plan", group: "Agent", desc: "toggle plan mode (design first, then implement)" },
@@ -38,6 +40,7 @@ export const SLASH_COMMANDS = [
   { name: "/think", group: "Agent", desc: "thinking mode & reasoning effort" },
   { name: "/config", group: "Agent", desc: "config management (embedding / agent)" },
   { name: "/upgrade", group: "System", desc: "check for updates & upgrade" },
+  { name: "/fold", group: "System", desc: "toggle result folding on/off" },
   { name: "/new", group: "Session", desc: "new session (old one archived to slot)" },
   { name: "/session", group: "Session", desc: "list/switch archived sessions" },
   { name: "/clear", group: "Session", desc: "clear screen" },
@@ -47,6 +50,7 @@ export const SLASH_COMMANDS = [
   { name: "/mcp", group: "Project", desc: "manage MCP servers" },
   { name: "/reindex", group: "Project", desc: "rebuild memory index" },
   { name: "/restore", group: "Project", desc: "restore checkpoint" },
+  { name: "/undo", group: "Project", desc: "undo recent file modifications" },
   { name: "/exit", group: "System", desc: "exit" },
   { name: "/help", group: "System", desc: "this list" },
 ]
@@ -70,6 +74,8 @@ const HANDLERS = {
   "/model": handleModelCommand,
   "/config": handleConfigCommand,
   "/upgrade": handleUpgradeCommand,
+  "/fold": handleFoldCommand,
+  "/undo": handleUndoCommand,
   "/extract": handleExtractCommand,
   "/help": handleHelpCommand,
 }