tachibot-mcp 2.7.10 → 2.9.0

package/dist/src/application/services/focus/FocusExecutionService.js

@@ -0,0 +1,359 @@
+/**
+ * FocusExecutionService - Manages focus sessions and step execution
+ * Enables executeNow mode for focus tool to actually run model calls
+ */
+import { randomBytes } from "crypto";
+import { ToolExecutionService } from "../../../orchestrators/collaborative/services/tool-execution/ToolExecutionService.js";
+import { ReasoningMode } from "../../../reasoning-chain.js";
+import { createFocusDeepPlan, generateFocusDeepVisualization } from "../../../focus-deep.js";
+import { SESSION_TIMEOUT_MS, } from "./types/FocusSession.js";
+/**
+ * Generate UUID v4 using randomBytes
+ */
+function generateUUID() {
+    const bytes = randomBytes(16);
+    // Set version (4) and variant bits
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/**
+ * FocusExecutionService - Session management and step execution for focus modes
+ */
+export class FocusExecutionService {
+    constructor(toolExecutionService) {
+        this.sessions = new Map();
+        this.cleanupInterval = null;
+        this.toolExecutionService = toolExecutionService || new ToolExecutionService({ verbose: false });
+        // Start cleanup interval
+        this.startCleanupInterval();
+    }
+    /**
+     * Start a new focus session and execute the first step
+     */
+    async startFocusSession(params) {
+        const { query, mode, domain, rounds = 5, models = [], temperature = 0.7, maxTokensPerRound = 2000, pingPongStyle = "collaborative", tokenEfficient = false, saveSession = true, } = params;
+        // Create the focus plan
+        const plan = createFocusDeepPlan(query, domain);
+        // Create session
+        const sessionId = generateUUID();
+        const session = {
+            sessionId,
+            mode,
+            query,
+            domain,
+            currentStepIndex: 0,
+            totalSteps: plan.steps.length,
+            plan,
+            stepOutputs: new Map(),
+            status: "running",
+            config: {
+                rounds,
+                models: models.length > 0 ? models : plan.availableModels,
+                temperature,
+                maxTokensPerRound,
+                pingPongStyle,
+                tokenEfficient,
+                saveSession,
+            },
+            createdAt: new Date(),
+            lastActivityAt: new Date(),
+        };
+        this.sessions.set(sessionId, session);
+        // Execute first step
+        return this.executeNextStep(session);
+    }
+    /**
+     * Continue an existing focus session
+     */
+    async continueFocus(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return {
+                sessionId,
+                status: "failed",
+                progress: 0,
+                output: `Error: Session not found. Session ID: ${sessionId}`,
+                hasMoreSteps: false,
+                totalSteps: 0,
+                currentStep: 0,
+            };
+        }
+        // Check timeout
+        if (this.isSessionTimedOut(session)) {
+            session.status = "failed";
+            session.error = "Session timed out after 30 minutes of inactivity";
+            return {
+                sessionId,
+                status: "failed",
+                progress: this.calculateProgress(session),
+                output: `Error: ${session.error}`,
+                hasMoreSteps: false,
+                totalSteps: session.totalSteps,
+                currentStep: session.currentStepIndex,
+            };
+        }
+        if (session.status === "completed") {
+            return this.buildCompletedResult(session);
+        }
+        if (session.status === "failed") {
+            return {
+                sessionId,
+                status: "failed",
+                progress: this.calculateProgress(session),
+                output: `Error: Session failed - ${session.error}`,
+                hasMoreSteps: false,
+                totalSteps: session.totalSteps,
+                currentStep: session.currentStepIndex,
+            };
+        }
+        // Execute next step
+        return this.executeNextStep(session);
+    }
+    /**
+     * Get session status without executing
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Execute the next step in the session
+     */
+    async executeNextStep(session) {
+        const stepIndex = session.currentStepIndex;
+        const step = session.plan.steps[stepIndex];
+        if (!step) {
+            // No more steps - session complete
+            session.status = "completed";
+            return this.buildCompletedResult(session);
+        }
+        const startTime = Date.now();
+        try {
+            // Build context from previous steps
+            const context = this.buildStepContext(session, stepIndex);
+            // Build the prompt for this step
+            const prompt = this.buildStepPrompt(session, step, context);
+            // Execute the step using ToolExecutionService
+            const output = await this.toolExecutionService.executeRealTool(step.model, prompt, ReasoningMode.DEEP_REASONING);
+            const duration = Date.now() - startTime;
+            // Store step output
+            const stepOutput = {
+                stepIndex,
+                model: step.model,
+                action: step.action,
+                output,
+                duration,
+                timestamp: new Date(),
+            };
+            session.stepOutputs.set(stepIndex, stepOutput);
+            // Move to next step
+            session.currentStepIndex++;
+            session.lastActivityAt = new Date();
+            // Check if we're done
+            if (session.currentStepIndex >= session.totalSteps) {
+                session.status = "completed";
+                return this.buildCompletedResult(session);
+            }
+            // Return progress result
+            return {
+                sessionId: session.sessionId,
+                status: "running",
+                progress: this.calculateProgress(session),
+                stepOutput,
+                output: this.formatStepOutput(stepOutput, session),
+                hasMoreSteps: true,
+                totalSteps: session.totalSteps,
+                currentStep: session.currentStepIndex,
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const duration = Date.now() - startTime;
+            // Store error output
+            const stepOutput = {
+                stepIndex,
+                model: step.model,
+                action: step.action,
+                output: "",
+                duration,
+                timestamp: new Date(),
+                error: errorMsg,
+            };
+            session.stepOutputs.set(stepIndex, stepOutput);
+            session.status = "failed";
+            session.error = `Step ${stepIndex + 1} failed: ${errorMsg}`;
+            return {
+                sessionId: session.sessionId,
+                status: "failed",
+                progress: this.calculateProgress(session),
+                stepOutput,
+                output: `Error executing step ${stepIndex + 1} (${step.model}:${step.action}): ${errorMsg}`,
+                hasMoreSteps: false,
+                totalSteps: session.totalSteps,
+                currentStep: session.currentStepIndex,
+            };
+        }
+    }
+    /**
+     * Build context from previous step outputs
+     */
+    buildStepContext(session, currentStepIndex) {
+        if (currentStepIndex === 0) {
+            return "";
+        }
+        const previousOutputs = [];
+        for (let i = 0; i < currentStepIndex; i++) {
+            const output = session.stepOutputs.get(i);
+            if (output && !output.error) {
+                const step = session.plan.steps[i];
+                previousOutputs.push(`### Step ${i + 1}: ${step.action} (${step.model})\n${output.output}`);
+            }
+        }
+        return previousOutputs.join("\n\n---\n\n");
+    }
+    /**
+     * Build prompt for a specific step
+     */
+    buildStepPrompt(session, step, previousContext) {
+        let prompt = `## Objective\n${session.query}\n\n`;
+        if (session.domain) {
+            prompt += `## Domain\n${session.domain}\n\n`;
+        }
+        if (previousContext) {
+            prompt += `## Previous Analysis\n${previousContext}\n\n---\n\n`;
+        }
+        prompt += `## Current Task: ${step.action.toUpperCase()}\n`;
+        prompt += `${step.prompt}\n\n`;
+        if (step.reasoning) {
+            prompt += `**Why this step**: ${step.reasoning}\n\n`;
+        }
+        prompt += `Please provide your ${step.action} analysis.`;
+        return prompt;
+    }
+    /**
+     * Format step output for display
+     */
+    formatStepOutput(stepOutput, session) {
+        const step = session.plan.steps[stepOutput.stepIndex];
+        const progress = this.calculateProgress(session);
+        let output = `## Step ${stepOutput.stepIndex + 1}/${session.totalSteps}: ${step.action.toUpperCase()}\n`;
+        output += `**Model**: ${stepOutput.model}\n`;
+        output += `**Duration**: ${stepOutput.duration}ms\n`;
+        output += `**Progress**: ${progress.toFixed(0)}%\n\n`;
+        if (stepOutput.error) {
+            output += `### Error\n${stepOutput.error}\n`;
+        }
+        else {
+            output += `### Output\n${stepOutput.output}\n`;
+        }
+        output += `\n---\n`;
+        output += `Session ID: \`${session.sessionId}\`\n`;
+        output += `Use \`continue_focus\` with this session ID to continue.\n`;
+        return output;
+    }
+    /**
+     * Build completed session result with summary
+     */
+    buildCompletedResult(session) {
+        // Collect all outputs
+        const allOutputs = [];
+        for (let i = 0; i < session.totalSteps; i++) {
+            const output = session.stepOutputs.get(i);
+            if (output) {
+                allOutputs.push(output);
+            }
+        }
+        // Build summary output
+        let output = `# Focus-Deep Session Complete\n\n`;
+        output += `**Objective**: ${session.query}\n`;
+        output += `**Mode**: ${session.mode}\n`;
+        output += `**Steps Completed**: ${allOutputs.length}/${session.totalSteps}\n\n`;
+        // Add each step's output
+        output += `## Step-by-Step Analysis\n\n`;
+        for (const stepOutput of allOutputs) {
+            const step = session.plan.steps[stepOutput.stepIndex];
+            output += `### Step ${stepOutput.stepIndex + 1}: ${step.action.toUpperCase()} (${stepOutput.model})\n`;
+            output += `*Duration: ${stepOutput.duration}ms*\n\n`;
+            if (stepOutput.error) {
+                output += `**Error**: ${stepOutput.error}\n\n`;
+            }
+            else {
+                output += `${stepOutput.output}\n\n`;
+            }
+            output += `---\n\n`;
+        }
+        // Add final synthesis prompt
+        const lastOutput = allOutputs[allOutputs.length - 1];
+        if (lastOutput && !lastOutput.error) {
+            output += `## Final Synthesis\n\n`;
+            output += `The focus-deep analysis has completed. The final step (${session.plan.steps[lastOutput.stepIndex].action}) provides the synthesized conclusion.\n`;
+        }
+        return {
+            sessionId: session.sessionId,
+            status: "completed",
+            progress: 100,
+            output,
+            hasMoreSteps: false,
+            totalSteps: session.totalSteps,
+            currentStep: session.totalSteps,
+            allOutputs,
+        };
+    }
+    /**
+     * Calculate session progress percentage
+     */
+    calculateProgress(session) {
+        if (session.totalSteps === 0)
+            return 100;
+        return (session.currentStepIndex / session.totalSteps) * 100;
+    }
+    /**
+     * Check if session has timed out
+     */
+    isSessionTimedOut(session) {
+        const now = Date.now();
+        const lastActivity = session.lastActivityAt.getTime();
+        return now - lastActivity > SESSION_TIMEOUT_MS;
+    }
+    /**
+     * Start interval to clean up timed out sessions
+     */
+    startCleanupInterval() {
+        // Clean up every 5 minutes
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupTimedOutSessions();
+        }, 5 * 60 * 1000);
+    }
+    /**
+     * Clean up timed out sessions
+     */
+    cleanupTimedOutSessions() {
+        const now = Date.now();
+        for (const [sessionId, session] of this.sessions) {
+            const lastActivity = session.lastActivityAt.getTime();
+            if (now - lastActivity > SESSION_TIMEOUT_MS) {
+                this.sessions.delete(sessionId);
+                console.error(`[FocusExecutionService] Cleaned up timed out session: ${sessionId}`);
+            }
+        }
+    }
+    /**
+     * Stop the cleanup interval (for testing/shutdown)
+     */
+    stopCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+    /**
+     * Get plan-only visualization (for executeNow: false)
+     */
+    getPlanVisualization(query, domain) {
+        const plan = createFocusDeepPlan(query, domain);
+        return generateFocusDeepVisualization(plan);
+    }
+}
+// Export singleton instance
+export const focusExecutionService = new FocusExecutionService();

package/dist/src/application/services/focus/FocusTool.service.js

@@ -6,29 +6,70 @@
  * Architecture:
  * 1. FocusModeRegistry - For complex extracted modes (FocusDeepMode, TachibotStatusMode)
  * 2. Delegate Map - For simple orchestrator calls
- * 3. Legacy fallback - For modes with complex conditional logic (handled by server.ts)
+ * 3. FocusExecutionService - For executeNow mode (actual model execution)
+ * 4. Legacy fallback - For modes with complex conditional logic (handled by server.ts)
  */
 import { TechnicalDomain } from '../../../reasoning-chain.js';
-import { renderBigText } from '../../../utils/ink-renderer.js';
+import { stripFormatting } from '../../../utils/format-stripper.js';
 export class FocusToolService {
-    constructor(modeRegistry, collaborativeOrchestrator) {
+    constructor(modeRegistry, collaborativeOrchestrator, executionService) {
         this.modeRegistry = modeRegistry;
         this.collaborativeOrchestrator = collaborativeOrchestrator;
         this.name = 'focus';
         this.description = 'Multi-model reasoning with various modes';
+        this.executionService = null;
         this.delegateHandlers = this.createDelegateHandlers();
+        this.executionService = executionService || null;
+    }
+    /**
+     * Set the execution service (for lazy initialization)
+     */
+    setExecutionService(service) {
+        this.executionService = service;
     }
     async execute(params) {
         const modeName = params.mode || 'simple';
-        // BigText header (disabled via TACHIBOT_BIG_HEADERS=false)
-        const header = renderBigText('FOCUS', { font: 'block', gradient: 'cristal' });
+        const executeNow = params.executeNow !== false; // Default to true
+        // BigText header disabled - plain text only
+        const header = '';
+        // 0. For focus-deep mode with executeNow, use the execution service
+        if (modeName === 'focus-deep' && executeNow && this.executionService) {
+            const result = await this.executionService.startFocusSession({
+                query: params.query,
+                mode: modeName,
+                domain: params.domain,
+                context: params.context,
+                rounds: params.rounds,
+                models: params.models,
+                temperature: params.temperature,
+                maxTokensPerRound: params.maxTokensPerRound,
+                pingPongStyle: params.pingPongStyle,
+                tokenEfficient: params.tokenEfficient,
+                saveSession: params.saveSession,
+            });
+            return {
+                output: stripFormatting(header + result.output),
+                metadata: {
+                    mode: modeName,
+                    sessionId: result.sessionId,
+                    status: result.status,
+                    progress: result.progress,
+                    hasMoreSteps: result.hasMoreSteps,
+                    totalSteps: result.totalSteps,
+                    currentStep: result.currentStep,
+                    timestamp: Date.now()
+                }
+            };
+        }
         // 1. Try extracted modes first (Strategy Pattern)
+        // For focus-deep with executeNow: false, this returns the plan visualization
         const mode = this.modeRegistry.get(modeName);
         if (mode) {
-            const result = await mode.execute(params);
+            // Pass executeNow to the mode for conditional behavior
+            const result = await mode.execute({ ...params, executeNow });
             return {
                 ...result,
-                output: header + result.output
+                output: stripFormatting(header + result.output)
             };
         }
         // 2. Try delegate handlers (simple orchestrator calls)
@@ -36,7 +77,7 @@ export class FocusToolService {
         if (handler) {
             const output = await handler(params);
             return {
-                output: header + output,
+                output: stripFormatting(header + output),
                 metadata: {
                     mode: modeName,
                     timestamp: Date.now()
@@ -71,22 +112,20 @@ export class FocusToolService {
             const query = params.query;
             const domain = parseDomain(params.domain);
             const plan = await this.collaborativeOrchestrator.startDeepReasoning(query, domain);
-            const title = "🧠 **DEEP COLLABORATIVE REASONING**";
-            return `${title}\n\n${plan}\n\n🔄 **How it works**: Models collaborate, critique, and build upon each other's ideas to find optimal solutions.`;
+            return `🧠 DEEP COLLABORATIVE REASONING\n${'═'.repeat(40)}\n\n${plan}\n\n🔄 How it works: Models collaborate, critique, and build upon each other's ideas to find optimal solutions.`;
         });
         handlers.set('code-brainstorm', async (params) => {
             const query = params.query;
             const domain = parseDomain(params.domain);
             const plan = await this.collaborativeOrchestrator.startDeepReasoning(query, domain);
-            const title = "💡 **CODE BRAINSTORMING SESSION**";
-            return `${title}\n\n${plan}\n\n🔄 **How it works**: Models collaborate, critique, and build upon each other's ideas to find optimal solutions.`;
+            return `💡 CODE BRAINSTORMING SESSION\n${'═'.repeat(40)}\n\n${plan}\n\n🔄 How it works: Models collaborate, critique, and build upon each other's ideas to find optimal solutions.`;
         });
         // Dynamic debate
         handlers.set('dynamic-debate', async (params) => {
             const query = params.query;
             const domain = parseDomain(params.domain);
             const plan = await this.collaborativeOrchestrator.startDynamicDebate(query, domain);
-            return `⚔️ **DYNAMIC DEBATE SESSION**\n\n${plan}\n\n🥊 **How it works**: Models take opposing positions, argue their cases, provide rebuttals, and engage in intellectual combat to explore all angles of complex problems.`;
+            return `⚔️ DYNAMIC DEBATE SESSION\n${'═'.repeat(40)}\n\n${plan}\n\n🥊 How it works: Models take opposing positions, argue their cases, provide rebuttals, and engage in intellectual combat to explore all angles of complex problems.`;
         });
         // Template-based modes
         const templateModes = [

package/dist/src/application/services/focus/modes/focus-deep.mode.js

@@ -2,17 +2,42 @@
  * FocusDeep Mode - Ultimate reasoning combining Sequential Thinking + Multi-Model
  * Extracted from server.ts (Phase 2: SOLID refactoring)
  * Wraps existing focus-deep.ts functionality
+ *
+ * Supports two modes:
+ * - executeNow: false - Returns plan visualization (current behavior)
+ * - executeNow: true - Actual execution handled by FocusExecutionService in FocusTool.service.ts
  */
 import { createFocusDeepPlan, generateFocusDeepVisualization } from '../../../../focus-deep.js';
 export class FocusDeepMode {
     constructor() {
         this.modeName = 'focus-deep';
         this.description = 'Ultimate reasoning combining Sequential Thinking + Multi-Model orchestration';
+        this.supportsExecution = true;
     }
     async execute(params) {
         const query = params.query;
         const domain = params.domain;
+        const executeNow = params.executeNow;
+        // Create the plan (needed for both visualization and execution metadata)
         const plan = createFocusDeepPlan(query, domain);
+        // If executeNow is explicitly false, return plan visualization only
+        // (executeNow: true is handled by FocusExecutionService in FocusTool.service.ts)
+        if (executeNow === false) {
+            const viz = generateFocusDeepVisualization(plan);
+            return {
+                output: viz,
+                metadata: {
+                    mode: this.modeName,
+                    sessionId: plan.sessionId,
+                    models: plan.availableModels,
+                    estimatedThoughts: plan.estimatedThoughts,
+                    executeNow: false
+                }
+            };
+        }
+        // Default: return plan visualization
+        // Note: When executeNow is true and FocusExecutionService is available,
+        // the request is intercepted by FocusTool.service.ts before reaching here
         const viz = generateFocusDeepVisualization(plan);
         return {
             output: viz,

package/dist/src/application/services/focus/types/FocusSession.js

@@ -0,0 +1,8 @@
+/**
+ * FocusSession Types - Type definitions for Focus execution sessions
+ * Supports step-by-step execution of focus plans with session management
+ */
+/**
+ * Session timeout configuration
+ */
+export const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes

package/dist/src/config/model-constants.js

@@ -125,6 +125,7 @@ export const CURRENT_MODELS = {
         brainstorm: OPENAI_MODELS.DEFAULT, // Creative ideation (gpt-5.2 + effort=medium)
         code: OPENAI_MODELS.DEFAULT, // Code tasks (gpt-5.2 + effort=medium)
         explain: OPENAI_MODELS.DEFAULT, // Explanations (gpt-5.2 + effort=low)
+        search: OPENAI_MODELS.DEFAULT, // Web search (gpt-5.2 + web_search tool)
         // Premium option for opt-in (use sparingly - 12x more expensive)
         premium: OPENAI_MODELS.PRO, // Expert mode (gpt-5.2-pro - 88.4% GPQA, $21/$168)
     },
@@ -175,6 +176,12 @@ export const TOOL_DEFAULTS = {
         maxTokens: 1500,
         temperature: 0.7,
     },
+    openai_search: {
+        model: CURRENT_MODELS.openai.search,
+        reasoning_effort: OPENAI_REASONING.LOW,
+        maxTokens: 6000,
+        temperature: 0.3,
+    },
     // Gemini tools
     gemini_brainstorm: {
         model: CURRENT_MODELS.gemini.default,

package/dist/src/focus-deep.js

@@ -243,3 +243,37 @@ export function canRunFocusDeep() {
         quality
     };
 }
+/**
+ * Execute a Focus-Deep step with actual tool execution
+ * Uses ToolExecutionService for model calls
+ */
+export async function executeFocusDeepStepWithTools(step, context, toolService) {
+    const startTime = Date.now();
+    // Build the full prompt with context
+    let fullPrompt = context;
+    if (step.reasoning) {
+        fullPrompt += `\n\n**Why this step**: ${step.reasoning}`;
+    }
+    fullPrompt += `\n\n**Task**: ${step.prompt}`;
+    try {
+        // Execute using the tool service
+        // Import ReasoningMode dynamically to avoid circular dependency
+        const { ReasoningMode } = await import("./reasoning-chain.js");
+        const output = await toolService.executeRealTool(step.model, fullPrompt, ReasoningMode.DEEP_REASONING);
+        const duration = Date.now() - startTime;
+        return {
+            output,
+            model: step.model,
+            duration
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+            output: `[Error executing ${step.model}: ${errorMsg}]`,
+            model: step.model,
+            duration
+        };
+    }
+}

package/dist/src/modes/challenger.js

@@ -21,7 +21,46 @@ import { createProgressStream } from '../utils/progress-stream.js';
 import { smartAPIClient } from '../utils/smart-api-client.js';
 import { getSmartTimeout } from '../config/timeout-config.js';
 import { execSync } from 'child_process';
-import { renderTable, renderKeyValueTable, renderGradientBorderBox, renderGradientDivider, brailleBar, icons, } from '../utils/ink-renderer.js';
+// import {
+//   renderTable,
+//   renderKeyValueTable,
+//   renderGradientBorderBox,
+//   renderGradientDivider,
+//   brailleBar,
+//   icons,
+// } from '../utils/ink-renderer.js';
+// Ink disabled - using plain text functions
+const renderTable = (data) => {
+    if (data.length === 0)
+        return '';
+    const keys = Object.keys(data[0]);
+    const header = '| ' + keys.join(' | ') + ' |';
+    const separator = '|' + keys.map(() => '---').join('|') + '|';
+    const rows = data.map(row => '| ' + keys.map(k => row[k] || '').join(' | ') + ' |');
+    return [header, separator, ...rows].join('\n');
+};
+const renderKeyValueTable = (data) => {
+    return Object.entries(data).map(([k, v]) => `${k}: ${v}`).join('\n');
+};
+const renderGradientBorderBox = (content, _opts) => {
+    return `--- ${content} ---`;
+};
+const renderGradientDivider = (width = 50, _preset) => '-'.repeat(width);
+const brailleBar = (value, max, width = 20) => {
+    const filled = Math.round((value / max) * width);
+    return '[' + '#'.repeat(filled) + '-'.repeat(width - filled) + ']';
+};
+const icons = {
+    search: '?',
+    brain: '*',
+    check: '+',
+    alertCircle: '!',
+    file: '#',
+    folder: '#',
+    bot: '@',
+    sparkle: '*',
+    chartBar: '|',
+};
 // ============================================
 // CONSTANTS
 // ============================================

package/dist/src/modes/scout.js

@@ -5,7 +5,29 @@ import { createProgressStream } from '../utils/progress-stream.js';
 import { providerRouter } from '../utils/provider-router.js';
 import { getSmartTimeout } from '../config/timeout-config.js';
 import { execSync } from 'child_process';
-import { renderKeyValueTable, renderGradientBorderBox, renderGradientDivider, icons, } from '../utils/ink-renderer.js';
+// import {
+//   renderKeyValueTable,
+//   renderGradientBorderBox,
+//   renderGradientDivider,
+//   icons,
+// } from '../utils/ink-renderer.js';
+// Ink disabled - using plain text functions
+const renderKeyValueTable = (data) => {
+    return Object.entries(data)
+        .filter(([_, v]) => v !== undefined)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join('\n');
+};
+const renderGradientBorderBox = (content, _opts) => {
+    return `--- ${content} ---`;
+};
+const renderGradientDivider = (width = 50, _preset) => '-'.repeat(width);
+const icons = {
+    search: '?',
+    brain: '*',
+    info: 'i',
+    check: '+',
+};
 // Provider name constants
 const PROVIDER_PERPLEXITY = 'perplexity';
 const PROVIDER_GROK = 'grok';