tachibot-mcp 2.24.0 → 2.26.1

package/README.md

@@ -4,18 +4,18 @@
 
 ### Multi-Model AI Orchestration Platform
 
-[![Version](https://img.shields.io/badge/version-2.24.0-blue.svg)](https://www.npmjs.com/package/tachibot-mcp)
-[![Tools](https://img.shields.io/badge/tools-61_active-brightgreen.svg)](#-tool-ecosystem-61-tools)
+[![Version](https://img.shields.io/badge/version-2.26.1-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%3D22.0.0-brightgreen.svg)](https://nodejs.org)
 [![MCP](https://img.shields.io/badge/MCP-Compatible-purple.svg)](https://modelcontextprotocol.io)
 
-**61 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-61-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,46 @@ from Claude Code, Claude Desktop, Cursor, or any MCP client.
 
 ---
 
-## What's New in v2.15.0
+## What's New
 
-### `/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.
+### v2.26.1
+- **`/test` and `/audit` skills** (19 skills total) — `/test` generates runnable tests via `testgen`; `/audit` runs an OWASP/CWE security review via `security_review`.
+- **Skill install in the wizard** — `tachibot init` now offers to install Claude Code skills with a per-skill skip choice (`[Enter]`=all · `[s]`=choose which to skip · `[n]`=none). Skills are opt-in — `postinstall` no longer writes to `~/.claude` silently (`npm run install-skills` still installs all non-interactively).
+- **Fixes** — the one-click `.mcpb` extension now points at a valid entry point (was broken) and tracks the package version; `tachibot init` exits cleanly on non-interactive/CI stdin instead of hanging.
 
-### 31 Prompt Engineering Techniques (was 22)
-Added 9 research-backed techniques for coding and decision-making:
+### v2.26.0
 
-| 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 |
+#### 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.
 
-Techniques are embedded directly in tool system prompts for automatic application.
+#### 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.
 
-### 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
+#### New tools & skills (64 tools · 19 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`
 
-### 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 14 slash commands for Claude Code. These orchestrate the tools into powerful workflows:
+TachiBot ships with 19 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` |
@@ -87,6 +81,9 @@ TachiBot ships with 14 slash commands for Claude Code. These orchestrate the too
 | `/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>` |
+| `/test` | Generate runnable tests (edge cases first) | `/test src/auth.ts` |
+| `/audit` | Security review — OWASP/CWE findings + fixes | `/audit the login handler` |
 | `/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.
@@ -98,7 +95,7 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 ## Key Features
 
 ### Multi-Model Intelligence
-- **61 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
@@ -115,10 +112,10 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 |---------|-------|----------|
 | **Minimal** | 13 | Quick tasks, low token budget |
 | **Research Power** | 35 | Deep investigation, multi-source |
-| **Code Focus** | 39 | Software development, SWE tasks |
-| **Balanced** | 50 | General-purpose, mixed workflows |
-| **Heavy Coding** | 54 | Max code tools + agentic workflows |
-| **Full** (default) | 61 | 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
@@ -136,6 +133,14 @@ Skills automatically adapt to your configured API keys. Even with just 1-2 provi
 npm install -g tachibot-mcp
 ```
 
+### 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
@@ -146,6 +151,8 @@ Then verify with `/mcp`. Add API keys with `--env`, e.g. `--env OPENROUTER_API_K
 
 ### 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:
 
 ```json
@@ -188,16 +195,16 @@ See [Installation Guide](docs/INSTALLATION_BOTH.md) for detailed instructions.
 
 ---
 
-## Tool Ecosystem (61 Tools)
+## Tool Ecosystem (64 Tools)
 
 ### 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 (10)
-`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`
+### 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 (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`
@@ -208,8 +215,8 @@ See [Installation Guide](docs/INSTALLATION_BOTH.md) for detailed instructions.
 ### 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,218 @@
+/**
+ * `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";
+import { fileURLToPath } from "node:url";
+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)}…` : "");
+/** The package's bundled skills dir. dist/src/cli/init.js → up 3 → pkg root. */
+export function resolveSkillsDir() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(here, "..", "..", "..", "skills");
+}
+/** Read `skills/<name>/SKILL.md`, pulling the frontmatter `description`. */
+export function listAvailableSkills(skillsDir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(skillsDir).sort();
+    }
+    catch {
+        return [];
+    }
+    const skills = [];
+    for (const name of entries) {
+        let text;
+        try {
+            text = fs.readFileSync(path.join(skillsDir, name, "SKILL.md"), "utf8");
+        }
+        catch {
+            continue;
+        } // not a skill dir
+        const m = text.match(/^description:\s*(.+)$/m);
+        skills.push({ name, description: m ? m[1].trim() : "" });
+    }
+    return skills;
+}
+/**
+ * Parse a "skip which" answer ("1,3, 5") into a set of 0-based indices over a
+ * list of `count`. Blanks, non-numbers, and out-of-range tokens are ignored so
+ * a fat-fingered entry never throws or skips the wrong skill.
+ */
+export function parseSkipSelection(input, count) {
+    const skip = new Set();
+    for (const tok of input.split(/[\s,]+/).filter(Boolean)) {
+        const n = Number(tok);
+        if (Number.isInteger(n) && n >= 1 && n <= count)
+            skip.add(n - 1);
+    }
+    return skip;
+}
+/** Copy the chosen skills' SKILL.md into `targetDir/<name>/`. Returns installed names. */
+export function installSkills(names, skillsDir, targetDir) {
+    const installed = [];
+    for (const name of names) {
+        const src = path.join(skillsDir, name, "SKILL.md");
+        if (!fs.existsSync(src))
+            continue;
+        const dest = path.join(targetDir, name);
+        fs.mkdirSync(dest, { recursive: true });
+        fs.copyFileSync(src, path.join(dest, "SKILL.md"));
+        installed.push(name);
+    }
+    return installed;
+}
+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})` : ""}`);
+    // Non-interactive (piped stdin / CI): prompting would hang on EOF with an
+    // "unsettled top-level await". Print the config for both clients with sane
+    // defaults and how to install skills, then exit cleanly.
+    if (!process.stdin.isTTY) {
+        out("\n(non-interactive: printing full config — run in a terminal to choose options)\n");
+        out("— Claude Code —\n");
+        out(buildClaudeCodeCommand(setup));
+        out("\n— Claude Desktop — double-click the .mcpb from GitHub releases, or merge into");
+        out((setup.clients.desktopConfigPath ?? desktopConfigPath()) + ":\n");
+        out(buildDesktopSnippet(setup, "full"));
+        const n = listAvailableSkills(resolveSkillsDir()).length;
+        out(`\nClaude Code skills (${n}): install with  npm run install-skills  (or re-run this wizard in a terminal to choose which).`);
+        out("\nOnce connected, run the `doctor` tool to see which tools your keys unlock.");
+        return;
+    }
+    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 64 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.");
+        }
+        // Skills — Claude Code slash commands, opt-in with per-skill skip.
+        const skillsDir = resolveSkillsDir();
+        const available = listAvailableSkills(skillsDir);
+        if (available.length > 0 && choice !== "2") {
+            const target = path.join(os.homedir(), ".claude", "skills");
+            const ans = (await rl.question(`\nInstall ${available.length} Claude Code skills to ${target}? [Enter]=all · [s]=choose which to skip · [n]=none > `)).trim().toLowerCase();
+            if (ans !== "n") {
+                let chosen = available.map((s) => s.name);
+                if (ans === "s") {
+                    out("");
+                    available.forEach((s, i) => out(`  ${String(i + 1).padStart(2)}. /${s.name} — ${s.description}`));
+                    const skip = parseSkipSelection((await rl.question("\nSkip which? (comma-separated numbers, blank = skip none) > ")).trim(), available.length);
+                    chosen = available.filter((_, i) => !skip.has(i)).map((s) => s.name);
+                }
+                const installed = installSkills(chosen, skillsDir, target);
+                out(`\n✓ Installed ${installed.length} skill${installed.length === 1 ? "" : "s"}: ${installed.map((n) => "/" + n).join(", ")}`);
+                const skipped = available.filter((s) => !installed.includes(s.name));
+                if (skipped.length)
+                    out(`  Skipped: ${skipped.map((s) => "/" + s.name).join(", ")}`);
+            }
+        }
+        out("\nFirst thing to run once connected: the `doctor` tool — it shows which tools your keys unlock.");
+    }
+    finally {
+        rl.close();
+    }
+}

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,5 +1,5 @@
 export const balancedProfile = {
-    description: "Balanced set for general use (50 tools)",
+    description: "Balanced set for general use (53 tools)",
     tools: {
         think: true,
         focus: true,
@@ -12,6 +12,7 @@ export const balancedProfile = {
         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,

package/dist/src/profiles/code_focus.js

@@ -1,5 +1,5 @@
 export const codeFocusProfile = {
-    description: "Code-heavy work with debugging and analysis (39 tools)",
+    description: "Code-heavy work with debugging and analysis (42 tools)",
     tools: {
         think: true,
         focus: true,
@@ -12,6 +12,7 @@ export const codeFocusProfile = {
         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,

package/dist/src/profiles/full.js

@@ -1,5 +1,5 @@
 export const fullProfile = {
-    description: "Default profile — all tools enabled for maximum capability (61 tools)",
+    description: "Default profile — all tools enabled for maximum capability (64 tools)",
     tools: {
         think: true,
         focus: true,
@@ -12,6 +12,7 @@ export const fullProfile = {
         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,

package/dist/src/profiles/heavy_coding.js

@@ -1,5 +1,5 @@
 export const heavyCodingProfile = {
-    description: "Heavy coding with all reasoning & code tools (54 tools)",
+    description: "Heavy coding with all reasoning & code tools (57 tools)",
     tools: {
         // Core reasoning - all enabled
         think: true,
@@ -15,6 +15,7 @@ export const heavyCodingProfile = {
         grok_reason: true,
         grok_code: true,
         grok_debug: true,
+        debug_triage: true,
         grok_architect: true,
         grok_brainstorm: true,
         grok_search: true,
@@ -24,6 +25,8 @@ export const heavyCodingProfile = {
         openai_code_review: true,
         openai_explain: true,
         openai_search: true,
+        spec_writer: true,
+        refine_prompt: true,
         // Gemini - all enabled
         gemini_brainstorm: true,
         gemini_analyze_code: true,

package/dist/src/profiles/minimal.js

@@ -12,6 +12,7 @@ export const minimalProfile = {
         grok_reason: true,
         grok_code: false,
         grok_debug: false,
+        debug_triage: false,
         grok_architect: false,
         grok_brainstorm: false,
         grok_search: false,
@@ -20,6 +21,8 @@ export const minimalProfile = {
         openai_code_review: false,
         openai_explain: false,
         openai_search: false,
+        spec_writer: false,
+        refine_prompt: false,
         gemini_brainstorm: true,
         gemini_analyze_code: false,
         gemini_analyze_text: false,