@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/hooks/use-input-handler.js

@@ -7,6 +7,7 @@ import { ConfirmationService } from "../utils/confirmation-service.js";
 import { useEnhancedInput } from "./use-enhanced-input.js";
 import { getErrorMessage } from "../types/index.js";
 import { filterCommandSuggestions } from "../ui/components/CommandSuggestions.js";
+import { isModelCompatibleWithProvider } from "../providers/model-provider-compat.js";
 import { loadModelConfig } from "../utils/model-config.js";
 // Import enhanced features
 import { getSlashCommandManager } from "../commands/slash-commands.js";
@@ -18,11 +19,13 @@ import { extractFileReference, getFileSuggestions } from "../ui/components/FileA
 import { getInteractionLogger } from "../logging/interaction-logger.js";
 import { maybeContinueGoalAfterTurn } from "../goals/goal-loop.js";
 import { logger } from '../utils/logger.js';
+import { takeFirstUseHint } from "../utils/first-use-hints.js";
 // Import history manager for persistent command history
 import { getHistoryManager } from "../utils/history-manager.js";
 export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProcessing, setIsStreaming, setTokenCount, setProcessingTime, setCurrentActivity, processingStartTime, isProcessing, isStreaming, isConfirmationActive = false, appendStreamingContent, finalizeStreamingEntry, updateToolCallEntry, }) {
     const [showCommandSuggestions, setShowCommandSuggestions] = useState(false);
     const [selectedCommandIndex, setSelectedCommandIndex] = useState(0);
+    const commandSelectionMoved = useRef(false);
     const [showModelSelection, setShowModelSelection] = useState(false);
     const [selectedModelIndex, setSelectedModelIndex] = useState(0);
     const [showFileAutocomplete, setShowFileAutocomplete] = useState(false);
@@ -33,6 +36,22 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         const sessionFlags = confirmationService.getSessionFlags();
         return sessionFlags.allOperations;
     });
+    const runningTurn = useRef(false);
+    const pendingMessages = useRef([]);
+    const [queuedMessageCount, setQueuedMessageCount] = useState(0);
+    useEffect(() => {
+        if (isProcessing || isStreaming || runningTurn.current)
+            return;
+        const next = pendingMessages.current.shift();
+        if (next !== undefined) {
+            setQueuedMessageCount(pendingMessages.current.length);
+            // No turn is streaming here, so a tip entry cannot split a streaming message.
+            const tip = takeFirstUseHint('message_queued');
+            if (tip)
+                setChatHistory((prev) => [...prev, { type: "assistant", content: `💡 ${tip}`, timestamp: new Date() }]);
+            void processUserMessage(next);
+        }
+    }, [isProcessing, isStreaming, queuedMessageCount]);
     // Track last escape time for double-escape detection
     const lastEscapeTimeRef = useRef(0);
     const DOUBLE_ESCAPE_THRESHOLD = 500; // ms
@@ -115,6 +134,15 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         return false; // Let default escape handling work
     };
     const handleCommandSuggestionsNav = (key) => {
+        const commandName = input.trim().split(/\s+/)[0]?.slice(1);
+        // Enter runs an explicitly typed command; Tab is completion only.
+        if (key.return && !commandSelectionMoved.current && commandName &&
+            (getSlashCommandManager().getCommand(commandName) || commandName === 'models')) {
+            setShowCommandSuggestions(false);
+            setSelectedCommandIndex(0);
+            void handleInputSubmit(input);
+            return true;
+        }
         const filteredSuggestions = filterCommandSuggestions(commandSuggestions, input);
         if (filteredSuggestions.length === 0) {
             setShowCommandSuggestions(false);
@@ -123,14 +151,16 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         }
         else {
             if (key.upArrow) {
+                commandSelectionMoved.current = true;
                 setSelectedCommandIndex((prev) => prev === 0 ? filteredSuggestions.length - 1 : prev - 1);
                 return true;
             }
             if (key.downArrow) {
+                commandSelectionMoved.current = true;
                 setSelectedCommandIndex((prev) => (prev + 1) % filteredSuggestions.length);
                 return true;
             }
-            if (key.tab || key.return) {
+            if (key.tab || key.return || (key.rightArrow && !key.ctrl && !key.meta && !key.shift && cursorPosition === input.length)) {
                 const safeIndex = Math.min(selectedCommandIndex, filteredSuggestions.length - 1);
                 const selectedSuggestion = filteredSuggestions[safeIndex];
                 let newInput;
@@ -151,7 +181,14 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
                 }
                 else {
                     // For commands, just use the command
-                    newInput = selectedSuggestion.command + " ";
+                    newInput = selectedSuggestion.command;
+                    if (key.return) {
+                        setShowCommandSuggestions(false);
+                        setSelectedCommandIndex(0);
+                        void handleInputSubmit(newInput);
+                        return true;
+                    }
+                    newInput += ' ';
                 }
                 setInput(newInput);
                 setCursorPosition(newInput.length);
@@ -163,6 +200,13 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         return false;
     };
     const handleModelSelectionNav = (key) => {
+        if (key.leftArrow || key.escape) {
+            setShowModelSelection(false);
+            setSelectedModelIndex(0);
+            return true;
+        }
+        if (availableModels.length === 0)
+            return true;
         if (key.upArrow) {
             setSelectedModelIndex((prev) => prev === 0 ? availableModels.length - 1 : prev - 1);
             return true;
@@ -171,18 +215,8 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
             setSelectedModelIndex((prev) => (prev + 1) % availableModels.length);
             return true;
         }
-        if (key.tab || key.return) {
+        if (key.tab || key.return || key.rightArrow) {
             const selectedModel = availableModels[selectedModelIndex];
-            // Delegate to Dispatcher implicitly via handleDirectCommand?
-            // No, UI navigation logic remains here, but the action can be manual.
-            // Or we can construct a command string and let dispatcher handle it.
-            // But we have state setters here.
-            // Let's keep UI state manipulation here for selection, but action execution via command if possible.
-            // Actually, standard behavior:
-            // agent.setModel(selectedModel.model);
-            // updateCurrentModel(selectedModel.model);
-            // ...
-            // We can use a helper, but for now let's leave this UI logic as is, or use handleDirectCommand("/models " + model)
             if (selectedModel) {
                 handleDirectCommand(`/models ${selectedModel.model}`);
             }
@@ -190,7 +224,7 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
             setSelectedModelIndex(0);
             return true;
         }
-        return false;
+        return true; // Keep typing from modifying the draft while choosing a model.
     };
     const handleFileAutocompleteNav = (key) => {
         if (fileSuggestions.length > 0) {
@@ -202,7 +236,7 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
                 setSelectedFileIndex((prev) => (prev + 1) % fileSuggestions.length);
                 return true;
             }
-            if (key.tab || key.return) {
+            if (key.tab || key.return || (key.rightArrow && !key.ctrl && !key.meta && !key.shift && cursorPosition === input.length)) {
                 const selectedFile = fileSuggestions[selectedFileIndex];
                 const { startPos } = extractFileReference(input);
                 if (selectedFile && startPos >= 0) {
@@ -336,12 +370,19 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
                 await handleDirectCommand(userInput);
             }
             else {
-                await processUserMessage(userInput);
+                if (runningTurn.current || pendingMessages.current.length > 0) {
+                    pendingMessages.current.push(userInput);
+                    setQueuedMessageCount(pendingMessages.current.length);
+                }
+                else {
+                    await processUserMessage(userInput);
+                }
             }
         }
     };
     // Removed handleShellBypass as it's now in ClientCommandDispatcher
     const handleInputChange = (newInput) => {
+        commandSelectionMoved.current = false;
         // Update command suggestions based on input
         if (newInput.startsWith("/")) {
             setShowCommandSuggestions(true);
@@ -369,11 +410,17 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         onSubmit: handleInputSubmit,
         onSpecialKey: handleSpecialKey,
         disabled: isConfirmationActive,
+        multiline: true,
     });
     // Hook up the actual input handling
     useInput((inputChar, key) => {
+        // A picker owns the keyboard, including text-editing shortcuts such as Ctrl+J.
+        if (showModelSelection) {
+            handleModelSelectionNav(key);
+            return;
+        }
         handleInput(inputChar, key);
-    });
+    }, { isActive: !isConfirmationActive });
     // Update command suggestions when input changes
     useEffect(() => {
         handleInputChange(input);
@@ -387,9 +434,13 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         }));
     }, []);
     // Load models from configuration with fallback to defaults
+    const current = agent.getCurrentModel?.();
+    const provider = agent.getClient?.().getCurrentProvider?.();
     const availableModels = useMemo(() => {
-        return loadModelConfig(); // Return directly, interface already matches
-    }, []);
+        const models = [...(current ? [{ model: current }] : []), ...loadModelConfig()];
+        return models.filter((option, index) => models.findIndex(other => other.model === option.model) === index &&
+            isModelCompatibleWithProvider(option.model, provider));
+    }, [current, provider]);
     const handleDirectCommand = async (input) => {
         const context = {
             agent,
@@ -411,6 +462,7 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         return await ClientCommandDispatcher.dispatch(input, context);
     };
     const processUserMessage = async (userInput) => {
+        runningTurn.current = true;
         const mySeq = ++turnSeqRef.current;
         goalInterruptedRef.current = false;
         const userEntry = {
@@ -431,7 +483,8 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         }
         setIsProcessing(true);
         setCurrentActivity?.('Sending to LLM...');
-        clearInput();
+        // The submit handler already cleared the sent text. A queued turn must
+        // preserve whatever draft the user is now editing.
         let fullResponseContent = "";
         try {
             setIsStreaming(true);
@@ -622,6 +675,10 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
             setIsStreaming(false);
             setCurrentActivity?.('');
         }
+        // Persist the finished turn before a queued message or exit can start (never throws).
+        await agent.persistInteractiveSession();
+        runningTurn.current = false;
+        setIsStreaming(false);
         setIsProcessing(false);
         setCurrentActivity?.('');
         processingStartTime.current = 0;
@@ -648,10 +705,12 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
             }
             // Skip the continuation if a newer turn started while we were judging —
             // the user's message preempts the loop and gets judged after its turn.
-            if (outcome?.continuationPrompt && turnSeqRef.current === mySeq) {
+            if (outcome?.continuationPrompt && turnSeqRef.current === mySeq && pendingMessages.current.length === 0) {
                 const continuation = outcome.continuationPrompt;
                 setTimeout(() => {
-                    void processUserMessage(continuation);
+                    if (turnSeqRef.current === mySeq && !runningTurn.current && pendingMessages.current.length === 0) {
+                        void processUserMessage(continuation);
+                    }
                 }, 50);
             }
         }
@@ -673,6 +732,7 @@ export function useInputHandler({ agent, chatHistory, setChatHistory, setIsProce
         availableModels,
         agent,
         autoEditEnabled,
+        queuedMessageCount,
         handleInputSubmit,
     };
 }

package/dist/hooks/use-input-history.js

@@ -28,6 +28,7 @@ export function useInputHistory() {
             }
             else if (currentIndex === history.length - 1) {
                 newIndex = -1;
+                setCurrentIndex(-1);
                 return originalInput;
             }
             else {

package/dist/identity/lisa-introspection.js

@@ -165,7 +165,8 @@ const DESCRIBE_PATTERNS = [
     /\bde quoi (?:es tu|etes vous) (?:fait|faite|faits|faites|compose|composee|composes|composees)\b/,
     /\bqui (?:es tu|etes vous)\b/,
     /\b(?:quell?e est )?(?:ton|votre) architecture\b/,
-    /\b(?:quels? (?:sont )?)?(?:tes|vos) (?:capteurs?|outils?|modules?)(?: (?:sont|restent|semblent))?(?: (?:actifs?|disponibles?|operationnels?))?\b/,
+    /\bquels? (?:sont )?(?:tes|vos) (?:capteurs?|outils?|modules?)(?: (?:sont|restent|semblent))?(?: (?:actifs?|disponibles?|operationnels?))?\b/,
+    /^(?:tes|vos) (?:capteurs?|outils?|modules?)(?: (?:sont|restent|semblent))?(?: (?:actifs?|disponibles?|operationnels?))?\s*[?.!]*$/,
     /\bquels? (?:modules?|composants?|outils?) (?:as tu|avez vous)\b/,
     /\bquell?es? (?:sont )?(?:tes|vos) limit(?:e|es|ation|ations)\b/,
     /\b(?:lisa|l assistant|l assistante|l agent)\b.{0,96}\b(?:conscient|consciente|conscience d elle meme|modele d elle meme|se connaitre)\b/,
@@ -354,7 +355,9 @@ export function renderLisaOperationalSelfResponse(model, raw, intent) {
 }
 /** Classify a request about Lisa's own technical implementation. */
 export function classifyLisaIntrospection(raw) {
-    const text = normalizeIntrospectionText(raw);
+    // Using tools to do a task does not make the tools the inspection target.
+    // Keep any explicit target that follows (e.g. 'inspect your own code').
+    const text = normalizeIntrospectionText(raw).replace(/\b(?:(?:utilise|utilisez|utiliser) (?:tes|vos)|use your) (?:outils|tools)\b/g, '');
     if (!text)
         return null;
     // A request for introspection of the user's life, emotions, relationship, or

package/dist/identity/operational-self-model.d.ts

@@ -44,6 +44,8 @@ export interface OperationalSelfArea {
     state: 'verified' | 'partial' | 'unavailable';
 }
 export interface CompanionRuntimeEvidence {
+    /** Live CLI theme, only when attested by that UI host. */
+    theme?: string;
     model?: string;
     provider?: string;
     /** False when the report is built locally without dispatching a model. */

package/dist/identity/operational-self-model.js

@@ -809,6 +809,10 @@ function runtimeFacts(runtime, observedAt) {
         : undefined));
     facts.push(fact(observedAt, 'turn.surface', 'Surface', surface ? 'verified' : 'unknown', surface || 'inconnue', ['agent turn metadata']));
     facts.push(fact(observedAt, 'turn.permission', 'Mode de permission', permissionMode ? 'verified' : 'unknown', permissionMode || 'inconnu', ['agent turn metadata']));
+    const theme = surface === 'cli' ? normalizedRuntimeIdentifier(runtime.theme) : undefined;
+    if (theme) {
+        facts.push(fact(observedAt, 'turn.theme', 'Thème CLI actif', 'verified', theme, ['in-process Ink ThemeManager']));
+    }
     const registered = normalizedToolNames(runtime.registeredToolNames);
     const exposed = normalizedToolNames(runtime.exposedToolNames);
     facts.push(fact(observedAt, 'tools.registered', 'Outils enregistrés', runtime.registeredToolNames !== undefined ? 'verified' : 'unknown', runtime.registeredToolNames !== undefined

package/dist/index.js

@@ -1328,7 +1328,7 @@ program
     .option("--no-emoji", "disable emoji in output")
     .option("--list-models", "list available models from the API endpoint and exit")
     .option("--continue", "continue from the most recent saved session (like mistral-vibe)")
-    .option("--resume <sessionId>", "resume a specific session by ID (supports partial matching)")
+    .option("--resume [sessionId]", "resume a specific session by ID (supports partial matching); without an ID, pick a recent session")
     .option("--search-sessions <query>", "search saved sessions by content")
     .option("--max-price <dollars>", "maximum cost in dollars before stopping (like mistral-vibe)", "10.0")
     .option("--auto-approve", "automatically approve all tool executions (like mistral-vibe)")
@@ -1519,6 +1519,14 @@ program
         cli.info(`   ${lastSession.messages.length} messages, last accessed: ${lastSession.lastAccessedAt.toLocaleString()}\n`);
     }
     // Handle --resume flag (resume specific session by ID, like mistral-vibe)
+    if (options.resume === true) {
+        // P6: `--resume` without an ID opens the recent-session picker.
+        const { pickRecentSession } = await import("./cli/session-commands.js");
+        const picked = await pickRecentSession(20);
+        if (!picked)
+            process.exit(process.exitCode ?? 1);
+        options.resume = picked;
+    }
     if (options.resume) {
         const { getSessionStore } = await import("./persistence/session-store.js");
         const sessionStore = getSessionStore();
@@ -1534,7 +1542,9 @@ program
         }
         await sessionStore.resumeSession(session.id);
         cli.info(`📂 Resuming session: ${session.name} (${session.id.slice(0, 8)})`);
-        cli.info(`   ${session.messages.length} messages, last accessed: ${session.lastAccessedAt.toLocaleString()}\n`);
+        cli.info(`   ${session.messages.length} messages, last accessed: ${session.lastAccessedAt.toLocaleString()}`);
+        const { buildSessionRecap, formatSessionRecap } = await import("./cli/session-picker.js");
+        cli.info(`${formatSessionRecap(buildSessionRecap(session)).join("\n")}\n`);
     }
     // Load environment before changing cwd so root .env values (API keys) remain available
     // even when --directory points to a workspace without its own .env file.
@@ -1900,6 +1910,7 @@ program
         await ensureUserSettingsDirectory();
         recordStartupPhase('user-settings-done');
         // ── Crash recovery: detect unclean shutdown and offer session resume ──
+        let crashResumed = false;
         if (!options.resume && !options.continue) {
             try {
                 const { checkCrashRecovery, clearRecoveryFiles } = await import('./errors/crash-recovery.js');
@@ -1921,6 +1932,7 @@ program
                             const session = await sessionStore.getSessionByPartialId(recovery.sessionId);
                             if (session) {
                                 await sessionStore.resumeSession(session.id);
+                                crashResumed = true;
                                 cli.info(`   Resuming session: ${session.name} (${session.messages.length} messages)`);
                             }
                             else {
@@ -1978,7 +1990,24 @@ program
         // Only the interactive TUI enables it, so cron/headless/sub-agent runs cannot
         // trigger a review (recursion + cost safety).
         agent.enableBackgroundReview();
-        render(React.createElement(ChatInterface, { agent, initialMessage }), inkOptions);
+        // Memory fact reconciliation (remember tool and /remember) must use the
+        // provider this session runs on, never a provider auto-detected from env.
+        const { setFactsMemorySessionClient } = await import('./memory/facts-memory.js');
+        setFactsMemorySessionClient(agent.getClient());
+        // A resumed session (--resume, --continue, crash recovery) must reach both the model
+        // history and the chat view; resumeSession() alone only selects the store's current session.
+        let initialHistory;
+        if (options.resume || options.continue || crashResumed) {
+            const { getSessionStore } = await import('./persistence/session-store.js');
+            const resumedStore = getSessionStore();
+            const resumedId = resumedStore.getCurrentSessionId();
+            const resumed = resumedId ? await resumedStore.loadSession(resumedId) : null;
+            if (resumed) {
+                agent.hydratePersistedSession(resumed);
+                initialHistory = agent.getChatHistory();
+            }
+        }
+        render(React.createElement(ChatInterface, { agent, initialMessage, initialHistory }), inkOptions);
         // Initialize plugin system in background (non-blocking)
         setImmediate(async () => {
             try {
@@ -2733,12 +2762,13 @@ program
         cli.error(LOGIN_NEEDS_BROWSER_MESSAGE);
         process.exit(1);
     }
-    const { loginInteractive, getCodexAuthFilePath } = await import("./providers/codex-oauth.js");
+    const { getCodexAuthFilePath } = await import("./providers/codex-oauth.js");
+    const { loginChatGptWithBrowser } = await import('./commands/login-chatgpt.js');
     cli.stdout("🔐 ChatGPT login");
-    cli.stdout("Opening your browser to https://auth.openai.com/oauth/authorize ...");
+    cli.stdout("Opening your browser for ChatGPT sign-in ...");
     cli.stdout("Sign in with your ChatGPT account, then return to this terminal.\n");
     try {
-        const auth = await loginInteractive();
+        const auth = await loginChatGptWithBrowser(cli);
         cli.stdout("✅ Authenticated successfully");
         if (auth.email)
             cli.stdout(`   Account:    ${auth.email}`);
@@ -3080,6 +3110,10 @@ addLazyCommandGroup(program, 'curator', 'Propose-only maintenance report (memory
     const { registerCuratorCommand } = await import('./commands/curator-cli.js');
     registerCuratorCommand(program);
 });
+addLazyCommandGroup(program, 'triage', 'Write a local redacted support bundle and prompt (no network, launches nothing)', async () => {
+    const { registerTriageCommand } = await import('./commands/cli/triage-command.js');
+    registerTriageCommand(program);
+});
 addLazyCommandGroup(program, 'gateway-pairing', 'Operator approval for gateway device pairing', async () => {
     const { registerGatewayPairingCommands } = await import('./commands/cli/native-engine-commands.js');
     registerGatewayPairingCommands(program);
@@ -3116,6 +3150,14 @@ addLazyCommand(program, 'token', 'Mint a signed JWT for the API and the mobile P
     const { createTokenCommand } = await import('./commands/token.js');
     return createTokenCommand();
 });
+addLazyCommand(program, 'pair', 'Pair an Android authenticator with a local one-time code', async () => {
+    const { createPairCommand } = await import('./commands/device-auth.js');
+    return createPairCommand();
+});
+addLazyCommand(program, 'devices', 'Manage Android authentication devices', async () => {
+    const { createDevicesCommand } = await import('./commands/device-auth.js');
+    return createDevicesCommand();
+});
 addLazyCommandGroup(program, 'fleet', 'Inspect Fleet routing and dispatch policy decisions', async () => {
     const { registerFleetCommands } = await import('./commands/cli/fleet-commands.js');
     registerFleetCommands(program);
@@ -3298,6 +3340,10 @@ addLazyCommand(program, 'lessons', 'Manage lessons learned — self-improvement
     const { createLessonsCommand } = await import('./commands/lessons.js');
     return createLessonsCommand();
 });
+addLazyCommand(program, 'resources', 'Explicit network resource inventory and read-only health selection', async () => {
+    const { createResourcesCommand } = await import('./commands/resources.js');
+    return createResourcesCommand();
+});
 // Spec — BMAD-inspired spec-driven, review-gated work pipeline
 addLazyCommandGroup(program, 'spec', 'Spec-driven, review-gated work pipeline (durable stories; approve before implementing)', async () => {
     const { createSpecCommand } = await import('./commands/spec.js');

package/dist/mcp/client.d.ts

@@ -14,9 +14,20 @@ export declare class MCPManager extends EventEmitter {
     private serverStatuses;
     private retryCounts;
     private healthCheckIntervals;
+    private reconnectTimers;
+    /**
+     * Bumped by removeServer. A still-running addServerInternal must not overwrite
+     * 'disconnected' with 'error' nor schedule autoReconnect (which would reopen
+     * the OAuth browser ~1s after an explicit cancel).
+     */
+    private connectEpochs;
     private serverAddPromises;
     private initializationPromise;
     addServer(config: MCPServerConfig): Promise<void>;
+    private currentEpoch;
+    private bumpConnectEpoch;
+    private assertConnectCurrent;
+    private clearReconnectTimer;
     private addServerInternal;
     private startHealthCheck;
     private stopHealthCheck;

package/dist/mcp/client.js

@@ -1,6 +1,8 @@
+import { mcpToolAllowed, validateMCPToolFilter } from './import-normalize.js';
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { EventEmitter } from "events";
 import { createTransport } from "./transports.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { logger } from "../utils/logger.js";
 export const DEFAULT_MCP_INIT_TIMEOUT_MS = 15_000;
 const MAX_MCP_INIT_TIMEOUT_MS = 10 * 60_000;
@@ -25,9 +27,19 @@ export class MCPManager extends EventEmitter {
     serverStatuses = new Map();
     retryCounts = new Map();
     healthCheckIntervals = new Map();
+    reconnectTimers = new Map();
+    /**
+     * Bumped by removeServer. A still-running addServerInternal must not overwrite
+     * 'disconnected' with 'error' nor schedule autoReconnect (which would reopen
+     * the OAuth browser ~1s after an explicit cancel).
+     */
+    connectEpochs = new Map();
     serverAddPromises = new Map();
     initializationPromise = null;
     async addServer(config) {
+        if (config.enabled === false)
+            return;
+        validateMCPToolFilter(config.toolFilter);
         if (this.serverStatuses.get(config.name) === 'connected' &&
             this.clients.has(config.name) &&
             this.transports.has(config.name)) {
@@ -47,9 +59,30 @@ export class MCPManager extends EventEmitter {
             }
         }
     }
+    currentEpoch(serverName) {
+        return this.connectEpochs.get(serverName) ?? 0;
+    }
+    bumpConnectEpoch(serverName) {
+        const next = this.currentEpoch(serverName) + 1;
+        this.connectEpochs.set(serverName, next);
+        return next;
+    }
+    assertConnectCurrent(serverName, epoch) {
+        if (this.currentEpoch(serverName) !== epoch) {
+            throw new Error(`MCP server "${serverName}" connection cancelled`);
+        }
+    }
+    clearReconnectTimer(serverName) {
+        const timer = this.reconnectTimers.get(serverName);
+        if (timer) {
+            clearTimeout(timer);
+            this.reconnectTimers.delete(serverName);
+        }
+    }
     async addServerInternal(config) {
         this.serverConfigs.set(config.name, config);
         this.serverStatuses.set(config.name, 'connecting');
+        const epoch = this.currentEpoch(config.name);
         try {
             // Handle legacy stdio-only configuration
             let transportConfig = config.transport;
@@ -76,8 +109,24 @@ export class MCPManager extends EventEmitter {
             });
             this.clients.set(config.name, client);
             // Connect
-            const sdkTransport = await transport.connect();
-            await client.connect(sdkTransport);
+            let sdkTransport = await transport.connect();
+            this.assertConnectCurrent(config.name, epoch);
+            try {
+                await client.connect(sdkTransport);
+                this.assertConnectCurrent(config.name, epoch);
+            }
+            catch (error) {
+                // First connection may end in UnauthorizedError once the OAuth code has been
+                // exchanged (SDK contract): reconnect once with the stored token.
+                if (!(error instanceof UnauthorizedError) || transportConfig.auth?.type !== 'oauth')
+                    throw error;
+                await transport.disconnect().catch(() => undefined);
+                this.assertConnectCurrent(config.name, epoch);
+                sdkTransport = await transport.connect();
+                this.assertConnectCurrent(config.name, epoch);
+                await client.connect(sdkTransport);
+                this.assertConnectCurrent(config.name, epoch);
+            }
             // Drain the captured MCP stderr to the logger. The stream only exists
             // for stdio transports created with stderr:'pipe' (see StdioTransport);
             // without a consumer the PassThrough back-pressures the child once its
@@ -92,8 +141,11 @@ export class MCPManager extends EventEmitter {
             }
             // List available tools
             const toolsResult = await client.listTools();
+            this.assertConnectCurrent(config.name, epoch);
             // Register tools
             for (const tool of toolsResult.tools) {
+                if (!mcpToolAllowed(tool.name, config.toolFilter))
+                    continue;
                 const mcpTool = {
                     name: `mcp__${config.name}__${tool.name}`,
                     description: tool.description || `Tool from ${config.name} server`,
@@ -108,6 +160,10 @@ export class MCPManager extends EventEmitter {
             this.emit('serverAdded', config.name, toolsResult.tools.length);
         }
         catch (error) {
+            if (this.currentEpoch(config.name) !== epoch) {
+                // Explicit removeServer raced this connect; keep disconnected.
+                throw error;
+            }
             this.serverStatuses.set(config.name, 'error');
             this.handleServerError(config.name, error);
             throw error;
@@ -153,8 +209,13 @@ export class MCPManager extends EventEmitter {
         if (retryCount < maxRetries) {
             this.retryCounts.set(serverName, retryCount + 1);
             const delay = Math.min(1000 * Math.pow(2, retryCount), 30000);
+            const epochAtError = this.currentEpoch(serverName);
             logger.info(`Attempting to reconnect to ${serverName} in ${delay}ms (attempt ${retryCount + 1}/${maxRetries})`);
-            setTimeout(async () => {
+            this.clearReconnectTimer(serverName);
+            const timer = setTimeout(async () => {
+                this.reconnectTimers.delete(serverName);
+                if (this.currentEpoch(serverName) !== epochAtError)
+                    return;
                 try {
                     await this.removeServer(serverName);
                     await this.addServer(config);
@@ -163,6 +224,7 @@ export class MCPManager extends EventEmitter {
                     logger.debug(`Reconnection attempt failed for ${serverName}`, { reconnectError });
                 }
             }, delay);
+            this.reconnectTimers.set(serverName, timer);
         }
         else {
             logger.error(`Max reconnection attempts reached for ${serverName}`);
@@ -173,6 +235,9 @@ export class MCPManager extends EventEmitter {
         return this.serverStatuses.get(serverName);
     }
     async removeServer(serverName) {
+        this.bumpConnectEpoch(serverName);
+        this.clearReconnectTimer(serverName);
+        this.serverAddPromises.delete(serverName);
         this.stopHealthCheck(serverName);
         this.serverStatuses.set(serverName, 'disconnected');
         // Remove tools

package/dist/mcp/config.d.ts

@@ -7,8 +7,28 @@ export type { MCPConfig } from "./types.js";
 export interface LoadMCPConfigOptions {
     /** Include disabled entries for inventory and diagnostics. Runtime callers omit this. */
     includeDisabled?: boolean;
+    /**
+     * Project directory whose `.codebuddy/mcp.json` and `.codebuddy/settings.json` are read.
+     * Defaults to `process.cwd()` (historical behaviour). Lets diagnostics inspect another
+     * project without `process.chdir()`, which is global state shared across awaits.
+     */
+    cwd?: string;
 }
 export declare function loadMCPConfig(options?: LoadMCPConfigOptions): MCPConfig;
+export interface MCPConfigReadOnlyResult {
+    servers: MCPServerConfig[];
+    /** Sanitized warnings (no config content, no secrets). Empty when all sources are missing/valid. */
+    warnings: string[];
+}
+/**
+ * Strictly read-only MCP configuration loader for diagnostics. Reads the same
+ * three sources with the same precedence, disabled masking, and env resolution
+ * as `loadMCPConfig`, but never restores/renames/chmods/creates config or
+ * backups/temporaries. Corrupt or unreadable sources yield sanitized warnings
+ * instead of being silently treated as "no server configured". Missing config
+ * is normal and produces no warning.
+ */
+export declare function loadMCPConfigReadOnly(options?: LoadMCPConfigOptions): MCPConfigReadOnlyResult;
 export declare function saveMCPConfig(config: MCPConfig): void;
 export declare function addMCPServer(config: MCPServerConfig): void;
 export declare function removeMCPServer(serverName: string): void;