@ebowwa/coder 0.7.63 → 0.7.65

package/dist/interfaces/ui/terminal/shared/loading-state.js

@@ -0,0 +1,246 @@
+/**
+ * Loading State Manager for Coder CLI
+ * Tracks global loading state across the application
+ */
+import { EventEmitter } from "events";
+// ============================================
+// LOADING STATE CLASS
+// ============================================
+export class LoadingState extends EventEmitter {
+    state;
+    static instance = null;
+    constructor() {
+        super();
+        this.state = {
+            isLoading: false,
+            phase: "idle",
+            message: "",
+            startTime: 0,
+            activeTools: new Set(),
+            activeToolCount: 0,
+            hasActiveTools: false,
+            responseLength: 0,
+            paused: false,
+            pausedTime: 0,
+        };
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!LoadingState.instance) {
+            LoadingState.instance = new LoadingState();
+        }
+        return LoadingState.instance;
+    }
+    /**
+     * Reset singleton (for testing)
+     */
+    static reset() {
+        if (LoadingState.instance) {
+            LoadingState.instance.removeAllListeners();
+            LoadingState.instance = null;
+        }
+    }
+    /**
+     * Start loading
+     */
+    start(phase = "processing", message = "") {
+        const previousPhase = this.state.phase;
+        this.state.isLoading = true;
+        this.state.phase = phase;
+        this.state.message = message;
+        this.state.startTime = Date.now();
+        this.emit("state-change", this.getState());
+        if (previousPhase !== phase) {
+            this.emit("phase-change", phase, previousPhase);
+        }
+    }
+    /**
+     * Stop loading
+     */
+    stop() {
+        const previousPhase = this.state.phase;
+        this.state.isLoading = false;
+        this.state.phase = "idle";
+        this.state.message = "";
+        this.state.activeTools.clear();
+        this.state.activeToolCount = 0;
+        this.state.responseLength = 0;
+        this.emit("state-change", this.getState());
+        this.emit("phase-change", "idle", previousPhase);
+    }
+    /**
+     * Update phase
+     */
+    setPhase(phase) {
+        const previousPhase = this.state.phase;
+        this.state.phase = phase;
+        this.emit("phase-change", phase, previousPhase);
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Update message
+     */
+    setMessage(message) {
+        this.state.message = message;
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Update both phase and message
+     */
+    update(phase, message) {
+        const previousPhase = this.state.phase;
+        this.state.phase = phase;
+        this.state.message = message;
+        this.emit("phase-change", phase, previousPhase);
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Report progress
+     */
+    progress(message) {
+        this.state.message = message;
+        this.emit("progress", message);
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Mark tool as started
+     */
+    toolStart(toolName) {
+        this.state.activeTools.add(toolName);
+        this.state.activeToolCount = this.state.activeTools.size;
+        this.state.hasActiveTools = true;
+        this.emit("tool-start", toolName);
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Mark tool as completed
+     */
+    toolEnd(toolName) {
+        this.state.activeTools.delete(toolName);
+        this.state.activeToolCount = this.state.activeTools.size;
+        if (this.state.activeTools.size === 0) {
+            this.state.hasActiveTools = false;
+        }
+        this.emit("tool-end", toolName);
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Update response length (for streaming)
+     */
+    setResponseLength(length) {
+        this.state.responseLength = length;
+        this.emit("state-change", this.getState());
+    }
+    /**
+     * Pause loading state
+     */
+    pause() {
+        if (!this.state.paused) {
+            this.state.paused = true;
+            this.state.pausedTime = Date.now();
+            this.emit("state-change", this.getState());
+        }
+    }
+    /**
+     * Resume loading state
+     */
+    resume() {
+        if (this.state.paused) {
+            this.state.paused = false;
+            this.state.pausedTime = 0;
+            this.emit("state-change", this.getState());
+        }
+    }
+    /**
+     * Get current state (copy)
+     */
+    getState() {
+        return {
+            ...this.state,
+            activeTools: new Set(this.state.activeTools),
+        };
+    }
+    /**
+     * Check if loading
+     */
+    isLoading() {
+        return this.state.isLoading;
+    }
+    /**
+     * Get current phase
+     */
+    getPhase() {
+        return this.state.phase;
+    }
+    /**
+     * Get elapsed time in ms
+     */
+    getElapsedMs() {
+        if (this.state.startTime === 0) {
+            return 0;
+        }
+        return Date.now() - this.state.startTime;
+    }
+    /**
+     * Get active tool names
+     */
+    getActiveTools() {
+        return Array.from(this.state.activeTools);
+    }
+    /**
+     * Check if specific tool is active
+     */
+    isToolActive(toolName) {
+        return this.state.activeTools.has(toolName);
+    }
+    /**
+     * Get formatted state for display
+     */
+    getFormattedState() {
+        if (!this.state.isLoading) {
+            return "Ready";
+        }
+        const parts = [];
+        if (this.state.message) {
+            parts.push(this.state.message);
+        }
+        if (this.state.activeToolCount > 0) {
+            parts.push(`(${this.state.activeToolCount} tool${this.state.activeToolCount > 1 ? "s" : ""} active)`);
+        }
+        const elapsed = Math.floor(this.getElapsedMs() / 1000);
+        if (elapsed > 0) {
+            parts.push(`[${elapsed}s]`);
+        }
+        return parts.join(" ") || this.state.phase;
+    }
+}
+// ============================================
+// CONVENIENCE EXPORTS
+// ============================================
+/**
+ * Get the global loading state instance
+ */
+export function getLoadingState() {
+    return LoadingState.getInstance();
+}
+/**
+ * Quick access to loading state methods
+ * These call getInstance() each time to handle reset() properly
+ */
+export const setLoading = (phase, message) => {
+    LoadingState.getInstance().start(phase, message);
+};
+export const stopLoading = () => {
+    LoadingState.getInstance().stop();
+};
+export const updateLoading = (message) => {
+    LoadingState.getInstance().progress(message);
+};
+export const startTool = (toolName) => {
+    LoadingState.getInstance().toolStart(toolName);
+};
+export const endTool = (toolName) => {
+    LoadingState.getInstance().toolEnd(toolName);
+};

package/dist/interfaces/ui/terminal/shared/query.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Single Query Execution
+ * Shared query runner for CLI -q mode
+ */
+import type { ToolDefinition, GitStatus } from "../../../../types/index.js";
+import { HookManager } from "../../../../ecosystem/hooks/index.js";
+import { SessionStore } from "../../../../core/session-store.js";
+import type { CLIArgs } from "./args.js";
+export interface QueryOptions {
+    apiKey: string;
+    args: CLIArgs;
+    systemPrompt: string;
+    tools: ToolDefinition[];
+    query: string;
+    sessionStore: SessionStore;
+    sessionId: string;
+    hookManager: HookManager;
+    workingDirectory: string;
+    gitStatus?: GitStatus | null;
+}
+export declare function runSingleQuery(options: QueryOptions): Promise<void>;
+//# sourceMappingURL=query.d.ts.map

package/dist/interfaces/ui/terminal/shared/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../../packages/src/interfaces/ui/terminal/shared/query.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAW,cAAc,EAA0B,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE7G,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAOjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC9B;AAMD,wBAAsB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA2GzE"}

package/dist/interfaces/ui/terminal/shared/query.js

@@ -0,0 +1,100 @@
+/**
+ * Single Query Execution
+ * Shared query runner for CLI -q mode
+ */
+import { agentLoop, formatCost, formatCostBrief } from "../../../../core/agent-loop.js";
+import { HookManager } from "../../../../ecosystem/hooks/index.js";
+import { SessionStore } from "../../../../core/session-store.js";
+import { createStreamHighlighter } from "../../../../core/stream-highlighter.js";
+import { renderStatusLine, getContextWindow, } from "./status-line.js";
+// ============================================
+// SINGLE QUERY RUNNER
+// ============================================
+export async function runSingleQuery(options) {
+    const { apiKey, args, systemPrompt, tools, query, sessionStore, sessionId, hookManager, workingDirectory, gitStatus, } = options;
+    // Show initial status line
+    const initialStatusOptions = {
+        permissionMode: args.permissionMode,
+        tokensUsed: 0,
+        maxTokens: getContextWindow(args.model),
+        model: args.model,
+        isLoading: true,
+    };
+    console.log(`\x1b[90m${renderStatusLine(initialStatusOptions)}\x1b[0m\n`);
+    // Track tokens for final status
+    let totalTokens = 0;
+    const messages = [
+        {
+            role: "user",
+            content: [{ type: "text", text: query }],
+        },
+    ];
+    // Save user message to session
+    await sessionStore.saveMessage(messages[0]);
+    // Create stream highlighter for code blocks
+    const highlighter = createStreamHighlighter();
+    // Build extended thinking config
+    const extendedThinkingConfig = args.extendedThinking
+        ? {
+            enabled: true,
+            effort: args.effort ?? "medium",
+            interleaved: args.interleaved ?? true,
+        }
+        : undefined;
+    try {
+        const result = await agentLoop(messages, {
+            apiKey,
+            model: args.model,
+            maxTokens: args.maxTokens,
+            systemPrompt,
+            tools,
+            permissionMode: args.permissionMode,
+            workingDirectory,
+            gitStatus: gitStatus ?? undefined,
+            extendedThinking: extendedThinkingConfig,
+            hookManager,
+            sessionId,
+            onText: (text) => {
+                const highlighted = highlighter.process(text);
+                if (highlighted) {
+                    process.stdout.write(highlighted);
+                }
+            },
+            onThinking: (thinking) => {
+                process.stdout.write(`\x1b[90m${thinking}\x1b[0m`);
+            },
+            onMetrics: async (metrics) => {
+                // Track tokens for final status
+                totalTokens = metrics.usage.input_tokens + metrics.usage.output_tokens;
+                console.log(`\n\x1b[90m${formatCostBrief(metrics)}\x1b[0m`);
+                await sessionStore.saveMetrics(metrics);
+            },
+        });
+        // Flush any remaining highlighted content
+        const remaining = highlighter.flush();
+        if (remaining) {
+            process.stdout.write(remaining);
+        }
+        // Save assistant message to session
+        const lastMessage = result.messages[result.messages.length - 1];
+        if (lastMessage && lastMessage.role === "assistant") {
+            await sessionStore.saveMessage(lastMessage);
+        }
+        // Show final status line
+        const finalStatusOptions = {
+            permissionMode: args.permissionMode,
+            tokensUsed: totalTokens,
+            maxTokens: getContextWindow(args.model),
+            model: args.model,
+            isLoading: false,
+        };
+        console.log(`\n\x1b[90m${renderStatusLine(finalStatusOptions)}\x1b[0m`);
+        console.log(`\x1b[90mSession: ${sessionId}\x1b[0m`);
+        console.log(`\x1b[90mTotal cost: ${formatCost(result.totalCost)}\x1b[0m`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${errorMessage}`);
+        process.exit(1);
+    }
+}

package/dist/interfaces/ui/terminal/shared/setup.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Session Setup
+ * Shared initialization logic for CLI and TUI modes
+ */
+import type { MCPServerConfig, ToolDefinition, PermissionMode } from "../../../../types/index.js";
+import { MCPClientImpl } from "../../../mcp/client.js";
+import { HookManager } from "../../../../ecosystem/hooks/index.js";
+import { SkillManager } from "../../../../ecosystem/skills/index.js";
+import { TeammateManager } from "../../../../teammates/index.js";
+import { type LoadedConfig, type SettingsConfig } from "../../../../core/config-loader.js";
+import type { CLIArgs } from "./args.js";
+export interface SessionSetup {
+    loadedConfig: LoadedConfig;
+    mergedSettings: SettingsConfig;
+    hookManager: HookManager;
+    skillManager: SkillManager;
+    teammateManager: TeammateManager;
+    mcpClients: Map<string, MCPClientImpl>;
+    tools: ToolDefinition[];
+    permissionMode: PermissionMode;
+    allowedTools: Set<string>;
+    disallowedTools: Set<string>;
+}
+export interface SetupOptions {
+    args: CLIArgs;
+    apiKey: string;
+    workingDirectory: string;
+    onProgress?: (message: string) => void;
+}
+export declare function loadMCPConfig(configPath: string): Promise<Record<string, MCPServerConfig>>;
+export declare function mcpToolsToToolDefinitions(mcpClients: Map<string, MCPClientImpl>): ToolDefinition[];
+export declare function setupSession(options: SetupOptions): Promise<SessionSetup>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/interfaces/ui/terminal/shared/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../packages/src/interfaces/ui/terminal/shared/setup.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAClG,OAAO,EAAE,aAAa,EAAoB,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAQL,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,eAAe,EAAE,eAAe,CAAC;IACjC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAMD,wBAAsB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CA0BhG;AAMD,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,cAAc,EAAE,CAuBlG;AAMD,wBAAsB,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAoL/E"}

package/dist/interfaces/ui/terminal/shared/setup.js

@@ -0,0 +1,226 @@
+/**
+ * Session Setup
+ * Shared initialization logic for CLI and TUI modes
+ */
+import { MCPClientImpl, createMCPClients } from "../../../mcp/client.js";
+import { HookManager } from "../../../../ecosystem/hooks/index.js";
+import { createPromptEvaluator } from "../../../../ecosystem/hooks/prompt-evaluator.js";
+import { SkillManager } from "../../../../ecosystem/skills/index.js";
+import { TeammateManager } from "../../../../teammates/index.js";
+import { loadAllConfigs, getMergedSettings, getPermissionMode, getAllowedTools, getDisallowedTools, getAllMCPServers, settingsToHookDefinitions, } from "../../../../core/config-loader.js";
+import { createSecurityHookHandlers } from "../../../../core/cognitive-security/hooks.js";
+// ============================================
+// MCP CONFIG LOADER
+// ============================================
+export async function loadMCPConfig(configPath) {
+    try {
+        const file = Bun.file(configPath);
+        const content = await file.text();
+        const config = JSON.parse(content);
+        // Support both formats:
+        // 1. { "servers": { "name": {...} } }
+        // 2. { "name": {...} } (direct server config)
+        if ("servers" in config && typeof config.servers === "object" && config.servers !== null) {
+            return config.servers;
+        }
+        // Check if it looks like direct server config (has "type" at top level)
+        if ("type" in config) {
+            // Single server config without "servers" wrapper
+            const servers = {};
+            servers["default"] = config;
+            return servers;
+        }
+        return config;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load MCP config from ${configPath}: ${errorMessage}`);
+    }
+}
+// ============================================
+// MCP TOOLS CONVERTER
+// ============================================
+export function mcpToolsToToolDefinitions(mcpClients) {
+    const tools = [];
+    for (const [serverName, client] of mcpClients) {
+        for (const mcpTool of client.tools) {
+            tools.push({
+                name: `mcp__${serverName}__${mcpTool.name}`,
+                description: mcpTool.description,
+                input_schema: mcpTool.inputSchema,
+                handler: async (args, context) => {
+                    if (!client.connected) {
+                        return {
+                            content: `Error: MCP server "${serverName}" is not connected`,
+                            is_error: true,
+                        };
+                    }
+                    return client.callTool(mcpTool.name, args);
+                },
+            });
+        }
+    }
+    return tools;
+}
+// ============================================
+// SESSION SETUP
+// ============================================
+export async function setupSession(options) {
+    const { args, apiKey, workingDirectory, onProgress } = options;
+    const log = (msg) => {
+        if (onProgress)
+            onProgress(msg);
+        else
+            console.log(`\x1b[90m${msg}\x1b[0m`);
+    };
+    // ============================================
+    // LOAD CONFIGURATION
+    // ============================================
+    log("Loading configuration...");
+    let loadedConfig;
+    try {
+        loadedConfig = await loadAllConfigs(workingDirectory);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log(`Warning: Failed to load config: ${errorMessage}`);
+        // Use empty defaults
+        loadedConfig = {
+            main: {},
+            settings: {},
+            keybindings: { bindings: [] },
+            projectSettings: {},
+            sources: [],
+        };
+    }
+    // Get merged settings (project overrides global)
+    const mergedSettings = getMergedSettings(loadedConfig.settings, loadedConfig.projectSettings);
+    // Log loaded config sources
+    if (loadedConfig.sources.length > 0) {
+        log(`  Config sources: ${loadedConfig.sources.length} files`);
+    }
+    // Determine permission mode
+    let permissionMode = args.permissionMode;
+    if (permissionMode === "default") {
+        const configMode = getPermissionMode(mergedSettings);
+        if (configMode !== "default") {
+            permissionMode = configMode;
+            log(`  Permission mode: ${configMode} (from config)`);
+        }
+    }
+    // Get allowed/disallowed tools from config
+    const allowedTools = getAllowedTools(mergedSettings);
+    const disallowedTools = getDisallowedTools(mergedSettings);
+    // ============================================
+    // INITIALIZE MANAGERS
+    // ============================================
+    // Create prompt evaluator for LLM-based hooks
+    const promptEvaluator = createPromptEvaluator({
+        apiKey,
+        model: "claude-haiku-4-5", // Fast model for hook evaluation
+        maxTokens: 256,
+    });
+    // Initialize components
+    const hookManager = new HookManager(60000, promptEvaluator);
+    const skillManager = new SkillManager();
+    const teammateManager = new TeammateManager();
+    // ============================================
+    // REGISTER HOOKS
+    // ============================================
+    // Register hooks from config
+    const hookDefinitions = settingsToHookDefinitions(mergedSettings);
+    for (const [event, definitions] of Object.entries(hookDefinitions)) {
+        for (const def of definitions) {
+            hookManager.register(event, def);
+        }
+    }
+    if (Object.keys(hookDefinitions).length > 0) {
+        log(`  Hooks registered: ${Object.keys(hookDefinitions).length} events`);
+    }
+    // Register cognitive security hooks (in-process handlers)
+    // When bypassPermissions is set, disable all security checks
+    const isBypassMode = permissionMode === "bypassPermissions";
+    const securityHandlers = createSecurityHookHandlers({
+        enabled: !isBypassMode, // Disable entirely in bypass mode
+        checkIntentAlignment: !isBypassMode,
+        enforceFlowPolicies: !isBypassMode,
+        preventLeaks: !isBypassMode,
+        trackTaints: !isBypassMode,
+        logEvents: true, // Always log for audit trail
+        blockOnViolation: false, // Never block - log only
+        minAlignmentScore: 0.3,
+        approvalRequiredSensitivities: ["secret", "top_secret"],
+    });
+    hookManager.registerHandler("SessionStart", securityHandlers.SessionStart);
+    hookManager.registerHandler("PreToolUse", securityHandlers.PreToolUse);
+    hookManager.registerHandler("PostToolUse", securityHandlers.PostToolUse);
+    hookManager.registerHandler("UserPromptSubmit", securityHandlers.UserPromptSubmit);
+    hookManager.registerHandler("SessionEnd", securityHandlers.SessionEnd);
+    // Load skills from project
+    const skillsDir = workingDirectory + "/.claude/skills";
+    skillManager.loadFromDirectory(skillsDir, "project");
+    // ============================================
+    // MCP SETUP
+    // ============================================
+    const mcpClients = new Map();
+    // Get MCP servers from loaded config
+    const configServers = getAllMCPServers(loadedConfig.main, workingDirectory);
+    // If --mcp-config is specified, it overrides config file servers
+    let servers = configServers;
+    if (args.mcpConfig) {
+        try {
+            log(`Loading MCP config from ${args.mcpConfig}...`);
+            const fileServers = await loadMCPConfig(args.mcpConfig);
+            servers = fileServers;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log(`Warning: Failed to load MCP config file: ${errorMessage}`);
+        }
+    }
+    // Connect to MCP servers
+    if (Object.keys(servers).length > 0) {
+        // Only count enabled servers
+        const enabledServers = Object.entries(servers).filter(([_, config]) => !config.disabled);
+        const serverCount = enabledServers.length;
+        if (serverCount > 0) {
+            log(`  Connecting to ${serverCount} MCP server(s)...`);
+            const connectedClients = await createMCPClients(servers, (message) => {
+                log(`    ${message}`);
+            });
+            for (const [name, client] of connectedClients) {
+                mcpClients.set(name, client);
+            }
+            if (mcpClients.size > 0) {
+                log(`  Connected to ${mcpClients.size} MCP server(s)`);
+            }
+            else {
+                log(`  Warning: No MCP servers connected successfully`);
+            }
+        }
+        else if (Object.keys(servers).length > 0) {
+            log(`  MCP config loaded but all ${Object.keys(servers).length} server(s) are disabled`);
+        }
+    }
+    // ============================================
+    // BUILD TOOLS
+    // ============================================
+    // Import built-in tools dynamically to avoid circular deps
+    const { builtInTools } = await import("../../../../ecosystem/tools/index.js");
+    const tools = [
+        ...builtInTools,
+        ...mcpToolsToToolDefinitions(mcpClients),
+    ];
+    return {
+        loadedConfig,
+        mergedSettings,
+        hookManager,
+        skillManager,
+        teammateManager,
+        mcpClients,
+        tools,
+        permissionMode,
+        allowedTools,
+        disallowedTools,
+    };
+}