thincoder 0.11.1 → 0.12.0

package/README.md

@@ -205,6 +205,14 @@ Code conventions: pure `.mjs`, no semicolons, no npm dependencies allowed (inclu
 
 ## Changelog
 
+### 0.12.0 (2026-07)
+- **Interactive slash command UX** — `/advisor`, `/think`, `/config`, `/mcp` now use persistent menu loops with live state feedback. Toggle, change settings, and see results without re-entering the command. Cursor position is remembered across menu cycles. `/plan` and `/auto` now show immediate local feedback (`❯ Plan: ON/OFF`).
+- **User-level AGENTS.md** — `~/.thincoder/AGENTS.md` is now loaded alongside the project-level `AGENTS.md`. User-level preferences (language, style, format) apply across all projects; project-level rules take priority.
+- **Skill subdirectory format** — `.thincoder/skills/` now supports the standard `skill-name/SKILL.md` subdirectory convention (Claude Code / Cursor compatible). Flat `.md` files remain fully backward-compatible. Subdirectories take priority when both formats exist with the same name.
+- **MCP stdio `env` field** — `env` key in MCP stdio server config is now merged into the child process environment. Enables MCP servers requiring custom environment variables (e.g. `deveco-mcp`).
+- **Project-level `.mcp.json`** — `.mcp.json` in the project root is auto-loaded at startup (standard MCP client convention). Servers defined here are merged with `config.json` servers — `config.json` takes priority for same-named entries.
+- **Cleaner conversations** — Removed redundant `[System reminder: ...]` injections from `/advisor`, `/plan`, `/auto`, and `/think` toggles. All feedback is now local TUI output, not conversation noise.
+
 ### 0.10.0 (2026-07)
 - **LSP tool** — `lsp` tool provides code intelligence via Language Server Protocol: go-to-definition, find-references, hover info, document symbols, diagnostics. Zero-dependency JSON-RPC 2.0 over stdio client. Lazy-starts language servers on first call. Configurable via `lsp.servers` in config.json (defaults: `typescript-language-server` for JS/TS, `pyright-langserver` for Python).
 - **Smart context: compaction checkpoint** — `compressIfNeeded` now auto-creates a git checkpoint before compaction. A checkpoint reference is injected after compaction so the model can reconstruct context from git diff + recent messages + task progress. Prevents information loss during long sessions.

package/package.json

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

package/src/advisor.mjs

@@ -18,6 +18,15 @@
  *   Round 3+: strict convergence — only checks the prior issue table.
  *   No hard round cap — the convergence protocol naturally limits divergence.
  *
+ * Session memory (agent._advisorSession):
+ *   All advisor calls within one run share a single conversation — round 2+
+ *   just appends a follow-up (agent response + refreshed diff + round rules),
+ *   so the advisor keeps its exploration context instead of re-discovering
+ *   everything. The session is discarded when the run ends (runAgent resets it);
+ *   the next task starts a fresh advisor session. After an app restart the
+ *   in-memory session is gone — falls back to a fresh session seeded from the
+ *   issue/response tables in the main history.
+ *
  *
  * Project customisation: .thincoder/advisor.md in the project root.
  */
@@ -32,7 +41,6 @@ import { toOpenAISchema } from "./tools/index.mjs"
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
 const ADVISOR_MD_PATH = ".thincoder/advisor.md"
-const MAX_TASK_SUMMARY = 500
 const GIT_TIMEOUT = 5_000
 
 const DEFAULT_CRITERIA = `Review the code changes, focusing on:
@@ -180,6 +188,39 @@ function findReviewRepos(agent) {
 
 // ────────────────────────────────────────
 
+/** Cap per-repo embedded diff — generous (large-context models); advisor can fetch the rest via its git tool */
+const MAX_EMBEDDED_DIFF = 50_000
+
+/**
+ * Collect git status + diff for each repo, embedded into the review context so
+ * the advisor doesn't need to spend its first tool calls discovering changes.
+ */
+function collectRepoSnapshots(repos, cwd) {
+  const targets = repos.length > 0 ? repos : [cwd]
+  const parts = []
+  for (const repo of targets) {
+    let status = "", diff = ""
+    try {
+      status = execFileSync("git", ["status", "--porcelain"], {
+        cwd: repo, encoding: "utf8", timeout: GIT_TIMEOUT, stdio: ["ignore", "pipe", "pipe"],
+      }).trim()
+      diff = execFileSync("git", ["diff", "HEAD"], {
+        cwd: repo, encoding: "utf8", timeout: GIT_TIMEOUT, stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: 8 * 1024 * 1024,
+      })
+    } catch { continue /* not a git repo or git failed */ }
+    if (!status && !diff.trim()) continue
+    parts.push(`### ${repo}`)
+    if (status) parts.push("```", status, "```")
+    if (diff.trim()) {
+      const truncated = diff.length > MAX_EMBEDDED_DIFF
+      parts.push("```diff", truncated ? diff.slice(0, MAX_EMBEDDED_DIFF) : diff.trimEnd(), "```")
+      if (truncated) parts.push(`(diff truncated at ${MAX_EMBEDDED_DIFF} chars — use the git tool to see the rest)`)
+    }
+  }
+  return parts
+}
+
 export function loadAdvisorMd(cwd) {
   const path = join(cwd, ADVISOR_MD_PATH)
   if (!existsSync(path)) return DEFAULT_CRITERIA
@@ -191,16 +232,46 @@ export function loadAdvisorMd(cwd) {
   }
 }
 
-function extractTaskSummary(history) {
-  for (let i = history.length - 1; i >= 0; i--) {
+const MAX_BACKGROUND_CHARS = 20_000
+const MAX_BG_USER_CHARS = 2000
+const MAX_BG_ASSISTANT_CHARS = 1500
+
+/**
+ * Recent conversation context for the advisor: the last few user↔assistant
+ * exchanges (default 3 user turns). The last user message alone often lacks
+ * context ("把那个问题改一下" means nothing without the preceding turns) —
+ * the advisor needs the background to judge whether the changes match intent.
+ * Tool messages are skipped (noise); texts are truncated with generous caps
+ * (models have large context windows — completeness beats frugality).
+ */
+export function extractConversationBackground(history, maxTurns = 3) {
+  const isNoise = (c) => c.startsWith("[System reminder:") || c.startsWith("[User interrupt:")
+  const picked = []
+  let userCount = 0
+  for (let i = history.length - 1; i >= 0 && userCount < maxTurns; i--) {
     const m = history[i]
-    if (m.role !== "user") continue
-    const content = typeof m.content === "string" ? m.content : ""
-    if (content.startsWith("[System reminder:") || content.startsWith("[User interrupt:")) continue
-    const firstPara = content.split("\n\n")[0]
-    return firstPara.length > MAX_TASK_SUMMARY ? firstPara.slice(0, MAX_TASK_SUMMARY) + "…" : firstPara
+    if (m.role !== "user" && m.role !== "assistant") continue
+    const content = typeof m.content === "string" ? m.content.trim() : ""
+    if (!content || isNoise(content)) continue
+    picked.unshift({ role: m.role === "user" ? "User" : "Assistant", text: content })
+    if (m.role === "user") userCount++
   }
-  return null
+  if (picked.length === 0) return null
+
+  const lines = picked.map((e) => {
+    const cap = e.role === "User" ? MAX_BG_USER_CHARS : MAX_BG_ASSISTANT_CHARS
+    const text = e.text.length > cap ? e.text.slice(0, cap) + "…" : e.text
+    return `${e.role}: ${text}`
+  })
+  // Keep the most recent lines within the total budget
+  const out = []
+  let total = 0
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (out.length > 0 && total + lines[i].length > MAX_BACKGROUND_CHARS) break
+    total += lines[i].length
+    out.unshift(lines[i])
+  }
+  return out.join("\n")
 }
 
 // ────────────────────────────────────────
@@ -254,11 +325,21 @@ export function buildAdvisorUserMessage(agent, _prior) {
   parts.push(repoList)
   parts.push("")
 
-  // Task summary
-  const taskSummary = extractTaskSummary(agent.history)
-  if (taskSummary) {
-    parts.push("## Task")
-    parts.push(taskSummary)
+  // Pre-collected changes — saves the advisor from spending its first tool
+  // calls on discovery (git status / git diff) every single round.
+  const snapshots = collectRepoSnapshots(repos, agent.cwd)
+  agent._advisorLastSnapshot = snapshots.join("\n") // dedup baseline for follow-up rounds
+  if (snapshots.length > 0) {
+    parts.push("## Current Changes (git status + git diff HEAD, pre-collected)")
+    parts.push(...snapshots)
+    parts.push("")
+  }
+
+  // Conversation background — recent user↔assistant exchanges for intent context
+  const background = extractConversationBackground(agent.history)
+  if (background) {
+    parts.push("## Conversation Background (recent turns)")
+    parts.push(background)
     parts.push("")
   }
 
@@ -268,34 +349,128 @@ export function buildAdvisorUserMessage(agent, _prior) {
   parts.push(criteria)
   parts.push("")
 
-  // Instructions
+  // Instructions — round-aware: re-reviews skip convention discovery entirely
+  const isReReview = prior && (agent._advisorRound || 0) > 0
   parts.push("## Instructions")
-  parts.push("1. Read `AGENTS.md` and any design documents first — understand project conventions, version requirements, and architecture decisions before flagging issues.")
-  parts.push("2. Run `git diff HEAD` in each repo to discover uncommitted changes.")
-  parts.push("3. `read` changed files for full context beyond the diff.")
-  parts.push("4. Use `grep` or `lsp` to trace callers, imports, and dependencies.")
-  parts.push("5. Produce your review table based on the review criteria above.")
+  parts.push("1. The uncommitted changes are already provided above — do NOT re-run `git status` / `git diff` unless the embedded diff is marked truncated.")
+  if (isReReview) {
+    parts.push("2. Do NOT re-read AGENTS.md / design docs — conventions were established in round 1. Focus on verifying the prior issue table against the current diff.")
+    parts.push("3. `read` only the files touched by the fixes. Batch independent reads/greps in a single reply.")
+    parts.push("4. Produce your verification table. Do not re-read content you already have.")
+  } else {
+    parts.push("2. Read `AGENTS.md` / design docs only if they exist (check once; do not re-probe with multiple patterns).")
+    parts.push("3. `read` changed files for full context beyond the diff. Batch independent reads/greps in a single reply instead of one call per round-trip.")
+    parts.push("4. Use `grep` or `lsp` to trace callers, imports, and dependencies — only where the diff leaves genuine doubt.")
+    parts.push("5. Produce your review table based on the review criteria above. Do not re-read content you already have.")
+  }
   parts.push("Do NOT flag features that are valid under the project's stated platform requirements.")
 
   return parts.join("\n")
 }
 
+// ────────────────────────────────────────
+// Session continuity — one advisor conversation per run
+// ────────────────────────────────────────
+
+/**
+ * Follow-up message for round 2+ in a continued advisor session.
+ * The advisor already has full context (its exploration, its issue table) in
+ * the conversation — the follow-up only carries what changed: the agent's
+ * response table, the fresh diff snapshot, and this round's rules.
+ */
+export function buildAdvisorFollowUp(agent, _prior) {
+  const prior = _prior ?? extractPriorIssueTable(agent.history)
+  const round = (agent._advisorRound || 0) + 1
+  const response = (prior ? extractAgentResponseTable(agent.history, prior.sinceIdx) : null)
+    || "(Agent did not provide a response table — re-evaluate each issue)"
+  const rules = round === 2
+    ? "Verify each item in your prior issue table against the current changes. " +
+      "You may flag obvious NEW issues introduced by the fixes — but only crashes, data loss, or logic errors clearly visible in the diff. Do not nitpick style."
+    : "Strictly verify only your prior issue table against the current changes. Do NOT look for new issues."
+
+  const parts = [
+    `## Round ${round} — ${round === 2 ? "Verify Prior Table + Flag New Issues" : "Strict Verification"}`,
+    "",
+    rules,
+    "",
+    'If every prior issue is resolved, say exactly: "All issues resolved — review passed."',
+    "",
+    "Do NOT re-read AGENTS.md / design docs or re-run git status/diff (current changes are below) — you already have full context from previous rounds.",
+    "",
+    "## Agent Response to Your Review",
+    response,
+    "",
+  ]
+  const snapshots = collectRepoSnapshots(findReviewRepos(agent), agent.cwd)
+  const snapshotText = snapshots.join("\n")
+  // Skip re-pushing an identical diff (e.g. advisor re-run without any file changes) —
+  // the previous snapshot is already in the conversation, duplicating it wastes tokens.
+  if (snapshotText && snapshotText === agent._advisorLastSnapshot) {
+    parts.push("## Current Changes", "(No changes since your previous review.)")
+  } else if (snapshots.length > 0) {
+    parts.push("## Current Changes (git status + git diff HEAD, refreshed)", ...snapshots)
+  }
+  agent._advisorLastSnapshot = snapshotText
+  return parts.join("\n")
+}
+
+/**
+ * Build or continue the advisor conversation for this run.
+ * First call in a run: fresh [system, user] session. Later calls: append a
+ * follow-up to the existing session so the advisor keeps its context.
+ * After an app restart (session lost), falls back to a fresh session whose
+ * system prompt is picked from history tables (round 2/3 style).
+ */
+export function prepareAdvisorMessages(agent) {
+  const prior = extractPriorIssueTable(agent.history)
+  let session = agent._advisorSession
+  if (session) {
+    session.push({ role: "user", content: buildAdvisorFollowUp(agent, prior) })
+    return session
+  }
+  session = [
+    { role: "system", content: buildAdvisorSystemPrompt(agent, prior) },
+    { role: "user", content: buildAdvisorUserMessage(agent, prior) },
+  ]
+  return session
+}
+
 // ────────────────────────────────────────
 // Advisor tool loop
 // ────────────────────────────────────────
 
+/**
+ * Compact one-line summary of tool args for panel progress lines.
+ * Picks the most identifying field; falls back to truncated JSON.
+ */
+function summarizeToolArgs(args) {
+  // e.g. "git diff HEAD", "read src/x.mjs" — action first when present
+  const parts = [args.action, args.path ?? args.pattern ?? args.command].filter((v) => v != null)
+  let s = parts.length > 0 ? parts.map(String).join(" ") : JSON.stringify(args)
+  s = s.replace(/\s+/g, " ").trim()
+  return s.length > 80 ? s.slice(0, 79) + "…" : s
+}
+
 /**
  * Run the advisor's tool loop: chat → execute tools → repeat.
  * Stops when the model produces text without tool calls.
+ *
+ * Progress lines (→ tool args) are emitted via onOutput between model bursts so
+ * the panel keeps moving while the advisor explores — otherwise the panel sits
+ * frozen through every tool-call phase and the review appears to have stalled.
  */
 async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, cwd) {
+  // Kind-tagged wrappers: the TUI panel colors reasoning / answer / tool progress differently.
+  const emit = (kind) => (onOutput ? (text) => onOutput({ kind, text }) : undefined)
+  const onThink = emit("think")
+  const onText = emit("text")
   while (true) {
     const response = await chat(provider, {
       messages,
       tools: ADVISOR_TOOL_SCHEMAS,
       signal: (signal && !signal.aborted) ? signal : new AbortController().signal,
-      onToken: onOutput,
-      onReasoning: onOutput,
+      onToken: onText,
+      onReasoning: onThink,
     })
 
     // No tool calls — this is the final review text
@@ -317,12 +492,14 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
     // Execute each tool call
     for (const tc of response.toolCalls) {
       const tool = ADVISOR_TOOL_BY_NAME.get(tc.name)
+      let args = {}
+      try { args = JSON.parse(tc.arguments || "{}") } catch { /* summarized as raw JSON below */ }
+      onOutput?.({ kind: "tool", text: `\n→ ${tc.name} ${summarizeToolArgs(args)}\n` })
       let result
       if (!tool) {
         result = `Error: unknown tool "${tc.name}". Available: ${[...ADVISOR_TOOL_BY_NAME.keys()].join(", ")}`
       } else {
         try {
-          const args = JSON.parse(tc.arguments || "{}")
           result = await tool.execute(args, {
             cwd,
             agent,
@@ -372,20 +549,18 @@ export async function runAdvisorReview(agent, onOutput, signal) {
   if ((agent._touchedFiles ?? []).length === 0) return null
 
   const provider = resolveAdvisorProvider(agent)
-  const priorIssue = extractPriorIssueTable(agent.history)
-  const systemPrompt = buildAdvisorSystemPrompt(agent, priorIssue)
-  const userMessage = buildAdvisorUserMessage(agent, priorIssue)
 
   // Set the advisor's cwd to the first repo (for tool context)
   const advisorCwd = repos.length > 0 ? repos[0] : agent.cwd
 
-  const messages = [
-    { role: "system", content: systemPrompt },
-    { role: "user", content: userMessage },
-  ]
+  const messages = prepareAdvisorMessages(agent)
 
   try {
-    return await runAdvisorToolLoop(provider, messages, onOutput, signal, agent, advisorCwd)
+    const result = await runAdvisorToolLoop(provider, messages, onOutput, signal, agent, advisorCwd)
+    // Persist the conversation: the next advisor call in this run continues here
+    // (reset by runAgent when the run ends — each task gets a fresh advisor session)
+    agent._advisorSession = messages
+    return result
   } catch (e) {
     if (e.name === "AbortError" && signal?.reason?.interrupt) throw e
     return `Advisor: review failed — ${e.message || "unknown error"}. You may retry or proceed to verify.`

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"
@@ -178,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.mjs

@@ -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({
@@ -62,7 +63,7 @@ export function createAgent({
     overlay, tasks, history,
     planMode, autoApprove, goal,
     _mutatedThisRun: false, _verifiedThisRun: false, _verifyPassed: undefined, _calledAdvisorThisRun: false,
-    _touchedFiles: [], _verifyRetries: 0, _advisorRound: 0,
+    _touchedFiles: [], _verifyRetries: 0, _advisorRound: 0, _advisorSession: null,
     _pendingReminders: [],
     _pendingTimers: [],
     _sessionStart: sessionStart,
@@ -85,7 +86,9 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
   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):
@@ -284,16 +287,19 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
           continue
         }
       }
-      // --- advisor guard: push model to review changes before completion ---
-      // When advisor is enabled and guard is not explicitly disabled, mutated files
-      // must be reviewed before the turn ends. No hard round cap — convergence protocol
-      // (round 3+ strict verification) naturally limits divergence.
+      // --- 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) {
+        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 but haven't reviewed with advisor (round ${agent._advisorRound + 1}). Call the \`advisor\` tool to get an independent code review. After the review, produce a response table for every issue found (see discipline rules for format). If the changes are trivial (typo, one-liner, formatting only), you may skip and explain why in your reply.]`,
+            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
@@ -333,6 +339,7 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
 
     // 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)

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/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

@@ -3,14 +3,14 @@ Perform a full-scope review of the code changes.
 You have read-only tools to explore the codebase.
 
 Review workflow:
-1. Read AGENTS.md and any design documents to understand project conventions, version requirements, and architecture decisions.
-2. Run git diff HEAD to discover uncommitted changes.
-3. Read changed files for full context.
-4. Use grep or lsp to trace callers, imports, and dependencies.
+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 task summary.
+- 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 |

package/src/prompts/advisor-round2.md

@@ -4,10 +4,10 @@ You may note obvious new issues introduced by the fixes.
 You have read-only tools to explore the codebase.
 
 Review workflow:
-1. Read AGENTS.md and any design documents to understand project conventions, version requirements, and architecture decisions.
-2. Run git diff HEAD to see what changed since the last review.
-3. Read changed files for full context.
-4. Use grep or lsp to trace callers, imports, and dependencies.
+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:

package/src/prompts/advisor-round3.md

@@ -4,9 +4,9 @@ Do NOT look for new issues.
 You have read-only tools to explore the codebase.
 
 Review workflow:
-1. Read AGENTS.md and any design documents to understand project conventions, version requirements, and architecture decisions.
-2. Run git diff HEAD to see what changed since the last review.
-3. Read changed files for full context.
+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.
 

package/src/prompts/discipline.md

@@ -81,7 +81,7 @@ Testing discipline (right check at the right time):
   - If advisor says "all clear": proceed to verify.
   - If issues persist: fix them, update your response table, re-run advisor.
   - No hard round cap — the convergence protocol naturally limits divergence.
-  - The advisor is optional if you only made trivial changes (typo, one-liner).
+  - **Calling advisor is mandatory when it is enabled and you changed code** — it is not your call to skip, even for trivial changes (a trivial diff makes the review fast, not optional). The run cannot finish until advisor has reviewed the changes.
 
 Debugging strategy (when something goes wrong, three steps before anything else):
 - **Step 0 — Set a timer before you start reasoning**: immediately call `timer(180, "试试加个日志？")` to give yourself a bounded thinking window.