thincoder 0.8.12 → 0.9.0

package/README.md

@@ -205,6 +205,33 @@ 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.
+- **Processing hints** — Input box shows "Ctrl+U clear" hint during processing. Tab during processing treated as Ctrl+I. Slash commands re-render the frame.
+- **Compression visibility** — `compressIfNeeded` now forwards `onToken`/`onReasoning` callbacks, making compression activity visible in the TUI.
+- **Session: data-preserving fallback** — when atomic rename fails during session save, fall back to direct write instead of losing data.
+- **Distill: balanced-bracket JSON extraction** — handles nested arrays in LLM output (e.g. `"tags": ["a", "b"]`), replacing the broken non-greedy regex approach.
+- **File tools: EOL normalization** — `normalizeEOL` (`\r\n` → `\n`) applied on all reads (`read`, `edit`, `hashline_edit`, `insert_after`, `grep`, `repomap`), making hash computation and string matching platform-consistent.
+- **hashline_edit: multiple-match detection** — when a hash sequence matches multiple positions, reports all with surrounding context instead of silently picking one.
+- **delete: symlink-safe** — uses `lstat` instead of `stat` to correctly identify symlinks (not directories even if pointing to one).
+- **repomap: large file guard** — skip files >10MB in dependency outline builds to prevent OOM.
+- **Improved error messages** — `grep` and `insert_after` now catch invalid regex patterns at validation time with clear error messages.
+- **Advisor session persistence** — advisor config saved/restored across sessions.
+- **Timeout hardening** — auto-think uses `AbortSignal.timeout(5s)`, embedding requests add 60s timeout, MCP HTTP connect uses `INIT_TIMEOUT_MS`, fetch timeout extended to 10 minutes.
+- **ClearScreen on exit** — terminal restored with `clearScreen` ANSI on TUI cleanup.
+
 ### 0.8.12 (2026-07)
 - **Indexing: git-repo-only** — `codeSync` and `docSync` now only index inside git worktrees (via `git ls-files`), respecting `.gitignore`. Non-git directories get empty indexes. Prevents 2.9GB memory.db from accidentally indexing entire user profiles (AppData, browser extensions, Office add-ins, Program Files)
 - **Indexing: file-size caps** — code files >1MB and doc files >512KB are skipped during bulk indexing (minified bundles, test fixtures, generated code)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.8.12",
+  "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/setup.mjs

@@ -1,12 +1,9 @@
 /**
  * agent/setup.mjs — runAgent pre-flight setup: context injection, system prompt construction, tool injection
  */
-import { compressIfNeeded, compressFallback, COMPRESS_FAILURE_LIMIT } from "../context.mjs"
 import { search as memorySearch, docSearch } from "../memory.mjs"
 import { toOpenAISchema } from "../tools/index.mjs"
 import { loadSkills, formatSkillListing } from "../skills.mjs"
-import { specForModel } from "../config.mjs"
-import { join } from "node:path"
 import {
   escapeXml, repairHistory, listWorkDir, readonlyToolNames,
   collectGitContext, loadProjectInstructions, OUTLINE_INJECT_PREFIX,

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/agent.mjs

@@ -92,7 +92,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     const lastRole = agent.history.at(-1)?.role
     if (lastRole === "user" || lastRole === "tool") {
       try {
-        if (await compressIfNeeded(agent, threshold)) {
+        if (await compressIfNeeded(agent, threshold, callbacks)) {
           agent._compressFailures = 0
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
           callbacks.onCompress?.()
@@ -118,7 +118,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // Runs only on turn 0 of user input; failure is silent — falls back to current setting.
     if (agent.config?.agent?.autoThink && turn === 0) {
       const { classifyAndApply } = await import("./auto-think.mjs")
-      classifyAndApply(agent, turn).catch(() => {})
+      await classifyAndApply(agent, turn).catch(() => {})
     }
 
     try {
@@ -132,14 +132,12 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       })
     } catch (e) {
       // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
-      // The abort may fire before the SSE stream starts (during rate gate or HTTP request).
-      // Inject the user's message into history and retry from the same context.
+      // Inject the message into history and let the outer loop recreate the controller.
       if (e.name === "AbortError" && signal?.reason?.interrupt) {
         agent.history.push({
           role: "user",
           content: `[User interrupt: ${signal.reason.message}]`,
         })
-        continue
       }
       throw e
     }
@@ -170,7 +168,8 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     // User interrupted mid-generation (Ctrl+I): the SSE stream was aborted while content
-    // was partially generated. Commit partial output + inject user message, then retry.
+    // was partially generated. Commit partial output + inject user message, then signal
+    // the outer loop to recreate the controller and resume.
     if (response.interrupted) {
       if (response.content) {
         agent.history.push({ role: "assistant", content: response.content })
@@ -179,7 +178,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
         role: "user",
         content: `[User interrupt: ${response.interruptMessage}]`,
       })
-      continue
+      throw Object.assign(new Error("User interrupted"), { name: "AbortError" })
     }
 
     if (response.usage) {

package/src/auto-think.mjs

@@ -62,7 +62,7 @@ export async function classifyAndApply(agent, turn) {
         { role: "user", content: prompt.slice(0, 2000) },
       ],
       tools: [],
-      signal: new AbortController().signal,
+      signal: AbortSignal.timeout(5_000),
     })
     const word = (response.content ?? "").trim().toLowerCase()
     if (word.startsWith("low")) level = "low"

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/context.mjs

@@ -143,7 +143,7 @@ function applyCompression(agent, headEnd, tailStart, note) {
  * Only called at safe points in the loop (history ends with user or tool message — a complete exchange boundary).
  * Automatically re-injects task list state after compaction.
  */
-export async function compressIfNeeded(agent, threshold) {
+export async function compressIfNeeded(agent, threshold, callbacks) {
   const history = agent.history
   // Prefer the real baseline: the last response's prompt_tokens is the measured value for the full context (system+tools+history).
   // Subsequent appended messages use estimation as increment; when no measured value exists (first turn / after restore / right after compaction), fall back to pure estimation
@@ -174,6 +174,8 @@ export async function compressIfNeeded(agent, threshold) {
   // The summary is a plain-text task, no reasoning needed — passing thinking to the compaction provider wastes tokens
   const summary = await chat({ ...agent.provider, thinking: null, reasoningEffort: null }, {
     messages: [{ role: "user", content: SUMMARIZE_PROMPT + serialized }],
+    onToken: callbacks?.onToken,
+    onReasoning: callbacks?.onReasoning,
   })
 
   applyCompression(agent, split.headEnd, split.tailStart, COMPACTION_PREFIX + summary.content)

package/src/distill.mjs

@@ -47,11 +47,26 @@ export async function extractCandidates(provider, transcript) {
   const res = await chat(provider, {
     messages: [{ role: "user", content: DISTILL_PROMPT + transcript }],
   })
-  // Non-greedy match first JSON array (greedy [\s\S]* would eat across multiple arrays including interstitial text)
-  const match = res.content.match(/\[[\s\S]*?\]/)
-  if (!match) return []
+  // Balanced-bracket extraction: find the first '[' and track depth through nested
+  // brackets (tags arrays, nested objects, etc.) until the matching ']'.
+  // Non-greedy regex (/\[[\s\S]*?\]/) stops at the FIRST ']', which is wrong when
+  // LLM output contains nested arrays like `"tags": ["a", "b"]`.
+  const start = res.content.indexOf("[")
+  if (start === -1) return []
+  let depth = 0
+  let end = -1
+  for (let i = start; i < res.content.length; i++) {
+    const ch = res.content[i]
+    if (ch === "[" && (i === start || res.content[i - 1] !== "\\")) depth++
+    else if (ch === "]" && res.content[i - 1] !== "\\") {
+      depth--
+      if (depth === 0) { end = i + 1; break }
+    }
+  }
+  if (end === -1) return []
+  const jsonText = res.content.slice(start, end)
   try {
-    const parsed = JSON.parse(match[0])
+    const parsed = JSON.parse(jsonText)
     if (!Array.isArray(parsed)) return []
     return parsed.filter((c) => c?.type && c?.title && c?.content)
   } catch {

package/src/embedding.mjs

@@ -84,7 +84,9 @@ async function requestWithRetry(embedder, input, signal) {
           Authorization: `Bearer ${embedder.apiKey}`,
         },
         body: JSON.stringify({ model: embedder.model, input }),
-        signal,
+        signal: signal
+          ? AbortSignal.any([signal, AbortSignal.timeout(60_000)])
+          : AbortSignal.timeout(60_000),
       })
     } catch (error) {
       if (error.name === "AbortError") throw error

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/mcp/transport-http.mjs

@@ -1,7 +1,7 @@
 /**
  * mcp/transport-http.mjs — MCP HTTP + SSE transport (Streamable HTTP)
  */
-import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, withTimeout } from "./helpers.mjs"
+import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, INIT_TIMEOUT_MS, withTimeout } from "./helpers.mjs"
 
 /** Create an MCP HTTP+SSE transport for Streamable HTTP servers */
 export function httpTransport(baseURL, extraHeaders = {}) {
@@ -56,10 +56,11 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     if (closed) return
     abortController?.abort()
     abortController = new AbortController()
+    const signal = AbortSignal.any([abortController.signal, AbortSignal.timeout(INIT_TIMEOUT_MS)])
     const resp = await fetch(url, {
       method: "GET",
       headers: { Accept: "text/event-stream", ...extraHeaders },
-      signal: abortController.signal,
+      signal,
     })
     if (!resp.ok) throw new Error(`SSE connect failed: HTTP ${resp.status}`)
     eventSource = parseSSE(resp)

package/src/memory/docs.mjs

@@ -7,12 +7,11 @@ import { join } from "node:path"
 import { embed, cosine, toBlob, fromBlob } from "../embedding.mjs"
 import { commitAndPush } from "../git/gitmem.mjs"
 import { DOC_EXTS, SKIP_DIRS, MAX_DOC_FILE_BYTES } from "./schema.mjs"
-import { buildFtsQuery, put, search, putMarkdown } from "./core.mjs"
+import { buildFtsQuery, put, search, putMarkdown, EMBED_TEXT_MAX_LEN } from "./core.mjs"
 import { _upsertDocFile, yieldTick } from "./code-index.mjs"
 import { markIndexedCommit, listProjectFiles } from "./code-sync.mjs"
 
 const DOC_EMBED_BATCH = 64
-const EMBED_TEXT_MAX_LEN = 2000
 
 /**
  * Sync doc index: scan all .md/.mdc/.txt/.rst/.adoc under dir → chunk → upsert into doc_chunks.

package/src/provider/core.mjs

@@ -10,7 +10,7 @@ import {
   estimateRequestTokens, rateGate, recordRate,
 } from "./rate.mjs"
 
-const FETCH_TIMEOUT_MS = 120000
+const FETCH_TIMEOUT_MS = 600_000
 
 /** Create a validated provider config object from raw config */
 export function createProvider(config) {
@@ -315,6 +315,13 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal })
   if (!response.body) throw new Error("No stream response body")
   try {
     for await (const chunk of response.body) {
+      // Active signal check: Ctrl+I abort should halt stream immediately, not wait for
+      // the underlying fetch stream to propagate the abort (delayed on Windows).
+      if (signal?.aborted) {
+        const e = new DOMException("The operation was aborted", "AbortError")
+        e.reason = signal.reason
+        throw e
+      }
       buffer += decoder.decode(chunk, { stream: true })
       const lines = buffer.split("\n")
       buffer = lines.pop()

package/src/session.mjs

@@ -40,7 +40,9 @@ function writeSessionFile(p, data) {
       // rename succeeded: clean up temp file
       try { unlinkSync(tmp) } catch {}
     } catch {
-      // rename still failed: keep tmp as fallback data (next read prefers main file; if missing, tmp is at least there)
+      // rename still failed — fall back to direct write (non-atomic but data-preserving)
+      // p was deleted above; avoid losing both old and new data
+      writeFileSync(p, readFileSync(tmp, "utf8"), "utf8")
     }
   }
 }
@@ -161,6 +163,7 @@ export function saveSession(agent, display) {
     planMode: agent.planMode ?? false,
     autoApprove: agent.autoApprove ?? false,
     goal: agent.goal ?? null,
+    advisor: agent.config?.advisor ?? null,
     pendingReminders: agent._pendingReminders ?? [],
     sessionStart: agent._sessionStart ?? null,
   }
@@ -214,6 +217,9 @@ export function applySession(agent, data) {
   agent.goal = data.goal ?? null
   agent._pendingReminders = data.pendingReminders ?? []
   agent._sessionStart = data.sessionStart ?? null
+  if (data.advisor) {
+    agent.config.advisor = { ...data.advisor }
+  }
   // Reset stall/compaction state on session switch
   agent._compressFailures = 0
   agent._verifyRetries = 0
@@ -234,7 +240,7 @@ export function clearSession(cwd) {
   try {
     archiveCurrent(cwd)
     const p = sessionPath(cwd)
-    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, pendingReminders: [], sessionStart: null })
+    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null })
   } catch {
     // Can't clear, oh well — next save will overwrite
   }

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")