thincoder 0.12.34 → 0.12.36

package/README.md

@@ -15,7 +15,7 @@ Design philosophy (the entire meaning of the name): if the Node standard library
 - **Fix-verify loop**: file changes without `verify` get pushed back — syntax check + tests must pass before the agent can claim completion (auto-repair up to 3 rounds)
 - **Checkpoint system**: auto-snapshot before every user task, `list`/`create`/`rewind` tools for the model, single-file restore — rewinding itself is reversible (pre-rewind state auto-saved)
 - **Codebase understanding** ⭐0.5.0: `repo_outline` (dependency outline, auto-injected at startup), `code_search` (source FTS5 + vectors + JSDoc extraction), `doc_search` (docs chunked by ## headings) — background indexing, auto-incremental updates on file writes, three tools guided by "structure → intent → details"
-- **Model adaptation** ⭐: top-tier only, latest only. Built-in flagship models from seventeen providers — DeepSeek / Kimi / Kimi For Coding / GLM / Qwen / Qwen Token Plan / MiniMax / OpenAI / Claude / Gemini / Grok / Mistral / Volcengine Ark (豆包) / Hunyuan (腾讯混元) / SiliconFlow (硅基流动) / OpenRouter / Groq. No legacy model compatibility, no local model support. Auto-matched context windows, truncation-resume protocols (prefix/partial), thinking-mode APIs (thinking.type / reasoning_effort), reasoning_content echo strategies (reasoningEcho), output limits, temperature range clamping — all deeply adapted.
+- **Model adaptation** ⭐: top-tier only, latest only. Built-in flagship models from seventeen providers — DeepSeek / Kimi / Kimi For Coding / GLM / Qwen / Qwen Token Plan / MiniMax / OpenAI / Claude / Gemini / Grok / Mistral / Volcengine Ark (豆包) / Hunyuan (腾讯混元) / SiliconFlow (硅基流动) / OpenRouter / Groq. No legacy model compatibility. Auto-matched context windows, truncation-resume protocols (prefix/partial), thinking-mode APIs (thinking.type / reasoning_effort), reasoning_content echo strategies (reasoningEcho), output limits, temperature range clamping — all deeply adapted.
 - **Toolset**: `read` / `write` / `edit` / `bash` / `glob` (supports `**`) / `grep` / `websearch` / `ls` / `fetch` + `read_image` (image/video paste) + three retrieval tools + MCP — all zero-dependency, file tools confined to the working directory
 - **Memory system**: three layers (personal/project/team), FTS5 + vector RRF hybrid retrieval, git-friendly markdown format
 - **Two-phase tool scheduling**: permission prompts serialized, read-only tools parallelized, side-effect tools serialized

package/package.json

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

package/src/advisor/messages.mjs

@@ -185,13 +185,27 @@ export function buildAdvisorUserMessage(agent, prior, reviewType, designToken =
       } catch { /* file doesn't exist — skip */ }
     }
 
+    // Document map (docs/design/README.md) — inject when the discovered
+    // project root has one: the reviewer checks document ownership against it
+    // (a change for an existing section must amend that section's document,
+    // not spawn a new file for it). Absent map → skip (nothing to check against).
+    try {
+      const mapPath = resolve(guideRoot ?? agent.cwd, "docs", "design", "README.md")
+      if (existsSync(mapPath)) {
+        parts.push("## Document Map")
+        parts.push("The document map below registers which document files exist per section. Use it for the Document ownership criterion: a change for an existing section must amend that section's document, not create a new file.")
+        parts.push(readFileSync(mapPath, "utf8"))
+        parts.push("")
+      }
+    } catch { /* file doesn't exist or is unreadable — skip */ }
+
     parts.push("## Instructions")
     if (docList.length > 0) {
       parts.push("1. Read every document in the Documents to Review list in full — review ONLY those files. Read METHODOLOGY.md to understand the project's standards.")
     } else {
       parts.push("1. Read the design document fully. Read METHODOLOGY.md to understand the project's standards.")
     }
-    parts.push("2. Review against: completeness (all requirements covered?), feasibility (can this be built?), clarity (specific enough?), acceptance criteria (verifiable?), scope (appropriate?).")
+    parts.push("2. Review against: completeness (all requirements covered?), feasibility (can this be built?), methodology compliance (does it follow the project's METHODOLOGY.md?), clarity (specific enough?), acceptance criteria (verifiable?), scope (appropriate?).")
     parts.push("3. If the ## Project Guide (AGENTS.md) section above is present, also check requirement fit: does the design match what the requirements documents it points to actually ask for?")
     parts.push("4. Do NOT run git diff or look for code changes — there are none at this stage.")
     parts.push("5. If you find issues, produce your review table with the format: | # | Category | Severity | Issue | Suggestion |. If the design passes, no table is needed.")

package/src/advisor/run.mjs

@@ -361,13 +361,11 @@ function extractUnfixedIssues(priorText) {
 export async function runAdvisorReview(agent, reviewType, callbacks, designToken = null, documents = null, paths = null) {
   const onOutput = callbacks?.onOutput
   const signal = callbacks?.signal
-  const cfg = agent.config?.advisor
   const startTime = Date.now()
-  
-  // Engineering mode overrides advisor toggle — reviews are mandatory regardless
-  if (!cfg?.enabled && !agent.config?.agent?.engineering) {
-    return "Advisor: not enabled (set advisor.enabled in config.json)."
-  }
+
+  // Advisor reviews are ALWAYS available (2026-08-21 semantic refactor): the
+  // former advisor.enabled gate is removed — review capability has no off
+  // switch; only the guard (completion pushback) is opt-in via advisor.guard.
 
   // Mechanical convergence cap — refuse further reviews once the protocol has run
   // its rounds. _advisorRound counts completed advisor calls (incremented by the

package/src/advisor.mjs

@@ -72,14 +72,11 @@ const ADVISOR_ROUND1 = loadPrompt("advisor-round1.md", "advisor-round1.md")
 // buildAdvisorSystemPrompt when _advisorRound > 0.
 const ADVISOR_ROUND2 = loadPrompt("advisor-round2.md", "advisor-round2.md")
 const ADVISOR_ROUND3 = loadPrompt("advisor-round3.md", "advisor-round3.md")
-// Fallback when advisor-design.md is missing — keep in sync with the real
-// file (table format + workflow steps).
-const ADVISOR_DESIGN_FALLBACK = `You are an independent design reviewer for an engineering-mode project. Review the design document in the changes below. Evaluate: completeness, feasibility, clarity, scope, acceptance criteria. Read METHODOLOGY.md if provided. Produce a review table with | # | Category | Severity | Issue | Suggestion | format.`
-let ADVISOR_DESIGN = ""
-// Design review is OPTIONAL (engineering mode only) — silent fallback to the
-// in-code constant is intentional, unlike the mandatory round prompts which
-// must exist for every review (loadPrompt throws a descriptive error there).
-try { ADVISOR_DESIGN = readFileSync(join(__dirname, "prompts", "advisor-design.md"), "utf8") } catch { /* fallback below */ }
+// Design-review prompt — hard-loaded like the round prompts (decision
+// 2026-08-21): a missing file means a broken installation, and silently
+// degrading to a lesser in-code prompt would quietly strip the approval-signal
+// and citation rules, disabling design approval entirely. loadPrompt throws.
+const ADVISOR_DESIGN = loadPrompt("advisor-design.md", "advisor-design.md")
 
 // ────────────────────────────────────────
 // System prompt building
@@ -109,7 +106,7 @@ export function buildAdvisorSystemPrompt(agent, prior, reviewType) {
   // approval token); rounds 2+ converge like code reviews (verify agent fix claims).
   if (reviewType === "design") {
     if (!hasPrior) {
-      return ADVISOR_DESIGN || ADVISOR_DESIGN_FALLBACK
+      return ADVISOR_DESIGN
     }
     const round = (agent._advisorRound || 0) + 1
     if (round === 2) return ADVISOR_ROUND2

package/src/agent/completion.mjs

@@ -111,10 +111,11 @@ export function handleCompletion(agent, response, depth, turn, guardPushbacks, h
   }
 
   // --- advisor guard: review of mutated files before completion ---
-  // Active by default when advisor.enabled is set (opt-out via guard: false),
-  // and NEVER in engineering mode.
+  // OPT-IN ONLY (advisor.guard === true, default OFF — 2026-08-21 semantic
+  // refactor), and NEVER in engineering mode. The advisor tool itself is always
+  // available; this guard only controls whether completion is pushed back.
   const cfg = agent.config?.advisor
-  const advisorReview = cfg?.enabled && cfg?.guard !== false
+  const advisorReview = cfg?.guard === true
   if (depth === 0 && advisorReview && !agent.config?.agent?.engineering) {
     // Cap sync: beyond MAX_ADVISOR_ROUNDS the advisor tool refuses to review
     // (run.mjs convergence cap) — pushing back further would loop forever

package/src/agent/helpers.mjs

@@ -4,7 +4,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 { writeFile, mkdir, readdir, stat, unlink } from "node:fs/promises"
 import { join } from "node:path"
 import { execSync } from "node:child_process"
 
@@ -23,6 +23,9 @@ export const REPORT_CONTINUATION =
 const TOOL_RESULT_OFFLOAD_LIMIT = 16_000
 const TOOL_RESULT_PREVIEW = 2_000
 
+/** Offload-dir write-time self-cleanup retention window (2026-08-21): files older than 3 days are deleted on the next offload. */
+export const TMP_RETENTION_MS = 3 * 24 * 3600 * 1000
+
 const GIT_TIMEOUT_MS = 5000
 const MAX_GIT_CHANGES_DISPLAY = 20
 
@@ -39,11 +42,35 @@ export function tryCanonicalize(name, args) {
   try { return name + ":" + JSON.stringify(JSON.parse(args)) } catch { return name + ":" + args }
 }
 
-/** Offload oversized tool results (>16k chars) to disk, returning a preview + file path */
-export async function offloadToolResult(text, callId) {
+/**
+ * Best-effort write-time self-cleanup: delete files in dir whose mtime exceeds TMP_RETENTION_MS.
+ * Subdirectories are never touched; every failure is silent — cleanup must not affect offload.
+ */
+export async function cleanupOldToolResults(dir) {
+  const now = Date.now()
+  let entries
+  try {
+    entries = await readdir(dir, { withFileTypes: true })
+  } catch {
+    return // dir missing or unreadable → nothing to clean
+  }
+  for (const entry of entries) {
+    if (!entry.isFile()) continue // subdirectories untouched
+    try {
+      const st = await stat(join(dir, entry.name))
+      if (now - st.mtimeMs > TMP_RETENTION_MS) await unlink(join(dir, entry.name))
+    } catch {
+      /* entry vanished concurrently or I/O error — best effort, keep going */
+    }
+  }
+}
+
+/** Offload oversized tool results (>16k chars) to disk, returning a preview + file path.
+ *  Writes trigger write-time self-cleanup of the offload dir first (dir param overridable for tests). */
+export async function offloadToolResult(text, callId, dir = join(configDir, "tool-results")) {
   if (text.length <= TOOL_RESULT_OFFLOAD_LIMIT) return text
   try {
-    const dir = join(configDir, "tool-results")
+    await cleanupOldToolResults(dir)
     await mkdir(dir, { recursive: true })
     const file = join(dir, `${Date.now()}-${String(callId).replace(/[^a-zA-Z0-9_-]/g, "_")}.log`)
     await writeFile(file, text, "utf8")

package/src/agent-tools/subagent.mjs

@@ -53,7 +53,7 @@ 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.\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" +
+    "Use role='explore' for codebase search/analysis (read-only, fast — specify thoroughness in the task: quick / medium / thorough (default medium)), 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" +

package/src/config.mjs

@@ -52,7 +52,7 @@ const DEFAULTS = {
     consultTurns: 40,      // per-consultant tool-turn budget (diagnosis tasks)
     consultTimeoutMs: 600000, // wall-clock ceiling per consultant (10min)
     streamRules: [],      // time-traveling stream rules: [{ pattern: "regex", message: "reminder", action: "abort"|"warn", repeat: "always"|"once" }]
-    advisor: { enabled: false },  // code review; { enabled: true, provider: "deepseek", model: "deepseek-chat", thinking: { type: "enabled" }, reasoningEffort: "max", guard: true }
+    advisor: { guard: false },  // code review is always available; guard: true pushes completion back until reviewed (opt-in). Also accepts provider/model/thinking/reasoningEffort overrides. Deprecated: enabled (2026-08-21)
     autoThink: false,     // auto-classify task difficulty and set reasoning effort per-turn
     engineering: false,   // strict methodology enforcement — read METHODOLOGY.md, design-before-code
   },

package/src/prompts/advisor-design.md

@@ -12,6 +12,7 @@ Evaluate the design against these dimensions:
 4. **Clarity** — Is the design specific enough to implement? Are the affected files identified?
 5. **Acceptance criteria** — Are they verifiable? Do they cover normal paths, edge cases, and error conditions?
 6. **Scope** — Is the scope appropriate? Are there opportunities to simplify? Is there scope creep?
+7. **Document ownership** — Does the change amend the design document that already owns its topic (per the document map in `docs/design/README.md`), or does it fragment by creating a new file for an existing section? Does the wording duplicate or contradict existing documents?
 
 ## Output Format
 
@@ -27,6 +28,14 @@ Severity levels:
 - 🟡 Advisory — design could be improved; NOT a blocker for approval
 - 🔵 Note — optional observation; NOT a blocker
 
+Document ownership severity:
+- Wording that CONTRADICTS an existing document (same mechanism described differently in two places) → 🔴
+- Creating a new file for an existing section, or duplicating a description that already exists elsewhere → 🟡
+
+## Citation Discipline
+
+When you cite design-document text, use the exact `file:line` format (e.g. `docs/design/AGENT-LOOP.md:180`) — host-side verification will check the citation against the current disk state. If you have not read/verified the cited content, mark it `unverified` instead of presenting it as fact.
+
 ## Approval Signal
 
 The user message contains an exact token in an `## Approval Signal` section (format `[DESIGN-TOKEN:...]`).

package/src/prompts/engineering.md

@@ -19,6 +19,16 @@ subagents only.
    non-functional standards. Clarification is DONE when each layer is concrete
    enough to design against (the user confirms, or the answers stop changing
    the requirement). Do NOT start the design before this.
+   - **Plan confirmation before writing any doc — no exemptions.** When
+     clarification is DONE, and before writing the requirements doc (or the
+     design doc), state in plain text your understanding of the requirement
+     plus your next-step plan, and WAIT for the user's explicit confirmation
+     ("OK / 可以 / continue"-type reply) before writing. No confirmation,
+     silence, or a new question from the user → do not write. Even if you
+     are completely sure you understand, you must still write the plan out
+     and wait — "this is obvious enough to skip asking" is never a valid
+     reason. Writing docs is a writing action — it is under the same
+     discipline.
 2. **Design.** Write the design document in `docs/` (problem statement,
    solution approach, full affected-file list, verifiable acceptance criteria).
    Do NOT open any code file for editing before this document exists.

package/src/prompts/explore.md

@@ -15,3 +15,8 @@ Guidelines:
 - Complete the search efficiently and report findings in a structured format
 - If the expected pattern doesn't exist, report that explicitly: what you searched for, which tools you used, and that nothing matched. "Probably there" is not a finding — only report what you actually saw.
 - If something is ambiguous, note it in your report; do not ask the user
+
+**Thoroughness levels** — pick the depth the task actually needs (the parent agent may state one in the task description):
+- quick — a single targeted search answering one specific question
+- medium — the default: a moderate multi-pronged search, several probes in parallel
+- thorough — exhaustive analysis across multiple locations and naming conventions; your report must list what you searched for and what you did NOT find

package/src/prompts/main.md

@@ -10,6 +10,7 @@ For tasks that match the Coding discipline's "complex" tier, plan mode is your d
 
 Delegate well — spawn subagents for independent subtasks.
 - Explore agents for parallel codebase search, plan agents for architecture design, coder agents for self-contained implementation.
+- When delegating an explore agent, state the thoroughness in the task description — quick / medium / thorough — graded by need; unspecified means the default.
 - Delegate breadth-first exploration; do precision edits yourself.
 - Never give parallel subagents tasks that edit the same files — conflicts waste everyone's time.
 - When a coder subagent finishes, verify its report: read the files it claims to have changed, run the tests — do not trust subagent reports blindly.

package/src/prompts/system.md

@@ -8,9 +8,12 @@ Programming is collaborative labor between you and the human. The human decides
 
 **How you work — before you write any code:**
 - **Read design docs first.** Use `doc_search` to find relevant design docs, AGENTS.md, and architecture decisions. Code without design context is guesswork. If docs conflict with code, docs are right. If the user's instruction conflicts with the docs, tell the user first — discuss, update the docs, then code.
+- **Document ownership — find the doc that owns the topic before writing.** Before writing to `docs/design/`, check the `docs/design/README.md` document map (no map → check AGENTS.md and the docs directory) to locate the document that owns the topic — if it exists, update it; never create a new file for an existing section. Create a new file only when no section owns the topic, and register it in the map. Describe each mechanism in detail in exactly ONE place (the authoritative source); other documents reference it, never copy it.
 - **Check existing code.** Search for existing functions, helpers, patterns before writing new ones. Duplicates are technical debt.
 - **Understand intent.** Ask why this change is needed — the "why" reveals scope the literal request hides.
-- **Confirm understanding.** State what you believe the user asked for and what you plan to deliver. Wait for confirmation. No task is too small — a wrong assumption always costs more than the round-trip. Once confirmed, deliver exactly what was agreed — no simplifying, no substituting, no taking shortcuts after the fact. Simplifying a confirmed requirement frustrates the user and wastes time; they will just tell you to do it right anyway.
+- **Confirm understanding.** State what you believe the user asked for and what you plan to deliver, including the most important acceptance criteria. Wait for confirmation. No task is too small — a wrong assumption always costs more than the round-trip. Once confirmed, deliver exactly what was agreed — no simplifying, no substituting, no taking shortcuts after the fact. Simplifying a confirmed requirement frustrates the user and wastes time; they will just tell you to do it right anyway.
+- **Confirm before any file-writing action — no exemptions.** Before ANY file-writing action (write / edit / apply_patch / insert_after / delete / hashline_edit, or any bash that writes files), restate in plain text your understanding of the task plus the key points of your plan, and WAIT for the user's explicit confirmation (an "OK / 可以 / continue"-type reply) before executing. No confirmation, silence, or the user answering with a new question or a new requirement → do not touch anything, no matter how small or obvious the change seems. Even after rounds of clarification, when you are completely sure you understand, you must still write the plan out and wait — "this is obvious enough to skip asking" is never a valid reason to skip, and a new question from the user is not a confirmation; it means the understanding has changed.
+- **Re-confirm when the requirement changes.** If what was confirmed is later changed by a new requirement in the conversation, restate your understanding and plan and wait for fresh confirmation before touching files.
 
 **How you work — while coding:**
 - When you need multiple independent pieces of information, call tools in parallel — read files, search, grep all at once.

package/src/tui/agent-turn.mjs

@@ -94,7 +94,7 @@ export async function runAgentTurn(ctx, text) {
   const callbacks = {
     onToken: (t) => {
       // Subagent streaming: prefix format role#id/ → extract id, update subTask streaming text
-      const subMatch = t.match(/^(\w+)#(\d+)\//)
+      const subMatch = t.match(/^([\w-]+)#(\d+)\//)
       if (subMatch) {
         const key = `${subMatch[1]}#${subMatch[2]}`
         const payload = t.slice(subMatch[0].length)
@@ -114,7 +114,7 @@ export async function runAgentTurn(ctx, text) {
     },
     onReasoning: (t) => {
       // Subagent reasoning tokens also carry role#id/ prefix, go into subTasks panel
-      const subMatch = t.match(/^(\w+)#(\d+)\//)
+      const subMatch = t.match(/^([\w-]+)#(\d+)\//)
       if (subMatch) {
         const key = `${subMatch[1]}#${subMatch[2]}`
         if (!state.subTasks[key]) {
@@ -129,7 +129,7 @@ export async function runAgentTurn(ctx, text) {
     },
     onToolCall: (name, args) => {
       // Subagent tool call: prefix role#id/toolName → update subTask current tool
-      const subMatch = name.match(/^(\w+)#(\d+)\//)
+      const subMatch = name.match(/^([\w-]+)#(\d+)\//)
       if (subMatch) {
         const key = `${subMatch[1]}#${subMatch[2]}`
         const toolName = name.slice(subMatch[0].length)

package/src/tui/cmd-advisor.mjs

@@ -1,4 +1,4 @@
-/** /advisor command: toggle advisor on/off, select model, configure thinking.
+/** /advisor command: configure review model/thinking and toggle the review guard.
  *  Interactive loop UX — stays in menu after each action, Esc to exit.
  *  ctx: { agent, showPicker, pushLine, pushLabel, persistRaw } */
 import { ansi, C } from "./ansi.mjs"
@@ -6,6 +6,9 @@ import { ansi, C } from "./ansi.mjs"
 export async function handleAdvisorCommand(ctx) {
   const { agent, showPicker, pushLine, pushLabel } = ctx
   const cfg = agent.config.advisor ??= {}
+  // Deprecated field cleanup (2026-08-21): advisor.enabled is no longer read
+  // anywhere; drop it here so persist() never re-writes the stale flag.
+  delete cfg.enabled
 
   const persist = async () => {
     if (ctx.persistRaw) {
@@ -21,13 +24,12 @@ export async function handleAdvisorCommand(ctx) {
 
   // ── State helpers ──
   function advisorStatus() {
-    const enabled = cfg.enabled === true
     const curModel = cfg.model || agent.provider.model
     const thinkInfo = cfg.thinking === null ? "off"
       : cfg.thinking?.type === "disabled" ? "off"
       : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
       : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
-    return `Advisor: ${enabled ? "ON" : "OFF"} | Model: ${curModel} | Think: ${thinkInfo}`
+    return `Advisor: always available | Model: ${curModel} | Think: ${thinkInfo}`
   }
 
   function headerLine() {
@@ -105,14 +107,12 @@ export async function handleAdvisorCommand(ctx) {
   // ── Main loop ──
   let mainIdx = 0
   for (;;) {
-    const enabled = cfg.enabled === true
     const curProvider = cfg.provider || "(main)"
     const curModel = cfg.model || agent.provider.model
     const guardInfo = cfg.guard === true ? "on" : "off"
 
     const entries = [
       { type: "header", text: headerLine() },
-      { type: "item", text: `Advisor: ${enabled ? "ON" : "OFF"}`, action: "toggle" },
       { type: "item", text: `Model: ${curModel}`, action: "model", note: `Provider: ${curProvider}` },
       { type: "item", text: `Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, action: "thinking" },
       { type: "item", text: `Guard: ${guardInfo}`, action: "guard" },
@@ -125,21 +125,13 @@ export async function handleAdvisorCommand(ctx) {
 
     if (choice.action === "view") {
       pushLabel("❯ Advisor", ansi.bold + C.tool)
-      pushLine(`Status:   ${enabled ? "ON" : "OFF"}`, C.dim)
+      pushLine(`Status:   always available`, C.dim)
       pushLine(`Model:    ${curModel} (provider: ${curProvider})`, C.dim)
       pushLine(`Guard:    ${guardInfo}`, C.dim)
       pushLine(`Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, C.dim)
       continue
     }
 
-    if (choice.action === "toggle") {
-      cfg.enabled = !cfg.enabled
-      await persist().catch(err => pushLine(`[error] Advisor toggle: ${err.message}`, C.error))
-      pushLabel("❯ Advisor", ansi.bold + C.tool)
-      pushLine(`Advisor: ${cfg.enabled ? "ON" : "OFF"}`, C.tool)
-      continue
-    }
-
     if (choice.action === "guard") {
       cfg.guard = !(cfg.guard === true)
       await persist().catch(err => pushLine(`[error] ${err.message}`, C.error))

package/src/tui/render-frame.mjs

@@ -268,9 +268,9 @@ export function renderStatus(state, agent, cols, slashCommands) {
   const statusLine = buildStatusLine(state, agent, { cols, slashCommands })
   const autoBanner = agent.autoApprove ? `${C.warn} AUTO${ansi.reset}${ansi.dim}│` : ""
   const planBanner = agent.planMode ? `${C.tool} PLAN${ansi.reset}${ansi.dim}│` : ""
-  const advisorBanner = agent.config?.advisor?.enabled ? `${C.advisor} ADVISOR${ansi.reset}${ansi.dim}│` : ""
+  const advisorBanner = agent.config?.advisor?.guard === true ? `${C.advisor} GUARD${ansi.reset}${ansi.dim}│` : ""
   const engBanner = agent.config?.agent?.engineering ? `${C.advisor} ENG${ansi.reset}${ansi.dim}│` : ""
-  const bannerPrefix = (agent.planMode ? " PLAN│ " : "") + (agent.autoApprove ? " AUTO│ " : "") + (agent.config?.advisor?.enabled ? " ADVISOR│ " : "") + (agent.config?.agent?.engineering ? " ENG│ " : "")
+  const bannerPrefix = (agent.planMode ? " PLAN│ " : "") + (agent.autoApprove ? " AUTO│ " : "") + (agent.config?.advisor?.guard === true ? " GUARD│ " : "") + (agent.config?.agent?.engineering ? " ENG│ " : "")
   const statusMax = cols - 1 - (bannerPrefix ? stringWidth(bannerPrefix) : 0)
   return `${ansi.dim}${planBanner}${autoBanner}${advisorBanner}${engBanner}${sliceByWidth(statusLine, Math.max(10, statusMax))}${ansi.reset}`
 }