@auxiora/runtime 1.10.16 → 1.10.19

package/dist/index.js

@@ -250,6 +250,8 @@ export class Auxiora {
     activeAgents = new Map();
     channelTargetsPath = path.join(path.dirname(getBehaviorsPath()), 'channel-targets.json');
     orchestrationHistory = [];
+    /** Per-session run state for message queueing. */
+    sessionRunStates = new Map();
     async initialize(options = {}) {
         // Read version from package.json
         try {
@@ -2572,6 +2574,8 @@ export class Auxiora {
         }
         // Append tool usage guidance
         this.standardPrompt += '\n\n---\n\n## Tool Usage\n'
+            + '- IMPORTANT: When the user asks you to create files, generate projects, write code, or perform actions on the filesystem, you MUST use the `bash` and `file_write` tools to actually do the work. Do not just describe what you would do — execute it.\n'
+            + '- Use `bash` to run shell commands (mkdir, npm init, git init, etc.) and `file_write` to create files with content.\n'
             + '- For reading web pages, searching, fetching articles, or looking up information, use the `web_browser` tool. It is fast, lightweight, and always available.\n'
             + '- Only use `browser_navigate` and other browser_* tools when you need JavaScript rendering or interactive features (clicking buttons, filling forms, taking screenshots).\n'
             + '- Never expose raw tool errors to the user. If a tool fails, explain the situation naturally.';
@@ -2871,269 +2875,313 @@ export class Auxiora {
                 senderId: client.senderId,
             });
         }
-        // Apply redaction if guardrails flagged PII
-        let processedContent = content;
-        if (inputScan?.action === 'redact' && inputScan.redactedContent) {
-            processedContent = inputScan.redactedContent;
-            audit('guardrail.triggered', {
-                action: 'redact',
-                direction: 'input',
-                threatCount: inputScan.threats.length,
-                channelType: 'webchat',
-                sessionId: session.id,
-            });
-        }
-        else if (inputScan?.action === 'warn') {
-            audit('guardrail.triggered', {
-                action: 'warn',
-                direction: 'input',
-                threatCount: inputScan.threats.length,
-                channelType: 'webchat',
-                sessionId: session.id,
+        // ── Message queue gate ─────────────────────────────────────────
+        if (!this.acquireSessionRun(session.id)) {
+            this.enqueueMessage(session.id, {
+                content: payload?.content ?? '',
+                enqueuedAt: Date.now(),
+                client,
+                requestId,
+                chatId: payload?.chatId,
+                modelOverride: payload?.model,
+                providerOverride: payload?.provider,
             });
-        }
-        // Add user message
-        await this.sessions.addMessage(session.id, 'user', processedContent);
-        // Check if providers are available
-        if (!this.providers) {
             this.sendToClient(client, {
-                type: 'message',
-                id: requestId,
-                payload: {
-                    role: 'assistant',
-                    content: 'I need API keys to respond. Please add them:\n\n```\nauxiora vault add ANTHROPIC_API_KEY\n```',
-                },
+                type: 'queued',
+                requestId,
+                position: this.getSessionRunState(session.id).queue.length,
             });
             return;
         }
-        // Get context messages
-        const contextMessages = this.sessions.getContextMessages(session.id, this.getProviderMaxTokens(this.providers.getPrimaryProvider()), 4096);
-        const chatMessages = sanitizeTranscript(contextMessages).map((m) => ({
-            role: m.role,
-            content: m.content,
-        }));
         try {
-            // Get tool definitions from registry
-            const tools = toolRegistry.toProviderFormat();
-            // Resolve per-chat personality (metadata overrides global default)
-            const chatRecord = chatId ? this.sessions.getChat(chatId) : undefined;
-            const chatPersonality = chatRecord?.metadata?.personality;
-            const useArchitect = chatPersonality
-                ? chatPersonality === 'the-architect'
-                : this.config.agent.personality === 'the-architect';
-            const basePrompt = useArchitect ? this.architectPrompt : this.standardPrompt;
-            // Build enriched prompt through pipeline
-            let enrichedPrompt = basePrompt;
-            let architectResult = { prompt: basePrompt };
-            // Reset Architect conversation state for new chats
-            if (useArchitect && this.architect && chatId && !this.architectResetChats.has(chatId)) {
-                this.architectResetChats.add(chatId);
-                this.architect.resetConversation();
-                audit('personality.reset', { sessionId: session.id, chatId });
-            }
-            if (this.enrichmentPipeline) {
-                const enrichCtx = {
-                    basePrompt,
-                    userMessage: processedContent,
-                    history: contextMessages,
+            // Apply redaction if guardrails flagged PII
+            let processedContent = content;
+            if (inputScan?.action === 'redact' && inputScan.redactedContent) {
+                processedContent = inputScan.redactedContent;
+                audit('guardrail.triggered', {
+                    action: 'redact',
+                    direction: 'input',
+                    threatCount: inputScan.threats.length,
                     channelType: 'webchat',
-                    chatId: chatId ?? session.id,
                     sessionId: session.id,
-                    userId: client.senderId ?? 'anonymous',
-                    toolsUsed: this.lastToolsUsed.get(session.id) ?? [],
-                    config: this.config,
-                };
-                const result = await this.enrichmentPipeline.run(enrichCtx);
-                enrichedPrompt = result.prompt;
-                architectResult = { prompt: enrichedPrompt, architectMeta: result.metadata.architect };
-            }
-            // Route to best model for this message
-            let provider;
-            let routingResult;
-            if (providerOverride || modelOverride) {
-                // Manual override — skip router
-                provider = this.providers.getProvider(providerOverride || this.config.provider.primary);
-            }
-            else if (this.modelRouter && this.config.routing?.enabled !== false) {
-                try {
-                    routingResult = this.modelRouter.route(processedContent, { hasImages: false });
-                    provider = this.providers.getProvider(routingResult.selection.provider);
-                }
-                catch {
-                    provider = this.providers.getPrimaryProvider();
-                }
+                });
             }
-            else {
-                provider = this.providers.getPrimaryProvider();
-            }
-            // Inject model identity so the AI knows what it's running on
-            enrichedPrompt += this.buildModelIdentityFragment(provider, routingResult?.selection.model ?? modelOverride);
-            // Execute streaming AI call with tool follow-up loop
-            const processingStartTime = Date.now();
-            const fallbackCandidates = this.providers.resolveFallbackCandidates();
-            const toolsUsed = [];
-            let streamChunkCount = 0;
-            const { response: fullResponse, usage } = await this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
-                if (type === 'text') {
-                    streamChunkCount++;
-                    this.sendToClient(client, { type: 'chunk', id: requestId, payload: { content: data } });
-                }
-                else if (type === 'thinking') {
-                    this.sendToClient(client, { type: 'thinking', id: requestId, payload: { content: data } });
-                }
-                else if (type === 'tool_use') {
-                    toolsUsed.push({ name: data?.name ?? 'unknown', success: true });
-                    this.sendToClient(client, { type: 'tool_use', id: requestId, payload: data });
-                }
-                else if (type === 'tool_result') {
-                    // Update last tool's success based on result
-                    if (toolsUsed.length > 0 && data?.error) {
-                        toolsUsed[toolsUsed.length - 1].success = false;
-                    }
-                    this.sendToClient(client, { type: 'tool_result', id: requestId, payload: data });
-                }
-                else if (type === 'status') {
-                    this.sendToClient(client, { type: 'status', id: requestId, payload: data });
-                }
-            }, { tools, fallbackCandidates });
-            // Feed tool usage to awareness collector
-            if (this.architectAwarenessCollector && toolsUsed.length > 0) {
-                this.architectAwarenessCollector.updateToolContext(toolsUsed);
-            }
-            // Store tools for next turn's enrichment context
-            this.lastToolsUsed.set(session.id, toolsUsed);
-            // ── Guardrail output scan ─────────────────────────────────────
-            const outputScan = this.checkOutputGuardrails(fullResponse);
-            const finalResponse = outputScan.response;
-            if (outputScan.wasModified) {
+            else if (inputScan?.action === 'warn') {
                 audit('guardrail.triggered', {
-                    action: outputScan.action,
-                    direction: 'output',
+                    action: 'warn',
+                    direction: 'input',
+                    threatCount: inputScan.threats.length,
                     channelType: 'webchat',
                     sessionId: session.id,
                 });
-                // Send correction since chunks were already streamed
+            }
+            // Add user message
+            await this.sessions.addMessage(session.id, 'user', processedContent);
+            // Check if providers are available
+            if (!this.providers) {
                 this.sendToClient(client, {
-                    type: 'guardrail_correction',
+                    type: 'message',
                     id: requestId,
-                    payload: { content: finalResponse },
+                    payload: {
+                        role: 'assistant',
+                        content: 'I need API keys to respond. Please add them:\n\n```\nauxiora vault add ANTHROPIC_API_KEY\n```',
+                    },
                 });
+                return;
             }
-            // Collect transparency metadata (best-effort)
-            let transparencyMeta;
+            // Get context messages
+            const contextMessages = this.sessions.getContextMessages(session.id, this.getProviderMaxTokens(this.providers.getPrimaryProvider()), 4096);
+            const chatMessages = sanitizeTranscript(contextMessages).map((m) => ({
+                role: m.role,
+                content: m.content,
+            }));
+            // Snapshot message count before agentic loop so we can rollback on failure
+            let messageCountSnapshot;
             try {
-                const modelId = routingResult?.selection.model ?? modelOverride ?? provider.defaultModel;
-                const caps = provider.metadata.models[modelId];
-                if (caps) {
-                    transparencyMeta = collectTransparencyMeta({
-                        enrichment: this.enrichmentPipeline
-                            ? { prompt: enrichedPrompt, metadata: { architect: architectResult.architectMeta, stages: architectResult.stages ?? [] } }
-                            : { prompt: enrichedPrompt, metadata: { stages: [] } },
-                        completion: { content: finalResponse, usage, model: modelId, finishReason: 'stop', toolUse: toolsUsed.map(t => ({ name: t.name })) },
-                        capabilities: { costPer1kInput: caps.costPer1kInput, costPer1kOutput: caps.costPer1kOutput },
-                        providerName: provider.name,
-                        awarenessSignals: [],
-                        responseText: finalResponse,
-                        processingStartTime,
+                // Get tool definitions from registry
+                const tools = toolRegistry.toProviderFormat();
+                // Resolve per-chat personality (metadata overrides global default)
+                const chatRecord = chatId ? this.sessions.getChat(chatId) : undefined;
+                const chatPersonality = chatRecord?.metadata?.personality;
+                const useArchitect = chatPersonality
+                    ? chatPersonality === 'the-architect'
+                    : this.config.agent.personality === 'the-architect';
+                const basePrompt = useArchitect ? this.architectPrompt : this.standardPrompt;
+                // Build enriched prompt through pipeline
+                let enrichedPrompt = basePrompt;
+                let architectResult = { prompt: basePrompt };
+                // Reset Architect conversation state for new chats
+                if (useArchitect && this.architect && chatId && !this.architectResetChats.has(chatId)) {
+                    this.architectResetChats.add(chatId);
+                    this.architect.resetConversation();
+                    audit('personality.reset', { sessionId: session.id, chatId });
+                }
+                if (this.enrichmentPipeline) {
+                    const enrichCtx = {
+                        basePrompt,
+                        userMessage: processedContent,
+                        history: contextMessages,
+                        channelType: 'webchat',
+                        chatId: chatId ?? session.id,
+                        sessionId: session.id,
+                        userId: client.senderId ?? 'anonymous',
+                        toolsUsed: this.lastToolsUsed.get(session.id) ?? [],
+                        config: this.config,
+                    };
+                    const result = await this.enrichmentPipeline.run(enrichCtx);
+                    enrichedPrompt = result.prompt;
+                    architectResult = { prompt: enrichedPrompt, architectMeta: result.metadata.architect };
+                }
+                // Route to best model for this message
+                let provider;
+                let routingResult;
+                if (providerOverride || modelOverride) {
+                    // Manual override — skip router
+                    provider = this.providers.getProvider(providerOverride || this.config.provider.primary);
+                }
+                else if (this.modelRouter && this.config.routing?.enabled !== false) {
+                    try {
+                        routingResult = this.modelRouter.route(processedContent, { hasImages: false });
+                        provider = this.providers.getProvider(routingResult.selection.provider);
+                    }
+                    catch {
+                        provider = this.providers.getPrimaryProvider();
+                    }
+                }
+                else {
+                    provider = this.providers.getPrimaryProvider();
+                }
+                // Inject model identity so the AI knows what it's running on
+                enrichedPrompt += this.buildModelIdentityFragment(provider, routingResult?.selection.model ?? modelOverride);
+                // Execute streaming AI call with tool follow-up loop
+                const processingStartTime = Date.now();
+                const fallbackCandidates = this.providers.resolveFallbackCandidates();
+                const toolsUsed = [];
+                let streamChunkCount = 0;
+                // Snapshot message count so we can rollback orphaned messages if the loop fails
+                messageCountSnapshot = this.sessions.getMessageCount(session.id);
+                const { response: fullResponse, usage } = await this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
+                    if (type === 'text') {
+                        streamChunkCount++;
+                        this.sendToClient(client, { type: 'chunk', id: requestId, payload: { content: data } });
+                    }
+                    else if (type === 'thinking') {
+                        this.sendToClient(client, { type: 'thinking', id: requestId, payload: { content: data } });
+                    }
+                    else if (type === 'tool_use') {
+                        toolsUsed.push({ name: data?.name ?? 'unknown', success: true });
+                        this.sendToClient(client, { type: 'tool_use', id: requestId, payload: data });
+                    }
+                    else if (type === 'tool_result') {
+                        // Update last tool's success based on result
+                        if (toolsUsed.length > 0 && data?.error) {
+                            toolsUsed[toolsUsed.length - 1].success = false;
+                        }
+                        this.sendToClient(client, { type: 'tool_result', id: requestId, payload: data });
+                    }
+                    else if (type === 'status') {
+                        this.sendToClient(client, { type: 'status', id: requestId, payload: data });
+                    }
+                }, { tools, fallbackCandidates });
+                // Feed tool usage to awareness collector
+                if (this.architectAwarenessCollector && toolsUsed.length > 0) {
+                    this.architectAwarenessCollector.updateToolContext(toolsUsed);
+                }
+                // Store tools for next turn's enrichment context
+                this.lastToolsUsed.set(session.id, toolsUsed);
+                // ── Guardrail output scan ─────────────────────────────────────
+                const outputScan = this.checkOutputGuardrails(fullResponse);
+                const finalResponse = outputScan.response;
+                if (outputScan.wasModified) {
+                    audit('guardrail.triggered', {
+                        action: outputScan.action,
+                        direction: 'output',
+                        channelType: 'webchat',
+                        sessionId: session.id,
+                    });
+                    // Send correction since chunks were already streamed
+                    this.sendToClient(client, {
+                        type: 'guardrail_correction',
+                        id: requestId,
+                        payload: { content: finalResponse },
                     });
                 }
-            }
-            catch {
-                // Transparency is best-effort — never block message delivery
-            }
-            // Save assistant message (skip if empty — happens when response is tool-only)
-            if (finalResponse) {
-                await this.sessions.addMessage(session.id, 'assistant', finalResponse, {
-                    input: usage.inputTokens,
-                    output: usage.outputTokens,
-                }, {
-                    ...(architectResult.architectMeta ? { architectDomain: architectResult.architectMeta.detectedContext.domain } : {}),
-                    ...(transparencyMeta ? { transparency: transparencyMeta } : {}),
+                // Collect transparency metadata (best-effort)
+                let transparencyMeta;
+                try {
+                    const modelId = routingResult?.selection.model ?? modelOverride ?? provider.defaultModel;
+                    const caps = provider.metadata.models[modelId];
+                    if (caps) {
+                        transparencyMeta = collectTransparencyMeta({
+                            enrichment: this.enrichmentPipeline
+                                ? { prompt: enrichedPrompt, metadata: { architect: architectResult.architectMeta, stages: architectResult.stages ?? [] } }
+                                : { prompt: enrichedPrompt, metadata: { stages: [] } },
+                            completion: { content: finalResponse, usage, model: modelId, finishReason: 'stop', toolUse: toolsUsed.map(t => ({ name: t.name })) },
+                            capabilities: { costPer1kInput: caps.costPer1kInput, costPer1kOutput: caps.costPer1kOutput },
+                            providerName: provider.name,
+                            awarenessSignals: [],
+                            responseText: finalResponse,
+                            processingStartTime,
+                        });
+                    }
+                }
+                catch {
+                    // Transparency is best-effort — never block message delivery
+                }
+                // Save assistant message (skip if empty — happens when response is tool-only)
+                if (finalResponse) {
+                    await this.sessions.addMessage(session.id, 'assistant', finalResponse, {
+                        input: usage.inputTokens,
+                        output: usage.outputTokens,
+                    }, {
+                        ...(architectResult.architectMeta ? { architectDomain: architectResult.architectMeta.detectedContext.domain } : {}),
+                        ...(transparencyMeta ? { transparency: transparencyMeta } : {}),
+                    });
+                }
+                // Record usage for cost tracking
+                if (this.modelRouter && routingResult) {
+                    this.modelRouter.recordUsage(routingResult.selection.provider, routingResult.selection.model, usage.inputTokens, usage.outputTokens);
+                }
+                // Extract memories and learn from conversation (if auto-extract enabled)
+                if (this.config.memory?.autoExtract !== false && this.memoryStore && finalResponse && processedContent.length > 20) {
+                    void this.extractAndLearn(processedContent, finalResponse, session.id);
+                }
+                // Auto-title webchat chats after first exchange
+                if (finalResponse &&
+                    session.metadata.channelType === 'webchat' &&
+                    session.messages.length <= 3) {
+                    void this.generateChatTitle(session.id, processedContent, finalResponse, client);
+                }
+                // Send done signal
+                this.sendToClient(client, {
+                    type: 'done',
+                    id: requestId,
+                    payload: {
+                        usage,
+                        routing: routingResult ? {
+                            model: routingResult.selection.model,
+                            provider: routingResult.selection.provider,
+                            isLocal: routingResult.selection.isLocal,
+                            taskType: routingResult.classification.type,
+                        } : (providerOverride || modelOverride) ? {
+                            model: modelOverride,
+                            provider: providerOverride || this.config.provider.primary,
+                            override: true,
+                        } : undefined,
+                        architect: architectResult.architectMeta,
+                        transparency: transparencyMeta,
+                    },
+                });
+                // Background self-awareness analysis
+                if (this.selfAwarenessAssembler) {
+                    this.selfAwarenessAssembler.afterResponse({
+                        userId: client.senderId ?? 'anonymous',
+                        sessionId: session.id,
+                        chatId: chatId ?? session.id,
+                        currentMessage: processedContent,
+                        recentMessages: contextMessages,
+                        response: finalResponse,
+                        responseTime: Date.now() - (session.metadata.lastActiveAt ?? Date.now()),
+                        tokensUsed: { input: usage?.inputTokens ?? 0, output: usage?.outputTokens ?? 0 },
+                        streamChunks: streamChunkCount,
+                    }).catch(() => { });
+                }
+                // Record conversation in consciousness journal
+                if (this.consciousness) {
+                    const journalBase = {
+                        sessionId: session.id,
+                        type: 'message',
+                        context: {
+                            domains: architectResult.architectMeta
+                                ? [architectResult.architectMeta.detectedContext.domain]
+                                : ['general'],
+                        },
+                        selfState: {
+                            health: (this.healthMonitor?.getHealthState().overall === 'unhealthy' ? 'degraded' : this.healthMonitor?.getHealthState().overall ?? 'healthy'),
+                            activeProviders: [this.config.provider.primary],
+                            uptime: Math.round(process.uptime()),
+                        },
+                    };
+                    this.consciousness.journal.record({ ...journalBase, message: { role: 'user', content: processedContent } }).catch(() => { });
+                    this.consciousness.journal.record({ ...journalBase, message: { role: 'assistant', content: finalResponse } }).catch(() => { });
+                }
+                audit('message.sent', {
+                    sessionId: session.id,
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    model: routingResult?.selection.model,
+                    provider: routingResult?.selection.provider,
                 });
             }
-            // Record usage for cost tracking
-            if (this.modelRouter && routingResult) {
-                this.modelRouter.recordUsage(routingResult.selection.provider, routingResult.selection.model, usage.inputTokens, usage.outputTokens);
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                audit('channel.error', { sessionId: session.id, error: errorMessage });
+                // Rollback orphaned messages from interrupted agentic tool loops.
+                // executeWithTools saves intermediate messages (tool announces + tool results)
+                // incrementally — if it throws, those partial messages pollute the next request.
+                if (typeof messageCountSnapshot === 'number') {
+                    const rolled = this.sessions.rollbackMessages(session.id, messageCountSnapshot);
+                    if (rolled > 0) {
+                        this.logger.info('Rolled back orphaned messages from interrupted tool loop', {
+                            sessionId: session.id,
+                            rolledBack: rolled,
+                        });
+                    }
+                }
+                this.sendToClient(client, {
+                    type: 'error',
+                    id: requestId,
+                    payload: { message: `Error: ${errorMessage}` },
+                });
             }
-            // Extract memories and learn from conversation (if auto-extract enabled)
-            if (this.config.memory?.autoExtract !== false && this.memoryStore && finalResponse && processedContent.length > 20) {
-                void this.extractAndLearn(processedContent, finalResponse, session.id);
+        }
+        finally {
+            try {
+                await this.drainSessionQueue(session.id);
             }
-            // Auto-title webchat chats after first exchange
-            if (finalResponse &&
-                session.metadata.channelType === 'webchat' &&
-                session.messages.length <= 3) {
-                void this.generateChatTitle(session.id, processedContent, finalResponse, client);
+            finally {
+                this.releaseSessionRun(session.id);
             }
-            // Send done signal
-            this.sendToClient(client, {
-                type: 'done',
-                id: requestId,
-                payload: {
-                    usage,
-                    routing: routingResult ? {
-                        model: routingResult.selection.model,
-                        provider: routingResult.selection.provider,
-                        isLocal: routingResult.selection.isLocal,
-                        taskType: routingResult.classification.type,
-                    } : (providerOverride || modelOverride) ? {
-                        model: modelOverride,
-                        provider: providerOverride || this.config.provider.primary,
-                        override: true,
-                    } : undefined,
-                    architect: architectResult.architectMeta,
-                    transparency: transparencyMeta,
-                },
-            });
-            // Background self-awareness analysis
-            if (this.selfAwarenessAssembler) {
-                this.selfAwarenessAssembler.afterResponse({
-                    userId: client.senderId ?? 'anonymous',
-                    sessionId: session.id,
-                    chatId: chatId ?? session.id,
-                    currentMessage: processedContent,
-                    recentMessages: contextMessages,
-                    response: finalResponse,
-                    responseTime: Date.now() - (session.metadata.lastActiveAt ?? Date.now()),
-                    tokensUsed: { input: usage?.inputTokens ?? 0, output: usage?.outputTokens ?? 0 },
-                    streamChunks: streamChunkCount,
-                }).catch(() => { });
-            }
-            // Record conversation in consciousness journal
-            if (this.consciousness) {
-                const journalBase = {
-                    sessionId: session.id,
-                    type: 'message',
-                    context: {
-                        domains: architectResult.architectMeta
-                            ? [architectResult.architectMeta.detectedContext.domain]
-                            : ['general'],
-                    },
-                    selfState: {
-                        health: (this.healthMonitor?.getHealthState().overall === 'unhealthy' ? 'degraded' : this.healthMonitor?.getHealthState().overall ?? 'healthy'),
-                        activeProviders: [this.config.provider.primary],
-                        uptime: Math.round(process.uptime()),
-                    },
-                };
-                this.consciousness.journal.record({ ...journalBase, message: { role: 'user', content: processedContent } }).catch(() => { });
-                this.consciousness.journal.record({ ...journalBase, message: { role: 'assistant', content: finalResponse } }).catch(() => { });
-            }
-            audit('message.sent', {
-                sessionId: session.id,
-                inputTokens: usage.inputTokens,
-                outputTokens: usage.outputTokens,
-                model: routingResult?.selection.model,
-                provider: routingResult?.selection.provider,
-            });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            audit('channel.error', { sessionId: session.id, error: errorMessage });
-            this.sendToClient(client, {
-                type: 'error',
-                id: requestId,
-                payload: { message: `Error: ${errorMessage}` },
-            });
         }
     }
     async generateChatTitle(chatId, userMessage, assistantResponse, client) {
@@ -3294,22 +3342,35 @@ export class Auxiora {
      * for synthesis, looping up to maxToolRounds times.
      */
     async executeWithTools(sessionId, messages, enrichedPrompt, provider, onChunk, options) {
-        const maxRounds = options?.maxToolRounds ?? 10;
+        const maxRounds = options?.maxToolRounds ?? 20;
         const maxContinuations = 3; // Safety cap for auto-continue on truncation
         const tools = options?.tools ?? toolRegistry.toProviderFormat();
         let currentMessages = [...messages];
         let totalUsage = { inputTokens: 0, outputTokens: 0 };
         let fullResponse = '';
         let lastRoundHadTools = false;
-        const loopState = createLoopDetectionState();
+        const loopState = createLoopDetectionState({
+            genericRepeatWarn: 3, // Catch loops faster (default 5)
+            genericRepeatCritical: 8, // Stop after blocked attempts too (default 10)
+            noProgressWarn: 4, // Detect identical results sooner (default 8)
+            noProgressCritical: 8, // Hard stop (default 15)
+        });
+        // Track tools to temporarily exclude when loop is detected
+        const excludedToolNames = new Set();
+        // Track file paths written to detect same-file rewrites
+        const writtenFiles = new Map(); // path → count
         for (let round = 0; round < maxRounds; round++) {
             let roundResponse = '';
             let roundUsage = { inputTokens: 0, outputTokens: 0 };
             let roundFinishReason = '';
             const toolUses = [];
+            // Filter out excluded tools (loop breaker)
+            const roundTools = excludedToolNames.size > 0
+                ? tools.filter(t => !excludedToolNames.has(t.name))
+                : tools;
             const streamOptions = {
                 systemPrompt: enrichedPrompt,
-                tools: tools.length > 0 ? tools : undefined,
+                tools: roundTools.length > 0 ? roundTools : undefined,
                 passThroughAllTools: true,
             };
             const candidates = options?.fallbackCandidates ?? [
@@ -3337,9 +3398,25 @@ export class Auxiora {
             }
             totalUsage.inputTokens += roundUsage.inputTokens;
             totalUsage.outputTokens += roundUsage.outputTokens;
-            // No tool calls — check if response was truncated
+            // No tool calls — check if we should nudge the model to continue
             if (toolUses.length === 0) {
                 fullResponse += roundResponse;
+                // Nudge the model to use tools if it only output text.
+                // Case 1 (round 0): Model described a plan but never called tools.
+                //   The user likely asked for an action, so give the model one more
+                //   chance by injecting a "please use tools" follow-up.
+                // Case 2 (round > 0, lastRoundHadTools): Model used tools last round
+                //   but emitted a short text-only response this round (stalled).
+                const shouldNudge = round < maxRounds - 1 && ((round === 0) ||
+                    (lastRoundHadTools && roundResponse.length < 200));
+                if (shouldNudge) {
+                    this.logger.info('Model stated intent without tool calls, nudging to continue', { round, responseLength: roundResponse.length });
+                    currentMessages.push({ role: 'assistant', content: roundResponse });
+                    currentMessages.push({ role: 'user', content: 'Please proceed — use the bash and file_write tools to do the work now. Do not describe what you will do — actually call the tools.' });
+                    onChunk('status', { message: 'Continuing...' });
+                    // Don't break — let the loop continue so the model can make tool calls
+                    continue;
+                }
                 // Auto-continue if response was cut off by token limit
                 const wasTruncated = roundFinishReason === 'max_tokens' || roundFinishReason === 'length';
                 if (wasTruncated && fullResponse.length > 0) {
@@ -3389,6 +3466,7 @@ export class Auxiora {
                 sessionId,
                 workingDirectory: getWorkspacePath(),
                 timeout: 30000,
+                environment: { ALLOW_OUTSIDE_WORKSPACE: 'true' },
             };
             const toolResultParts = [];
             for (const toolUse of toolUses) {
@@ -3402,6 +3480,15 @@ export class Auxiora {
                     recordToolOutcome(loopState, toolUse.id, mapped.skip);
                     continue;
                 }
+                // Block excluded tools (loop breaker — tool was disabled due to repetition)
+                if (excludedToolNames.has(mapped.name) || excludedToolNames.has(toolUse.name)) {
+                    const blockMsg = `Tool "${toolUse.name}" is temporarily disabled because you were repeating the same call. Use a DIFFERENT tool. For creating files, use file_write (or Write). Do NOT call ${toolUse.name} again.`;
+                    onChunk('tool_result', { tool: toolUse.name, success: false, error: blockMsg });
+                    toolResultParts.push(`[${toolUse.name}]: Error: ${blockMsg}`);
+                    recordToolCall(loopState, toolUse.id, mapped.name, mapped.input);
+                    recordToolOutcome(loopState, toolUse.id, blockMsg);
+                    continue;
+                }
                 recordToolCall(loopState, toolUse.id, mapped.name, mapped.input);
                 try {
                     const result = await toolExecutor.execute(mapped.name, mapped.input, context);
@@ -3418,6 +3505,15 @@ export class Auxiora {
                     }
                     toolResultParts.push(`[${toolUse.name}]: ${output}`);
                     recordToolOutcome(loopState, toolUse.id, output);
+                    // Track file writes to detect same-file rewrites
+                    if ((mapped.name === 'file_write' || toolUse.name === 'Write') && mapped.input?.path) {
+                        const filePath = mapped.input.path;
+                        const count = (writtenFiles.get(filePath) || 0) + 1;
+                        writtenFiles.set(filePath, count);
+                        if (count > 1) {
+                            this.logger.info('Same file rewritten multiple times', { filePath, count });
+                        }
+                    }
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -3428,7 +3524,14 @@ export class Auxiora {
             }
             // Append tool results directly to conversation (don't rebuild from getContextMessages
             // which can drop messages due to token windowing)
-            const toolResultsMessage = `[Tool Results]\n${toolResultParts.join('\n')}`;
+            let toolResultsMessage = `[Tool Results]\n${toolResultParts.join('\n')}`;
+            // Detect same-file rewrites and nudge to move on
+            const rewrittenFiles = [...writtenFiles.entries()].filter(([, count]) => count > 1);
+            if (rewrittenFiles.length > 0) {
+                const fileList = rewrittenFiles.map(([f, c]) => `${f} (${c}x)`).join(', ');
+                toolResultsMessage += `\n\n⚠️ You have rewritten the same file(s) multiple times: ${fileList}. Each file only needs to be written ONCE. Move on to creating the NEXT file in the project. Do NOT rewrite files you've already created.`;
+                this.logger.info('Same-file rewrite nudge injected', { rewrittenFiles: rewrittenFiles.map(([f, c]) => ({ file: f, count: c })) });
+            }
             currentMessages.push({ role: 'user', content: toolResultsMessage });
             await this.sessions.addMessage(sessionId, 'user', toolResultsMessage);
             // Check for tool loop patterns
@@ -3444,11 +3547,24 @@ export class Auxiora {
                 break;
             }
             if (detection.severity === 'warning') {
-                this.logger.info('Tool loop warning', {
+                // Temporarily exclude the looping tool to force the model to use alternatives
+                const loopingTool = detection.details?.toolName;
+                if (loopingTool) {
+                    excludedToolNames.add(loopingTool);
+                    // Also exclude CC-equivalent names
+                    const ccEquivalents = { bash: 'Bash', file_read: 'Read', file_write: 'Write', file_list: 'Glob' };
+                    const auxEquivalents = { Bash: 'bash', Read: 'file_read', Write: 'file_write', Glob: 'file_list' };
+                    if (ccEquivalents[loopingTool])
+                        excludedToolNames.add(ccEquivalents[loopingTool]);
+                    if (auxEquivalents[loopingTool])
+                        excludedToolNames.add(auxEquivalents[loopingTool]);
+                }
+                this.logger.info('Tool loop warning — excluding tool from next round', {
                     detector: detection.detector,
                     message: detection.message,
+                    excludedTools: Array.from(excludedToolNames),
                 });
-                currentMessages.push({ role: 'user', content: `⚠️ Loop detection warning: ${detection.message}\nPlease try a different approach or different parameters.` });
+                currentMessages.push({ role: 'user', content: `⚠️ You are repeating the same tool call. ${detection.message}\nThe previous calls already succeeded — the ${loopingTool} tool is now temporarily disabled. Move on to the NEXT step: create the actual files using the file_write tool (or Write tool). Do NOT try to create directories again.` });
             }
             // Notify the client that tool processing is done and AI is thinking about results
             onChunk('status', { message: 'Analyzing results...' });
@@ -3589,6 +3705,93 @@ export class Auxiora {
             client.ws.send(JSON.stringify(message));
         }
     }
+    acquireSessionRun(sessionId) {
+        let state = this.sessionRunStates.get(sessionId);
+        if (!state) {
+            state = { running: false, queue: [], lastRunStartedAt: 0 };
+            this.sessionRunStates.set(sessionId, state);
+        }
+        if (state.running)
+            return false;
+        state.running = true;
+        state.lastRunStartedAt = Date.now();
+        return true;
+    }
+    releaseSessionRun(sessionId) {
+        const state = this.sessionRunStates.get(sessionId);
+        if (state) {
+            state.running = false;
+        }
+    }
+    getSessionRunState(sessionId) {
+        let state = this.sessionRunStates.get(sessionId);
+        if (!state) {
+            state = { running: false, queue: [], lastRunStartedAt: 0 };
+            this.sessionRunStates.set(sessionId, state);
+        }
+        return state;
+    }
+    enqueueMessage(sessionId, pending) {
+        const state = this.getSessionRunState(sessionId);
+        const cap = this.config.queue?.cap ?? 20;
+        state.queue.push(pending);
+        if (state.queue.length > cap) {
+            const dropped = state.queue.shift();
+            this.logger.warn('Message queue overflow — dropped oldest message', {
+                sessionId,
+                droppedContent: dropped?.content.slice(0, 80),
+                queueLength: state.queue.length,
+            });
+        }
+    }
+    async drainSessionQueue(sessionId) {
+        const state = this.sessionRunStates.get(sessionId);
+        if (!state)
+            return;
+        while (state.queue.length > 0) {
+            const pending = state.queue.shift();
+            // Skip webchat messages if the client disconnected
+            if (pending.client && !pending.inbound && pending.client.ws.readyState !== 1) {
+                this.logger.info('Skipping queued webchat message — client disconnected', { sessionId });
+                continue;
+            }
+            // Skip if session was destroyed
+            const session = await this.sessions.get(sessionId);
+            if (!session) {
+                this.logger.info('Skipping queued messages — session destroyed', { sessionId });
+                state.queue.length = 0;
+                break;
+            }
+            try {
+                // Release the lock so the re-entrant call can acquire it
+                state.running = false;
+                if (pending.inbound) {
+                    await this.handleChannelMessage(pending.inbound);
+                }
+                else if (pending.client) {
+                    const wsMessage = {
+                        id: pending.requestId ?? `queued-${Date.now()}`,
+                        type: 'message',
+                        payload: {
+                            content: pending.content,
+                            sessionId,
+                            chatId: pending.chatId,
+                            model: pending.modelOverride,
+                            provider: pending.providerOverride,
+                        },
+                    };
+                    await this.handleMessage(pending.client, wsMessage);
+                }
+            }
+            catch (err) {
+                this.logger.error('Error processing queued message', {
+                    sessionId,
+                    error: err instanceof Error ? err : new Error(String(err)),
+                });
+            }
+        }
+        state.running = false;
+    }
     /** Load persisted channel targets from disk so behavior delivery survives restarts. */
     async loadChannelTargets() {
         try {
@@ -3696,260 +3899,300 @@ export class Auxiora {
                 }
                 return;
             }
-            // Process media attachments and add user message
-            let messageContent = inbound.content;
-            if (inbound.attachments && inbound.attachments.length > 0 && this.mediaProcessor) {
-                messageContent = await this.mediaProcessor.process(inbound.attachments, inbound.content);
-            }
-            // ── Guardrail input scan ──────────────────────────────────────
-            const inputScan = this.checkInputGuardrails(messageContent);
-            if (inputScan && inputScan.action === 'block') {
-                audit('guardrail.triggered', {
-                    action: 'block',
-                    direction: 'input',
-                    threatCount: inputScan.threats.length,
-                    channelType: inbound.channelType,
-                    sessionId: session.id,
+            // ── Message queue gate ─────────────────────────────────────────
+            if (!this.acquireSessionRun(session.id)) {
+                this.enqueueMessage(session.id, {
+                    content: inbound.content,
+                    enqueuedAt: Date.now(),
+                    inbound,
                 });
                 if (this.channels) {
                     await this.channels.send(inbound.channelType, inbound.channelId, {
-                        content: this.GUARDRAIL_BLOCK_MESSAGE,
+                        content: "Got it — I'll get to that after I finish the current task.",
                         replyToId: inbound.id,
                     });
                 }
                 return;
             }
-            // Apply redaction if guardrails flagged PII
-            if (inputScan?.action === 'redact' && inputScan.redactedContent) {
-                messageContent = inputScan.redactedContent;
-                audit('guardrail.triggered', {
-                    action: 'redact',
-                    direction: 'input',
-                    threatCount: inputScan.threats.length,
-                    channelType: inbound.channelType,
-                });
-            }
-            else if (inputScan?.action === 'warn') {
-                audit('guardrail.triggered', {
-                    action: 'warn',
-                    direction: 'input',
-                    threatCount: inputScan.threats.length,
-                    channelType: inbound.channelType,
-                });
-            }
-            await this.sessions.addMessage(session.id, 'user', messageContent);
-            // Check if providers are available
-            if (!this.providers) {
-                if (this.channels) {
-                    await this.channels.send(inbound.channelType, inbound.channelId, {
-                        content: 'I need API keys to respond. Please configure them in the vault.',
-                        replyToId: inbound.id,
-                    });
+            try {
+                // Process media attachments and add user message
+                let messageContent = inbound.content;
+                if (inbound.attachments && inbound.attachments.length > 0 && this.mediaProcessor) {
+                    messageContent = await this.mediaProcessor.process(inbound.attachments, inbound.content);
                 }
-                return;
-            }
-            // Get context messages — channel sessions use a capped token budget and turn limit
-            // to prevent excessively long API calls from models with huge context windows.
-            const contextMessages = this.sessions.getContextMessages(session.id, this.getProviderMaxTokens(this.providers.getPrimaryProvider()), 4096, { isChannel: true });
-            const chatMessages = sanitizeTranscript(contextMessages).map((m) => ({
-                role: m.role,
-                content: m.content,
-            }));
-            // Show typing indicator while generating response
-            const stopTyping = this.channels
-                ? await this.channels.startTyping(inbound.channelType, inbound.channelId)
-                : () => { };
-            const channelAgentId = `channel:${inbound.channelType}:${inbound.channelId}:${Date.now()}`;
-            // 4-minute timeout for the entire LLM response cycle.
-            // Increased from 2min to accommodate auto-continuations (max_tokens → "Continue")
-            // and tool round-trips. If the provider stream hangs (network issue, overloaded API),
-            // this ensures the user gets an error message instead of infinite "typing…".
-            const CHANNEL_RESPONSE_TIMEOUT_MS = 240_000;
-            let draftLoop = null;
-            let draftMessageId = null;
-            try { // outer try — finally block guarantees stopTyping() runs
-                try {
-                    // Get tool definitions from registry
-                    const tools = toolRegistry.toProviderFormat();
-                    // Build enriched prompt through pipeline
-                    let enrichedPrompt = this.systemPrompt;
-                    const channelChatId = `${inbound.channelType}:${inbound.channelId}`;
-                    let channelArchitectResult = { prompt: this.systemPrompt };
-                    // Reset Architect conversation state for new channel chats
-                    const useChannelArchitect = this.config.agent.personality === 'the-architect';
-                    if (useChannelArchitect && this.architect && !this.architectResetChats.has(channelChatId)) {
-                        this.architectResetChats.add(channelChatId);
-                        this.architect.resetConversation();
-                        audit('personality.reset', { sessionId: session.id, chatId: channelChatId });
+                // ── Guardrail input scan ──────────────────────────────────────
+                const inputScan = this.checkInputGuardrails(messageContent);
+                if (inputScan && inputScan.action === 'block') {
+                    audit('guardrail.triggered', {
+                        action: 'block',
+                        direction: 'input',
+                        threatCount: inputScan.threats.length,
+                        channelType: inbound.channelType,
+                        sessionId: session.id,
+                    });
+                    if (this.channels) {
+                        await this.channels.send(inbound.channelType, inbound.channelId, {
+                            content: this.GUARDRAIL_BLOCK_MESSAGE,
+                            replyToId: inbound.id,
+                        });
                     }
-                    if (this.enrichmentPipeline) {
-                        const enrichCtx = {
-                            basePrompt: this.systemPrompt,
-                            userMessage: messageContent,
-                            history: contextMessages,
-                            channelType: inbound.channelType,
-                            chatId: channelChatId,
-                            sessionId: session.id,
-                            userId: inbound.senderId ?? 'anonymous',
-                            toolsUsed: this.lastToolsUsed.get(session.id) ?? [],
-                            config: this.config,
-                            senderName: inbound.senderName,
-                            groupContext: inbound.groupContext,
-                        };
-                        const result = await this.enrichmentPipeline.run(enrichCtx);
-                        enrichedPrompt = result.prompt;
-                        channelArchitectResult = { prompt: enrichedPrompt, architectMeta: result.metadata.architect };
+                    return;
+                }
+                // Apply redaction if guardrails flagged PII
+                if (inputScan?.action === 'redact' && inputScan.redactedContent) {
+                    messageContent = inputScan.redactedContent;
+                    audit('guardrail.triggered', {
+                        action: 'redact',
+                        direction: 'input',
+                        threatCount: inputScan.threats.length,
+                        channelType: inbound.channelType,
+                    });
+                }
+                else if (inputScan?.action === 'warn') {
+                    audit('guardrail.triggered', {
+                        action: 'warn',
+                        direction: 'input',
+                        threatCount: inputScan.threats.length,
+                        channelType: inbound.channelType,
+                    });
+                }
+                await this.sessions.addMessage(session.id, 'user', messageContent);
+                // Check if providers are available
+                if (!this.providers) {
+                    if (this.channels) {
+                        await this.channels.send(inbound.channelType, inbound.channelId, {
+                            content: 'I need API keys to respond. Please configure them in the vault.',
+                            replyToId: inbound.id,
+                        });
                     }
-                    // Use executeWithTools for channels — collect final text for channel reply
-                    const provider = this.providers.getPrimaryProvider();
-                    // Inject model identity so the AI knows what it's running on
-                    enrichedPrompt += this.buildModelIdentityFragment(provider);
-                    this.agentStart(channelAgentId, 'channel', `Processing message on ${inbound.channelType}`, inbound.channelType);
-                    // Draft streaming: edit message in place if adapter supports it
-                    const adapter = this.channels?.getAdapter(inbound.channelType);
-                    const supportsDraft = !!adapter?.editMessage;
-                    let accumulatedText = '';
-                    if (supportsDraft && this.channels) {
-                        const channels = this.channels;
-                        draftLoop = new DraftStreamLoop(async (text) => {
-                            try {
-                                if (!draftMessageId) {
-                                    const result = await channels.send(inbound.channelType, inbound.channelId, {
-                                        content: text,
-                                        replyToId: inbound.id,
-                                    });
-                                    if (result.success && result.messageId) {
-                                        draftMessageId = result.messageId;
+                    return;
+                }
+                // Get context messages — channel sessions use a capped token budget and turn limit
+                // to prevent excessively long API calls from models with huge context windows.
+                const contextMessages = this.sessions.getContextMessages(session.id, this.getProviderMaxTokens(this.providers.getPrimaryProvider()), 4096, { isChannel: true });
+                const chatMessages = sanitizeTranscript(contextMessages).map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                }));
+                // Show typing indicator while generating response
+                const stopTyping = this.channels
+                    ? await this.channels.startTyping(inbound.channelType, inbound.channelId)
+                    : () => { };
+                const channelAgentId = `channel:${inbound.channelType}:${inbound.channelId}:${Date.now()}`;
+                // 30-minute timeout for the entire LLM response cycle.
+                // Agentic tool loops can take many rounds (up to 20), each requiring a full LLM
+                // call (30-90s) + tool execution. A multi-file generation task easily takes 10-20 minutes.
+                const CHANNEL_RESPONSE_TIMEOUT_MS = 1_800_000;
+                let draftLoop = null;
+                let draftMessageId = null;
+                // Snapshot message count before agentic loop so we can rollback on failure
+                let channelMessageSnapshot;
+                try { // outer try — finally block guarantees stopTyping() runs
+                    try {
+                        // Get tool definitions from registry
+                        const tools = toolRegistry.toProviderFormat();
+                        // Build enriched prompt through pipeline
+                        let enrichedPrompt = this.systemPrompt;
+                        const channelChatId = `${inbound.channelType}:${inbound.channelId}`;
+                        let channelArchitectResult = { prompt: this.systemPrompt };
+                        // Reset Architect conversation state for new channel chats
+                        const useChannelArchitect = this.config.agent.personality === 'the-architect';
+                        if (useChannelArchitect && this.architect && !this.architectResetChats.has(channelChatId)) {
+                            this.architectResetChats.add(channelChatId);
+                            this.architect.resetConversation();
+                            audit('personality.reset', { sessionId: session.id, chatId: channelChatId });
+                        }
+                        if (this.enrichmentPipeline) {
+                            const enrichCtx = {
+                                basePrompt: this.systemPrompt,
+                                userMessage: messageContent,
+                                history: contextMessages,
+                                channelType: inbound.channelType,
+                                chatId: channelChatId,
+                                sessionId: session.id,
+                                userId: inbound.senderId ?? 'anonymous',
+                                toolsUsed: this.lastToolsUsed.get(session.id) ?? [],
+                                config: this.config,
+                                senderName: inbound.senderName,
+                                groupContext: inbound.groupContext,
+                            };
+                            const result = await this.enrichmentPipeline.run(enrichCtx);
+                            enrichedPrompt = result.prompt;
+                            channelArchitectResult = { prompt: enrichedPrompt, architectMeta: result.metadata.architect };
+                        }
+                        // Use executeWithTools for channels — collect final text for channel reply
+                        const provider = this.providers.getPrimaryProvider();
+                        // Inject model identity so the AI knows what it's running on
+                        enrichedPrompt += this.buildModelIdentityFragment(provider);
+                        this.agentStart(channelAgentId, 'channel', `Processing message on ${inbound.channelType}`, inbound.channelType);
+                        // Draft streaming: edit message in place if adapter supports it
+                        const adapter = this.channels?.getAdapter(inbound.channelType);
+                        const supportsDraft = !!adapter?.editMessage;
+                        let accumulatedText = '';
+                        if (supportsDraft && this.channels) {
+                            const channels = this.channels;
+                            draftLoop = new DraftStreamLoop(async (text) => {
+                                try {
+                                    if (!draftMessageId) {
+                                        const result = await channels.send(inbound.channelType, inbound.channelId, {
+                                            content: text,
+                                            replyToId: inbound.id,
+                                        });
+                                        if (result.success && result.messageId) {
+                                            draftMessageId = result.messageId;
+                                        }
+                                        return result.success;
+                                    }
+                                    else {
+                                        const result = await channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: text });
+                                        return result.success;
                                     }
-                                    return result.success;
                                 }
-                                else {
-                                    const result = await channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: text });
-                                    return result.success;
+                                catch {
+                                    return false;
                                 }
+                            }, 1000);
+                        }
+                        const fallbackCandidates = this.providers.resolveFallbackCandidates();
+                        const channelToolsUsed = [];
+                        // Snapshot message count so we can rollback orphaned messages on timeout/error
+                        channelMessageSnapshot = this.sessions.getMessageCount(session.id);
+                        const { response: channelResponse, usage: channelUsage } = await Promise.race([
+                            this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
+                                if (type === 'text' && data && draftLoop) {
+                                    accumulatedText += data;
+                                    draftLoop.update(accumulatedText);
+                                }
+                                else if (type === 'tool_use') {
+                                    channelToolsUsed.push({ name: data?.name ?? 'unknown', success: true });
+                                }
+                                else if (type === 'tool_result') {
+                                    if (channelToolsUsed.length > 0 && data?.error) {
+                                        channelToolsUsed[channelToolsUsed.length - 1].success = false;
+                                    }
+                                }
+                            }, { tools, fallbackCandidates }),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error('Response timed out — the task did not complete within 30 minutes. Try breaking it into smaller steps.')), CHANNEL_RESPONSE_TIMEOUT_MS)),
+                        ]);
+                        // Feed tool usage to awareness collector
+                        if (this.architectAwarenessCollector && channelToolsUsed.length > 0) {
+                            this.architectAwarenessCollector.updateToolContext(channelToolsUsed);
+                        }
+                        this.lastToolsUsed.set(session.id, channelToolsUsed);
+                        // Flush final draft text
+                        if (draftLoop) {
+                            if (channelResponse && channelResponse !== accumulatedText) {
+                                draftLoop.update(channelResponse);
                             }
-                            catch {
-                                return false;
-                            }
-                        }, 1000);
-                    }
-                    const fallbackCandidates = this.providers.resolveFallbackCandidates();
-                    const channelToolsUsed = [];
-                    const { response: channelResponse, usage: channelUsage } = await Promise.race([
-                        this.executeWithTools(session.id, chatMessages, enrichedPrompt, provider, (type, data) => {
-                            if (type === 'text' && data && draftLoop) {
-                                accumulatedText += data;
-                                draftLoop.update(accumulatedText);
-                            }
-                            else if (type === 'tool_use') {
-                                channelToolsUsed.push({ name: data?.name ?? 'unknown', success: true });
+                            await draftLoop.flush();
+                            draftLoop.stop();
+                        }
+                        // ── Guardrail output scan ─────────────────────────────────────
+                        const channelOutputScan = this.checkOutputGuardrails(channelResponse);
+                        const finalChannelResponse = channelOutputScan.response;
+                        if (channelOutputScan.wasModified) {
+                            audit('guardrail.triggered', {
+                                action: channelOutputScan.action,
+                                direction: 'output',
+                                channelType: inbound.channelType,
+                                sessionId: session.id,
+                            });
+                            // If draft streaming already sent partial text, do a final edit with clean version
+                            if (draftMessageId && adapter?.editMessage) {
+                                await adapter.editMessage(inbound.channelId, draftMessageId, { content: finalChannelResponse });
                             }
-                            else if (type === 'tool_result') {
-                                if (channelToolsUsed.length > 0 && data?.error) {
-                                    channelToolsUsed[channelToolsUsed.length - 1].success = false;
-                                }
+                        }
+                        // Save assistant message
+                        await this.sessions.addMessage(session.id, 'assistant', finalChannelResponse, {
+                            input: channelUsage.inputTokens,
+                            output: channelUsage.outputTokens,
+                        }, channelArchitectResult.architectMeta ? { architectDomain: channelArchitectResult.architectMeta.detectedContext.domain } : undefined);
+                        // Extract memories and learn from conversation (if auto-extract enabled)
+                        if (this.config.memory?.autoExtract !== false && this.memoryStore && finalChannelResponse && messageContent.length > 20) {
+                            void this.extractAndLearn(messageContent, finalChannelResponse, session.id);
+                        }
+                        // Send final response. The draft stream loop edits a single message,
+                        // but Discord silently truncates edits at 2000 chars. For long responses,
+                        // replace the draft with a chunked send so nothing is lost.
+                        const DRAFT_SAFE_LENGTH = 1900; // leave margin below Discord's 2000 char limit
+                        if (draftMessageId && this.channels && finalChannelResponse.length > DRAFT_SAFE_LENGTH) {
+                            // Draft only showed partial content — replace it with a pointer and send full chunked response
+                            if (adapter?.editMessage) {
+                                await adapter.editMessage(inbound.channelId, draftMessageId, {
+                                    content: '*\u2026 (full response below)*',
+                                });
                             }
-                        }, { tools, fallbackCandidates }),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('Response timed out — the AI provider did not respond within 4 minutes. Please try again.')), CHANNEL_RESPONSE_TIMEOUT_MS)),
-                    ]);
-                    // Feed tool usage to awareness collector
-                    if (this.architectAwarenessCollector && channelToolsUsed.length > 0) {
-                        this.architectAwarenessCollector.updateToolContext(channelToolsUsed);
-                    }
-                    this.lastToolsUsed.set(session.id, channelToolsUsed);
-                    // Flush final draft text
-                    if (draftLoop) {
-                        if (channelResponse && channelResponse !== accumulatedText) {
-                            draftLoop.update(channelResponse);
+                            await this.channels.send(inbound.channelType, inbound.channelId, {
+                                content: finalChannelResponse,
+                            });
                         }
-                        await draftLoop.flush();
-                        draftLoop.stop();
-                    }
-                    // ── Guardrail output scan ─────────────────────────────────────
-                    const channelOutputScan = this.checkOutputGuardrails(channelResponse);
-                    const finalChannelResponse = channelOutputScan.response;
-                    if (channelOutputScan.wasModified) {
-                        audit('guardrail.triggered', {
-                            action: channelOutputScan.action,
-                            direction: 'output',
+                        else if (!draftMessageId && this.channels) {
+                            await this.channels.send(inbound.channelType, inbound.channelId, {
+                                content: finalChannelResponse,
+                                replyToId: inbound.id,
+                            });
+                        }
+                        audit('message.sent', {
                             channelType: inbound.channelType,
                             sessionId: session.id,
+                            inputTokens: channelUsage.inputTokens,
+                            outputTokens: channelUsage.outputTokens,
                         });
-                        // If draft streaming already sent partial text, do a final edit with clean version
-                        if (draftMessageId && adapter?.editMessage) {
-                            await adapter.editMessage(inbound.channelId, draftMessageId, { content: finalChannelResponse });
-                        }
-                    }
-                    // Save assistant message
-                    await this.sessions.addMessage(session.id, 'assistant', finalChannelResponse, {
-                        input: channelUsage.inputTokens,
-                        output: channelUsage.outputTokens,
-                    }, channelArchitectResult.architectMeta ? { architectDomain: channelArchitectResult.architectMeta.detectedContext.domain } : undefined);
-                    // Extract memories and learn from conversation (if auto-extract enabled)
-                    if (this.config.memory?.autoExtract !== false && this.memoryStore && finalChannelResponse && messageContent.length > 20) {
-                        void this.extractAndLearn(messageContent, finalChannelResponse, session.id);
+                        this.agentEnd(channelAgentId, true);
                     }
-                    // Send final response. The draft stream loop edits a single message,
-                    // but Discord silently truncates edits at 2000 chars. For long responses,
-                    // replace the draft with a chunked send so nothing is lost.
-                    const DRAFT_SAFE_LENGTH = 1900; // leave margin below Discord's 2000 char limit
-                    if (draftMessageId && this.channels && finalChannelResponse.length > DRAFT_SAFE_LENGTH) {
-                        // Draft only showed partial content — replace it with a pointer and send full chunked response
-                        if (adapter?.editMessage) {
-                            await adapter.editMessage(inbound.channelId, draftMessageId, {
-                                content: '*\u2026 (full response below)*',
-                            });
+                    catch (error) {
+                        if (draftLoop)
+                            draftLoop.stop();
+                        this.agentEnd(channelAgentId, false);
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        audit('channel.error', { sessionId: session.id, error: errorMessage });
+                        // Rollback orphaned messages from interrupted agentic tool loops.
+                        // This is critical for channel messages where timeouts are common (30-min limit).
+                        if (typeof channelMessageSnapshot === 'number') {
+                            const rolled = this.sessions.rollbackMessages(session.id, channelMessageSnapshot);
+                            if (rolled > 0) {
+                                this.logger.info('Rolled back orphaned channel messages from interrupted tool loop', {
+                                    sessionId: session.id,
+                                    channelType: inbound.channelType,
+                                    rolledBack: rolled,
+                                });
+                            }
                         }
-                        await this.channels.send(inbound.channelType, inbound.channelId, {
-                            content: finalChannelResponse,
-                        });
-                    }
-                    else if (!draftMessageId && this.channels) {
-                        await this.channels.send(inbound.channelType, inbound.channelId, {
-                            content: finalChannelResponse,
-                            replyToId: inbound.id,
-                        });
-                    }
-                    audit('message.sent', {
-                        channelType: inbound.channelType,
-                        sessionId: session.id,
-                        inputTokens: channelUsage.inputTokens,
-                        outputTokens: channelUsage.outputTokens,
-                    });
-                    this.agentEnd(channelAgentId, true);
-                }
-                catch (error) {
-                    if (draftLoop)
-                        draftLoop.stop();
-                    this.agentEnd(channelAgentId, false);
-                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                    audit('channel.error', { sessionId: session.id, error: errorMessage });
-                    if (this.channels) {
-                        const errorContent = `Error: ${errorMessage}`;
-                        // If a draft message exists, edit it with the error instead of sending a new one
-                        if (draftMessageId) {
-                            try {
-                                await this.channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: errorContent });
+                        if (this.channels) {
+                            const errorContent = `Error: ${errorMessage}`;
+                            // If a draft message exists, edit it with the error instead of sending a new one
+                            if (draftMessageId) {
+                                try {
+                                    await this.channels.editMessage(inbound.channelType, inbound.channelId, draftMessageId, { content: errorContent });
+                                }
+                                catch {
+                                    // Edit failed — fall back to new message
+                                    await this.channels.send(inbound.channelType, inbound.channelId, {
+                                        content: errorContent,
+                                        replyToId: inbound.id,
+                                    });
+                                }
                             }
-                            catch {
-                                // Edit failed — fall back to new message
+                            else {
                                 await this.channels.send(inbound.channelType, inbound.channelId, {
                                     content: errorContent,
                                     replyToId: inbound.id,
                                 });
                             }
                         }
-                        else {
-                            await this.channels.send(inbound.channelType, inbound.channelId, {
-                                content: errorContent,
-                                replyToId: inbound.id,
-                            });
-                        }
                     }
                 }
+                finally {
+                    stopTyping();
+                }
             }
             finally {
-                stopTyping();
+                try {
+                    await this.drainSessionQueue(session.id);
+                }
+                finally {
+                    this.releaseSessionRun(session.id);
+                }
             }
         }); // end runWithRequestId
     }
@@ -4257,6 +4500,7 @@ export class Auxiora {
             catch { /* best-effort — don't block shutdown */ }
         }
         this.consciousness?.shutdown();
+        this.sessionRunStates.clear();
         this.sessions.destroy();
         this.vault.lock();
         this.running = false;