thincoder 0.12.5 → 0.12.6

package/README.md

@@ -174,7 +174,8 @@ src/
   config.mjs        config loading
   tui/              bare-ANSI terminal UI — index.mjs (startTUI), render.mjs (drawing primitives),
                     render-frame.mjs (frame layout), render-conversation.mjs (conversation panel),
-                    markdown.mjs (lightweight inline markdown → ANSI), ansi.mjs
+                    markdown.mjs (lightweight inline markdown → ANSI), mouse.mjs (SGR clicks),
+                    clipboard.mjs (paste/copy), ansi.mjs
   tui.mjs           re-export shim → src/tui/index.mjs
   tui-render.mjs    re-export shim → src/tui/render.mjs
   prompts/          prompt texts — system.md (core), discipline.md (coding/testing rules),
@@ -208,6 +209,13 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.12.6 (2026-08)
+- **Checkpoint v2 — full-file-copy snapshots** — snapshots now store complete copies of changed files (tracked + untracked) instead of a git diff patch: rollback works even after commits happened post-snapshot. New `versions` checkpoint action lists a file's historical copies across snapshots (time / size / content hash) and restores a specific version. **Full rollback is disabled** (as dangerous as a working-tree reset — silently discards post-snapshot work); oversized files (>5MB) are skipped with an explicit notice; files created after a snapshot are never deleted by a restore.
+- **Git destructive-command protection** — `checkout --` / `restore` / `reset --hard` / `clean -f` (including bypass variants like `checkout HEAD -- .`) auto-snapshot every uncommitted file **before** running, then execute without blocking — a model rollback can no longer destroy uncommitted work. Snapshot triggers slimmed to: destructive-git guard, pre-restore, manual.
+- **Fix: bash no longer hangs on background processes** — `start /b`, `&`, `nohup` children that hold the output pipe no longer stall the tool until timeout (resolves after a short grace with a notice).
+- **Mouse support** (SGR-protocol terminals) — click a picker option to select it, click a folded-block hint to expand it, click a message line for an action menu (copy to clipboard / load into the input box). **Long messages (>12 wrapped lines) auto-fold** to first/hint/last with click-to-expand — folding now has real objects in everyday sessions.
+- **Fix: legacy session hash migration** — the 12→40 char hash migration now tries every historical algorithm (CLI 12-char, VS Code 16-char, both drive-letter cases): Windows sessions from older versions are found and migrated on next startup instead of being stranded.
+
 ### 0.12.5 (2026-08)
 - **Fix: inline code styling** — markdown code spans now render with underline instead of reverse video (less harsh on the eyes)
 

package/package.json

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

package/src/context.mjs

@@ -211,25 +211,8 @@ export async function compressIfNeeded(agent, threshold, callbacks, extras = {})
     messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
   })
 
-  // Auto-checkpoint before compaction: snapshot current state so the model can
-  // reconstruct context from git diff + recent messages + task progress later.
-  let cpId = null
-  try {
-    const { createCheckpoint } = await import("../git/checkpoint.mjs")
-    const cp = await createCheckpoint(agent.cwd)
-    cpId = cp?.id
-  } catch { /* checkpoint might fail — compaction itself should not be blocked */ }
-
   applyCompression(agent, split.headEnd, split.tailStart, COMPACTION_PREFIX + summary.content)
 
-  // Inject checkpoint reference after compaction so the model knows it can use /restore
-  if (cpId) {
-    agent.history.splice(split.headEnd, 0, {
-      role: "user",
-      content: `[System: context compacted. A checkpoint (id: ${cpId}) was auto-created before compaction. Use the checkpoint tool to review pre-compaction state if needed. File changes since then are tracked in git diff.]`,
-    })
-  }
-
   return true
 }
 

package/src/git/checkpoint.mjs

@@ -1,13 +1,16 @@
 /**
- * checkpoint.mjs — workspace snapshot and rollback
- * Snapshot = git diff HEAD patch + untracked file copies (respects .gitignore).
+ * checkpoint.mjs — workspace snapshot and rollback (v2: full-file copies)
+ * Snapshot = full copies of changed tracked files + untracked file copies (respects .gitignore).
+ * v1 stored only a git diff patch — rewind depended on HEAD being unchanged (a commit after the
+ * snapshot made `git apply` fail and the failure recovery chain collapse). v2 copies files, so
+ * rewind works regardless of later commits.
  * Only available inside git repos. Rewind creates a new snapshot first (rewind is reversible).
- * rewind supports a path parameter for per-file restore (restores only the specified file).
+ * rewind supports a path parameter for per-file restore.
  */
 import { execFileSync } from "node:child_process"
 import { createHash } from "node:crypto"
-import { existsSync, readFileSync } from "node:fs"
-import { cp, mkdir, readFile, readdir, rm, writeFile, copyFile } from "node:fs/promises"
+import { existsSync, readFileSync, statSync } from "node:fs"
+import { cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { configDir } from "../config.mjs"
 
@@ -15,6 +18,12 @@ const CWD_HASH_LEN = 12
 
 const MAX_CHECKPOINTS = 20
 
+/** Files larger than this are NOT copied (sqlite db, bundles…) — they are recorded as skipped. */
+const MAX_FILE_BYTES = 5 * 1024 * 1024
+
+/** meta.version 2 = full-copy snapshots; 1 = legacy patch-only snapshots */
+const META_VERSION = 2
+
 function git(cwd, args, { allowFail = false } = {}) {
   try {
     return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim()
@@ -56,7 +65,28 @@ export function isGitRepo(cwd) {
 }
 
 /**
- * Create a snapshot. Returns { id, time, files } or null (non-git repo).
+ * Copy a file into a snapshot directory, skipping oversized files.
+ * Returns { size, sha } (sha = SHA256 hex, 12 chars) or null when skipped/failed.
+ */
+async function copyInto(dir, rel, src, skipped) {
+  let size
+  try { size = statSync(src).size } catch { return null }
+  if (size > MAX_FILE_BYTES) {
+    skipped.push(rel)
+    return null
+  }
+  const buf = await readFile(src).catch((e) => { console.error(`[checkpoint] skipping ${rel}: ${e.message}`); return null })
+  if (!buf) return null
+  const dst = join(dir, rel)
+  await mkdir(dirname(dst), { recursive: true })
+  await writeFile(dst, buf)
+  return { size: buf.length, sha: createHash("sha256").update(buf).digest("hex").slice(0, 12) }
+}
+
+/**
+ * Create a snapshot. Returns { id, time, files, tracked, untracked, skipped } or null (non-git repo).
+ * Per-file metadata ({ size, sha } per copied file) is stored in meta.json — this powers
+ * listFileVersions (per-file history across snapshots) without rescanning copies.
  */
 export async function createCheckpoint(cwd) {
   if (!isGitRepo(cwd)) return null
@@ -64,30 +94,42 @@ export async function createCheckpoint(cwd) {
   // Random suffix: prevents id collisions for two snapshots in the same millisecond (sorting stays ordered by timestamp prefix)
   const id = Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 6)
   const dir = join(checkpointRoot(cwd), id)
+  await mkdir(join(dir, "files"), { recursive: true })
   await mkdir(join(dir, "untracked"), { recursive: true })
 
-  // Tracked file changes → patch
+  // v2: full copies of changed tracked files (git apply of a stale patch is the v1 failure mode).
+  // The patch is still written for legacy tooling/debugging, but rewind uses the copies.
+  const head = git(cwd, ["rev-parse", "HEAD"], { allowFail: true }) ?? ""
+  const changedRaw = git(cwd, ["diff", "HEAD", "--name-only", "-z"], { allowFail: true }) ?? ""
+  const changed = changedRaw ? changedRaw.split("\0").filter(Boolean) : []
+  const trackedAllRaw = git(cwd, ["ls-files", "-z"], { allowFail: true }) ?? ""
+  const trackedAll = trackedAllRaw ? trackedAllRaw.split("\0").filter(Boolean) : []
   const patch = git(cwd, ["diff", "HEAD", "--binary"], { allowFail: true }) ?? ""
   await writeFile(join(dir, "patch.diff"), patch, "utf8")
-  const tracked = trackedFilesFromPatch(patch)
+
+  const skipped = []
+  const fileMeta = {}
+  for (const rel of changed) {
+    const m = await copyInto(join(dir, "files"), rel, join(cwd, rel), skipped)
+    if (m) fileMeta[rel] = m
+  }
 
   // Untracked files (respects .gitignore) → copy as-is
   const untrackedRaw = git(cwd, ["ls-files", "--others", "--exclude-standard"], { allowFail: true }) ?? ""
   const untracked = untrackedRaw ? untrackedRaw.split("\n").filter(Boolean) : []
+  const untrackedMeta = {}
   for (const rel of untracked) {
-    const src = join(cwd, rel)
-    const dst = join(dir, "untracked", rel)
-    await mkdir(dirname(dst), { recursive: true })
-    // Copy failed (socket/device file etc.) — skip, but log in case it's unexpected
-    await copyFile(src, dst).catch((e) => console.error(`[checkpoint] skipping ${rel}: ${e.message}`))
+    const m = await copyInto(join(dir, "untracked"), rel, join(cwd, rel), skipped)
+    if (m) untrackedMeta[rel] = m
   }
 
   await writeFile(join(dir, "meta.json"), JSON.stringify({
-    id, time: Date.now(), untracked, tracked,
+    version: META_VERSION, id, time: Date.now(), untracked, tracked: changed, skipped,
+    head, trackedAll, fileMeta, untrackedMeta,
   }, null, 2), "utf8")
 
   await pruneCheckpoints(cwd)
-  return { id, time: Date.now(), files: untracked.length + tracked.length, tracked, untracked }
+  return { id, time: Date.now(), files: changed.length + untracked.length, tracked: changed, untracked, skipped }
 }
 
 /** List checkpoints (newest→oldest), with file change summary */
@@ -108,6 +150,7 @@ export async function listCheckpoints(cwd) {
       out.push({
         id, time: meta.time,
         untracked: meta.untracked ?? [],
+        skipped: meta.skipped ?? [],
         tracked,
       })
     } catch {
@@ -119,49 +162,12 @@ export async function listCheckpoints(cwd) {
 
 // ---- restore core ----
 
-/** Full restore of tracked files from a checkpoint: reset to HEAD → apply patch */
-async function fullRestoreTracked(cwd, dir) {
-  git(cwd, ["restore", "--source=HEAD", "--staged", "--worktree", "."])
-  const patch = await readFile(join(dir, "patch.diff"), "utf8")
-  if (patch.trim()) {
-    git(cwd, ["apply", "--whitespace=nowarn", join(dir, "patch.diff")])
-  }
-  return Boolean(patch.trim())
-}
-
-/** Full restore of untracked files from a checkpoint: delete new ones → restore from snapshot */
-async function fullRestoreUntracked(cwd, dir, meta) {
-  const nowUntracked = (git(cwd, ["ls-files", "--others", "--exclude-standard"], { allowFail: true }) ?? "")
-    .split("\n")
-    .filter(Boolean)
-  const checkpointSet = new Set(meta.untracked)
-  let deleted = 0
-  for (const rel of nowUntracked) {
-    if (!checkpointSet.has(rel)) {
-      await rm(join(cwd, rel), { force: true })
-      deleted++
-    }
-  }
-
-  let restored = 0
-  for (const rel of meta.untracked) {
-    const src = join(dir, "untracked", rel)
-    if (existsSync(src)) {
-      await mkdir(dirname(join(cwd, rel)), { recursive: true })
-      await cp(src, join(cwd, rel), { force: true })
-      restored++
-    }
-  }
-  return { deleted, restored }
-}
-
-/** Restore a single tracked file: checkout HEAD → apply that file's patch hunks */
-async function partialRestoreTracked(cwd, patchContent, filePath) {
-  // Reset the file to HEAD state first
+/** v1 legacy fallback: reset file to HEAD then apply its patch hunks. */
+async function partialRestoreTrackedViaPatch(cwd, root, patchContent, filePath) {
   git(cwd, ["checkout", "HEAD", "--", filePath], { allowFail: true })
   const hunks = extractFileHunks(patchContent, filePath)
   if (!hunks) return false
-  const tmpFile = join(checkpointRoot(cwd), ".tmp_partial.patch")
+  const tmpFile = join(root, ".tmp_partial.patch")
   await writeFile(tmpFile, hunks, "utf8")
   try {
     git(cwd, ["apply", "--whitespace=nowarn", tmpFile])
@@ -171,85 +177,136 @@ async function partialRestoreTracked(cwd, patchContent, filePath) {
   }
 }
 
-/** Restore a single untracked file */
-async function partialRestoreUntracked(cwd, dir, filePath) {
-  const src = join(dir, "untracked", filePath)
+/** Restore a single file from a snapshot copy. Returns true when the copy existed. */
+async function restoreFromCopy(snapshotDir, rel, cwd) {
+  const src = join(snapshotDir, rel)
   if (!existsSync(src)) return false
-  await mkdir(dirname(join(cwd, filePath)), { recursive: true })
-  await cp(src, join(cwd, filePath), { force: true })
+  await mkdir(dirname(join(cwd, rel)), { recursive: true })
+  await cp(src, join(cwd, rel), { force: true })
   return true
 }
 
-// ---- rewind ----
+// ---- restore (single-file only) ----
 
 /**
- * Rewind to a specific snapshot (saves current state as a new snapshot first, making rewind reversible).
+ * Restore ONE file from a specific snapshot (saves current state as a new snapshot first,
+ * making the restore reversible).
  *
- * Options:
- * - path: restore only this single file (tracked or untracked); other files are left untouched.
- *   Omit for a full rewind (all changes → snapshot state).
+ * FULL restore is deliberately DISABLED: rolling the whole working tree back to a snapshot
+ * is exactly as dangerous as `git checkout -- .` — it silently discards every change made
+ * after the snapshot. Restore files individually (rewind with path / restoreFile).
  *
- * Returns summary { patchApplied, deleted?, restored? }; in path mode includes { file, type }.
+ * Returns { path, type, restored }.
  */
 export async function rewind(cwd, id, { path } = {}) {
+  if (!path) {
+    throw new Error(
+      "Full rewind is disabled — it is as dangerous as `git checkout -- .` (silently discards all work after the snapshot). " +
+      "Restore files individually: rewind(cwd, id, { path }) or restoreFile(cwd, path, id)."
+    )
+  }
+
   const root = checkpointRoot(cwd)
   const dir = join(root, id)
   if (!existsSync(join(dir, "meta.json"))) throw new Error(`checkpoint ${id} not found`)
   const meta = JSON.parse(await readFile(join(dir, "meta.json"), "utf8"))
+  const isV2 = meta.version === META_VERSION
   const patchContent = await readFile(join(dir, "patch.diff"), "utf8")
 
-  // Rewind is reversible: snapshot current state first
-  const preRewindCp = await createCheckpoint(cwd)
+  // Restore is reversible: snapshot current state first
+  await createCheckpoint(cwd)
 
-  // ---- per-file restore ----
-  if (path) {
-    // Determine whether it's a tracked or untracked file
-    const isTracked = meta.tracked?.includes(path) ?? extractFileHunks(patchContent, path) !== ""
-    const inUntracked = (meta.untracked ?? []).includes(path)
+  const tracked = meta.tracked ?? []
+  const trackedAll = meta.trackedAll ?? []
+  const isTracked = tracked.includes(path) || trackedAll.includes(path) || extractFileHunks(patchContent, path) !== ""
+  const inUntracked = (meta.untracked ?? []).includes(path)
 
-    if (!isTracked && !inUntracked) {
-      throw new Error(`file "${path}" not found in checkpoint ${id} (tracked: ${(meta.tracked ?? []).join(", ") || "none"}, untracked: ${(meta.untracked ?? []).join(", ") || "none"})`)
-    }
+  // Oversized files were never copied — nothing to restore, say so explicitly.
+  if ((meta.skipped ?? []).includes(path)) {
+    throw new Error(`file "${path}" was NOT snapshotted in checkpoint ${id} (oversized, >5MB) — no copy exists to restore`)
+  }
 
-    let ok = false
-    if (isTracked) {
-      ok = await partialRestoreTracked(cwd, patchContent, path)
-    }
-    if (inUntracked) {
-      ok = await partialRestoreUntracked(cwd, dir, path) || ok
-    }
+  if (!isTracked && !inUntracked) {
+    throw new Error(`file "${path}" not found in checkpoint ${id} (tracked: ${tracked.join(", ") || "none"}, untracked: ${(meta.untracked ?? []).join(", ") || "none"})`)
+  }
 
-    return { path, type: isTracked ? "tracked" : "untracked", restored: ok, patchApplied: false }
+  let ok = false
+  if (inUntracked) {
+    ok = await restoreFromCopy(join(dir, "untracked"), path, cwd) || ok
+  }
+  if (isTracked) {
+    if (isV2 && existsSync(join(dir, "files", path))) {
+      ok = await restoreFromCopy(join(dir, "files"), path, cwd) || ok
+    } else if (isV2 && meta.head) {
+      // Untouched at snapshot time (content = snapshot HEAD) → checkout that commit's version.
+      // Works even if HEAD moved since — the commit object is immutable.
+      git(cwd, ["checkout", meta.head, "--", path], { allowFail: true })
+      ok = true
+    } else {
+      // v1 snapshot → patch fallback
+      ok = await partialRestoreTrackedViaPatch(cwd, root, patchContent, path) || ok
+    }
   }
 
-  // ---- full rewind ----
-  try {
-    const patchApplied = await fullRestoreTracked(cwd, dir)
-    const { deleted, restored } = await fullRestoreUntracked(cwd, dir, meta)
-    return { deleted, restored, patchApplied }
-  } catch (e) {
-    // git apply failed: working tree may have been reset to HEAD by restore.
-    // Restore from pre-rewind snapshot to ensure no data is lost on rewind failure
-    const preDir = join(root, preRewindCp.id)
-    try {
-      await fullRestoreTracked(cwd, preDir)
-      await fullRestoreUntracked(cwd, preDir, JSON.parse(await readFile(join(preDir, "meta.json"), "utf8")))
-    } catch {
-      // Double failure: pre-rewind may also be corrupt, stop trying
+  return { path, type: isTracked ? "tracked" : "untracked", restored: ok }
+}
+
+// ---- per-file history ----
+
+/**
+ * List every historical version of a file across all snapshots (newest first).
+ * Distinguishing copies: each entry carries its snapshot id, time, byte size and
+ * content sha — the same file in different snapshots is a different version.
+ * @param {string} cwd
+ * @param {string} filePath — relative path as stored in snapshots
+ * @returns {Promise<Array<{snapshotId: string, time: number, size: number, sha: string, source: "tracked"|"untracked"}>>}
+ */
+export async function listFileVersions(cwd, filePath) {
+  const root = checkpointRoot(cwd)
+  if (!existsSync(root)) return []
+  const ids = (await readdir(root)).sort().reverse() // newest → oldest
+  const out = []
+  for (const id of ids) {
+    let meta
+    try { meta = JSON.parse(await readFile(join(root, id, "meta.json"), "utf8")) } catch { continue }
+    const trackedMeta = meta.fileMeta ?? {}
+    const untrackedMeta = meta.untrackedMeta ?? {}
+    let entry = null
+    if (trackedMeta[filePath]) {
+      entry = { snapshotId: id, time: meta.time, ...trackedMeta[filePath], source: "tracked" }
+    } else if (untrackedMeta[filePath]) {
+      entry = { snapshotId: id, time: meta.time, ...untrackedMeta[filePath], source: "untracked" }
+    } else if ((meta.tracked ?? []).includes(filePath) || (meta.untracked ?? []).includes(filePath)) {
+      // Legacy snapshot (no per-file meta): fall back to stat-ing the copy
+      const src = join((meta.tracked ?? []).includes(filePath) ? join(root, id, "files") : join(root, id, "untracked"), filePath)
+      let size = null, sha = null
+      try {
+        const buf = await readFile(src)
+        size = buf.length
+        sha = createHash("sha256").update(buf).digest("hex").slice(0, 12)
+      } catch { continue }
+      entry = { snapshotId: id, time: meta.time, size, sha, source: (meta.tracked ?? []).includes(filePath) ? "tracked" : "untracked" }
     }
-    throw new Error(
-      `Rewind to ${id} failed: ${e.message}. ` +
-      `The pre-rewind state was restored from checkpoint ${preRewindCp.id} — no work was lost.`
-    )
+    if (entry) out.push(entry)
   }
+  return out
 }
 
+/**
+ * Restore a single file's content from a specific snapshot (per-file restore —
+ * other files are left untouched). Thin wrapper over rewind path mode with clearer intent.
+ * @returns {Promise<{path: string, type: "tracked"|"untracked", restored: boolean}>}
+ */
+export async function restoreFile(cwd, filePath, snapshotId) {
+  return rewind(cwd, snapshotId, { path: filePath })
+}
+
+
 // ---- view ----
 
 /**
  * View a file's content from a checkpoint (does not modify the working tree).
- * Tracked files: temporarily restore via checkout HEAD + apply patch hunks, read, then restore original.
- * Untracked files: read the copy directly from the checkpoint directory.
+ * v2: read the snapshot copy directly. Legacy snapshots fall back to the temporary-restore path.
  * Returns the file content string.
  */
 export async function catFile(cwd, id, filePath) {
@@ -257,23 +314,31 @@ export async function catFile(cwd, id, filePath) {
   const dir = join(root, id)
   if (!existsSync(join(dir, "meta.json"))) throw new Error(`checkpoint ${id} not found`)
   const meta = JSON.parse(await readFile(join(dir, "meta.json"), "utf8"))
+  const isV2 = meta.version === META_VERSION
   const patchContent = await readFile(join(dir, "patch.diff"), "utf8")
 
-  const isTracked = meta.tracked?.includes(filePath) ?? extractFileHunks(patchContent, filePath) !== ""
+  const tracked = meta.tracked ?? []
+  const isTracked = tracked.includes(filePath) || extractFileHunks(patchContent, filePath) !== ""
   const inUntracked = (meta.untracked ?? []).includes(filePath)
 
   if (!isTracked && !inUntracked) {
     throw new Error(`file "${filePath}" not in checkpoint ${id}`)
   }
 
-  // Untracked file: read the copy directly
+  // v2: read the snapshot copy directly
+  const copy = join(inUntracked ? join(dir, "untracked") : join(dir, "files"), filePath)
+  if (isV2 && existsSync(copy)) {
+    return await readFile(copy, "utf8")
+  }
+
+  // Untracked legacy: read the copy if present
   if (inUntracked && !isTracked) {
     const src = join(dir, "untracked", filePath)
     if (!existsSync(src)) throw new Error(`untracked file "${filePath}" copy missing in checkpoint`)
     return await readFile(src, "utf8")
   }
 
-  // Tracked file: temporarily restore → read → restore working tree
+  // Tracked legacy: temporarily restore → read → restore working tree
   const abs = join(cwd, filePath)
   const existed = existsSync(abs)
   let saved = null

package/src/session.mjs

@@ -35,19 +35,38 @@ 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. */
+/** One-time migration: rename legacy short-hash session files to the full 40-char hash.
+ *  Idempotent; runs on first access per cwd.
+ *  Historical hash algorithms (all sha1, none normalized the drive letter):
+ *    - CLI:      sha1(cwd).slice(0, 12)      — cwd comes from process.cwd() (uppercase drive on Windows)
+ *    - VS Code:  sha1(cwd).slice(0, 16)      — cwd comes from uri.fsPath (LOWERCASE drive on Windows)
+ *  Plus the previous migration attempt's assumption (normalized 12 = first 12 of the full hash).
+ *  Every combination is tried — a migration that only checks one candidate misses real
+ *  legacy files (drive-letter case differs between CLI and VS Code historical paths). */
 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 lower = cwd.replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + ":")
+  const candidates = [
+    createHash("sha1").update(cwd).digest("hex").slice(0, 12),
+    createHash("sha1").update(cwd).digest("hex").slice(0, 16),
+    createHash("sha1").update(lower).digest("hex").slice(0, 12),
+    createHash("sha1").update(lower).digest("hex").slice(0, 16),
+    fullHash.slice(0, 12),
+  ]
   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 */ }
+  let migrated = false
+  for (const short of new Set(candidates)) {
+    const legacyBase = join(dir, `${short}.json`)
+    if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) continue
+    migrated = true
+    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 */ }
+  }
+  return migrated
 }
 
 /** Derive base session path from cwd hash. Migrates legacy short-hash files on first access. */

package/src/tools/git.mjs

@@ -16,12 +16,12 @@ export const gitTool = {
       action: { type: "string", enum: ["diff", "status", "log", "checkpoint"], description: "diff / status / log / checkpoint" },
       // diff/log params
       staged: { type: "boolean", description: "(diff) Show staged changes instead of working tree" },
-      path: { type: "string", description: "(diff/log/checkpoint:cat/checkpoint:rewind) File or directory to scope to" },
+      path: { type: "string", description: "(diff/log/checkpoint:cat/versions/rewind) File or directory to scope to" },
       ref: { type: "string", description: "(diff) Compare against this ref (default HEAD)" },
       count: { type: "number", description: "(log) Number of commits (default 10)" },
       oneline: { type: "boolean", description: "(log) One-line-per-commit format" },
       // checkpoint params
-      checkpointAction: { type: "string", enum: ["list", "create", "rewind", "cat"], description: "(checkpoint) list snapshots / create one / restore by id / read file from snapshot" },
+      checkpointAction: { type: "string", enum: ["list", "create", "rewind", "cat", "versions"], description: "(checkpoint) list snapshots / create one / restore by id / read file from snapshot / list a file's historical versions" },
       checkpointId: { type: "string", description: "(checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)" },
     },
     required: ["action"],
@@ -81,23 +81,34 @@ export const gitTool = {
         return truncate(out || "(no commits)")
       }
       case "checkpoint": {
-        const { createCheckpoint, listCheckpoints, rewind, isGitRepo } = await import("../git/checkpoint.mjs")
+        const { createCheckpoint, listCheckpoints, rewind, listFileVersions, isGitRepo } = await import("../git/checkpoint.mjs")
         if (!isGitRepo(ctx.cwd)) throw new Error("Not a git repository — checkpoints unavailable")
 
         const sub = args.checkpointAction
-        if (!sub) return "checkpoint: missing checkpointAction — use: list | create | rewind | cat"
+        if (!sub) return "checkpoint: missing checkpointAction — use: list | create | rewind | cat | versions"
 
         if (sub === "create") {
           const cp = await createCheckpoint(ctx.cwd)
           return `Checkpoint ${cp.id} created (${cp.files} file(s): ${cp.tracked.length} tracked, ${cp.untracked.length} untracked)`
         }
+        if (sub === "versions") {
+          if (!args.path) throw new Error("path is required for versions — the file whose history you want")
+          const versions = await listFileVersions(ctx.cwd, args.path)
+          if (versions.length === 0) return `No snapshot copies of "${args.path}" found (it was never part of an auto/protection snapshot).`
+          return (
+            `Historical versions of "${args.path}" (${versions.length}, newest first):\n` +
+            versions.map((v) =>
+              `  ${v.snapshotId}  ${new Date(v.time).toISOString()}  ${v.size}B  sha:${v.sha}  (${v.source})` +
+              (v.sha === versions[versions.indexOf(v) - 1]?.sha ? "  ← same content as previous" : "")
+            ).join("\n") +
+            `\nRestore a version: checkpointAction=rewind checkpointId=<snapshotId> path="${args.path}"`
+          )
+        }
         if (sub === "rewind") {
           if (!args.checkpointId) throw new Error("checkpointId is required for rewind — use checkpointAction=list to see snapshot ids")
+          if (!args.path) throw new Error("path is required for rewind — full restore is disabled (as dangerous as `git checkout -- .`). Restore files individually. Use checkpointAction=versions path=<file> to list a file's historical versions.")
           const s = await rewind(ctx.cwd, args.checkpointId, { path: args.path })
-          if (args.path) {
-            return `Restored "${args.path}" (${s.type}) from checkpoint ${args.checkpointId}.\n(The pre-rewind state was snapshotted first — you can rewind again to go back.)`
-          }
-          return `Rewound to checkpoint ${args.checkpointId}: patch ${s.patchApplied ? "applied" : "(empty)"}, ${s.restored ?? 0} untracked file(s) restored, ${s.deleted ?? 0} file(s) deleted.\n(The pre-rewind state was snapshotted first — you can rewind again to go back.)`
+          return `Restored "${args.path}" (${s.type}) from checkpoint ${args.checkpointId}.\n(The pre-restore state was snapshotted first — you can restore again to go back.)`
         }
         if (sub === "cat") {
           if (!args.checkpointId) throw new Error("checkpointId is required for cat — use checkpointAction=list to see snapshot ids")
@@ -107,7 +118,7 @@ export const gitTool = {
         }
         if (sub === "list") {
           const cps = await listCheckpoints(ctx.cwd)
-          if (cps.length === 0) return "(no checkpoints yet — one is auto-created before each user task)"
+          if (cps.length === 0) return "(no checkpoints yet)"
 
           // Specific id: show the file tree within that snapshot
           if (args.checkpointId) {
@@ -125,7 +136,7 @@ export const gitTool = {
             return parts.join("  ")
           }).join("\n")
         }
-        throw new Error(`Unknown checkpoint action: ${sub}. Use: list | create | rewind | cat`)
+        throw new Error(`Unknown checkpoint action: ${sub}. Use: list | create | rewind | cat | versions`)
       }
       default:
         return `Unknown action '${args.action}'. Use: diff | status | log | checkpoint`

package/src/tools/system.mjs

@@ -7,10 +7,8 @@ import {
   IGNORED_DIRS,
   resolveInCwd,
   shellSegments,
-  isDestructiveGitSegment,
   isDestructiveCommand,
   hasFileRedirection,
-  insideGitRepo,
   globToRegex,
   normalizeEOL,
 } from "./shared.mjs";
@@ -27,8 +25,10 @@ const MAX_STREAM_BUF = 2_000_000
 
 /**
  * Pre-execution safety checks for bash commands.
- * Three layers: file redirection → destructive commands → destructive git ops with uncommitted changes.
- * Throws with actionable guidance on failure.
+ * Layers: file redirection → destructive commands (rm -rf etc.).
+ * Git destructive ops are deliberately NOT rejected — the model would just find a
+ * way around the rejection; instead gitGuardSnapshot copies every uncommitted file
+ * and the command is ALLOWED (snapshot-then-proceed, never block).
  */
 function checkBashSafety(command, cwd) {
   if (hasFileRedirection(command)) {
@@ -40,21 +40,6 @@ function checkBashSafety(command, cwd) {
       "(If work was already destroyed, recover from auto-snapshot: checkpoint action=list then action=rewind.)"
     )
   }
-  if (shellSegments(command).some(isDestructiveGitSegment)) {
-    if (!insideGitRepo(cwd)) {
-      throw new Error(`Refusing destructive git command: not a git repository: ${cwd}`)
-    }
-    const status = execFileSync("git", ["status", "--porcelain"], {
-      cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
-    }).trim()
-    if (status) {
-      throw new Error(
-        `Refusing destructive git command: uncommitted changes exist.\n` +
-        `First create a checkpoint (action=create) to protect current work, then commit or stash before the destructive operation.\n` +
-        `(If uncommitted work was already lost, recover from the latest auto-snapshot: checkpoint action=list, then action=rewind.)\n\n${status}`
-      )
-    }
-  }
 }
 
 /**
@@ -96,6 +81,43 @@ function killProcessTree(child) {
  *
  * Returns a promise that resolves to the formatted output string (stdout + stderr + status + truncation note).
  */
+
+/**
+ * Detect destructive git commands and auto-snapshot BEFORE execution.
+ * The scenario: the model writes uncommitted code, then (after breaking things)
+ * runs `git checkout -- .` / `git restore` / `git reset --hard` / `git clean -f` to
+ * roll back — which silently DESTROYS all uncommitted work. The pre-task checkpoint
+ * cannot help (it was taken before the code was written); only a snapshot taken
+ * immediately before the destructive command can.
+ *
+ * This is layer 1 (defense in depth): a WIDE match that snapshots before the command
+ * runs. Layer 2 (checkBashSafety) then rejects the command when uncommitted changes
+ * exist — but a rejection alone is not enough: the model may retry a variant that
+ * slips through the exact matcher (e.g. `git checkout HEAD -- .`), or run git outside
+ * the bash tool. The snapshot taken here survives all of those paths.
+ *
+ * Matching is intentionally WIDE (false positives are harmless — one extra snapshot;
+ * a missed match is a data-loss disaster).
+ */
+const GIT_DESTRUCTIVE_RE = /\bgit\s+(?:checkout\s+(?:[\w./-]+\s+)?--(?!\w)|checkout\s+\.|restore\s+(?!--help\b)(?!--staged\b(?!.*--worktree))|reset\s+--hard|clean\s+-(?=\S*f)(?!\S*n))/i
+
+/** Returns { id, notice } when a snapshot was taken, else null. Never throws. */
+async function gitGuardSnapshot(command, cwd) {
+  if (!GIT_DESTRUCTIVE_RE.test(command)) return null
+  try {
+    const { isGitRepo, createCheckpoint } = await import("../git/checkpoint.mjs")
+    if (!isGitRepo(cwd)) return null
+    const cp = await createCheckpoint(cwd)
+    if (!cp) return null
+    return {
+      id: cp.id,
+      notice: `[auto-protection] Destructive git command detected — snapshot ${cp.id} created BEFORE execution (${cp.files} file(s): ${cp.tracked.length} tracked, ${cp.untracked.length} untracked). If this command destroyed uncommitted work, restore it: checkpoint action=checkpoint checkpointAction=rewind checkpointId=${cp.id}`,
+    }
+  } catch {
+    return null // protection is best-effort — never block the command
+  }
+}
+
 function runBash(command, cwd, { timeout, signal, onOutput }) {
   return new Promise((resolve) => {
     const child = spawn(command, {
@@ -134,13 +156,40 @@ function runBash(command, cwd, { timeout, signal, onOutput }) {
     const timer = setTimeout(killTree, timeout)
     if (signal) signal.addEventListener("abort", killTree, { once: true })
 
-    child.on("error", (error) => {
+    let settled = false
+    let graceTimer = null
+    const finish = (result) => {
+      if (settled) return
+      settled = true
       clearTimeout(timer)
-      resolve(truncate(`Command failed: ${error.message}\n[stdout]:\n${outBuf || "(empty)"}`))
+      clearTimeout(graceTimer)
+      resolve(result)
+    }
+
+    child.on("error", (error) => {
+      finish(truncate(`Command failed: ${error.message}\n[stdout]:\n${outBuf || "(empty)"}`))
+    })
+
+    // Shell exited. Normally 'close' follows within milliseconds — but a BACKGROUND
+    // child (start /b, &, nohup …) inherits the stdio pipes, so the pipe stays open
+    // and 'close' never fires: the tool would hang until the timeout. Resolve after
+    // a short grace period instead, returning whatever output was collected.
+    child.on("exit", (code, exitSignal) => {
+      graceTimer = setTimeout(() => {
+        const outFlush = sanitizeOutput(outDecoder(Buffer.alloc(0), true))
+        const errFlush = sanitizeOutput(errDecoder(Buffer.alloc(0), true))
+        if (outFlush) onOutput?.(outFlush)
+        if (errFlush) onOutput?.(errFlush)
+        const status = exitSignal ? `killed: ${exitSignal}` : `exit code ${code}`
+        const parts = [`[stdout]:\n${(outBuf + outFlush).trim() || "(empty)"}`]
+        if ((errBuf + errFlush).trim()) parts.push(`[stderr]:\n${(errBuf + errFlush).trim()}`)
+        parts.push(`(${status})`)
+        parts.push("[background] the shell exited but a child process still holds the output pipe — output may be incomplete; the process may still be running")
+        finish(truncate(parts.join("\n\n") + truncatedNote))
+      }, 1500)
     })
 
     child.on("close", (code, exitSignal) => {
-      clearTimeout(timer)
       // Flush decoder tails — also push final bytes to panel
       const outFlush = sanitizeOutput(outDecoder(Buffer.alloc(0), true))
       const errFlush = sanitizeOutput(errDecoder(Buffer.alloc(0), true))
@@ -157,7 +206,7 @@ function runBash(command, cwd, { timeout, signal, onOutput }) {
       const parts = [`[stdout]:\n${outBuf.trim() || "(empty)"}`]
       if (errBuf.trim()) parts.push(`[stderr]:\n${errBuf.trim()}`)
       parts.push(`(${status})`)
-      resolve(truncate(parts.join("\n\n") + truncatedNote))
+      finish(truncate(parts.join("\n\n") + truncatedNote))
     })
   })
 }
@@ -180,12 +229,18 @@ export const bashTool = {
   readonly: false,
   outputPanel: true, // stream stdout/stderr to panel during execution, collapse to summary on completion
   async execute(args, ctx) {
+    // Git destructive commands are NEVER rejected — the model would bypass the
+    // guard anyway. Instead: snapshot every uncommitted file first, then ALLOW
+    // the command. The snapshot makes the rollback reversible (defense in depth:
+    // the wide matcher also covers variants like `git checkout HEAD -- .`).
     checkBashSafety(args.command, ctx.cwd)
-    return runBash(args.command, ctx.cwd, {
+    const guard = await gitGuardSnapshot(args.command, ctx.cwd)
+    const result = await runBash(args.command, ctx.cwd, {
       timeout: args.timeout ?? BASH_TIMEOUT_MS,
       signal: ctx.signal,
       onOutput: ctx.onOutput,
     })
+    return guard ? `${guard.notice}\n\n${result}` : result
   },
 }
 

package/src/tui/agent-turn.mjs

@@ -32,14 +32,6 @@ export async function runAgentTurn(ctx, text) {
   pushLabel(`❯ You:`, ansi.bold + C.user)
   pushLine(text, C.text)
 
-  // Auto-checkpoint before task (git repo only; failure is silent, doesn't block the task)
-  try {
-    const { createCheckpoint } = await import("../git/checkpoint.mjs")
-    await createCheckpoint(agent.cwd)
-  } catch {
-    // Checkpoint failure doesn't block the task
-  }
-
   ctx.assistantLabeled = false
   state.processing = true
   state.status = "Processing..."

package/src/tui/clipboard.mjs

@@ -18,6 +18,26 @@ export async function readClipboardText() {
   }
 }
 
+/** Write text to the system clipboard (Set-Clipboard / pbcopy / xclip). Throws on failure. */
+export async function copyToClipboard(text) {
+  const { execFile } = await import("node:child_process")
+  const isWin = process.platform === "win32"
+  const isMac = process.platform === "darwin"
+  await new Promise((resolve, reject) => {
+    if (isWin) {
+      const child = execFile("powershell", ["-NoProfile", "-Command", "[Console]::In.ReadToEnd() | Set-Clipboard"], { timeout: 5000 }, (err) => err ? reject(err) : resolve())
+      child.stdin?.end(text)
+    } else if (isMac) {
+      const child = execFile("pbcopy", [], { timeout: 5000 }, (err) => err ? reject(err) : resolve())
+      child.stdin?.end(text)
+    } else {
+      const child = execFile("xclip", ["-selection", "clipboard"], { timeout: 5000 }, (err) => err ? reject(err) : resolve())
+      child.stdin?.end(text)
+    }
+  })
+}
+
+
 /** Insert pasted text into the active text target.
  *  Free-text question active → append to its answer (single-line field: newlines stripped).
  *  Options question active → ignore (no text field; must not leak into the input box).

package/src/tui/index.mjs

@@ -28,6 +28,7 @@ import { createPickers } from "./pickers.mjs"
 import { runDistill as runDistillImpl } from "./distill-cmd.mjs"
 import { createInteraction } from "./interaction.mjs"
 import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText, translateShiftEnter } from "./clipboard.mjs"
+import { parseMouseClicks, handleMouseClick } from "./mouse.mjs"
 import { runAgentTurn } from "./agent-turn.mjs"
 import { createKeyHandler } from "./key-handler.mjs"
 import { showStartup, backgroundIndex } from "./startup.mjs"
@@ -179,6 +180,16 @@ export async function startTUI(agent, opts = {}) {
       }
     }
 
+    // Left-click: \x1b[<0;col;rowM → picker selection / line action menu
+    for (const click of parseMouseClicks(text)) {
+      try {
+        onMouseClick(click.col, click.row)
+      } catch (e) {
+        pushLine(`[mouse] ${e.message || e}`, C.error)
+        render()
+      }
+    }
+
     // Strip complete mouse sequences; keep incomplete tail for reassembly with next chunk
     text = text.replace(/\x1b\[<\d+;\d+;\d+[Mm]/g, "")
     const tail = text.match(/\x1b\[<[\d;]*$/)
@@ -375,6 +386,9 @@ export async function startTUI(agent, opts = {}) {
     }
   })
 
+  // Mouse clicks (SGR \x1b[<0;col;rowM) — picker selection + line action menu.
+  const onMouseClick = (col, row) => handleMouseClick({ state, render, showPicker, popPicker, pushLine }, col, row)
+
   // ---------------------------------------------------------- Startup screen + background indexing
 
   showStartup({ agent, state, opts, pushLine, pushLabel, render, startWizard })

package/src/tui/mouse.mjs

@@ -0,0 +1,117 @@
+/**
+ * mouse.mjs — SGR mouse support: click parsing + hit-testing + line actions.
+ *
+ * Protocol (enabled at startup via \x1b[?1000h\x1b[?1006h):
+ *   press:    \x1b[<b;col;rowM   (b=0 left, 64/65 wheel up/down — wheel handled upstream)
+ *   release:  \x1b[<b;col;rowm   (ignored — actions fire on press)
+ * Coordinates are 1-based; col comes FIRST in the sequence.
+ *
+ * Only left-click (button 0) is consumed. Everything else stays stripped
+ * upstream (sequence fragments must never leak into the input box).
+ */
+import { computeLayout } from "./layout.mjs"
+import { buildConvLines } from "./render-conversation.mjs"
+import { sanitizeDisplay } from "./render.mjs"
+
+/** Extract left-click presses from a chunk. Returns [{ col, row }] (1-based). */
+export function parseMouseClicks(text) {
+  const out = []
+  for (const m of text.matchAll(/\x1b\[<0;(\d+);(\d+)M/g)) {
+    out.push({ col: Number(m[1]), row: Number(m[2]) })
+  }
+  return out
+}
+
+/** Map a 0-based screen row to a conversation line index (same math as renderConversation). */
+export function convGlobalIndex(convLen, convH, scroll) {
+  const maxScroll = Math.max(0, convLen - convH)
+  const clamped = Math.min(scroll, maxScroll)
+  const end = convLen - clamped
+  const start = Math.max(0, end - convH) // content shorter than the panel: rows start at 0
+  return (localRow) => {
+    if (localRow < 0 || localRow >= convH) return null
+    const idx = start + localRow
+    return idx >= 0 && idx < convLen ? idx : null
+  }
+}
+
+/**
+ * Handle a left-click at SGR (col, row) — 1-based terminal coordinates.
+ * ctx: { state, render, showPicker, popPicker, pushLine }
+ * Returns true when the click was consumed.
+ */
+export function handleMouseClick(ctx, col, row) {
+  const { state, render } = ctx
+  const r = row - 1 // 0-based screen row
+  if (r < 0) return false
+  const dims = { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }
+  const layout = computeLayout(state, dims)
+  const P = layout.panels
+
+  // ── Picker: click an option = select it (skip the title row) ──
+  if (state.picker && P.picker && r >= P.picker.y && r < P.picker.y + P.picker.h) {
+    const p = state.picker
+    const items = p.filteredItems ?? p.entries.filter((e) => e.type === "item")
+    const winH = Math.max(1, P.picker.h - 1)
+    const start = Math.max(0, Math.min(p.scroll, Math.max(0, p.lines.length - winH)))
+    const localRow = r - P.picker.y - 1
+    const lineEl = p.lines[start + localRow]
+    if (lineEl && lineEl._row !== undefined && items[lineEl._row]) {
+      ctx.popPicker(items[lineEl._row])
+    }
+    return true
+  }
+
+  // ── Conversation: fold-toggle line expands; a message line opens the action menu ──
+  if (r >= P.conversation.y && r < P.conversation.y + P.conversation.h) {
+    const convLines = buildConvLines(state, dims.cols)
+    const gIdx = convGlobalIndex(convLines.length, P.conversation.h, state.scroll ?? 0)(r - P.conversation.y)
+    if (gIdx === null) return false
+    const lineEl = convLines[gIdx]
+    if (!lineEl) return false
+
+    // Click on a folded-block hint → expand it
+    if (lineEl._foldToggle) {
+      state.expandedBlocks ??= new Set()
+      state.expandedBlocks.add(lineEl._foldToggle)
+      render()
+      return true
+    }
+    // Click on a message line → action menu
+    if (lineEl._src !== undefined) {
+      const src = state.lines[lineEl._src]
+      if (src) {
+        openLineMenu(ctx, src)
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
+/** Line action menu: copy / edit in input / (fold toggle if the source line folds). */
+async function openLineMenu(ctx, srcLine) {
+  const { state, render, showPicker, pushLine } = ctx
+  const text = sanitizeDisplay(srcLine.text)
+  const entries = [
+    { type: "item", text: `📋 Copy line (${text.length} chars)`, action: "copy" },
+    { type: "item", text: "✏️ Edit in input box", action: "edit" },
+  ]
+  const picked = await showPicker("Line actions", entries)
+  if (!picked) return
+  if (picked.action === "copy") {
+    try {
+      const { copyToClipboard } = await import("./clipboard.mjs")
+      await copyToClipboard(text)
+      pushLine(`[clipboard] copied ${text.length} chars`, (await import("./ansi.mjs")).C.dim)
+    } catch (e) {
+      pushLine(`[clipboard] copy failed: ${e.message}`, (await import("./ansi.mjs")).C.error)
+    }
+    render()
+  } else if (picked.action === "edit") {
+    state.input = [...text]
+    state.cursor = state.input.length
+    render()
+  }
+}

package/src/tui/pickers.mjs

@@ -63,7 +63,7 @@ export function createPickers(ctx) {
         const sel = row === p.index
         if (sel) selLine = lines.length
         const marker = e.marker ? `  ${e.marker}` : ""
-        lines.push({ text: `${sel ? " ▸ " : "   "}${e.text}${marker}`, color: sel ? ansi.bold + C.text : C.dim })
+        lines.push({ text: `${sel ? " ▸ " : "   "}${e.text}${marker}`, color: sel ? ansi.bold + C.text : C.dim, _row: row })
         row++
       }
     }

package/src/tui/render-conversation.mjs

@@ -10,7 +10,9 @@ let _convCache = { key: "", cols: 0, lines: [] }
 
 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}|${state.advisorStreaming?.length ?? 0}|${state._advisorThink?.length ?? 0}|${state.foldEnabled !== false ? "f" : "u"}`
+  // expandedBlocks participates: expanding/folding a block must invalidate the cache
+  const exp = state.expandedBlocks ? [...state.expandedBlocks].sort().join(",") : ""
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${state.advisorStreaming?.length ?? 0}|${state._advisorThink?.length ?? 0}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
 }
 
 function highlightSearchMatches(text, query, matchesInLine, globalCurrentIndex, allMatches, lineIndex) {
@@ -50,13 +52,28 @@ function buildConvLines(state, cols) {
       text = highlightSearchMatches(text, state.search.query, l._searchMatches, state.search.index, state.search.matches, i)
     }
 
+    // Long-message folding: a single line that wraps beyond LONG_FOLD_LINES display rows
+    // collapses to [first, "… N more — click/Enter to expand", last]. Keyed by the
+    // source-line index (`long-${i}`) so the toggle survives re-renders. This is the
+    // folding users actually see — tool outputs, long replies, big error blocks.
+    const LONG_FOLD_LINES = 12
+    const longKey = `long-${i}`
+    const folded = state.foldEnabled !== false && !state.expandedBlocks?.has(longKey)
+    const block = []
     for (const line of formatTables(sanitizeDisplay(text), cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
         // Lightweight markdown display (IK5VW3): headings bold + inline markers styled.
         // Runs AFTER wrapping so the ANSI it inserts never skews width math.
-        convLines.push({ text: renderMarkdownInline(renderMarkdownHeading(wrapped)), color: l.color, _foldId: l._foldId })
+        block.push({ text: renderMarkdownInline(renderMarkdownHeading(wrapped)), color: l.color, _foldId: l._foldId, _src: i })
       }
     }
+    if (folded && block.length > LONG_FOLD_LINES) {
+      convLines.push(block[0])
+      convLines.push({ text: `  … ${block.length - 2} more lines — click to expand`, color: C.fold, _foldToggle: longKey, _src: i })
+      convLines.push(block[block.length - 1])
+    } else {
+      convLines.push(...block)
+    }
   }
   if (state.reasoning) {
     for (const wrapped of wrapText(sanitizeDisplay(state.reasoning), cols - 1)) {
@@ -101,7 +118,7 @@ function buildConvLines(state, cols) {
         if (state.foldEnabled !== false && !state.expandedBlocks?.has(foldKey)) {
           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 })
+          folded.push({ text: `  … ${blockLen - 2} more lines — click to expand`, color: C.fold, _foldToggle: foldKey })
           i = j
           continue
         }
@@ -119,6 +136,8 @@ export function countConvLines(state, cols) {
   return buildConvLines(state, cols).length
 }
 
+export { buildConvLines }
+
 export function renderConversation(state, cols, visibleH, scroll) {
   const convLines = buildConvLines(state, cols)
   const maxScroll = Math.max(0, convLines.length - visibleH)