tachibot-mcp 2.23.3 → 2.26.0

package/README.md

@@ -4,18 +4,18 @@
 
 ### Multi-Model AI Orchestration Platform
 
-[![Version](https://img.shields.io/badge/version-2.23.2-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
-[![Tools](https://img.shields.io/badge/tools-57_active-brightgreen.svg)](#-tool-ecosystem-57-tools)
+[![Version](https://img.shields.io/badge/version-2.26.0-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
+[![Tools](https://img.shields.io/badge/tools-64_active-brightgreen.svg)](#-tool-ecosystem-64-tools)
 [![License](https://img.shields.io/badge/license-AGPL--3.0-green.svg)](LICENSE)
-[![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
+[![Node](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org)
 [![MCP](https://img.shields.io/badge/MCP-Compatible-purple.svg)](https://modelcontextprotocol.io)
 
-**57 AI tools. 12 providers. One protocol.**
+**64 AI tools. 12 providers. One protocol.**
 
 Orchestrate Perplexity, Grok, GPT-5.5, Gemini, Qwen, Kimi K2.7-Code, and MiniMax M3
 from Claude Code, Claude Desktop, Cursor, or any MCP client.
 
-[Get Started](#-quick-start) · [View Tools](#-tool-ecosystem-57-tools) · [Documentation](https://tachibot.com/docs)
+[Get Started](#-quick-start) · [View Tools](#-tool-ecosystem-64-tools) · [Documentation](https://tachibot.com/docs)
 
 <br>
 
@@ -28,52 +28,39 @@ from Claude Code, Claude Desktop, Cursor, or any MCP client.
 
 ---
 
-## What's New in v2.15.0
+## What's New in v2.26.0
 
-### `/blueprint` Skill &mdash; Multi-Model Implementation Planning
-New skill that creates bite-sized TDD implementation plans using a 7-step multi-model council:
-```
-/blueprint add OAuth with refresh tokens
-```
-Pipeline: Grok search → Qwen+Kimi analysis → Kimi decompose → GPT pre-mortem critique → Gemini final judgment → **bite-sized TDD output** (exact files, test-first steps, commit points).
-
-Bridges `planner_maker`'s multi-model intelligence with the `writing-plans` execution format.
-
-### 31 Prompt Engineering Techniques (was 22)
-Added 9 research-backed techniques for coding and decision-making:
+### Prompt stack, modernized
+- **`refine_prompt`** (new tool) &mdash; opt-in prompt improver on a cheap/fast model: raw query → goal-first brief + **what changed** + **open questions**. Never auto-fires, never executes anything — you review, then use the brief. In Claude Code, `/prompt refine` presents the open questions as clickable choices and merges your answers into a final brief.
+- **Curated technique list** &mdash; `list_prompt_techniques` now defaults to the ~9 core techniques that still help 2026 reasoning models (output contracts like `scot`, `pre_mortem`, `bdd_spec`); `all=true` for the full 31.
+- **`technique="auto"`** &mdash; `preview_prompt_technique` recommends the right technique for your task, with reasons. Ask `tachi` "improve my prompt" for the symptom-based menu.
 
-| Technique | Source | Category |
-|-----------|--------|----------|
-| `reflexion` | Shinn et al. 2023 | Engineering |
-| `react` (ReAct) | Yao et al. 2022 | Engineering |
-| `rubber_duck` | Hunt & Thomas 2008 | Engineering |
-| `test_driven` | Beck 2003 | Engineering |
-| `scot` (Structured CoT) | Li et al. 2025 (+13.79% HumanEval) | Structured Coding |
-| `pre_post` (Contracts) | Empirical SE 2025 | Structured Coding |
-| `bdd_spec` (Given/When/Then) | BDD 2025 | Structured Coding |
-| `least_to_most` | Zhou et al. 2022 | Research |
-| `pre_mortem` | Klein 2007 | Decision |
+### Setup, de-mystified
+- **`tachibot init`** (new CLI wizard) &mdash; detects your API keys and clients, prints the exact config for Claude Code and Claude Desktop. Never writes or echoes keys.
+- **One-click Claude Desktop install** &mdash; download the `.mcpb` from the latest release and double-click. No JSON editing.
+- **`doctor`** &mdash; shows which keys are set, which tools are visible vs hidden and why, and what to try first.
 
-Techniques are embedded directly in tool system prompts for automatic application.
+### New tools & skills (64 tools · 17 skills)
+- `debug_triage` &mdash; ranked root-cause hypotheses with the cheapest discriminating check for each (Grok 4.3)
+- `spec_writer` &mdash; loose request → reviewable spec: user stories, Given/When/Then, out-of-scope, open questions (GPT-5.5)
+- `diff_review` / `plan_critique` / `testgen` / `security_review` &mdash; multi-model diff review, adversarial plan red-team, test generation, OWASP/CWE audit
+- Skills: `/review`, `/redteam`, `/spec`, `/triage`, `/setup`
 
-### MiniMax M2.5 Upgrade
-- `minimax_code` &mdash; SWE-Bench **80.2%**, per-task TECHNIQUE tags (SCoT, reflexion, rubber_duck), per-task temperatures
-- `minimax_agent` &mdash; ReAct + least-to-most decomposition protocol, HALT criteria
-
-### Enhanced Skills
-- `/breakdown` &mdash; now uses `least_to_most` ordering + `pre_mortem` failure analysis
-- `/judge` &mdash; first judge now runs pre-mortem ("assume this FAILED")
-- `/decompose` &mdash; deep-dives include pre/post contracts per sub-problem
-- `/prompt` &mdash; auto-recommend flow with 30-intent matching guide, 13 categories
+### Fixes
+- `focus` orchestration screen: 37 lines of repeated scaffolding → 10 focused lines
+- `npm test` exits 0 again (uncancelled race timers leaked past Jest teardown)
+- GPT-5.5 high-effort reasoning no longer cut off at 3 minutes (timeout 180s → 600s)
 
 ---
 
 ## Skills (Claude Code)
 
-TachiBot ships with 12 slash commands for Claude Code. These orchestrate the tools into powerful workflows:
+TachiBot ships with 17 slash commands for Claude Code. These orchestrate the tools into powerful workflows:
 
 | Skill | What it does | Example |
 |-------|-------------|---------|
+| `/setup` | Guided configuration — runs doctor, walks through keys/profiles | `/setup` |
+| `/spec` | Request → reviewable spec before planning | `/spec add OAuth somehow` |
 | `/blueprint` | Multi-model planning → bite-sized TDD steps | `/blueprint add OAuth with refresh tokens` |
 | `/judge` | Multi-model council - parallel analysis with synthesis | `/judge how to implement rate limiting` |
 | `/think` | Sequential reasoning chain with any model | `/think grok,gemini design a cache layer` |
@@ -85,6 +72,9 @@ TachiBot ships with 12 slash commands for Claude Code. These orchestrate the too
 | `/lens` | Long-context analysis over Kimi's 256K window | `/lens find inconsistencies in this spec` |
 | `/reflect` | Grounded reflexion loop — critique vs external evidence | `/reflect harden this auth middleware` |
 | `/tot` | Tree-of-Thought: branch → jury-prune → synthesize | `/tot design a rate limiter` |
+| `/review` | Multi-model diff review — panel + Gemini judge verdict | `/review` (or paste a diff) |
+| `/redteam` | Adversarial plan red-team — pre-mortem, risks, plan edits | `/redteam <paste plan>` |
+| `/triage` | Ranked root-cause bug triage | `/triage <paste stack trace>` |
 | `/tachi` | Help - see available skills, tools, key status | `/tachi` |
 
 Skills automatically adapt to your configured API keys. Even with just 1-2 providers, all skills work.
@@ -96,7 +86,7 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 ## Key Features
 
 ### Multi-Model Intelligence
-- **57 AI Tools** across 12 providers &mdash; Perplexity, Grok, GPT-5, Gemini, Qwen, Kimi, MiniMax, DeepSeek, GLM (Zhipu), StepFun, ERNIE (Baidu), plus free local models (Ollama / LM Studio / llama.cpp / vLLM)
+- **64 AI Tools** across 12 providers &mdash; Perplexity, Grok, GPT-5, Gemini, Qwen, Kimi, MiniMax, DeepSeek, GLM (Zhipu), StepFun, ERNIE (Baidu), plus free local models (Ollama / LM Studio / llama.cpp / vLLM)
 - **Gemini 3.5 Flash** (`gemini-3.5-flash`, GA May 19 2026) &mdash; Flash/search tier; reasoning default stays `gemini-3.1-pro-preview`
 - **Multi-Model Council** &mdash; planner_maker synthesizes plans from 5+ models into bite-sized TDD steps
 - **Smart Routing** &mdash; Automatic model selection for optimal results
@@ -111,12 +101,12 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 ### Tool Profiles
 | Profile | Tools | Best For |
 |---------|-------|----------|
-| **Minimal** | 12 | Quick tasks, low token budget |
+| **Minimal** | 13 | Quick tasks, low token budget |
 | **Research Power** | 35 | Deep investigation, multi-source |
-| **Code Focus** | 34 | Software development, SWE tasks |
-| **Balanced** | 45 | General-purpose, mixed workflows |
-| **Heavy Coding** (default) | 50 | Max code tools + agentic workflows |
-| **Full** | 57 | Everything enabled |
+| **Code Focus** | 42 | Software development, SWE tasks |
+| **Balanced** | 53 | General-purpose, mixed workflows |
+| **Heavy Coding** | 57 | Max code tools + agentic workflows |
+| **Full** (default) | 64 | Everything enabled |
 
 ### Developer Experience
 - **Claude Code** &mdash; First-class support
@@ -134,7 +124,25 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 npm install -g tachibot-mcp
 ```
 
-### Setup
+### Setup wizard
+
+```bash
+npx -y -p tachibot-mcp tachibot init
+```
+
+Detects your keys and clients, then prints the exact config for Claude Code and Claude Desktop.
+
+### Claude Code (one-liner)
+
+```bash
+claude mcp add tachibot -- npx -y -p tachibot-mcp tachibot
+```
+
+Then verify with `/mcp`. Add API keys with `--env`, e.g. `--env OPENROUTER_API_KEY=sk-or-xxx --env PERPLEXITY_API_KEY=pplx-xxx`.
+
+### Setup (Claude Desktop)
+
+**One-click (easiest):** download [`tachibot-mcp.mcpb`](https://github.com/byPawel/tachibot-mcp/releases/latest) from the latest release and double-click it — Claude Desktop installs the extension with no JSON editing. Add your API keys when prompted (or later via the extension settings).
 
 **Gateway Mode (Recommended)** &mdash; 2 keys, all providers:
 
@@ -178,28 +186,28 @@ See [Installation Guide](docs/INSTALLATION_BOTH.md) for detailed instructions.
 
 ---
 
-## Tool Ecosystem (57 Tools)
+## Tool Ecosystem (64 Tools)
 
-### Research & Search (6)
-`perplexity_ask` &#183; `perplexity_research` &#183; `perplexity_reason` &#183; `grok_search` &#183; `openai_search` &#183; `gemini_search`
+### Research & Search (5)
+`perplexity_ask` &#183; `perplexity_reason` &#183; `grok_search` &#183; `openai_search` &#183; `gemini_search`
 
-### Reasoning & Planning (13)
-`grok_reason` &#183; `openai_reason` &#183; `qwen_reason` &#183; `qwq_reason` &#183; `kimi_thinking` &#183; `kimi_decompose` &#183; `deepseek_reason` &#183; `glm_reason` &#183; `stepfun_reason` &#183; `ernie_reason` &#183; `planner_maker` &#183; `planner_runner` &#183; `list_plans`
+### Reasoning & Planning (14)
+`grok_reason` &#183; `openai_reason` &#183; `qwen_reason` &#183; `qwq_reason` &#183; `kimi_thinking` &#183; `kimi_decompose` &#183; `deepseek_reason` &#183; `glm_reason` &#183; `stepfun_reason` &#183; `ernie_reason` &#183; `planner_maker` &#183; `planner_runner` &#183; `list_plans` &#183; `spec_writer`
 
-### Code Intelligence (9)
-`kimi_code` &#183; `grok_code` &#183; `grok_debug` &#183; `qwen_coder` &#183; `qwen_algo` &#183; `qwen_competitive` &#183; `deepseek_algo` &#183; `minimax_code` &#183; `minimax_agent`
+### Code Intelligence (11)
+`kimi_code` &#183; `grok_code` &#183; `grok_debug` &#183; `qwen_coder` &#183; `qwen_algo` &#183; `qwen_competitive` &#183; `deepseek_algo` &#183; `minimax_code` &#183; `minimax_agent` &#183; `testgen` &#183; `debug_triage`
 
-### Analysis & Judgment (11)
-`gemini_analyze_text` &#183; `gemini_analyze_code` &#183; `gemini_judge` &#183; `jury` &#183; `gemini_brainstorm` &#183; `openai_brainstorm` &#183; `openai_code_review` &#183; `openai_explain` &#183; `grok_brainstorm` &#183; `grok_architect` &#183; `kimi_long_context`
+### Analysis & Judgment (14)
+`gemini_analyze_text` &#183; `gemini_analyze_code` &#183; `gemini_judge` &#183; `jury` &#183; `diff_review` &#183; `plan_critique` &#183; `gemini_brainstorm` &#183; `openai_brainstorm` &#183; `openai_code_review` &#183; `openai_explain` &#183; `grok_brainstorm` &#183; `grok_architect` &#183; `security_review` &#183; `kimi_long_context`
 
-### Meta & Orchestration (5)
-`think` &#183; `nextThought` &#183; `focus` &#183; `tachi` &#183; `usage_stats`
+### Meta & Orchestration (6)
+`think` &#183; `nextThought` &#183; `focus` &#183; `tachi` &#183; `doctor` &#183; `usage_stats`
 
 ### Workflows (9)
 `workflow` &#183; `workflow_start` &#183; `continue_workflow` &#183; `list_workflows` &#183; `create_workflow` &#183; `visualize_workflow` &#183; `workflow_status` &#183; `validate_workflow` &#183; `validate_workflow_file`
 
-### Prompt Engineering (3)
-`list_prompt_techniques` &#183; `preview_prompt_technique` &#183; `execute_prompt_technique`
+### Prompt Engineering (4)
+`list_prompt_techniques` &#183; `preview_prompt_technique` &#183; `execute_prompt_technique` &#183; `refine_prompt`
 
 ### Local Models (1)
 `local_query` &mdash; any OpenAI-compatible local server (Ollama / LM Studio / llama.cpp / vLLM). Zero-cost, offline, private; also available as the `local` jury juror (`hermes` is accepted as a legacy alias). Runs whatever `LOCAL_LLM_MODEL` points at &mdash; e.g. a Nous Hermes build (`ollama pull hermes3`). Note the [Hermes agent](https://hermes-agent.nousresearch.com) itself is model-agnostic &mdash; it runs on 300+ backends (GPT, Claude, Gemini, DeepSeek, or self-hosted Ollama/vLLM) &mdash; so "Hermes" was never a guarantee of distinct weights.

package/dist/src/cli/init.js

@@ -0,0 +1,125 @@
+/**
+ * `tachibot init` — setup wizard. Detection + emission first: pure functions
+ * detect keys/clients and emit EXACT per-client instructions; a thin
+ * readline layer only picks the client. Keys are never written to disk by
+ * default and never echoed (masked to 6 chars). Node built-ins only.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as readline from "node:readline/promises";
+const KEYS = [
+    { name: "OpenRouter", envVar: "OPENROUTER_API_KEY", unlocks: "DeepSeek/GLM/Kimi/Qwen/MiniMax/StepFun/ERNIE + planner (~30 tools)" },
+    { name: "Perplexity", envVar: "PERPLEXITY_API_KEY", unlocks: "web research tools" },
+    { name: "Gemini / Google", envVar: "GOOGLE_API_KEY", unlocks: "Gemini tools + jury judge + diff_review/plan_critique" },
+    { name: "OpenAI", envVar: "OPENAI_API_KEY", unlocks: "GPT-5.5 tools + spec_writer" },
+    { name: "Grok / xAI", envVar: "GROK_API_KEY", unlocks: "Grok tools + debug_triage" },
+];
+function defaultProbe() {
+    return {
+        // PATH lookup done via fs, not a subprocess: no shell involved, no injection surface.
+        which: (bin) => {
+            const dirs = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
+            const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+            return dirs.some((dir) => exts.some((ext) => {
+                try {
+                    return fs.statSync(path.join(dir, bin + ext)).isFile();
+                }
+                catch {
+                    return false;
+                }
+            }));
+        },
+        exists: (p) => fs.existsSync(p),
+    };
+}
+function desktopConfigPath() {
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+        return path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
+    }
+    return path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+export function detectSetup(env = process.env, probe = defaultProbe()) {
+    const keys = KEYS.map((k) => ({
+        name: k.name,
+        envVar: k.envVar,
+        present: Boolean(env[k.envVar]?.trim()),
+        unlocks: k.unlocks,
+    }));
+    // Gemini/Grok alternates count as present
+    const alt = (primary, alternate) => {
+        const row = keys.find((k) => k.envVar === primary);
+        if (!row.present && env[alternate]?.trim())
+            row.present = true;
+    };
+    alt("GOOGLE_API_KEY", "GEMINI_API_KEY");
+    alt("GROK_API_KEY", "XAI_API_KEY");
+    const dcp = desktopConfigPath();
+    return {
+        keys,
+        clients: {
+            claudeCode: probe.which("claude"),
+            claudeDesktop: probe.exists(dcp),
+            desktopConfigPath: probe.exists(dcp) ? dcp : null,
+        },
+    };
+}
+export function buildClaudeCodeCommand(setup) {
+    const envFlags = setup.keys
+        .filter((k) => k.present)
+        .map((k) => `--env ${k.envVar}=<your-${k.name.toLowerCase().replace(/[^a-z]+/g, "-")}-key>`)
+        .join(" \\\n  ");
+    return [
+        "claude mcp add tachibot \\",
+        envFlags ? `  ${envFlags} \\` : null,
+        "  -- npx -y -p tachibot-mcp tachibot",
+    ].filter(Boolean).join("\n");
+}
+export function buildDesktopSnippet(setup, profile) {
+    const env = {};
+    for (const k of setup.keys.filter((k) => k.present))
+        env[k.envVar] = `<your-${k.envVar}>`;
+    env.TACHIBOT_PROFILE = profile;
+    return JSON.stringify({ mcpServers: { tachibot: { command: "tachibot", env } } }, null, 2);
+}
+const mask = (v) => (v ? `${v.slice(0, 6)}…` : "");
+export async function runInitWizard() {
+    const setup = detectSetup();
+    const out = (s) => process.stdout.write(s + "\n");
+    out("\nTACHIBOT INIT\n=============");
+    out("\nAPI keys detected in this shell:");
+    for (const k of setup.keys) {
+        out(`  ${k.present ? "✓" : "✗"} ${k.name} (${k.envVar})${k.present ? ` ${mask(process.env[k.envVar])}` : ""} — ${k.unlocks}`);
+    }
+    if (!setup.keys.some((k) => k.present)) {
+        out("\nNo keys found. Get ONE key to start — OPENROUTER_API_KEY unlocks the most tools (openrouter.ai).");
+    }
+    out("\nClients detected:");
+    out(`  ${setup.clients.claudeCode ? "✓" : "✗"} Claude Code (claude on PATH)`);
+    out(`  ${setup.clients.claudeDesktop ? "✓" : "✗"} Claude Desktop${setup.clients.desktopConfigPath ? ` (${setup.clients.desktopConfigPath})` : ""}`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const choice = (await rl.question("\nSet up for: [1] Claude Code  [2] Claude Desktop  [3] both  [q] quit > ")).trim();
+        if (choice === "q")
+            return;
+        const profile = (await rl.question("Profile [full=all 63 tools | balanced | code_focus] (default: full) > ")).trim() || "full";
+        if (choice === "1" || choice === "3") {
+            out("\n— Claude Code — run this (fill in your real keys):\n");
+            out(buildClaudeCodeCommand(setup));
+            out("\nThen verify with /mcp inside Claude Code.");
+        }
+        if (choice === "2" || choice === "3") {
+            out("\n— Claude Desktop — easiest: double-click the tachibot-mcp.mcpb extension package (see GitHub releases).");
+            out("Or merge this into " + (setup.clients.desktopConfigPath ?? desktopConfigPath()) + ":\n");
+            out(buildDesktopSnippet(setup, profile));
+            out("\nThen restart Claude Desktop.");
+        }
+        out("\nFirst thing to run once connected: the `doctor` tool — it shows which tools your keys unlock.");
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/src/config/timeout-config.js

@@ -77,14 +77,19 @@ export function formatTimeout(ms) {
     return `${minutes}m ${remainingSeconds}s`;
 }
 /**
- * Create timeout promise for use with Promise.race()
+ * Create timeout promise for use with Promise.race(), plus a cancel handle.
+ * The race's loser leaves its timer scheduled unless the caller cancels it —
+ * without that, a fast-resolving `promise` still leaves this setTimeout alive
+ * for the full `ms`, holding the event loop open.
  */
 export function createTimeoutPromise(ms, message) {
-    return new Promise((_, reject) => {
-        setTimeout(() => {
+    let timer;
+    const promise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
             reject(new Error(message || `Operation timed out after ${formatTimeout(ms)}`));
         }, ms);
     });
+    return { promise, cancel: () => clearTimeout(timer) };
 }
 /**
  * Wrap promise with timeout
@@ -93,10 +98,13 @@ export async function withTimeout(promise, timeoutMs, toolName) {
     const timeoutMessage = toolName
         ? `${toolName} operation timed out after ${formatTimeout(timeoutMs)}`
         : `Operation timed out after ${formatTimeout(timeoutMs)}`;
-    return Promise.race([
-        promise,
-        createTimeoutPromise(timeoutMs, timeoutMessage)
-    ]);
+    const raceTimeout = createTimeoutPromise(timeoutMs, timeoutMessage);
+    try {
+        return await Promise.race([promise, raceTimeout.promise]);
+    }
+    finally {
+        raceTimeout.cancel();
+    }
 }
 /**
  * Check if we should show progress (operation exceeds threshold)
@@ -127,7 +135,9 @@ export const SMART_TIMEOUT_DEFAULTS = {
         },
         openai: {
             base: 60000, // 60 seconds - GPT-5.4 reasoning needs more time
-            max: 180000 // 3 minutes - high/xhigh reasoning effort
+            max: 600000 // 10 minutes - GPT-5.5 high/xhigh effort can exceed the
+            // OpenAI SDK's 900s default; 180s was cutting off real
+            // reasoning runs (verified 2026-07 deep-research)
         },
         anthropic: {
             base: 20000, // 20 seconds

package/dist/src/orchestrators/collaborative/services/visualization/VisualizationService.js

@@ -1,14 +1,18 @@
-import { ReasoningMode, REASONING_TEMPLATES, MODEL_PERSONAS } from "../../../../reasoning-chain.js";
-const renderWorkflowCascade = (steps, title) => {
-    const lines = [`## ${title}`];
-    steps.forEach((s, i) => lines.push(`${i + 1}. [${s.status}] ${s.name} (${s.model})`));
-    return lines.join('\n');
-};
-const renderProgressReel = (phases, title) => {
-    const lines = [`## ${title}`];
-    phases.forEach(p => lines.push(`- [${p.status}] ${p.name}`));
-    return lines.join('\n');
-};
+import { ReasoningMode, REASONING_TEMPLATES } from "../../../../reasoning-chain.js";
+// import {
+//   renderWorkflowCascade,
+//   renderProgressReel,
+//   renderThinkingChainArbor,
+//   renderGradientDivider,
+//   renderGradientBorderBox,
+//   renderTable,
+//   renderKeyValueTable,
+//   renderQuickFlow,
+//   icons,
+//   WorkflowStep,
+//   ProgressPhase,
+// } from "../../../../utils/ink-renderer.js";
+// Ink disabled — MCP clients render markdown, so these emit plain markdown.
 const renderThinkingChainArbor = (thoughts, title) => {
     const lines = [`## ${title}`];
     thoughts.forEach((t, i) => lines.push(`${i + 1}. (${t.model}) ${t.thought}`));
@@ -30,9 +34,6 @@ const renderTable = (data) => {
 const renderKeyValueTable = (data) => {
     return Object.entries(data).map(([k, v]) => `${k}: ${v}`).join('\n');
 };
-const renderQuickFlow = (steps, title) => {
-    return `## ${title}\n${steps.join(' -> ')}`;
-};
 const icons = {
     brain: '*',
     sparkle: '*',
@@ -52,54 +53,26 @@ export class VisualizationService {
      */
     generateOrchestrationPlan(session) {
         const steps = session.chain.steps;
+        const done = session.currentStep;
+        // One clean header line + a per-step table. The old layout rendered the
+        // same step list four times (cascade, flow, progress reel, table) plus a
+        // metadata block and faux "gradient" boxes — a wall of duplicated scaffold.
+        // MCP clients render markdown, so a single table IS the visualization.
         const lines = [];
-        // Header with gradient border box
-        lines.push(renderGradientBorderBox(`${icons.brain} Collaborative Reasoning\n\n${session.objective}\n\nDomain: ${session.domain} | Session: ${session.id.slice(0, 8)}`, { width: 60, gradient: 'cristal' }));
-        lines.push('');
-        // Workflow cascade showing model flow
-        const cascadeSteps = steps.map((step, idx) => ({
-            name: `${this.getModeIcon(step.mode)} ${step.mode}`,
-            model: step.model,
-            status: idx < session.currentStep ? 'completed' :
-                idx === session.currentStep ? 'running' : 'pending',
-            duration: idx < session.currentStep ? 1000 + Math.random() * 2000 : undefined,
-        }));
-        lines.push(renderWorkflowCascade(cascadeSteps, 'Reasoning Chain'));
+        lines.push(`**Collaborative Reasoning** · ${session.objective}`);
+        lines.push(`${session.domain} · ${this.modelTurnTaking ? 'sequential' : 'parallel'} · ` +
+            `step ${Math.min(done + 1, steps.length)}/${steps.length} · \`${session.id.slice(0, 8)}\``);
         lines.push('');
-        // Quick flow diagram
-        const flowSteps = steps.map(s => `${s.model}: ${s.mode}`);
-        lines.push(renderQuickFlow(flowSteps, 'Execution Flow'));
-        lines.push('');
-        // Progress reel
-        const progressSteps = steps.map((step, idx) => ({
-            name: `${step.model} - ${step.mode}`,
-            status: idx < session.currentStep ? 'completed' :
-                idx === session.currentStep ? 'active' : 'pending',
+        // One table: status · mode · model, in order. The mode already conveys each
+        // step's job, so no "Role" column (its half-filled "AI" fallback is the bit
+        // that read as generic). Status marks done (✓) / current (▸) / pending (·).
+        const tableData = steps.map((step, idx) => ({
+            '#': String(idx + 1),
+            '': idx < done ? '✓' : idx === done ? '▸' : '·',
+            Step: `${this.getModeIcon(step.mode)} ${step.mode}`,
+            Model: step.model,
         }));
-        lines.push(renderProgressReel(progressSteps, 'Step Progress'));
-        lines.push('');
-        // Detailed steps table
-        const tableData = steps.map((step, idx) => {
-            const persona = Object.values(MODEL_PERSONAS).find(p => p.model === step.model);
-            return {
-                '#': String(idx + 1),
-                Mode: `${this.getModeIcon(step.mode)} ${step.mode}`,
-                Model: step.model,
-                Role: persona?.role || 'AI',
-                Status: idx < session.currentStep ? '✓' : idx === session.currentStep ? '⟳' : '○',
-            };
-        });
         lines.push(renderTable(tableData));
-        lines.push('');
-        // Session info
-        lines.push(renderKeyValueTable({
-            'Session ID': session.id,
-            'Total Steps': String(steps.length),
-            'Current Step': String(session.currentStep + 1),
-            'Turn Taking': this.modelTurnTaking ? 'Sequential' : 'Parallel',
-        }));
-        lines.push('');
-        lines.push(renderGradientDivider(60, 'rainbow'));
         return lines.join('\n');
     }
     /**
@@ -112,7 +85,7 @@ export class VisualizationService {
         const currentMode = currentStep?.mode || ReasoningMode.BRAINSTORM;
         const lines = [];
         // Thinking chain visualization
-        const thoughts = session.chain.steps.slice(0, stage + 1).map((step, idx) => ({
+        const thoughts = session.chain.steps.slice(0, stage + 1).map((step) => ({
             thought: `${step.mode}: ${step.prompt.slice(0, 50)}...`,
             model: step.model,
             isRevision: step.mode === ReasoningMode.CRITIQUE,

package/dist/src/profiles/balanced.js

@@ -1,17 +1,18 @@
 export const balancedProfile = {
-    description: "Balanced set for general use (~Xk tokens, 18 tools)",
+    description: "Balanced set for general use (53 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: true,
-        perplexity_research: false,
         grok_reason: true,
         grok_code: true,
         grok_debug: false,
+        debug_triage: true,
         grok_architect: false,
         grok_brainstorm: false,
         grok_search: true,
@@ -20,6 +21,8 @@ export const balancedProfile = {
         openai_code_review: false,
         openai_explain: false,
         openai_search: true,
+        spec_writer: true,
+        refine_prompt: true,
         gemini_brainstorm: true,
         gemini_analyze_code: true,
         gemini_analyze_text: true,
@@ -59,5 +62,13 @@ export const balancedProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };

package/dist/src/profiles/code_focus.js

@@ -1,17 +1,18 @@
 export const codeFocusProfile = {
-    description: "Code-heavy work with debugging and analysis (~Xk tokens, 15 tools)",
+    description: "Code-heavy work with debugging and analysis (42 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: false,
-        perplexity_research: false,
         grok_reason: true,
         grok_code: true,
         grok_debug: true,
+        debug_triage: true,
         grok_architect: false,
         grok_brainstorm: false,
         grok_search: false,
@@ -20,6 +21,8 @@ export const codeFocusProfile = {
         openai_code_review: true,
         openai_explain: false,
         openai_search: false,
+        spec_writer: true,
+        refine_prompt: true,
         gemini_brainstorm: true,
         gemini_analyze_code: true,
         gemini_analyze_text: false,
@@ -59,5 +62,13 @@ export const codeFocusProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };

package/dist/src/profiles/full.js

@@ -1,17 +1,18 @@
 export const fullProfile = {
-    description: "All tools enabled for maximum capability (57 tools)",
+    description: "Default profile — all tools enabled for maximum capability (64 tools)",
     tools: {
         think: true,
         focus: true,
         tachi: true,
+        doctor: true,
         nextThought: true,
         usage_stats: true,
         perplexity_ask: true,
         perplexity_reason: true,
-        perplexity_research: true,
         grok_reason: true,
         grok_code: true,
         grok_debug: true,
+        debug_triage: true,
         grok_architect: true,
         grok_brainstorm: true,
         grok_search: true,
@@ -20,6 +21,8 @@ export const fullProfile = {
         openai_code_review: true,
         openai_explain: true,
         openai_search: true,
+        spec_writer: true,
+        refine_prompt: true,
         gemini_brainstorm: true,
         gemini_analyze_code: true,
         gemini_analyze_text: true,
@@ -59,5 +62,13 @@ export const fullProfile = {
         planner_maker: true,
         planner_runner: true,
         list_plans: true,
+        // Test generation
+        testgen: true,
+        // Security audit
+        security_review: true,
+        // Diff-aware code review
+        diff_review: true,
+        // Adversarial plan red-team
+        plan_critique: true,
     }
 };