thincoder 0.12.6 → 0.12.8

package/README.md

@@ -209,6 +209,13 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.12.8 (2026-08)
+- **Fix: pending-task pushback fires at most once** — the completion guard that reminds the model to update pending tasks before finishing could loop forever when a pending item could not be resolved. Now each task-list state earns exactly one reminder; if the model insists on finishing anyway, it is allowed to (updating the list via the task tool resets the budget). VS Code extension synced.
+
+### 0.12.7 (2026-08)
+- **Fix: long replies and thinking are never folded** — the long-message folding feature (0.12.6) collapsed main output and reasoning behind a click when they exceeded 12 lines, hurting readability. Folding now applies to secondary dim-colored content (tool summaries/status) only; expanded blocks are exempt from the consecutive-dim folding so nothing folds twice.
+- **Fix: wide tables misaligned in narrow terminals** — a many-column table that still exceeded the terminal width after column shrinking (e.g. 8 columns at 40 cols) wrapped at the terminal and misaligned. Table rows are now clipped with an ellipsis instead of ever exceeding the width.
+
 ### 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.

package/package.json

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

package/src/agent/completion.mjs

@@ -54,13 +54,18 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
     )
   }
 
-  // Pending tasks: remind the model before it declares itself done
-  if (depth === 0 && agent.tasks.some((t) => t.status === "pending")) {
+  // Pending tasks: remind the model ONCE before it declares itself done.
+  // Deliberately capped at one pushback (reported pain: unbounded looping when a
+  // pending item can't be resolved). After the single reminder the model is free
+  // to finish — updating the task list (task tool) resets the budget, so a fresh
+  // list state earns one fresh reminder.
+  if (depth === 0 && agent.tasks.some((t) => t.status === "pending") && (agent._taskPushbacks ?? 0) < 1) {
+    agent._taskPushbacks = (agent._taskPushbacks ?? 0) + 1
     const pending = agent.tasks.filter((t) => t.status === "pending").map((t) => t.title).join(", ")
     pushReal(agent, { role: "assistant", content: response.content })
     agent.history.push({
       role: "user",
-      content: `[System reminder: you still have pending tasks: ${pending}. Update their status with the task tool before finishing — if they're done, mark them done; if they're not applicable, remove them.]`,
+      content: `[System reminder: you still have pending tasks: ${pending}. Update their status with the task tool before finishing — if they're done, mark them done; if they're not applicable, remove them. (This is your only reminder — if you choose not to, finish anyway.)]`,
     })
     callbacks.onTurnEnd?.(agent, turn)
     return { action: "continue", guardPushbacks, honestReminderInjected, advisorPushbacks }

package/src/agent-tools/task.mjs

@@ -77,6 +77,7 @@ export const taskTool = {
     const recentDone = raw.filter((t) => t.status === "done").slice(-3)
     const items = [...pending, ...recentDone].slice(0, 20)
     ctx.agent.tasks = items
+    ctx.agent._taskPushbacks = 0 // task list changed — the completion gate earns a fresh reminder
     ctx.agent._onTaskUpdate?.(items)
     const done = items.filter((i) => i.status === "done").length
     const open = items.length - done

package/src/tui/render-conversation.mjs

@@ -52,13 +52,15 @@ 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.
+    // Long-message folding: a single DIM line (tool summaries / status output — secondary
+    // content) that wraps beyond LONG_FOLD_LINES display rows collapses to
+    // [first, "… N more — click/expand", last]. MAIN OUTPUT (C.text replies) and
+    // THINKING (C.reason) are NEVER folded — folding them hurt readability (reported
+    // regression: long replies and thinking collapsed behind a click). Keyed by the
+    // source-line index (`long-${i}`) so the toggle survives re-renders.
     const LONG_FOLD_LINES = 12
     const longKey = `long-${i}`
-    const folded = state.foldEnabled !== false && !state.expandedBlocks?.has(longKey)
+    const folded = state.foldEnabled !== false && !state.expandedBlocks?.has(longKey) && l.color === C.dim
     const block = []
     for (const line of formatTables(sanitizeDisplay(text), cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
@@ -72,6 +74,11 @@ function buildConvLines(state, cols) {
       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 {
+      // Expanded long-DIM blocks must not re-trigger the consecutive-dim folding below
+      // (folding stacked on folding — reported regression). Only long blocks get the marker.
+      if (block.length > LONG_FOLD_LINES) {
+        for (const line of block) line._skipDimFold = true
+      }
       convLines.push(...block)
     }
   }
@@ -113,7 +120,9 @@ function buildConvLines(state, cols) {
       let j = i
       while (j < convLines.length && convLines[j].color === C.dim) j++
       const blockLen = j - i
-      if (blockLen > FOLD_LINES) {
+      // Expanded long-fold blocks are exempt — otherwise folding stacks on folding
+      const hasExpandedLong = convLines.slice(i, j).some((l) => l._skipDimFold)
+      if (blockLen > FOLD_LINES && !hasExpandedLong) {
         const foldKey = `fold-${foldCounter++}`
         if (state.foldEnabled !== false && !state.expandedBlocks?.has(foldKey)) {
           folded.push(convLines[i])

package/src/tui/render.mjs

@@ -108,14 +108,19 @@ function renderTable(block, width) {
   // Cell rendering: sliceByWidth truncates (single-line for header), padByWidth pads
   const fmtCell = (text, ci) => padByWidth(sliceByWidth(text, widths[ci]), widths[ci])
   const fmtRow = (cells) => "│ " + cells.map((c, i) => fmtCell(c, i)).join(" │ ") + " │"
+  // Many-column tables can still exceed `width` after shrinking to the 3-char floor
+  // (e.g. 8 columns → 8×3 + 25 borders = 49 > 40). Rows wider than the terminal would
+  // wrap and misalign — clip the row instead, with an ellipsis (fixes the reported
+  // "table no longer aligns" regression in narrow windows).
+  const clip = (line) => stringWidth(line) > width ? sliceByWidth(line, Math.max(1, width - 1)) + "…" : line
 
   // separator line
   const separator = "├" + widths.map((w) => "─".repeat(w + 2)).join("┼") + "┤"
 
   const out = []
   // Header: single-line truncation (header labels are usually short, truncation beats wrapping)
-  out.push(fmtRow(rows[0]))
-  out.push(separator)
+  out.push(clip(fmtRow(rows[0])))
+  out.push(clip(separator))
 
   // Data rows: over-long cells wrap by column width; one logical row may produce multiple display lines
   for (let r = 2; r < rows.length; r++) {
@@ -123,7 +128,7 @@ function renderTable(block, width) {
     const wrapped = rows[r].map((cell, ci) => wrapText(cell, widths[ci]))
     const height = Math.max(...wrapped.map((lines) => lines.length))
     for (let lineIdx = 0; lineIdx < height; lineIdx++) {
-      out.push(fmtRow(wrapped.map((lines) => lines[lineIdx] ?? "")))
+      out.push(clip(fmtRow(wrapped.map((lines) => lines[lineIdx] ?? ""))))
     }
   }