thincoder 0.12.8 → 0.12.9

package/README.md

@@ -209,6 +209,13 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.12.9 (2026-08)
+- **Prompt-system quality pass (both CLI and VS Code extension, byte-identical sync):**
+  - **Advisor-after-code rule moved from system.md to discipline.md** — engineering mode no longer receives the conflicting "call advisor after changing code" instruction (its review-timing rules say do not call unprompted). Standard mode behavior unchanged.
+  - **engineering.md delivery-review semantics unified** — the mandatory-flow step and the state table now both say: eng-coder self-reviews inside the subagent; the architect verifies against acceptance criteria and re-reviews only when asked or when the delivery looks wrong. (Previously the step forced a parent-side advisor code review that the hard rules contradicted.)
+  - **checkpoint description aligned with actual auto-snapshot triggers** (task-list deletion + context compaction; manual checkpoint for the rest).
+  - **advisor round budget wording fixed** — prompts advertise a 30-round budget; the mechanical hard cap is 100 rounds (loop guard). Both layers are now named explicitly.
+
 ### 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.
 

package/package.json

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

package/src/advisor/run.mjs

@@ -13,6 +13,9 @@ export const MAX_ADVISOR_TURNS = 100
 // (full review, verify+fix cycles, strict verification). A 6th call means the
 // model is looping — refuse it instead of burning tokens on a review that cannot
 // converge. Design reviews are exempt (each call resets the round).
+// NOTE: prompts/advisor-round{1,2,3}.md advertise a 30-round BUDGET — the
+// prompt-level efficiency target, distinct from this 100-round mechanical hard
+// cap (loop guard). Keep both in sync when either changes.
 export const MAX_ADVISOR_ROUNDS = 5
 
 // Context window limits

package/src/prompts/advisor-round1.md

@@ -1,7 +1,7 @@
 You are a code review advisor.
 Perform a full-scope review of the specified files.
 You have read-only tools to explore the codebase.
-You have a HARD limit of 30 tool rounds (chat turns) total — plan your exploration accordingly.
+You have a budget of 30 tool rounds (chat turns) — plan your exploration accordingly. Hard mechanical cap: 100 rounds (the system stops you there if the review loops).
 
 Review workflow:
 1. The files to review are listed in the review scope. Read them in full. The review scope defines exactly which files to inspect.

package/src/prompts/advisor-round2.md

@@ -2,7 +2,7 @@ You are a code review advisor.
 Verify the prior issue table (provided in the review context).
 You may note obvious new issues introduced by the fixes.
 You have read-only tools to explore the codebase.
-You have a HARD limit of 30 tool rounds (chat turns) total.
+You have a budget of 30 tool rounds (chat turns). Hard mechanical cap: 100 rounds.
 
 Review workflow:
 1. The files to review are listed in the review scope — read them in full. The prior issue table is HISTORY from a previous review, not current state.

package/src/prompts/advisor-round3.md

@@ -2,7 +2,7 @@ You are a code review advisor.
 Strictly verify only the prior issue table (provided in the review context).
 Do NOT look for new issues.
 You have read-only tools to explore the codebase.
-You have a HARD limit of 30 tool rounds (chat turns) total.
+You have a budget of 30 tool rounds (chat turns). Hard mechanical cap: 100 rounds.
 
 Review workflow:
 1. The files to review are listed in the review scope — read them in full. The prior issue table is HISTORY from a previous review, not current state.

package/src/prompts/discipline.md

@@ -9,4 +9,7 @@ Debugging strategy:
 - Verify against official docs before guessing.
 - Binary search: cut the problem in half, test which half has the fault.
 - Fix one thing at a time. Don't change multiple things at once.
-- Don't get stuck reading code — write tests, add logs. Trust the runtime over your theories.
+- Don't get stuck reading code — write tests, add logs. Trust the runtime over your theories.
+
+Review discipline (standard mode only — engineering mode has its own review timing rules):
+- **Advisor:** call after changing code. Must provide scope: `paths` (files/dirs to review) or `documents` (context). Response table: `| # | Action | Detail |`. Round 2 verifies prior table.

package/src/prompts/engineering.md

@@ -30,13 +30,11 @@ subagents only.
    criteria — AND the designToken verbatim (the exact token string from the
    advisor output). The token is required — eng-coder cannot modify files
    without it.
-5. **Code review.** After eng-coder returns, call the `advisor` tool with
-   `type="code"` to review the implementation against the design. Pass
-   `documents=[...]` — the task's Docs involved list from the implementation
-   handoff. Review scope = these docs (not the git diff).
-   - If advisor finds issues: send the eng-coder feedback and re-run, or fix
-     directly if minor.
-   - If advisor approves: present results to the user.
+5. **Delivery review.** After eng-coder returns, verify the delivery against
+   the acceptance criteria from the design. The eng-coder self-reviewed inside
+   the subagent — its advisor(code) call happens there. Re-review with the
+   `advisor` tool (`type="code"`, `documents=[...]` = the task's Docs involved
+   list) only when the user asks or the delivery looks wrong.
 6. **Verify.** Run `verify` — it must pass before you claim the task complete.
 
 ## Work Loop (every user message)
@@ -51,7 +49,7 @@ passed?
 | Design | Write or refine the DESIGN doc (approach + rationale, architecture/interface, affected files, key decisions), organized by business domain per METHODOLOGY, ask for confirmation |
 | Awaiting approval | Present design summary, WAIT for explicit approval |
 | Implementation | eng-coder is working — do not redesign in parallel |
-| Delivery review | Review the eng-coder delivery with advisor (type="code", scope = Docs involved + acceptance criteria), check acceptance criteria, report |
+| Delivery review | Verify the delivery against the acceptance criteria (the eng-coder self-reviewed inside the subagent); re-review with advisor (type="code", documents = Docs involved) only when the user asks or the delivery looks wrong; report |
 | Wrapped up | Report, wait for next instruction |
 
 Then handle the message:

package/src/prompts/system.md

@@ -33,7 +33,7 @@ Programming is collaborative labor between you and the human. The human decides
 - No TTY — run shell commands non-interactively (git commit -m, --no-pager, -y/--yes).
 - Never modify files outside the working directory. No bash redirects to bypass boundaries.
 - **Reversibility tiers:** local edits — yours. Destructive (rm -rf, force-push) — confirm. Outward (commit/push/publish) — confirm each time.
-- Checkpoint before risky bulk operations. Auto-snapshot before every task lets you recover.
+- Checkpoint before risky bulk operations. Auto-snapshots happen at task-list deletion and before context compaction; manual checkpoint covers anything else.
 - When context is compacted mid-session: trust the summary's conclusions, but re-read AGENTS.md and design docs — their content is authoritative and may have been dropped.
 - Long-term memory via memory_put/memory_search. Save bugs, conventions, preferences.
 - Codebase exploration order: repo_outline → doc_search → code_search. Structure → intent → details.
@@ -52,5 +52,4 @@ Before finalizing: pause and think through edge cases. What could go wrong? Self
 - After every write/edit: `lint`. Before done: `lint full=true`.
 - Before declaring completion: `verify` (syntax, related tests, self-review checklist).
 - Code changes need at least one test.
-- **Advisor:** call after changing code. Must provide scope: `paths` (files/dirs to review) or `documents` (context). Response table: `| # | Action | Detail |`. Round 2 verifies prior table.
 - **Done:** explain what you changed, why, what's simplified, what's not done.

package/src/tui/agent-turn.mjs

@@ -29,6 +29,12 @@ export async function runAgentTurn(ctx, text) {
   // 可注入覆盖（测试用）；默认走真实实现
   const runAgentImpl = ctx.runAgent ?? runAgent
   const saveSessionImpl = ctx.saveSession ?? saveSession
+  // A new user message starts a new turn: auto-expanded completed replies from the
+  // previous turn (kept open so the user could read them) collapse now.
+  for (const idx of state._autoExpand ?? []) {
+    state.expandedBlocks?.delete(`long-${idx}`)
+  }
+  state._autoExpand = []
   pushLabel(`❯ You:`, ansi.bold + C.user)
   pushLine(text, C.text)
 
@@ -52,11 +58,23 @@ export async function runAgentTurn(ctx, text) {
 
   const flushStream = () => {
     if (state.reasoning) {
+      const idx = state.lines.length
       pushLine(state.reasoning, C.reason)
+      // Completed reasoning stays expanded (user is reading it) until the next turn
+      state.expandedBlocks ??= new Set()
+      state.expandedBlocks.add(`long-${idx}`)
+      state._autoExpand ??= []
+      state._autoExpand.push(idx)
       state.reasoning = ""
     }
     if (state.streaming) {
+      const idx = state.lines.length
       pushLine(state.streaming, C.text)
+      // Completed main output stays expanded (user is reading it) until the next turn
+      state.expandedBlocks ??= new Set()
+      state.expandedBlocks.add(`long-${idx}`)
+      state._autoExpand ??= []
+      state._autoExpand.push(idx)
       state.streaming = ""
     }
     state.advisorStreaming = ""

package/src/tui/ansi.mjs

@@ -42,5 +42,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
+  fold: ansi.bold + ansi.fg(6),   // bold cyan — fold markers must stay visible on light AND dark themes (dim white vanished on light backgrounds)
 }

package/src/tui/clipboard.mjs

@@ -18,26 +18,6 @@ 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

@@ -81,6 +81,7 @@ export async function startTUI(agent, opts = {}) {
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
+    _autoExpand: [], // indices of completed replies kept expanded; cleared when the next user turn starts
     subTasks: {}, // sub-agent panel: { roleName: { role, text, done } }, one line per role, marked done briefly after completion
     currentTool: null, // currently executing tool name (shown in status bar)
     processingStarted: 0, // current turn start time (status bar timer)
@@ -386,8 +387,8 @@ 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)
+  // Mouse clicks (SGR \x1b[<0;col;rowM) — picker selection + fold expansion.
+  const onMouseClick = (col, row) => handleMouseClick({ state, render, popPicker }, col, row)
 
   // ---------------------------------------------------------- Startup screen + background indexing
 

package/src/tui/mouse.mjs

@@ -1,5 +1,5 @@
 /**
- * mouse.mjs — SGR mouse support: click parsing + hit-testing + line actions.
+ * mouse.mjs — SGR mouse support: click parsing + hit-testing.
  *
  * 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)
@@ -8,10 +8,14 @@
  *
  * Only left-click (button 0) is consumed. Everything else stays stripped
  * upstream (sequence fragments must never leak into the input box).
+ *
+ * Click actions (deliberately minimal — a line-action menu was removed as
+ * over-engineering: terminals already copy via drag-select):
+ *   - picker option click = select it
+ *   - folded-block hint click = expand it
  */
 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) {
@@ -37,7 +41,7 @@ export function convGlobalIndex(convLen, convH, scroll) {
 
 /**
  * Handle a left-click at SGR (col, row) — 1-based terminal coordinates.
- * ctx: { state, render, showPicker, popPicker, pushLine }
+ * ctx: { state, render, popPicker }
  * Returns true when the click was consumed.
  */
 export function handleMouseClick(ctx, col, row) {
@@ -62,56 +66,20 @@ export function handleMouseClick(ctx, col, row) {
     return true
   }
 
-  // ── Conversation: fold-toggle line expands; a message line opens the action menu ──
+  // ── Conversation: click a fold marker (expand hint or collapse marker) toggles it ──
   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
-      }
-    }
+    if (!lineEl?._foldToggle) return false
+    state.expandedBlocks ??= new Set()
+    // Bidirectional: click expands a folded block, collapses an expanded one
+    if (state.expandedBlocks.has(lineEl._foldToggle)) state.expandedBlocks.delete(lineEl._foldToggle)
+    else state.expandedBlocks.add(lineEl._foldToggle)
+    render()
+    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/render-conversation.mjs

@@ -15,8 +15,25 @@ export function convCacheKey(state) {
   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}`
 }
 
+/** Fold marker line: bold-cyan icon + "click to …" phrase underlined (clickable affordance).
+ *  No indent — flush with the content below it; the caller adds a blank line BEFORE it
+ *  so the control line stands apart from unrelated content (reported UX). */
+function foldHintLine(text, foldKey, srcIdx) {
+  // Underline just the actionable phrase — link/button convention
+  const withUnderline = text.replace(/(click to (?:expand|collapse))/, "\x1b[4m$1\x1b[24m")
+  return { text: withUnderline, color: C.fold, _foldToggle: foldKey, _src: srcIdx }
+}
+
+/** Blank separator before a fold control line (uncolored — must not join consecutive-dim folding).
+ *  Only the EXPANDED state uses it (▼ sits at the block head); the folded state's ▶
+ *  control line sits mid-block where the ellipsis used to be, so no separator needed. */
+function blankLine() {
+  return { text: "", color: "" }
+}
+
 function highlightSearchMatches(text, query, matchesInLine, globalCurrentIndex, allMatches, lineIndex) {
   if (!matchesInLine || matchesInLine.length === 0 || !query) return text
+
   let result = ""
   let lastEnd = 0
   for (const startIdx of matchesInLine) {
@@ -43,6 +60,10 @@ function buildConvLines(state, cols) {
   if (_convCache.key === key && _convCache.cols === cols) return _convCache.lines
 
   const convLines = []
+  // Folding constants (function scope — used by both the long-message fold below
+  // and the consecutive-dim fold at the bottom)
+  const LONG_FOLD_LINES = 12
+  const FOLD_KEEP = 5 // content lines kept in the folded state (first 4 + last 1)
   for (let i = 0; i < state.lines.length; i++) {
     const l = state.lines[i]
     let text = l.text
@@ -52,15 +73,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 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
+    // Long-message folding: ANY single line (main output C.text, thinking C.reason,
+    // tool summaries C.dim — whatever wraps beyond LONG_FOLD_LINES display rows)
+    // collapses to [blank, ▶, first 4, last] — 5 content lines. Main output and
+    // thinking are the REAL long content; bidirectional folding (collapse markers
+    // + click toggle) keeps them readable — the 0.12.7 dim-only restriction was a
+    // temporary fix for the single-direction era and is now reverted. 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) && l.color === C.dim
+    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)) {
@@ -70,15 +91,24 @@ function buildConvLines(state, cols) {
       }
     }
     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 })
+      // Folded state: first 4 content lines, then the ▶ control line where the
+      // ellipsis used to be (the marker itself reads "… N more lines" — ellipsis
+      // semantics built in), then the last line. No leading blank line needed:
+      // the block starts with real content now.
+      convLines.push(...block.slice(0, FOLD_KEEP - 1))
+      convLines.push(foldHintLine(`▶ … ${block.length - FOLD_KEEP} more lines — click to expand`, longKey, 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) {
+    } else if (block.length > LONG_FOLD_LINES) {
+      // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
+      // before the content. DIM blocks must not re-trigger the consecutive-dim
+      // folding below (folding stacked on folding — reported regression).
+      if (l.color === C.dim) {
         for (const line of block) line._skipDimFold = true
       }
+      convLines.push(blankLine())
+      convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
+      convLines.push(...block)
+    } else {
       convLines.push(...block)
     }
   }
@@ -125,12 +155,19 @@ function buildConvLines(state, cols) {
       if (blockLen > FOLD_LINES && !hasExpandedLong) {
         const foldKey = `fold-${foldCounter++}`
         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 — click to expand`, color: C.fold, _foldToggle: foldKey })
+          // First 4 lines, then the ▶ control line (ellipsis position), then the last line
+          folded.push(...convLines.slice(i, i + FOLD_KEEP - 1))
+          folded.push(foldHintLine(`▶ … ${blockLen - FOLD_KEEP} more lines — click to expand`, foldKey))
+          folded.push(convLines[j - 1])
           i = j
           continue
         }
+        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line
+        folded.push(blankLine())
+        folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
+        for (let k = i; k < j; k++) folded.push(convLines[k])
+        i = j
+        continue
       }
     }
     folded.push(line)