thincoder 0.11.0 → 0.12.0

package/src/agent/helpers.mjs

@@ -3,6 +3,7 @@
  */
 import { configDir } from "../config.mjs"
 import { readFileSync, readdirSync, existsSync } from "node:fs"
+import { homedir } from "node:os"
 import { writeFile, mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { execSync } from "node:child_process"
@@ -12,8 +13,12 @@ export const DEFAULT_SUBAGENT_TURNS = 100
 export const DEFAULT_GOAL_TURNS = 200
 export const MIN_REPORT_CHARS = 200
 export const REPORT_CONTINUATION =
-  "Your report is too brief to be a complete handoff — the parent agent sees nothing else from your run. " +
-  "Expand it: what you did and why, the path of every file you touched, how you verified (commands/tests run, with results), and anything left undone."
+  "Your report was sent back: too brief to be a complete handoff — the parent agent sees nothing else from your run. " +
+  "Rewrite your final message as a checklist:\n" +
+  "1. What you changed and why\n" +
+  "2. The path of every file you touched\n" +
+  "3. How you verified (tests run, commands executed, with results)\n" +
+  "4. Anything left undone or worth follow-up"
 
 const TOOL_RESULT_OFFLOAD_LIMIT = 16_000
 const TOOL_RESULT_PREVIEW = 2_000
@@ -22,7 +27,7 @@ const GIT_TIMEOUT_MS = 5000
 const MAX_GIT_CHANGES_DISPLAY = 20
 
 export const OUTLINE_INJECT_PREFIX = "[System reminder: project dependency outline:"
-export const FILE_MUTATORS = new Set(["write", "edit", "insert_after", "apply_patch", "delete"])
+export const FILE_MUTATORS = new Set(["write", "edit", "insert_after", "apply_patch", "delete", "hashline_edit"])
 
 /** Escape XML special characters in a string for safe embedding in XML/HTML */
 export function escapeXml(s) {
@@ -174,14 +179,22 @@ export function readonlyToolNames(tools) {
 
 const MAX_INSTRUCTION_CHARS = 32_000
 
-/** Load AGENTS.md / project_rules.md from the project root, return as project instructions */
+/** Load AGENTS.md / project_rules.md from user home and project root.
+ *  User-level (~/.thincoder/AGENTS.md) loaded first (lower priority).
+ *  Project-level overrides take precedence. */
 export async function loadProjectInstructions(cwd) {
   const parts = []
+  // 1. User-level: global preferences across all projects
+  try {
+    const userPath = join(homedir(), ".thincoder", "AGENTS.md")
+    const content = readFileSync(userPath, "utf8").trim()
+    if (content) parts.push(`<!-- From: ${userPath} -->\n${content}`)
+  } catch { /* file does not exist */ }
+  // 2. Project-level: project-specific conventions
   for (const name of ["AGENTS.md", "project_rules.md"]) {
     try {
       const content = readFileSync(join(cwd, name), "utf8").trim()
       if (!content) continue
-      const key = name.toLowerCase()
       parts.push(`<!-- From: ${join(cwd, name)} -->\n${content}`)
     } catch { /* file does not exist */ }
   }

package/src/agent/setup.mjs

@@ -117,8 +117,8 @@ export async function prepareRun(agent, input, callbacks, {
   }
 
   // task/plan tools are injected with the main loop; subagent/skill/goal/verify only at top level
-  const { planTool, subagentTool, taskTool, skillTool, goalTool, verifyTool, recentChangesTool, timerTool } = await import("../agent-tools.mjs")
-  const tools = [...agent.tools, taskTool, planTool, timerTool, ...(depth === 0 ? [subagentTool, skillTool, goalTool, verifyTool, recentChangesTool] : [])]
+  const { planTool, subagentTool, taskTool, skillTool, goalTool, verifyTool, recentChangesTool, timerTool, advisorTool } = await import("../agent-tools.mjs")
+  const tools = [...agent.tools, taskTool, planTool, timerTool, ...(depth === 0 ? [subagentTool, skillTool, goalTool, verifyTool, recentChangesTool, advisorTool] : [])]
   const toolSchemas = tools.map(toOpenAISchema)
   const toolByName = new Map(tools.map((t) => [t.name, t]))
   agent._onTaskUpdate = callbacks.onTaskUpdate

package/src/agent-tools/advisor.mjs

@@ -0,0 +1,36 @@
+/**
+ * agent-tools/advisor.mjs — advisor tool wrapper.
+ * The agent calls this explicitly at the end of a coding task to get a code review.
+ */
+import { runAdvisorReview } from "../advisor.mjs"
+
+export const advisorTool = {
+  name: "advisor",
+  description:
+    "Run a code review on your changes (convergence protocol). " +
+    "Call this when you have finished coding and want an independent review before finalising. " +
+    "The advisor is an independent read-only sub-agent that explores the codebase, runs git diff, " +
+    "reads files, and traces callers via grep/lsp. " +
+    "Review criteria come from .thincoder/advisor.md (if present) or sensible defaults. " +
+    "Round 1 does a full review and produces a numbered issue table. " +
+    "After the review, you MUST produce a response table (see discipline rules for format). " +
+    "Round 2 verifies the table + can flag obvious new issues. " +
+    "Round 3+ strictly checks only the prior table — convergence, not divergence. " +
+    "If issues are found, fix them, update your response table, then re-run advisor. " +
+    "If advisor says all clear, call verify.",
+  parameters: {
+    type: "object",
+    properties: {},
+  },
+  readonly: true,
+  sideEffectExempt: true,
+  outputPanel: true,
+  async execute(_args, ctx) {
+    const agent = ctx.agent
+
+    const result = await runAdvisorReview(agent, ctx.onOutput, ctx.signal)
+    if (!result) return "Advisor: review is disabled or no changes to review."
+
+    return result
+  },
+}

package/src/agent-tools/plan.mjs

@@ -2,7 +2,56 @@
  * plan tool: enter/exit plan mode.
  * In plan mode only read-only tools are allowed — explore code, design solutions, no code writing.
  * After the user approves the plan, exit plan mode and start implementing.
+ *
+ * Reminder cadence (kimi-code style): while plan mode is active the agent loop
+ * re-injects reminders — sparse every 2 turns, full every 5 turns or when the
+ * user sends a new message — so the constraint never fades from context.
  */
+
+export const PLAN_FULL_REMINDER =
+  "[System reminder: plan mode is ON. Workflow: (1) explore/read codebase with read-only tools, " +
+  "(2) design a solution considering trade-offs, (3) present your plan by calling plan with action='exit' " +
+  "so the user can approve it. Only read-only tools are allowed — do not write, edit, or run mutation commands. " +
+  "Your turn must end with either a clarifying question to the user or a call to plan with action='exit'.]"
+
+export const PLAN_SPARSE_REMINDER =
+  "[System reminder: plan mode still active — read-only tools only (the current plan file exempt). " +
+  "Design the solution, then call plan with action='exit' for user approval.]"
+
+export const PLAN_EXIT_REMINDER =
+  "[System reminder: plan mode is now OFF. Start implementing your plan — edit files, run commands. " +
+  "No need for a task list (plan already covered that) or further confirmation.]"
+
+/** Turns between reminder re-injections while plan mode is active */
+const SPARSE_INTERVAL = 2
+const FULL_INTERVAL = 5
+
+/**
+ * Decide which plan-mode reminder (if any) to inject this turn.
+ * @param {object} agent — the agent object (mutated: tracks reminder state)
+ * @param {boolean} userMessageSince — whether a user message arrived since the last reminder
+ * @returns {string|null} reminder text or null
+ */
+export function planReminderForTurn(agent, userMessageSince) {
+  if (!agent.planMode) {
+    agent._planTurnsSinceReminder = 0
+    agent._planTurnsSinceSparse = 0
+    return null
+  }
+  agent._planTurnsSinceReminder = (agent._planTurnsSinceReminder ?? 0) + 1
+  agent._planTurnsSinceSparse = (agent._planTurnsSinceSparse ?? 0) + 1
+  if (userMessageSince || agent._planTurnsSinceReminder >= FULL_INTERVAL) {
+    agent._planTurnsSinceReminder = 0
+    agent._planTurnsSinceSparse = 0
+    return PLAN_FULL_REMINDER
+  }
+  if (agent._planTurnsSinceSparse >= SPARSE_INTERVAL) {
+    agent._planTurnsSinceSparse = 0
+    return PLAN_SPARSE_REMINDER
+  }
+  return null
+}
+
 export const planTool = {
   name: "plan",
   description:
@@ -18,13 +67,15 @@ export const planTool = {
   async execute(args, ctx) {
     if (args.action === "exit") {
       ctx.agent.planMode = false
+      ctx.agent._planTurnsSinceReminder = 0
       ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-      ctx.agent._pendingReminders.push("[System reminder: plan mode is now OFF. Start implementing your plan — edit files, run commands. No need for a task list (plan already covered that) or further confirmation.]")
+      ctx.agent._pendingReminders.push(PLAN_EXIT_REMINDER)
       return "Plan mode exited. You may now edit files and run commands."
     }
     ctx.agent.planMode = true
+    ctx.agent._planTurnsSinceReminder = 0
     ctx.agent._pendingReminders = ctx.agent._pendingReminders ?? []
-    ctx.agent._pendingReminders.push("[System reminder: plan mode is now ON. Workflow: (1) explore/read codebase with read-only tools, (2) design a solution considering trade-offs, (3) present your plan by calling plan with action='exit' so the user can approve it. Only read-only tools are allowed — do not write, edit, or run mutation commands.]")
+    ctx.agent._pendingReminders.push(PLAN_FULL_REMINDER)
     return "Plan mode activated. You are now restricted to READ-ONLY tools. Explore the codebase, understand the architecture, design a solution. Present your plan to the user for approval before writing any code."
   },
 }

package/src/agent-tools/subagent.mjs

@@ -16,7 +16,13 @@ import {
 export const subagentTool = {
   name: "subagent",
   description:
-    "Spawn a sub-agent to handle an independent subtask in an isolated context. The sub-agent returns only its final report. Spawn MULTIPLE subagents in the SAME response for parallel work—they run concurrently. Use role='explore' for codebase search/analysis (read-only, fast), role='plan' for read-only implementation planning (returns a step-by-step plan, never edits), role='coder' for self-contained implementation tasks. Do not give parallel subagents tasks that edit the same files.",
+    "Spawn a sub-agent to handle an independent subtask in an isolated context. The sub-agent returns only its final report. Spawn MULTIPLE subagents in the SAME response for parallel work—they run concurrently.\n" +
+    "Use role='explore' for codebase search/analysis (read-only, fast), role='plan' for read-only implementation planning (returns a step-by-step plan, never edits), role='coder' for self-contained implementation tasks. Do not give parallel subagents tasks that edit the same files.\n\n" +
+    "Writing the prompt:\n" +
+    "- The sub-agent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\n" +
+    "- Put exact paths and commands in the prompt when you know them. The sub-agent should not search for things you already know.\n" +
+    "- Do not delegate understanding: if the task hinges on a file path or line number, find it yourself first and write it into the prompt.\n" +
+    "- Once a sub-agent is running, leave that scope to it: don't redo its searches in parallel, and don't abandon it midway to finish manually.",
   parameters: {
     type: "object",
     properties: {

package/src/agent-tools/timer.mjs

@@ -29,7 +29,7 @@ export const timerTool = {
   readonly: true,
   sideEffectExempt: true,
   execute(args, ctx) {
-    const seconds = args.seconds ?? 30
+    const seconds = args.seconds ?? 180
     const expiresAt = Date.now() + seconds * 1000
     const message = args.message || `⏰ Time's up (${seconds}s). Have you tried running the code, adding a console.log, or checking the output? Thinking more without data is guessing.`
 

package/src/agent-tools/verify.mjs

@@ -19,6 +19,7 @@ const MODULE_TO_TEST = {
   skills: "test/tools.test.mjs",
   distill: "test/tools.test.mjs",
   markdown: "test/agent.test.mjs",
+  advisor: "test/advisor.test.mjs",
   mcp: null,
   prompts: null,
   context: null,

package/src/agent-tools.mjs

@@ -11,3 +11,4 @@ export { goalTool } from "./agent-tools/goal.mjs"
 export { verifyTool } from "./agent-tools/verify.mjs"
 export { recentChangesTool } from "./agent-tools/recent-changes.mjs"
 export { timerTool } from "./agent-tools/timer.mjs"
+export { advisorTool } from "./agent-tools/advisor.mjs"

package/src/agent.mjs

@@ -31,7 +31,7 @@ export const EXPLORE_OVERLAY = _EXPLORE
 export const CODER_OVERLAY = _CODER
 export const PLAN_OVERLAY = _PLAN
 
-// Re-exported for consumption by agent-tools.mjs
+// exported for consumption by agent-tools.mjs
 export {
   ContinueError,
   repairHistory, listWorkDir, loadProjectInstructions,
@@ -49,6 +49,7 @@ const STALL_THRESHOLD = 3
 const GOAL_BUDGET_WARN_RATIO = 0.75
 const MAX_VERIFY_PUSHBACKS = 2
 const MAX_VERIFY_RETRIES = 3
+const MAX_ADVISOR_PUSHBACKS = 3
 
 /** Create a new agent state object with all fields initialized to defaults */
 export function createAgent({
@@ -61,8 +62,8 @@ export function createAgent({
     provider, tools, config, cwd, memory, _role: role,
     overlay, tasks, history,
     planMode, autoApprove, goal,
-    _mutatedThisRun: false, _verifiedThisRun: false, _verifyPassed: undefined,
-    _touchedFiles: [], _verifyRetries: 0,
+    _mutatedThisRun: false, _verifiedThisRun: false, _verifyPassed: undefined, _calledAdvisorThisRun: false,
+    _touchedFiles: [], _verifyRetries: 0, _advisorRound: 0, _advisorSession: null,
     _pendingReminders: [],
     _pendingTimers: [],
     _sessionStart: sessionStart,
@@ -81,11 +82,18 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
   agent._mutatedThisRun = false
   agent._verifiedThisRun = false
   agent._verifyPassed = undefined
+  agent._calledAdvisorThisRun = false
   agent._touchedFiles = []
   agent._verifyRetries = 0
+  agent._advisorRound = 0
+  agent._advisorSession = null // advisor session is per-run: discard when the task ends, next task starts fresh
   let guardPushbacks = 0
+  let advisorPushbacks = 0
   let honestReminderInjected = false
   const recentCallSigs = []
+  // repeat: "once" stream rules fire at most once per runAgent call (user turn):
+  // this set survives across chat() calls (rule abort-retry, tool loop) within the turn.
+  const streamRuleFired = new Set()
 
   for (let turn = 0; turn < maxTurns; turn++) {
 
@@ -94,6 +102,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       try {
         if (await compressIfNeeded(agent, threshold, callbacks)) {
           agent._compressFailures = 0
+          agent._planReminderAtLen = 0 // After compression history shrinks, reset cadence so reminders resume
           recentCallSigs.length = 0 // After compression history is rebuilt, reset stall detection counter
           callbacks.onCompress?.()
           if (agent.autoApprove && !agent.history.some((m) => m.content === AUTO_REMINDER)) {
@@ -111,6 +120,24 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
     }
 
+    // Plan-mode reminder cadence: re-inject constraint reminders while plan mode is active
+    // (sparse every 2 turns, full every 5 turns or when the user sends a new message),
+    // so the read-only restriction never fades from context.
+    if (agent.planMode) {
+      const lastMsg = agent.history.at(-1)
+      const realUserMsg = lastMsg?.role === "user"
+        && typeof lastMsg.content === "string"
+        && !lastMsg.content.startsWith("[System reminder:")
+        && !lastMsg.content.startsWith("[User interrupt:")
+      const newUserSince = realUserMsg && agent.history.length > (agent._planReminderAtLen ?? 0)
+      const { planReminderForTurn } = await import("./agent-tools/plan.mjs")
+      const reminder = planReminderForTurn(agent, newUserSince)
+      if (reminder) {
+        agent._planReminderAtLen = agent.history.length + 1
+        agent.history.push({ role: "user", content: reminder, transient: true })
+      }
+    }
+
     const messages = [{ role: "system", content: systemPrompt }, ...agent.history]
     let response
 
@@ -129,15 +156,18 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
         onWait: callbacks.onWait,
         signal,
         streamRules: agent.config.agent?.streamRules ?? [],
+        firedPatterns: streamRuleFired,
       })
     } catch (e) {
       // User interrupt (Ctrl+I): controller.abort({ interrupt: true, message: "…" }).
       // 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}]`,
-        })
+        const msg = `[User interrupt: ${signal.reason.message}]`
+        // Dedup: if the interrupt was already handled during tool execution (L302-310),
+        // don't push a duplicate — the outer loop will still recreate the controller.
+        if (agent.history.at(-1)?.content !== msg) {
+          agent.history.push({ role: "user", content: msg })
+        }
       }
       throw e
     }
@@ -219,6 +249,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           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.]`,
         })
+        callbacks.onTurnEnd?.(agent, turn)
         continue
       }
       // --- verify guard: push model to verify mutated files before completion ---
@@ -230,15 +261,15 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
             role: "user",
             content: "[System reminder: you modified files in this run but have not verified the changes. Before finishing: call the verify tool to run syntax checks and tests. If verify reports failures, fix them and run verify again. If verification is genuinely impossible here, say so explicitly in your reply.]",
           })
+          callbacks.onTurnEnd?.(agent, turn)
           continue
-        }
-        if (agent._verifiedThisRun && agent._verifyPassed === false && agent._verifyRetries < MAX_VERIFY_RETRIES) {
           agent._verifyRetries++
           agent.history.push({ role: "assistant", content: response.content })
           agent.history.push({
             role: "user",
             content: `[System reminder: verify reported test failures (retry ${agent._verifyRetries}/${MAX_VERIFY_RETRIES}). Review the failures, fix the issues, then run verify again. If you cannot fix after ${MAX_VERIFY_RETRIES} attempts, explain honestly what's blocking you.]`,
           })
+          callbacks.onTurnEnd?.(agent, turn)
           continue
         }
         if (agent._verifyPassed === false && agent._verifyRetries >= MAX_VERIFY_RETRIES) {
@@ -252,6 +283,25 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
             role: "user",
             content: `[System reminder: ${MAX_VERIFY_RETRIES} verify attempts exhausted and tests are still failing. In your response to the user, you MUST state explicitly: (1) what tests are still failing, (2) what you tried, (3) what you believe the root cause is. Do not present this as complete — the user needs to know the work is unfinished.]`,
           })
+          callbacks.onTurnEnd?.(agent, turn)
+          continue
+        }
+      }
+      // --- advisor guard: review of mutated files is mandatory before completion ---
+      // When advisor is enabled and guard is not explicitly disabled, the model MUST
+      // call advisor after mutating files — skipping is not offered as an option
+      // (offering it caused a skip → pushback loop). Pushbacks are capped as a
+      // backstop against pathological loops; convergence is unbounded by design.
+      if (depth === 0 && agent.config?.advisor?.enabled && agent.config?.advisor?.guard !== false) {
+        if (agent._mutatedThisRun && !agent._calledAdvisorThisRun && (agent._touchedFiles ?? []).length > 0
+            && advisorPushbacks < MAX_ADVISOR_PUSHBACKS) {
+          advisorPushbacks++
+          agent.history.push({ role: "assistant", content: response.content })
+          agent.history.push({
+            role: "user",
+            content: `[System reminder: you changed code in this run and MUST get an advisor review before finishing (round ${agent._advisorRound + 1}). Call the \`advisor\` tool now. This is required, not optional — do not skip it even if you believe the changes are trivial; a small diff just makes the review fast. After the review, produce a response table for every issue found (see discipline rules for format).]`,
+          })
+          callbacks.onTurnEnd?.(agent, turn)
           continue
         }
       }
@@ -276,8 +326,20 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
 
     const results = await executeToolCalls(agent, toolByName, response.toolCalls, callbacks, depth, signal)
 
+    // Ctrl+I interrupt during tool execution: skip committing partial results —
+    // the tool failure messages would mislead the model. Inject the interrupt and retry.
+    if (signal?.reason?.interrupt) {
+      agent.history.push({
+        role: "user",
+        content: `[User interrupt: ${signal.reason.message}]`,
+      })
+      callbacks.onTurnEnd?.(agent, turn)
+      continue
+    }
+
     // Model is executing tools → doing real work, reset guard pushback counter
     guardPushbacks = 0
+    advisorPushbacks = 0
 
     for (const { toolCall, result, ok } of results) {
       const tool = toolByName.get(toolCall.name)
@@ -308,8 +370,16 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       }
       agent.history.push({ role: "tool", tool_call_id: toolCall.id, content: result })
       if (tool && ok) {
-        if (!tool.readonly && !tool.sideEffectExempt) agent._mutatedThisRun = true
+        if (!tool.readonly && !tool.sideEffectExempt) {
+          agent._mutatedThisRun = true
+          // Any mutation after advisor invalidates the review — need re-review
+          if (agent._calledAdvisorThisRun) agent._calledAdvisorThisRun = false
+        }
         if (toolCall.name === "verify") agent._verifiedThisRun = true
+        if (toolCall.name === "advisor") {
+          agent._calledAdvisorThisRun = true
+          agent._advisorRound++  // advance convergence round
+        }
         if (FILE_MUTATORS.has(toolCall.name)) {
           const args = JSON.parse(toolCall.arguments)
           const paths = tool.touchedPaths ? tool.touchedPaths(args) : [args.path]
@@ -386,17 +456,6 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     }
 
     callbacks.onTurnEnd?.(agent, turn)
-
-    // Advisor: automated code review after each tool-execution turn.
-    // Runs asynchronously — failure is silent, main loop continues regardless.
-    if (agent.config?.advisor?.enabled) {
-      const { runAdvisor } = await import("./advisor.mjs")
-      const note = await runAdvisor(agent)
-      if (note) {
-        agent.history.push({ role: "user", content: note })
-        callbacks.onAdvisor?.(note)
-      }
-    }
   }
 
   throw new ContinueError(maxTurns)

package/src/auto-think.mjs

@@ -31,6 +31,26 @@ const EFFORT_MAP = {
   high: ["max", "max", "xhigh", "max"],
 }
 
+/**
+ * Build classifier input from history: the latest real user message (reminders and
+ * interrupt injections excluded), plus the previous user message as context when the
+ * latest is too short to classify on its own (e.g. "继续" / "还有几个问题").
+ * Exported for tests.
+ */
+export function buildClassifierInput(history) {
+  const isRealUser = (m) =>
+    m.role === "user" && typeof m.content === "string"
+    && !m.content.startsWith("[System reminder:") && !m.content.startsWith("[User interrupt:")
+  const users = history.filter(isRealUser)
+  const last = users.at(-1)
+  if (!last) return null
+  let prompt = last.content
+  if (prompt.length < 200 && users.length > 1) {
+    prompt = `Previous request (context):\n${users.at(-2).content.slice(0, 1200)}\n\nLatest message:\n${prompt}`
+  }
+  return prompt.slice(0, 2000)
+}
+
 /**
  * Classify the difficulty of the user's prompt and adjust reasoning effort.
  * Only runs on the first turn (turn === 0) of a user message.
@@ -47,10 +67,8 @@ export async function classifyAndApply(agent, turn) {
   const validEfforts = spec.reasoningEffortEnum
   if (!validEfforts) return null // Model doesn't support reasoning effort
 
-  // Get the last user message (should be the most recent history entry or the input)
-  const lastUser = [...agent.history].reverse().find(m => m.role === "user")
-  if (!lastUser) return null
-  const prompt = typeof lastUser.content === "string" ? lastUser.content : ""
+  const prompt = buildClassifierInput(agent.history)
+  if (prompt == null) return null
 
   // Classification call: use same provider, minimal tokens, no tools, no streaming
   let level
@@ -59,7 +77,7 @@ export async function classifyAndApply(agent, turn) {
     const response = await chat(classifierProvider, {
       messages: [
         { role: "system", content: CLASSIFY_PROMPT },
-        { role: "user", content: prompt.slice(0, 2000) },
+        { role: "user", content: prompt },
       ],
       tools: [],
       signal: AbortSignal.timeout(5_000),

package/src/cli/make-agent.mjs

@@ -52,6 +52,26 @@ export async function assembleAgent() {
 
   // MCP servers: connect in parallel (a dead server won't block startup), collect failures as warnings (stderr invisible in TUI, passed via agent object)
   const mcpServers = config.mcp?.servers ?? []
+  // Read project-level .mcp.json (standard MCP client convention) — merge into mcpServers
+  // config.json servers take priority over .mcp.json entries with the same name
+  try {
+    const { existsSync, readFileSync } = await import("node:fs")
+    const mcpJsonPath = join(cwd, ".mcp.json")
+    if (existsSync(mcpJsonPath)) {
+      const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8"))
+      if (mcpJson.mcpServers && typeof mcpJson.mcpServers === "object") {
+        const configNames = new Set(mcpServers.map((s) => s.name))
+        for (const [name, server] of Object.entries(mcpJson.mcpServers)) {
+          if (configNames.has(name)) continue // config.json takes priority
+          if (!server || typeof server !== "object") continue
+          mcpServers.push({ name, ...server })
+        }
+      }
+    }
+  } catch (e) {
+    // .mcp.json parse failure — non-fatal, log and continue
+    console.error(`[mcp] Failed to read .mcp.json: ${e.message}`)
+  }
   let mcpTools = []
   const mcpWarnings = []
   if (mcpServers.length) {

package/src/config.mjs

@@ -39,7 +39,7 @@ const DEFAULTS = {
     compactThreshold: 100000,
     verifyGuard: false,  // push model back to verify when files were mutated but verify not run (opt-in)
     streamRules: [],      // time-traveling stream rules: [{ pattern: "regex", message: "reminder", action: "abort"|"warn", repeat: "always"|"once" }]
-    advisor: { enabled: false },  // automated code review after each tool-execution turn; optionally: { enabled: true, provider: "deepseek", model: "deepseek-chat" }
+    advisor: { enabled: false },  // code review; { enabled: true, provider: "deepseek", model: "deepseek-chat", thinking: { type: "enabled" }, reasoningEffort: "max", guard: true }
     autoThink: false,     // auto-classify task difficulty and set reasoning effort per-turn
   },
   memory: {

package/src/mcp/transport-stdio.mjs

@@ -4,9 +4,10 @@
 import { spawn } from "node:child_process"
 import { rpcId, CALL_TIMEOUT_MS, withTimeout, quoteArg } from "./helpers.mjs"
 
-/** Create an MCP stdio transport over a spawned child process */
-export function stdioTransport(command, args) {
-  const spawnOptions = { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, env: { ...process.env } }
+/** Create an MCP stdio transport over a spawned child process.
+ *  @param {Object} [env] — extra environment variables merged on top of process.env */
+export function stdioTransport(command, args, env) {
+  const spawnOptions = { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, env: { ...process.env, ...env } }
   const child =
     process.platform === "win32" && !/\.exe$/i.test(command)
       ? spawn("cmd.exe", ["/d", "/s", "/c", [command, ...(args ?? [])].map(quoteArg).join(" ")], {

package/src/mcp.mjs

@@ -77,7 +77,7 @@ export async function connectMcpServer(config) {
   }
 
   if (config.command) {
-    const transport = stdioTransport(config.command, config.args ?? [])
+    const transport = stdioTransport(config.command, config.args ?? [], config.env)
     try {
       const mcpTools = await doInitialize(transport, config.name ?? config.command)
       return buildTools(mcpTools, transport, config)

package/src/prompts/advisor-round1.md

@@ -0,0 +1,23 @@
+You are a code review advisor.
+Perform a full-scope review of the code changes.
+You have read-only tools to explore the codebase.
+
+Review workflow:
+1. The uncommitted changes (git status + diff) are already provided in the review context — do not re-run them unless marked truncated.
+2. Read AGENTS.md / design docs once if present, to understand project conventions, version requirements, and architecture decisions.
+3. Read changed files for full context beyond the diff. Batch independent tool calls in one reply.
+4. Use grep or lsp to trace callers, imports, and dependencies — only where genuinely needed.
+5. Produce your review table.
+
+Rules:
+- Reply in the same language as the conversation background.
+- Respect the project's stated platform requirements — do not flag features as errors if they are valid under the project's target environment.
+- Output a Markdown table. This table becomes the sole basis for convergence in later rounds — be thorough.
+| # | File | Severity | Issue | Suggestion |
+|---|------|----------|-------|------------|
+| 1 | src/x.mjs | 🔴 | ... | ... |
+- Order by severity: 🔴 Critical · 🟡 Advisory · 🔵 Style.
+- For each issue state: which file, what the problem is, why it is a problem, how to fix it.
+- If the code is clean, say exactly: "No issues found — code quality looks good."
+- Cover everything now. Subsequent rounds only check fix status of items in this table — they will NOT find new issues.
+- Stop calling tools once you are ready to produce the review table.

package/src/prompts/advisor-round2.md

@@ -0,0 +1,26 @@
+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.
+
+Review workflow:
+1. The current changes (git status + diff) are already provided in the review context — do not re-run them unless marked truncated.
+2. Project conventions were established in round 1 — do NOT re-read AGENTS.md / design docs unless a fix appears to contradict the task itself.
+3. Read changed files for full context beyond the diff. Batch independent tool calls in one reply.
+4. Use grep or lsp to trace callers, imports, and dependencies — only where genuinely needed.
+5. Produce your review table.
+
+Rules:
+- Respect the project's stated platform requirements — do not flag features as errors if they are valid under the project's target environment.
+- Primarily check fix status of items in the prior issue table.
+- For items marked "fixed": verify they were actually fixed.
+- For items marked "not an issue": evaluate whether the reasoning is sound.
+- You may flag obvious new problems — but only if clearly visible in the diff and would cause crashes, data loss, or logic errors.
+- Do NOT nitpick style or naming.
+- Output a Markdown table listing all remaining problems (old or new):
+| # | Orig# | File | Severity | Status | Notes |
+|---|-------|------|----------|--------|-------|
+| 1 | 3     | src/x.mjs | 🔴 | Unfixed | ... |
+| N | (new) | src/y.mjs | 🔴 | New: null check missing after fix | ... |
+- If all issues are resolved, say exactly: "All issues resolved — review passed."
+- Stop calling tools once you are ready to produce the review table.

package/src/prompts/advisor-round3.md

@@ -0,0 +1,24 @@
+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.
+
+Review workflow:
+1. The current changes (git status + diff) are already provided in the review context — do not re-run them unless marked truncated.
+2. Project conventions were established in round 1 — do NOT re-read AGENTS.md / design docs.
+3. Read changed files for full context beyond the diff. Batch independent tool calls in one reply.
+4. Verify fix status of each item in the prior issue table.
+5. Produce your review table.
+
+Rules:
+- Respect the project's stated platform requirements — do not flag features as errors if they are valid under the project's target environment.
+- Only check fix status of items in the prior issue table.
+- For items marked "fixed": verify they were actually fixed.
+- For items marked "not an issue": evaluate whether the reasoning is sound.
+- Output a Markdown table. Only list items that still have problems:
+| # | Orig# | File | Severity | Status | Notes |
+|---|-------|------|----------|--------|-------|
+| 1 | 3     | src/x.mjs | 🔴 | Unfixed | ... |
+| 2 | 5     | src/y.mjs | 🟡 | Reasoning invalid | ... |
+- If all issues are resolved, say exactly: "All issues resolved — review passed."
+- Stop calling tools once you are ready to produce the review table.

package/src/prompts/coder.md

@@ -3,6 +3,7 @@ You are a coding subagent. The parent agent dispatched you to handle a self-cont
 Guidelines:
 - Work independently: use doc_search to learn project conventions and design, repo_outline to understand structure, then code_search to find implementations.
   Don't write code until you know what the project intends.
+- MINIMAL changes: solve the task, nothing more. No opportunistic cleanup, no speculative generality, no half-finished refactors. Keep the diff small enough to review at a glance — the parent agent evaluates your work by reading the diff, and every unrelated change dilutes it.
 - Write code in small, verified steps — don't write multiple files at once without checking each along the way:
   1. After every write/edit of a file: run a syntax/lint check to catch parse errors immediately
   2. After a logical group of changes: run the relevant tests to confirm behavior