tachibot-mcp 2.18.0 → 2.19.0

package/CHANGELOG.md

@@ -5,6 +5,29 @@ All notable changes to TachiBot MCP will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.19.0] - 2026-03-21
+
+### Added
+- **Sparse render mode** (`RENDER_OUTPUT=sparse`) — lightweight output formatting with ~72 tokens overhead per response
+- **ANSI model badges** — colored background badges for model name (provider color) + tool name (charcoal bg)
+- **Pastel section headers** — emoji section headers (`🧠 HEADER ───`) rendered as teal bg + dark bold text badges
+- **Color-coded verdicts** — `✅ pass` (sage green), `🫠 partial` (soft yellow), `💀 fail` (rose) with colored bg badges
+- **Summary badge** — tool name displayed as bold charcoal badge next to model badge
+- **`stripMarkdown` options** — `{ boldHeaders: true }` converts markdown/emoji headers to ANSI-styled badges
+- **Empty input guard** on `stripMarkdown` — early return for empty/whitespace input
+- **Strip markdown headers** — `##` prefixes and `───` decorators removed from output
+- **8 unit tests** for `stripMarkdown` covering headers, bold, bullets, code blocks, HR, empty input
+
+### Fixed
+- **ANSI truncation corruption** — truncate raw content BEFORE applying ANSI badges (prevents mid-escape code corruption)
+- **Summary badge without model** — tools returning null from `inferModelFromTool` (think, focus) still show tool name badge
+- **Unused imports** — cleaned up 10+ unused imports/variables in server.ts
+
+### Changed
+- **Emoji palette** — analysis 🧠, insight 🔮, key 🗝, verdict 👩‍⚖️ (replaced 🔍🧿🪩🎯)
+- **Auditor/Challenger** — use `EMOJI_PALETTE` constants instead of hardcoded emoji
+- **Planner** — topological task ordering with T-ID preservation and Dependencies metadata
+
 ## [2.18.0] - 2026-03-21
 
 ### Added

package/dist/src/modes/auditor.js

@@ -1,3 +1,4 @@
+import { EMOJI_PALETTE } from '../utils/format-constants.js';
 export class Auditor {
     constructor() {
         this.defaultModel = 'perplexity-sonar-pro';
@@ -328,7 +329,7 @@ export class Auditor {
         // Critical assumptions
         const criticalAssumptions = assumptions.filter(a => a.risk === 'high');
         if (criticalAssumptions.length > 0) {
-            synthesis += `**Critical Assumptions** 🔴:\n`;
+            synthesis += `**Critical Assumptions** ${EMOJI_PALETTE.bad}:\n`;
             criticalAssumptions.forEach(assumption => {
                 synthesis += `- ${assumption.description}\n`;
                 synthesis += `  Validation: ${assumption.validationMethod}\n`;

package/dist/src/modes/challenger.js

@@ -20,6 +20,7 @@ import { getChallengerModels } from '../config/model-defaults.js';
 import { createProgressStream } from '../utils/progress-stream.js';
 import { smartAPIClient } from '../utils/smart-api-client.js';
 import { getSmartTimeout } from '../config/timeout-config.js';
+import { EMOJI_PALETTE } from '../utils/format-constants.js';
 import { execSync } from 'child_process';
 // import {
 //   renderTable,
@@ -755,7 +756,7 @@ Write concrete, specific analysis. Do NOT include brackets or placeholders.`;
             lines.push('');
             const challengesTableData = challenges.map((ch, i) => {
                 const claim = claims.find(c => c.id === ch.claimId);
-                const severityIcon = ch.severity === 'high' ? '🔴' : ch.severity === 'medium' ? '🟡' : '🟢';
+                const severityIcon = ch.severity === 'high' ? EMOJI_PALETTE.bad : ch.severity === 'medium' ? EMOJI_PALETTE.warn : EMOJI_PALETTE.good;
                 return {
                     '#': String(i + 1),
                     Severity: `${severityIcon} ${ch.severity}`,
@@ -768,7 +769,7 @@ Write concrete, specific analysis. Do NOT include brackets or placeholders.`;
             // Show full challenges below
             challenges.forEach((ch, i) => {
                 const claim = claims.find(c => c.id === ch.claimId);
-                const severityIcon = ch.severity === 'high' ? '🔴' : ch.severity === 'medium' ? '🟡' : '🟢';
+                const severityIcon = ch.severity === 'high' ? EMOJI_PALETTE.bad : ch.severity === 'medium' ? EMOJI_PALETTE.warn : EMOJI_PALETTE.good;
                 lines.push(`${severityIcon} **Challenge #${i + 1}** (${ch.severity} severity)`);
                 lines.push(`Original: "${claim?.text}"`);
                 lines.push('');
@@ -863,9 +864,9 @@ Write concrete, specific analysis. Do NOT include brackets or placeholders.`;
         lines.push('');
         lines.push(renderKeyValueTable({
             'Total Challenges': String(challenges.length),
-            '🔴 High Severity': String(highSeverity),
-            '🟡 Medium Severity': String(mediumSeverity),
-            '🟢 Low Severity': String(lowSeverity),
+            [EMOJI_PALETTE.bad + ' High Severity']: String(highSeverity),
+            [EMOJI_PALETTE.warn + ' Medium Severity']: String(mediumSeverity),
+            [EMOJI_PALETTE.good + ' Low Severity']: String(lowSeverity),
             'Alternatives': String(alternatives.length),
             'Groupthink Risk': groupthinkRisk,
         }));

package/dist/src/server.js

@@ -25,7 +25,7 @@ const savedThemeVars = {
     RENDER_OUTPUT: process.env.RENDER_OUTPUT,
     TACHIBOT_THEME: process.env.TACHIBOT_THEME,
 };
-const envResult = dotenvConfig({
+dotenvConfig({
     path: envPath,
     override: true // API keys from .env take priority
 });
@@ -52,7 +52,7 @@ import { z } from "zod";
 import { InstructionOrchestrator } from "./orchestrator-instructions.js";
 import { validateToolInput, sanitizeForLogging } from "./utils/input-validator.js";
 import { isToolEnabled, logToolConfiguration } from "./utils/tool-config.js";
-import { stripMarkdown } from "./utils/ansi-renderer.js";
+import { renderOutput } from "./utils/ansi-renderer.js";
 import { getToolAnnotations } from "./utils/tool-annotations.js";
 import { truncateSmart } from "./utils/stream-distill.js";
 import { trackToolCall, inferModelFromTool, estimateTokens, isTrackingEnabled, getUsageSummary, getAllReposSummary, getStatsJson, resetStats } from "./utils/usage-tracker.js";
@@ -158,16 +158,17 @@ function safeAddTool(tool) {
                         // Silently ignore tracking errors
                     }
                 }
-                // Return clean plain text — strip markdown formatting since Claude Code
-                // doesn't render markdown in tool results (shows raw ** and ### as text)
+                // Apply render mode (sparse = badge + bold headers + stripped, etc.)
                 if (typeof result === 'string') {
-                    let cleanText = stripMarkdown(result);
-                    // Safety net: cap at 25K chars to prevent Claude Code's 30K truncation
-                    const MAX_RESPONSE_CHARS = 25000;
-                    if (cleanText.length > MAX_RESPONSE_CHARS) {
-                        cleanText = truncateSmart(cleanText, MAX_RESPONSE_CHARS);
+                    const model = inferModelFromTool(tool.name) || undefined;
+                    // Truncate raw content BEFORE ANSI rendering — prevents mid-escape corruption
+                    let raw = result;
+                    const MAX_RAW_CHARS = 24000;
+                    if (raw.length > MAX_RAW_CHARS) {
+                        raw = truncateSmart(raw, MAX_RAW_CHARS);
                     }
-                    return { type: "text", text: cleanText };
+                    const rendered = renderOutput(raw, { model, summary: tool.name });
+                    return { type: "text", text: rendered };
                 }
                 return result;
             }
@@ -226,7 +227,7 @@ safeAddTool({
     }),
     execute: async (args, mcpContext) => {
         const { log } = mcpContext;
-        let { query, mode = "simple", context, domain, tokenEfficient = false, rounds = 5, executeNow = true, models, temperature = 0.7, saveSession = true, maxTokensPerRound = 2000, pingPongStyle = "collaborative" } = args;
+        let { query, mode = "simple", context, domain, tokenEfficient = false, rounds = 5, executeNow: _executeNow = true, models, temperature = 0.7, saveSession: _saveSession = true, maxTokensPerRound: _maxTokensPerRound = 2000, pingPongStyle: _pingPongStyle = "collaborative" } = args;
         // Validate and sanitize input
         const queryValidation = validateToolInput(query);
         if (!queryValidation.valid) {
@@ -332,8 +333,7 @@ TIPS FOR EFFECTIVE SYNTHESIS:
 Ready to help synthesize your collective intelligence results!`;
             default: // simple mode
                 // BigText header disabled - plain text only
-                const focusHeader = '';
-                const focusBadge = '';
+                // BigText header/badge removed — plain text only
                 return `Enhanced reasoning for: "${query}"
 ${context ? `Context: ${context}` : ''}
 
@@ -458,8 +458,7 @@ MemoryProvider: Pluggable memory (devlog, mem0, custom). Set TACHIBOT_MEMORY_PRO
             });
             // Build response with model output if available
             // BigText header disabled - plain text only
-            const thinkBadge = '';
-            const thinkHeader = '';
+            // BigText header/badge removed — plain text only
             let response = '';
             if (result.modelResponse) {
                 response += `## Model Response (${args.model}):\n\n${result.modelResponse}\n\n---\n\n`;
@@ -691,7 +690,7 @@ async function initializeServer() {
         console.error("✅ Server.start() called successfully");
         // Keep the process alive with a heartbeat
         // This ensures the server doesn't exit prematurely
-        const heartbeatInterval = setInterval(() => {
+        setInterval(() => {
             // Heartbeat to keep process alive
             // Log every 30 seconds to show we're still alive
             const now = new Date().toISOString();

package/dist/src/tools/planner-tools.js

@@ -774,7 +774,8 @@ ${codeContext ? "\nNote: All analysis was performed on actual code provided." :
 
 OUTPUT FORMAT — Each task must be bite-sized (2-5 min):
 
-### Task N: [Component Name]
+### Task [T-ID]: [Component Name]
+**Dependencies:** Blocked by: T1,T3 | Blocks: T4 | Parallel: yes/no | Complexity: Low/Med/High
 **Files:** Create: path/to/file | Modify: path/to/file:lines | Test: path/to/test
 **Step 1:** Write the failing test (show test code)
 **Step 2:** Run test to verify it fails (exact command + expected output)
@@ -789,7 +790,8 @@ REQUIREMENTS:
 4. Exact commands with expected output
 5. Checkpoints at 50%, 80%, and 100%
 6. Address ALL pre-mortem failure causes from critique as mitigations
-7. Order tasks simplest → hardest (least-to-most)
+7. Order tasks topologically: a task MUST appear after all tasks that block it. Within independent groups, order simplest → hardest (using Complexity).
+8. Preserve exact task IDs from TASK DECOMPOSITION (T1, T1.1, T2). Do NOT renumber. Each task MUST include the Dependencies line with Blocked by/Blocks/Parallel/Complexity fields.
 
 **QUALITY ASSESSMENT (at the end):**
    - Code Quality: X/10

package/dist/src/utils/ansi-renderer.js

@@ -5,6 +5,7 @@
  * Uses the theme system from ansi-styles.ts and ink-markdown-renderer.tsx.
  *
  * Configuration:
+ *   RENDER_OUTPUT=sparse   - ANSI badge header for model/tool name + raw markdown body (~1.01x tokens)
  *   RENDER_OUTPUT=markdown - Raw markdown, no processing (default, ~1x tokens)
  *   RENDER_OUTPUT=ink      - React Ink rendering with themes, gradients, tables (~12x tokens)
  *   RENDER_OUTPUT=ansi     - Legacy marked-terminal rendering
@@ -20,7 +21,7 @@ import chalk from 'chalk';
 chalk.level = 3;
 // Force gradient-string colors
 process.env.FORCE_COLOR = '3';
-import { getTheme, renderModelBadge, toolResultHeader, dividers, } from './ansi-styles.js';
+import { getTheme, renderModelBadge, renderSummaryBadge, toolResultHeader, dividers, } from './ansi-styles.js';
 const renderGradientDivider = (width = 50, preset) => '-'.repeat(width);
 const renderGradientModelName = (model) => `[${model.toUpperCase()}]`;
 // import { renderMarkdownToAnsi as renderInkMarkdown } from './ink-markdown-renderer.js';
@@ -105,7 +106,7 @@ export function clearThemeCache() {
 export function getRenderMode() {
     if (!cachedRenderMode) {
         const mode = process.env.RENDER_OUTPUT?.toLowerCase();
-        if (mode === 'ink' || mode === 'plain' || mode === 'ansi') {
+        if (mode === 'ink' || mode === 'plain' || mode === 'ansi' || mode === 'sparse') {
             cachedRenderMode = mode;
         }
         else {
@@ -176,6 +177,18 @@ export function renderOutput(content, modelOrOptions) {
             output += renderAnsi(content);
             output += '\n' + simpleGradient(60) + '\n';
             break;
+        case 'sparse': {
+            // Sparse mode: badge bar (model + summary) + bold headers + stripped text
+            const parts = [];
+            if (options.model)
+                parts.push(renderModelBadge(options.model));
+            if (options.summary)
+                parts.push(renderSummaryBadge(options.summary));
+            if (parts.length)
+                output += parts.join('') + '\n';
+            output += stripMarkdown(content, { boldHeaders: true });
+            break;
+        }
         case 'plain':
             output += stripMarkdown(content);
             break;
@@ -422,18 +435,10 @@ function renderAnsi(md) {
         return md;
     }
 }
-// ============================================================================
-// PLAIN TEXT STRIPPER
-// ============================================================================
-/**
- * Strip decorative markdown formatting but KEEP structural elements.
- * Keeps: # headers, - bullets, 1. numbered lists, > blockquotes, | tables, indentation
- * Strips: **bold**, *italic*, ~~strike~~, `inline code` backticks, [link](url), ![img](url), ``` fences
- *
- * Code blocks are protected via placeholder extraction to avoid corrupting code content.
- * Underscore italic is skipped to avoid mangling snake_case identifiers.
- */
-export function stripMarkdown(md) {
+export function stripMarkdown(md, options) {
+    if (!md || !md.trim())
+        return '';
+    const { boldHeaders = false } = options || {};
     // 1. Extract code blocks to placeholders (protect from stripping)
     const codeBlocks = [];
     let text = md.replace(/```[\s\S]*?```/g, (match) => {
@@ -443,6 +448,20 @@ export function stripMarkdown(md) {
     });
     // 2. Strip decorative formatting on non-code text
     text = text
+        // Markdown headers — strip # prefix (or bold if boldHeaders)
+        .replace(/^#{1,6}\s+(.+)$/gm, boldHeaders ? '\x1b[1m$1\x1b[0m' : '$1')
+        // Emoji section headers — e.g. "🔍 TYPE SAFETY ───" → soft teal bg, dark bold text
+        .replace(/^(.{1,2})\s+([A-Z][A-Z\s&]+?)\s*─+$/gm, boldHeaders ? '\x1b[48;5;73m\x1b[30m\x1b[1m $1 $2 \x1b[0m' : '$1 $2')
+        // Verdict lines — color-coded: green=pass, yellow=partial, red=fail
+        .replace(/^(✅|🫠|💀|🟢|🟡|🔴)\s*(pass|partial|fail)\b(.*)$/gmi, (_match, emoji, status, rest) => {
+        if (!boldHeaders)
+            return `${emoji} ${status}${rest}`;
+        const s = status.toLowerCase();
+        const bg = s === 'pass' ? '\x1b[48;5;151m' : s === 'partial' ? '\x1b[48;5;186m' : '\x1b[48;5;174m';
+        return `${bg}\x1b[30m\x1b[1m ${emoji} ${status} \x1b[0m${rest}`;
+    })
+        // Horizontal rules
+        .replace(/^[-*_]{3,}\s*$/gm, '')
         // Normalize * bullets to - before italic strip (prevents stray * on "* Security:")
         .replace(/^(\s{0,3})\*(\s+)/gm, '$1-$2')
         // Images before links (avoid ![...] conflict)

package/dist/src/utils/ansi-styles.js

@@ -409,18 +409,19 @@ const fgMap = {
 };
 // Unicode colored emoji for badges (ANSI-free, works everywhere)
 const MODEL_EMOJI = {
-    grok: '🟣', // purple
-    gemini: '🔵', // blue
-    openai: '🟢', // green
-    perplexity: '🔷', // cyan diamond
-    kimi: '🟡', // yellow
-    qwen: '🔴', // red
-    focus: '⚪',
-    workflow: '⬜',
-    scout: '🔍',
+    grok: '🔮',
+    gemini: '🌀',
+    openai: '🧠',
+    perplexity: '🔭',
+    kimi: '🐉',
+    qwen: '🐉',
+    minimax: '🤖',
+    focus: '🎯',
+    workflow: '🌊',
+    scout: '🔎',
     verifier: '✅',
     challenger: '⚔️',
-    think: '💭',
+    think: '🫨',
 };
 /**
  * Render a model badge with ANSI background color
@@ -446,6 +447,16 @@ export function renderModelBadge(model, theme) {
     const label = badgeStyle.label || ` ${normalized} `;
     return `${bg}${fg}${ANSI.bold}${label}${ANSI.reset}`;
 }
+/**
+ * Render a summary badge with dimmed bg + dark text (pairs with model badge)
+ * e.g. model badge: [bright magenta] grok [reset] + summary: [dim gray] search query [reset]
+ */
+export function renderSummaryBadge(summary) {
+    // Dimmed bg + bold sits next to the bright model badge
+    const bg = '\x1b[48;5;238m'; // dark gray bg (ansi256 color 238)
+    const fg = '\x1b[97m'; // bright white text
+    return `${bg}${fg}${ANSI.bold} ${summary} ${ANSI.reset}`;
+}
 /**
  * Get model badge (alias for backward compatibility)
  */

package/dist/src/utils/format-constants.js

@@ -19,29 +19,67 @@ LISTS: Hierarchy for structure:
 
 CODE: \`\`\`lang blocks. Minimal inline comments.
 
-SECTIONS: 🔍 HEADER ───
+SECTIONS: 🧠 HEADER ───
 Blank line after. 2-4 sections max.
 
-VERDICT: 🟢 pass 🟡 partial 🔴 fail
+VERDICT: ✅ pass 🫠 partial 💀 fail
 End only. One line + reason.`;
 export const EMOJI_PALETTE = {
     // Section headers
-    analysis: '🔍',
-    verdict: '🎯',
-    insight: '💡',
-    key: '⚡',
+    analysis: '🧠',
+    verdict: '👩‍⚖️',
+    insight: '🔮',
+    key: '🗝',
     judge: '⚖️',
-    fix: '🔧',
+    fix: '🪛',
     search: '🔎',
-    idea: '💭',
-    warning: '⚠️',
+    idea: '🫧',
+    warning: '🫠',
+    sources: '📎',
+    compare: '⚡',
+    code: '🦾',
+    brainstorm: '🌩️',
+    reason: '🧪',
+    plan: '📋',
+    debug: '🐛',
+    security: '🛡️',
+    performance: '🔥',
+    architecture: '🏗️',
+    consensus: '🤝',
+    conflict: '⚔️',
+    caveat: '📌',
+    thinking: '🫨',
+    decompose: '🪆',
+    workflow: '🌊',
+    summary: '🧾',
     // Status indicators
     good: '🟢',
     warn: '🟡',
     bad: '🔴',
     info: '🔵',
+    pass: '✅',
+    fail: '💀',
+    partial: '🫠',
+    running: '⏳',
+    blocked: '🚫',
+    hot: '🔥',
+    cold: '🧊',
+    // Models
+    grok: '🔮',
+    gemini: '🌀',
+    openai: '🧠',
+    perplexity: '🔭',
+    kimi: '🐉',
+    qwen: '🐉',
+    minimax: '🤖',
     // Actions
     arrow: '→',
     check: '✓',
     cross: '✗',
+    link: '🔗',
+    pin: '📍',
+    time: '⏱️',
+    cost: '💰',
+    sparkle: '✨',
+    nuke: '💥',
 };

package/docs/superpowers/plans/2026-03-21-sparse-mode-ansi-bold-headers.md

@@ -0,0 +1,252 @@
+# Sparse Mode: ANSI Bold Headers Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Convert `## headers` to ANSI bold text (instead of stripping them) in sparse render mode, giving readable section separation at ~3 tokens/header instead of 0 (stripped) or ~12 (colored badge).
+
+**Architecture:** Modify `stripMarkdown()` in `ansi-renderer.ts` to accept an options parameter. When `boldHeaders: true`, headers get `\x1b[1m` ANSI bold wrapping instead of being stripped to plain text. The sparse case in `renderOutput()` calls `stripMarkdown` with this option enabled.
+
+**Tech Stack:** TypeScript, raw ANSI escape codes (`\x1b[1m`, `\x1b[0m`)
+
+---
+
+### Task 1: Add ANSI Bold Header Support to stripMarkdown
+
+**Files:**
+- Modify: `src/utils/ansi-renderer.ts:552-592` (stripMarkdown function)
+- Test: `src/utils/__tests__/strip-markdown.test.ts`
+
+- [ ] **Step 1: Write the failing test**
+
+```typescript
+// src/utils/__tests__/strip-markdown.test.ts
+import { describe, it, expect } from 'vitest';
+import { stripMarkdown } from '../ansi-renderer.js';
+
+describe('stripMarkdown', () => {
+  it('strips headers to plain text by default', () => {
+    expect(stripMarkdown('## Analysis')).toBe('Analysis');
+    expect(stripMarkdown('### Summary')).toBe('Summary');
+  });
+
+  it('converts headers to ANSI bold when boldHeaders is true', () => {
+    const result = stripMarkdown('## Analysis', { boldHeaders: true });
+    expect(result).toBe('\x1b[1mAnalysis\x1b[0m');
+  });
+
+  it('handles h1-h6 with ANSI bold', () => {
+    const result = stripMarkdown('# Title\n## Section\n### Sub', { boldHeaders: true });
+    expect(result).toContain('\x1b[1mTitle\x1b[0m');
+    expect(result).toContain('\x1b[1mSection\x1b[0m');
+    expect(result).toContain('\x1b[1mSub\x1b[0m');
+  });
+
+  it('strips bold/italic/strikethrough normally', () => {
+    expect(stripMarkdown('**bold** and *italic* and ~~strike~~')).toBe('bold and italic and strike');
+  });
+
+  it('preserves bullets and indentation', () => {
+    const input = '- Item 1\n  - Sub item\n    - Deep';
+    expect(stripMarkdown(input)).toBe(input);
+  });
+
+  it('preserves code blocks untouched', () => {
+    const input = '```js\nconst x = 1;\n```';
+    expect(stripMarkdown(input)).toContain('const x = 1;');
+  });
+
+  it('strips horizontal rules', () => {
+    expect(stripMarkdown('---')).toBe('');
+    expect(stripMarkdown('***')).toBe('');
+  });
+
+  it('adds blank line after bold header for readability', () => {
+    const result = stripMarkdown('## Analysis\nSome text', { boldHeaders: true });
+    expect(result).toBe('\x1b[1mAnalysis\x1b[0m\nSome text');
+  });
+});
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `npx vitest run src/utils/__tests__/strip-markdown.test.ts`
+Expected: FAIL — `stripMarkdown` does not accept options parameter
+
+- [ ] **Step 3: Add options parameter to stripMarkdown**
+
+In `src/utils/ansi-renderer.ts`, change the `stripMarkdown` signature and header regex:
+
+```typescript
+export interface StripMarkdownOptions {
+  /** Convert ## headers to ANSI bold instead of stripping # prefix */
+  boldHeaders?: boolean;
+}
+
+export function stripMarkdown(md: string, options?: StripMarkdownOptions): string {
+  const { boldHeaders = false } = options || {};
+
+  // ... existing code block extraction ...
+
+  // 2. Strip decorative formatting on non-code text
+  text = text
+    // Headers — ANSI bold or strip # prefix
+    .replace(/^#{1,6}\s+(.+)$/gm, boldHeaders ? '\x1b[1m$1\x1b[0m' : '$1')
+    // ... rest of existing regexes unchanged ...
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `npx vitest run src/utils/__tests__/strip-markdown.test.ts`
+Expected: ALL PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/utils/__tests__/strip-markdown.test.ts src/utils/ansi-renderer.ts
+git commit -m "feat(sparse): convert headers to ANSI bold in stripMarkdown"
+```
+
+---
+
+### Task 2: Wire Sparse Mode to Use Bold Headers
+
+**Files:**
+- Modify: `src/utils/ansi-renderer.ts:240-253` (sparse case in renderOutput)
+
+- [ ] **Step 1: Update sparse case to pass boldHeaders option**
+
+In the `renderOutput` function's sparse case:
+
+```typescript
+    case 'sparse': {
+      // Sparse mode: ANSI badge header + clean text with bold section headers
+      if (options.model) {
+        const badge = renderModelBadge(options.model);
+        if (options.summary) {
+          output = badge + renderSummaryBadge(options.summary, options.model) + '\n';
+        } else {
+          output = badge + '\n';
+        }
+      }
+      output += stripMarkdown(content, { boldHeaders: true });
+      break;
+    }
+```
+
+- [ ] **Step 2: Verify plain mode still strips headers (no bold)**
+
+The `plain` case should remain unchanged:
+```typescript
+    case 'plain':
+      output += stripMarkdown(content);  // no options = headers stripped flat
+      break;
+```
+
+- [ ] **Step 3: Build and test end-to-end**
+
+Run: `npm run build && node -e "
+import { renderOutput } from './dist/src/utils/ansi-renderer.js';
+const md = '## Analysis\n\n**Critical bug** in server.ts:\n- Missing null check\n\n### Summary\nLooks good.';
+console.log('--- sparse ---');
+console.log(renderOutput(md, { model: 'gemini', summary: 'gemini_analyze_code', mode: 'sparse' }));
+console.log('--- plain ---');
+console.log(renderOutput(md, { model: 'gemini', mode: 'plain' }));
+"`
+
+Expected:
+- sparse: badge + `\x1b[1mAnalysis\x1b[0m` (bold) + stripped body
+- plain: `Analysis` (no bold) + stripped body
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/utils/ansi-renderer.ts
+git commit -m "feat(sparse): wire bold headers in sparse render mode"
+```
+
+---
+
+### Task 3: Fix TS Unused Import Warnings in server.ts
+
+**Files:**
+- Modify: `src/server.ts:34,63,67,71,73,78,84,339,342`
+
+- [ ] **Step 1: Remove unused imports and variables**
+
+Lines to fix (from TS diagnostics):
+- Line 34: `envResult` — prefix with `void` or remove assignment: `dotenvConfig({ path: envPath, override: true });`
+- Line 63: `stripMarkdown` — already removed in this session
+- Line 67: `getUpdateStatus` — remove from import
+- Line 71: `TechnicalDomain` — remove import
+- Line 73: `getUnifiedAITools` — remove from import
+- Line 78: `createFocusDeepPlan`, `generateFocusDeepVisualization` — remove from import
+- Line 84: `getAllOpenRouterTools` — remove from import
+- Line 339: `executeNow` — remove or prefix unused destructure
+- Line 342: `saveSession` — remove or prefix unused destructure
+
+- [ ] **Step 2: Build to verify no errors**
+
+Run: `npm run build`
+Expected: Clean build, no warnings
+
+- [ ] **Step 3: Run existing tests**
+
+Run: `npm test`
+Expected: ALL PASS
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/server.ts
+git commit -m "chore: remove unused imports in server.ts"
+```
+
+---
+
+### Task 4: Set RENDER_OUTPUT=sparse as Default
+
+**Files:**
+- Modify: `.env` (add `RENDER_OUTPUT=sparse`)
+- Modify: `src/utils/ansi-renderer.ts:113` (optional: change default from `markdown` to `sparse`)
+
+- [ ] **Step 1: Add to .env**
+
+```bash
+echo 'RENDER_OUTPUT=sparse' >> .env
+```
+
+- [ ] **Step 2: Decide on code default**
+
+Option A: Keep `markdown` as code default, override in `.env` only (safer, no behavior change for other users)
+Option B: Change code default to `sparse` (all users get badges by default)
+
+Recommend: Option A — set in `.env`, keep code default as `markdown`.
+
+- [ ] **Step 3: Restart MCP server and test with a real tool call**
+
+Call any tachibot tool (e.g., `gemini_analyze_code`) and verify:
+- Colored badge appears at top
+- Summary badge next to it
+- Headers are bold
+- Body is clean (no `**`, `##`, `~~`)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add .env
+git commit -m "feat: enable sparse render mode in .env"
+```
+
+---
+
+### Token Cost Summary
+
+| Element | Tokens per instance | Instances/response | Total |
+|---------|-------------------:|-------------------:|------:|
+| Model badge (ANSI) | ~12 | 1 | 12 |
+| Summary badge (ANSI) | ~8 | 1 | 8 |
+| Bold header (ANSI) | ~3-4 | 2-4 | 8-16 |
+| Stripped `**`/`##`/`~~` | -2 each | 10-15 | -20 to -30 |
+| **Net per response** | | | **~0 to +6** |
+
+Sparse mode with bold headers is token-neutral vs raw markdown. You get visual readability for free.

package/docs/superpowers/plans/2026-03-21-sparse-mode-fixes.md

@@ -0,0 +1,187 @@
+# Sparse Mode Fixes — Multi-Model Jury Findings
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Fix critical bugs and edge cases found by 4-model jury (Gemini, GPT, Qwen, background Gemini) in sparse render mode.
+
+**Architecture:** Three targeted fixes to existing functions — no new files, no architectural changes. Truncation order swap in server.ts, input guards in stripMarkdown, cleanup of renderSummaryBadge.
+
+**Tech Stack:** TypeScript, raw ANSI escape codes
+
+---
+
+### Task 1: Truncate Raw Content BEFORE Rendering (Critical)
+
+**Why:** All 4 models flagged this. `truncateSmart` runs after `renderOutput`, which adds ANSI escape codes. If truncation lands mid-escape (`\x1b[1`), it corrupts terminal output and bleeds colors. Truncating the raw text first, then applying ANSI badges, guarantees clean output.
+
+**Files:**
+- Modify: `src/server.ts:262-272`
+- Test: Manual — build and verify with long content
+
+- [ ] **Step 1: Swap truncation order in server.ts**
+
+Change from:
+```typescript
+const model = inferModelFromTool(tool.name) || undefined;
+let rendered = renderOutput(result, { model, summary: tool.name });
+const MAX_RESPONSE_CHARS = 25000;
+if (rendered.length > MAX_RESPONSE_CHARS) {
+  rendered = truncateSmart(rendered, MAX_RESPONSE_CHARS);
+}
+return { type: "text" as const, text: rendered };
+```
+
+To:
+```typescript
+const model = inferModelFromTool(tool.name) || undefined;
+// Truncate raw content BEFORE adding ANSI — prevents mid-escape corruption
+let raw = result;
+const MAX_RAW_CHARS = 24000;
+if (raw.length > MAX_RAW_CHARS) {
+  raw = truncateSmart(raw, MAX_RAW_CHARS);
+}
+const rendered = renderOutput(raw, { model, summary: tool.name });
+return { type: "text" as const, text: rendered };
+```
+
+Note: Use 24K (not 25K) to leave ~1K headroom for badge ANSI codes.
+
+- [ ] **Step 2: Build and verify**
+
+Run: `npm run build`
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/server.ts
+git commit -m "fix: truncate raw content before ANSI rendering to prevent escape corruption"
+```
+
+---
+
+### Task 2: Show Summary Badge Even Without Model
+
+**Why:** GPT flagged that tools returning `null` from `inferModelFromTool` (e.g., `think`, `focus`, `nextThought`) lose their summary badge entirely. The tool name should still appear.
+
+**Files:**
+- Modify: `src/utils/ansi-renderer.ts:240-253` (sparse case)
+
+- [ ] **Step 1: Update sparse case to show summary independently**
+
+Change from:
+```typescript
+case 'sparse': {
+  if (options.model) {
+    const badge = renderModelBadge(options.model);
+    if (options.summary) {
+      output = badge + renderSummaryBadge(options.summary, options.model) + '\n';
+    } else {
+      output = badge + '\n';
+    }
+  }
+  output += stripMarkdown(content, { boldHeaders: true });
+  break;
+}
+```
+
+To:
+```typescript
+case 'sparse': {
+  const parts: string[] = [];
+  if (options.model) {
+    parts.push(renderModelBadge(options.model));
+  }
+  if (options.summary) {
+    parts.push(renderSummaryBadge(options.summary));
+  }
+  if (parts.length) output += parts.join('') + '\n';
+  output += stripMarkdown(content, { boldHeaders: true });
+  break;
+}
+```
+
+- [ ] **Step 2: Remove unused `model` param from renderSummaryBadge**
+
+In `src/utils/ansi-styles.ts`, change:
+```typescript
+export function renderSummaryBadge(summary: string, model?: string): string {
+```
+To:
+```typescript
+export function renderSummaryBadge(summary: string): string {
+```
+
+- [ ] **Step 3: Update import in ansi-renderer.ts if needed**
+
+Verify the call site no longer passes `model` to `renderSummaryBadge`.
+
+- [ ] **Step 4: Build and test**
+
+Run: `npm run build && node -e "
+import { renderOutput } from './dist/src/utils/ansi-renderer.js';
+// Test: no model, has summary
+console.log(renderOutput('Hello', { summary: 'think', mode: 'sparse' }));
+// Test: model + summary
+console.log(renderOutput('Hello', { model: 'grok', summary: 'grok_search', mode: 'sparse' }));
+// Test: no model, no summary
+console.log(renderOutput('Hello', { mode: 'sparse' }));
+"`
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/utils/ansi-renderer.ts src/utils/ansi-styles.ts
+git commit -m "fix(sparse): show summary badge even when model is null"
+```
+
+---
+
+### Task 3: Add Input Guards to stripMarkdown
+
+**Why:** GPT and Qwen flagged that empty/null input and missing early return can cause unnecessary regex processing.
+
+**Files:**
+- Modify: `src/utils/ansi-renderer.ts:557` (stripMarkdown function body)
+- Modify: `src/utils/__tests__/strip-markdown.test.ts` (add empty input test)
+
+- [ ] **Step 1: Add test for empty input**
+
+Add to the test file:
+```typescript
+it('returns empty string for empty/null input', () => {
+  expect(stripMarkdown('')).toBe('');
+  expect(stripMarkdown('   ')).toBe('');
+});
+```
+
+- [ ] **Step 2: Add early return to stripMarkdown**
+
+Add at the start of the function body (after destructuring options):
+```typescript
+if (!md || !md.trim()) return '';
+```
+
+- [ ] **Step 3: Run tests**
+
+Run: `npx vitest run src/utils/__tests__/strip-markdown.test.ts`
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/utils/ansi-renderer.ts src/utils/__tests__/strip-markdown.test.ts
+git commit -m "fix: add empty input guard to stripMarkdown"
+```
+
+---
+
+### Summary of What We're NOT Fixing
+
+| Finding | Decision | Reason |
+|---------|----------|--------|
+| Replace regex with markdown parser | Skip | Overkill — model output is ~95% simple markdown |
+| `@@CODE` placeholder collision | Skip | Probability near zero in real model output |
+| Code block with nested backticks | Skip | Models rarely output nested fences |
+| Link with `)` in URL | Skip | Models rarely output such URLs |
+| Windows `\r\n` line endings | Skip | MCP runs on Unix; models output `\n` |
+| ANSI enters LLM context | Accept | 1M context window; ~1.2x overhead acceptable |
+| Decouple UI from LLM payload | Skip | MCP architecture doesn't support split rendering |

package/package.json

@@ -2,7 +2,7 @@
   "name": "tachibot-mcp",
   "mcpName": "io.github.byPawel/tachibot-mcp",
   "displayName": "TachiBot MCP - Universal AI Orchestrator",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "type": "module",
   "main": "dist/src/server.js",
   "bin": {